WsfCommNetworkManager.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 WSFCOMMNETWORKMANAGER_HPP
#define WSFCOMMNETWORKMANAGER_HPP
 
#include "wsf_export.h"
 
#include <map>
#include <memory>
#include <set>
#include <unordered_map>
#include <unordered_set>
#include <vector>
 
#include "UtCallback.hpp"
#include "UtCallbackHolder.hpp"
#include "UtMemory.hpp"
#include "WsfComm.hpp"
#include "WsfCommAddress.hpp"
#include "WsfCommGraph.hpp"
#include "WsfCommNetwork.hpp"
#include "WsfCommReservedAddressing.hpp"
class WsfPlatform;
class WsfSimulation;
#include "WsfScenarioExtension.hpp"
#include "WsfSimulation.hpp"
#include "WsfSimulationExtension.hpp"
 
namespace wsf
{
namespace comm
{
 
class WSF_EXPORT NetworkManager : public WsfSimulationExtension
{
public:
   enum class NetworkTopology
   {
      cPOINT_TO_POINT,
      cMESH,
      cSTAR,
      cRING,
      cDIRECTED_RING
   };
 
   struct CommHash
   {
      size_t operator()(Comm* aCommPtr) const noexcept { return std::hash<unsigned int>()(aCommPtr->GetUniqueId()); }
   };

   using CommMap           = std::unordered_map<Address, Comm*>;           // Address -> Comm
   using AddressMap        = std::unordered_map<Comm*, Address, CommHash>; // Comm.GetUniqueId -> Address
   using AddressSet        = std::unordered_set<Address>;
   using NetworkSet        = std::set<Address>;
   using AddressNetworkMap = std::unordered_map<Address, std::string>;                  // Address -> Network Name
   using NetworkMap        = std::unordered_map<std::string, std::unique_ptr<Network>>; // Network name -> Network
   using AddressVector     = std::vector<Address>;                                      // A vector of Addresses
   using MultiAddressMap = std::unordered_map<Address, AddressVector>; // A mapping of an address to multiple addresses
   using CommVector      = std::vector<Comm*>;
   using RouterVector    = std::vector<router::Router*>;
 
   static NetworkManager* Find(const WsfSimulation& aSimulation);


   NetworkManager(WsfSimulation* aSimPtr);
   ~NetworkManager() override                 = default;
   NetworkManager(const NetworkManager& aSrc) = delete;
   NetworkManager& operator=(const NetworkManager& aSrc) = delete;
   NetworkManager(NetworkManager&& aSrc)                 = delete;
   NetworkManager& operator=(NetworkManager&& aSrc) = delete;


   bool Initialize() override;
   bool PlatformsInitialized() override;
   void PendingStart() override;



   const Address* GetAddress(Comm* aCommPtr) const;

   Comm* GetComm(const Address& aAddress) const;

   Network* GetNetwork(const std::string& aNetworkName) const;

   bool IsCommManaged(Comm* aCommPtr) const;

   bool IsAddressManaged(const Address& aAddress) const;

   bool IsNetworkManaged(const std::string& aNetworkName) const;

   std::vector<std::string> GetManagedNetworks() const;

   const Address* GetManagingNetworkAddress(const Address& aAddress) const;

   bool IsNetworkAddressManaged(const Address& aAddress) const;

   std::string GetNetworkNameFromAddress(const Address& aAddress) const;

   AddressSet GetAddressesInNetwork(const std::string& aNetworkName) const;

   AddressSet GetComms() const;

   graph::Graph& GetGraph();

   bool PathExists(const Address& aSourceAddress, const Address& aDestinationAddress) const;

   bool HasMulticastMember(const Address& aMulticastAddress, const std::string& aNetworkName) const;

   AddressSet GetMulticastMembers(const Address& aMulticastAddress, const std::string& aNetworkName) const;

   AddressSet GetMulticastMembers(const Address& aMulticastAddress) const;

   bool IsMulticastManaged(const Address& aMulticastAddress) const;

   void AddManagedComm(Comm* aCommPtr) { mComms.push_back(aCommPtr); }

   void AddManagedRouter(router::Router* aRouterPtr) { mRouters.push_back(aRouterPtr); }


   Address AddComm(double aSimTime, Comm* aCommPtr, std::string& aNetworkName, bool aNotifyObserver = true);
 
   std::string AddComm(double aSimTime, Comm* aCommPtr, const Address& aAddress, bool aNotifyObserver = true);


   void RemoveComm(double aSimTIme, Comm* aCommPtr, bool aNotifyObserver = true);
   void RemoveComm(double aSimTime, const Address& aAddress, bool aNotifyObserver = true);


   bool AddNetwork(double aSimTime, std::unique_ptr<Network> aNetwork, bool aSuppressReservedCheck = false);

   void RemoveNetwork(double aSimTime, const std::string& aNetworkName);


   bool EnableComm(double aSimTime, Comm* aCommPtr);
   bool EnableComm(double aSimTime, const Address& aAddress);


   bool DisableComm(double aSimTime, Comm* aCommPtr);
   bool DisableComm(double aSimTime, const Address& aAddress);


   bool AddConnection(double aSimTime, Comm* aSourceCommPtr, Comm* aDestinationCommPtr, bool aNotifyObserver = true);
   bool AddConnection(double         aSimTime,
                      const Address& aSourceAddress,
                      const Address& aDestinationAddress,
                      bool           aNotifyObserver = true);


   bool RemoveConnection(double aSimTime, Comm* aSourceCommPtr, Comm* aDestinationCommPtr, bool aNotifyObserver = true);
   bool RemoveConnection(double         aSimTime,
                         const Address& aSourceAddress,
                         const Address& aDestinationAddress,
                         bool           aNotifyObserver = true);


   bool EnableConnection(double aSimTime, Comm* aSourceCommPtr, Comm* aDestinationCommPtr, bool aNotifyObserver = true);
   bool EnableConnection(double         aSimTime,
                         const Address& aSourceAddress,
                         const Address& aDestinationAddress,
                         bool           aNotifyObserver = true);


   bool DisableConnection(double aSimTime, Comm* aSourceCommPtr, Comm* aDestinaationCommPtr, bool aNotifyObserver = true);
   bool DisableConnection(double         aSimTime,
                          const Address& aSourceAddress,
                          const Address& aDestinationAddress,
                          bool           aNotifyObserver = true);
 
   bool AddMulticastMember(double aSimTime, const Address& aMulticastAddress, const Address& aJoiningMember);
 
   bool RemoveMulticastMember(double aSimTime, const Address& aMulticastAddress, const Address& aLeavingMember);

   bool RemoveNetworkConnections(double aSimTime, const std::string& aNetworkName, bool aNotifyObserver = true);

   void ManageComm(double             aSimTime,
                   Comm*              aCommPtr,
                   const std::string& aNetworkName,
                   const Address&     aAddress,
                   const Address&     aNetworkAddress);

   void InitializeUserLinks(double aSimTime, Comm* aCommPtr);

   void Clear();

   WsfSimulation* GetSimulation() const { return mSimulationPtr; }


   void PlatformDeleted(double aSimTime, WsfPlatform* aPlatform);
   void PlatformInitialized(double aSimTime, WsfPlatform* aPlatform);

   const ReservedAddressing& GetReservedAddresses() const { return mReservedAddresses; }


   UtCallbackListN<void(double, Comm*)>                          CommAdded{};
   UtCallbackListN<void(double, Comm*)>                          CommRemoved{};
   UtCallbackListN<void(double, Network*)>                       NetworkAdded{};
   UtCallbackListN<void(double, Network*)>                       NetworkRemoved{};
   UtCallbackListN<void(double, Comm*)>                          CommEnabled{};
   UtCallbackListN<void(double, Comm*)>                          CommDisabled{};
   UtCallbackListN<void(double, const Address&, const Address&)> ConnectionAdded{};
   UtCallbackListN<void(double, const Address&, const Address&)> ConnectionRemoved{};
   UtCallbackListN<void(double, const Address&, const Address&)> ConnectionEnabled{};
   UtCallbackListN<void(double, const Address&, const Address&)> ConnectionDisabled{};

   UtCallbackListN<void()> CommFrameworkPendingStart{};

   UtCallbackListN<void(double, WsfPlatform*)> CommFrameworkPlatformInitialized{};

   UtCallbackListN<void(double, WsfPlatform*)> CommFrameworkPlatformDeleted{};
 
private:
   WsfSimulation* mSimulationPtr;

   CommMap    mAddressToCommMap;
   AddressMap mCommToAddressMap;

   AddressNetworkMap mAddressToNetworkMap;

   NetworkMap mNetworkMap;

   NetworkSet mNetworkAddressSet;

   graph::Graph mGraph;

   UtCallbackHolder mCallbacks;

   ReservedAddressing mReservedAddresses;

   MultiAddressMap mMulticastMap;

   CommVector mComms;

   RouterVector mRouters;
};
 
class NetworkManagerExtension : public WsfScenarioExtension
{
public:
   void SimulationCreated(WsfSimulation& aSimulation) override
   {
      aSimulation.RegisterExtension(GetExtensionName(), ut::make_unique<NetworkManager>(&aSimulation));
   }
};
 
} // namespace comm
} // namespace wsf
 
#endif