WsfCommNetwork.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 WSFCOMMNETWORK_HPP
#define WSFCOMMNETWORK_HPP
 
#include <string>
#include <unordered_map>
 
class UtInput;
#include "UtScriptClassDefine.hpp"
#include "WsfCommAddress.hpp"
#include "WsfObject.hpp"
class WsfSimulation;
#include "wsf_export.h"

 
namespace wsf
{
namespace comm
{

class WSF_EXPORT Network : public WsfObject
{
public:
   struct NamedComm
   {
      WsfStringId mPlatformName{};
      WsfStringId mCommName{};
 
      NamedComm() = default;
      NamedComm(WsfStringId aPlatformName, WsfStringId aCommName)
         : mPlatformName(aPlatformName)
         , mCommName(aCommName){};
 
      bool operator==(const NamedComm& aComm) const
      {
         return ((mPlatformName == aComm.mPlatformName) && (mCommName == aComm.mCommName));
      }
 
      bool operator!=(const NamedComm& aComm) const { return !(*this == aComm); }
   };
 
   using AddressList     = std::vector<Address>;
   using AddressLinkList = std::vector<std::pair<Address, Address>>;
   using NamedList       = std::vector<NamedComm>;
   using NamedLinkList   = std::vector<std::pair<NamedComm, NamedComm>>;

   Network()           = default;
   ~Network() override = default;
   Network(const std::string& aNetworkName, const Address& aAddress);
 
   Network(const Network& aSrc) = default;
   Network& operator=(const Network& aRhs) = default;
   Network(Network&& aSrc)                 = default;

   bool InitializeLinkage(WsfSimulation& aSimulation);
 
   bool         ProcessInput(UtInput& aInput) override { return false; }
   Network*     Clone() const override { return nullptr; }
   const char*  GetScriptClassName() const override;
   virtual bool Initialize(WsfSimulation& aSim) { return true; }


   bool AddMember(const Address& aAddress, WsfSimulation& aSimulation, const Address& aOptionalAddress = Address());
   bool RemoveMember(const Address& aAddress, WsfSimulation& aSimulation, const Address& aOptionalAddress = Address());
   bool AddLink(const Address& aSourceAddress,
                const Address& aDestinationAddress,
                WsfSimulation& aSimulation,
                const Address& aOptionalAddress = Address());
   bool RemoveLink(const Address& aSourceAddress,
                   const Address& aDestinationAddress,
                   WsfSimulation& aSimulation,
                   const Address& aOptionalAddress = Address());

 
   void SetAddress(const Address& aAddress) { mAddress = aAddress; }
   void SetIsManaged(bool aManaged) { mManaged = aManaged; }
 
   const Address& GetAddress() const { return mAddress; }
   size_t         GetHostsMax() const { return mAddress.GetNumHostAddresses(); }
   bool           IsManaged() const { return mManaged; }

   static Address GetAddressFromNamedComm(WsfStringId aPlatformName, WsfStringId aCommName, WsfSimulation& aSimulation);

   const NamedList& GetNamedMemberList() const { return mNamedList; }

   bool HasMember(const Address& aAddress) const;
 
protected:
   virtual bool InitializeLinkageP(WsfSimulation& aSimulation) { return true; }


   virtual bool ProcessAddressListInput(UtInput& aInput);
   virtual bool ProcessAddressLinkListInput(UtInput& aInput);
   virtual bool ProcessNamedListInput(UtInput& aInput);
   virtual bool ProcessNamedLinkListInput(UtInput& aInput);


   virtual bool AddMemberP(const Address& aAddress, WsfSimulation& aSimulation, const Address& aOptionalAddress = Address())
   {
      return true;
   }
   virtual bool RemoveMemberP(const Address& aAddress,
                              WsfSimulation& aSimulation,
                              const Address& aOptionalAddress = Address())
   {
      return true;
   }
   virtual bool AddLinkP(const Address& aSourceAddress,
                         const Address& aDestinationAddress,
                         WsfSimulation& aSimulation,
                         const Address& aOptionalAddress = Address())
   {
      return true;
   }
   virtual bool RemoveLinkP(const Address& aSourceAddress,
                            const Address& aDestinationAddress,
                            WsfSimulation& aSimulation,
                            const Address& aOptionalAddress = Address())
   {
      return true;
   }

 
   Address     mAddress{};
   AddressList mAddressList{};

   AddressList     mInputAddressList{};
   AddressLinkList mAddressLinkList{};

   AddressLinkList mInputAddressLinkList{};

   NamedList     mNamedList{};
   NamedLinkList mNamedLinkList{};

   bool mManaged{false};
};

class WSF_EXPORT ScriptNetworkClass : public UtScriptClass
{
public:
   ScriptNetworkClass(const std::string& aClassName, UtScriptTypes* aTypesPtr);
 
   std::string ToString(void* aObjectPtr) const override;
 
   UT_DECLARE_SCRIPT_METHOD(GetAddress);
   UT_DECLARE_SCRIPT_METHOD(GetName);
   UT_DECLARE_SCRIPT_METHOD(SetName);
   UT_DECLARE_SCRIPT_METHOD(SetAddress);
 
   UT_DECLARE_SCRIPT_METHOD(AddMember_1);
   UT_DECLARE_SCRIPT_METHOD(AddMember_2);
   UT_DECLARE_SCRIPT_METHOD(RemoveMember_1);
   UT_DECLARE_SCRIPT_METHOD(RemoveMember_2);
   UT_DECLARE_SCRIPT_METHOD(AddLink_1);
   UT_DECLARE_SCRIPT_METHOD(AddLink_2);
   UT_DECLARE_SCRIPT_METHOD(RemoveLink_1);
   UT_DECLARE_SCRIPT_METHOD(RemoveLink_2);
   UT_DECLARE_SCRIPT_METHOD(GetMembers);
 
   UT_DECLARE_SCRIPT_METHOD(AddNetwork);
   UT_DECLARE_SCRIPT_METHOD(RemoveNetwork);
   UT_DECLARE_SCRIPT_METHOD(GetNetwork_1);
   UT_DECLARE_SCRIPT_METHOD(GetNetwork_2);
   UT_DECLARE_SCRIPT_METHOD(GetManagedNetworks);
 
protected:
   template<typename T>
   static void DestroyHelper(void* aNetworkPtr)
   {
      static_assert(std::is_base_of<wsf::comm::Network, T>::value, "Template type must derive from wsf::comm::Network");
      auto network = static_cast<T*>(aNetworkPtr);
      if (!network->IsManaged())
      {
         delete network;
      }
   }
};
 
} // namespace comm
} // namespace wsf
 
UT_MAP_CLASS_TO_SCRIPT_NAME(wsf::comm::Network, "WsfNetwork")
 

namespace std
{
template<>
struct hash<wsf::comm::Network::NamedComm>
{
   size_t operator()(const wsf::comm::Network::NamedComm& aComm) const
   {
      return std::hash<WsfStringId>{}(aComm.mPlatformName) * 3 ^ std::hash<WsfStringId>{}(aComm.mCommName);
   }
};
} // namespace std
 
#endif