WsfCommReservedAddressing.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2018 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 WSFCOMMRESERVEDADDRESSING_HPP
#define WSFCOMMRESERVEDADDRESSING_HPP
 
#include <memory>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "WsfCommAddress.hpp"
 
namespace wsf
{
namespace comm
{

namespace reserved
{
constexpr const char* const cBROADCAST_LOCAL       = "BROADCAST_LOCAL";
constexpr const char* const cMULTICAST_INITIAL     = "MULTICAST_INITIAL";
constexpr const char* const cMULTICAST_LAST        = "MULTICAST_LAST";
constexpr const char* const cDEFAULT_INITIAL       = "DEFAULT_INITIAL";
constexpr const char* const cDEFAULT_LAST          = "DEFAULT_LAST";
constexpr const char* const cMULTICAST_ALL_HOSTS   = "MULTICAST_ALL_HOSTS";   // All multicast hosts
constexpr const char* const cMULTICAST_ALL_ROUTERS = "MULTICAST_ALL_ROUTERS"; // All multicast routers
constexpr const char* const cRIPv2_MULTICAST       = "RIPv2_MULTICAST";       // Local Network Only
constexpr const char* const cOSPF_MULTICAST_ALL    = "OSPF_MULTICAST_ALL";    // Hello and Protocol Usage
constexpr const char* const cOSPF_MULTICAST_DRBR   = "OSPF_MULTICAST_DRBR";   // DR/BR Usage Only
} // namespace reserved

class ReservedAddressingImplementation
{
public:
   ReservedAddressingImplementation()          = default;
   virtual ~ReservedAddressingImplementation() = default;

   virtual void Initialize() = 0;

   virtual bool    IsReserved(const Address& aAddress) const;
   virtual Address QueryAddressByType(const std::string& aReservedType) const;
 
protected:
   virtual bool IsReservedSimple(const Address& aAddress) const;

   struct AddressPairHash
   {
      std::size_t operator()(const std::pair<Address, Address>& aKey) const
      {
         auto hash1        = std::hash<Address>{}(aKey.first);
         auto hash2        = std::hash<Address>{}(aKey.second);
         auto combineHash1 = hash1 ^ (hash2 << 1);
         auto combineHash2 = hash2 ^ (hash1 << 1);
 
         return std::min(combineHash1, combineHash2);
      }
   };
 
   using ReservedSet     = std::unordered_set<Address>;
   using ReservedPairSet = std::unordered_set<std::pair<Address, Address>, AddressPairHash>;
   using ReservedTypeMap = std::unordered_map<std::string, Address>;
 
   ReservedSet     mReservedAddressSet;
   ReservedPairSet mReservedAddressRangeSet;
   ReservedTypeMap mReservedTypeToAddressMap;
};

class ReservedAddressing
{
public:
   using UniqueReserved = std::unique_ptr<ReservedAddressingImplementation>;
 
   ReservedAddressing()                               = default;
   ReservedAddressing(const ReservedAddressing& aSrc) = delete;
   ReservedAddressing& operator=(const ReservedAddressing& aSrc) = delete;
 
   virtual ~ReservedAddressing() = default;
   void Register(UniqueReserved aImplementation);
   void Initialize();
 
   bool    IsReserved(const Address& aAddress) const;
   Address QueryAddressByType(const std::string& aReservedType) const;
 
private:
   std::vector<UniqueReserved> mImplementations;
};

class ReservedAddressBase : public ReservedAddressingImplementation
{
public:
   void Initialize() override;
};
 
} // namespace comm
} // namespace wsf
 
#endif