WsfCommAddress.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2017 Infoscitex, a DCS Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
 
#ifndef WSFCOMMADDRESS_HPP
#define WSFCOMMADDRESS_HPP
 
#include "wsf_export.h"
 
#include <array>
#include <string>
#include <vector>
 
#include "UtScriptAccessible.hpp"
 
class UtInput;
 
namespace wsf
{
namespace comm
{

struct IPv4
{
   static constexpr size_t        cBIT_SIZE       = 32;
   static constexpr size_t        cNUM_FIELDS     = 4;
   static constexpr const char*   cDELIMITER      = ".";
   static constexpr std::uint32_t cMASK_MAX       = 0xFFFFFFFF;
   static constexpr std::uint32_t cMASK_FIELD     = 0xFF;
   static constexpr const char*   cNULL_ADDRESS   = "0.0.0.0"; // Uninitialized address indicator
   static constexpr size_t        cDEFAULT_CIDR   = 24;
   static constexpr const char*   cCIDR_DELIMITER = "/";
   using ByteArray                                = std::array<unsigned char, 4>;
};

class WSF_EXPORT Address : public UtScriptAccessible
{
public:
   Address() = default;
   Address(const std::string& aAddress, size_t aSubnetMaskBitLength = IPv4::cDEFAULT_CIDR);

   explicit Address(size_t aSubnetMaskBitLength);
 
   virtual ~Address() = default;
 
   const char* GetScriptClassName() const override;
 
   void SetAddress(const std::string& aAddress, size_t aSubnetBitLength = IPv4::cDEFAULT_CIDR);

   static Address ProcessInput(UtInput& aInput);

   static Address ProcessInput(std::string aInput);

   static bool IsValidAddress(const std::string& aPossibleAddress);

   static size_t GetCIDR_ValueFromString(std::string& aPossibleAddress);

   void GenerateAddress(const std::string& aGenerationToken, size_t aSubnetBitLength = IPv4::cDEFAULT_CIDR);
 
   const std::string& GetAddress() const { return mAddress; }
   size_t             GetSubnetMaskBitLength() const { return mSubnetMaskBitLength; }
   const std::string& GetRoutingPrefix() const { return mRoutingPrefix; }
   const std::string& GetSubnet() const { return mSubnet; }
   size_t             GetNumHostAddresses() const;
   bool               IsNull() const { return (mAddress == IPv4::cNULL_ADDRESS); }
   size_t             GetBinaryInteger() const { return mBinaryIntegerValue; }
 
   bool operator==(const Address& aRhs) const;
   bool operator!=(const Address& aRhs) const;
   bool operator<(const Address& aRhs) const;

   Address& operator++();    //++Address
   Address  operator++(int); // Address++
 
   friend WSF_EXPORT std::ostream& operator<<(std::ostream& aOut, const Address& aAddress);

   template<typename T>
   void Serialize(T& aBuff)
   {
      aBuff& mAddress& mRoutingPrefix& mSubnet& mSubnetMaskBitLength;
   }

   static size_t GetStringValue(const std::string& aString);

   static bool CheckInAddressRange(const Address& aNetworkAddress, const Address& aCheckAddress);

   std::string GetGenerationToken() const { return mAddressToken; }

   std::string GetBroadcastAddress() const;
 
private:
   std::vector<size_t> TranslateIntegerIP(size_t aIP_Value) const;
 
   static bool IsNumber(const std::string& aString);

   void PopulateAddressFromBytes();
 
   std::string     mAddress{IPv4::cNULL_ADDRESS};
   std::string     mRoutingPrefix{""};
   std::string     mSubnet{""};
   uint32_t        mSubnetIntegerValue{0};
   size_t          mSubnetMaskBitLength{IPv4::cDEFAULT_CIDR};
   uint32_t        mBinaryIntegerValue{0};
   IPv4::ByteArray mBytes{{0, 0, 0, 0}};
   std::string     mAddressToken{""};
};
 
} // namespace comm
} // namespace wsf
 
UT_MAP_CLASS_TO_SCRIPT_NAME(wsf::comm::Address, "WsfAddress")
 

namespace std
{
template<>
struct hash<wsf::comm::Address>
{
   size_t operator()(const wsf::comm::Address& aRhs) const
   {
      return hash<size_t>()(wsf::comm::Address::GetStringValue(aRhs.GetAddress()));
   }
};
 
} // namespace std
 
#endif