WsfComm.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2016 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 WSFCOMM_HPP
#define WSFCOMM_HPP
 
#include "wsf_export.h"
 
class UtInput;
#include "WsfArticulatedPart.hpp"
#include "WsfCommAddress.hpp"
#include "WsfCommComponent.hpp"
#include "WsfCommLayerMessage.hpp"
#include "WsfCommMediumContainer.hpp"
#include "WsfCommProtocolStack.hpp"
#include "WsfComponentList.hpp"
#include "WsfStringId.hpp"
 
namespace wsf
{
namespace comm
{
 
class Message;
class ProtocolInterface;
 
namespace router
{
class Router;
}

class WSF_EXPORT Comm : public WsfArticulatedPart
{
   friend class Event;
 
public:
   using LinkAddress = std::vector<wsf::comm::Address>;
   using LinkPair    = std::vector<std::pair<std::string, std::string>>;
 
   enum CommType
   {
      cCT_XMT_ONLY = 0x0001,                     
      cCT_RCV_ONLY = 0x0002,                     
      cCT_XMT_RCV  = cCT_XMT_ONLY | cCT_RCV_ONLY 
   };

   enum class MulticastConformanceLevel : size_t
   {
      cLEVEL_0, // no support for multicasting
      cLEVEL_1, // only supports sending of multicast, receive disabled
      cLEVEL_2  // full multicast support
   };

   struct Gateway
   {
      Address     mAddress;
      std::string mPlatformName;
      std::string mCommName;
   };
 
   Comm(const WsfScenario& aScenario, CommType aCommType = cCT_XMT_RCV);
   ~Comm() override = default;
   Comm& operator=(const Comm& aRhs) = delete;


   using ComponentList = WsfComponentListT<WsfComponentT<Comm>>;
   ComponentList&       GetComponents() { return mComponents; }
   const ComponentList& GetComponents() const { return mComponents; }


   WsfComponent* CloneComponent() const override { return Clone(); }
   const int*    GetComponentRoles() const override;
   void*         QueryInterface(int aRole) override;
   int           GetComponentInitializationOrder() const override { return cWSF_INITIALIZE_ORDER_COMM; }


   const char*  GetScriptClassName() const override;
   Comm*        Clone() const override;
   bool         PreInitialize(double aSimTime) override;
   bool         Initialize(double aSimTime) override;
   bool         Initialize2(double aSimTime) override;
   void         PreInput() override;
   bool         ProcessInput(UtInput& aInput) override;
   void         Update(double aSimTime) override;
   virtual void Setup();
   virtual void PendingStart();


   void PartBroken(double aSimTime) override;
   void SetNonOperational(double aSimTime) override;
   void SetOperational(double aSimTime) override;
   void TurnOff(double aSimTime) override;
   void TurnOn(double aSimTime) override;


   virtual void AddLinkAddress(const Address& aAddress) { mLinkAddresses.push_back(aAddress); }
   virtual void AddLink(const std::string& aPlatformName, const std::string& aCommName)
   {
      mLinks.emplace_back(aPlatformName, aCommName);
   }



   const Address&     GetGateway() const { return mGateway.mAddress; }
   const std::string& GetGatewayRemotePlatform() const { return mGateway.mPlatformName; }
   const std::string& GetGatewayRemoteComm() const { return mGateway.mCommName; }
   void               SetGateway(const Address& aAddress);

   virtual bool CanSendTo(double aSimTime, Comm* aRcvrPtr, Message* aMessagePtr = nullptr);


   virtual bool Receive(double aSimTime, Comm* aXmtrPtr, Message& aMessage);
   virtual bool Send(double aSimTime, std::unique_ptr<WsfMessage> aMessagePtr, const Address& aAddress);
   WSF_DEPRECATED
   virtual bool Send(double aSimTime, const WsfMessage& aMessage, const Address& aAddress) final;


   virtual bool ProcessLayerMessage(double aSimTime, size_t aLayerIndex, layer::Message aLayerMessage, Message* aCommMessagePtr);

   CommType GetCommType() const { return mCommTrueType; }

   WsfStringId GetClassId() const { return mClassId; }

   const Address& GetAddress() const { return mAddress; }

   const Address& GetInputAddress() const { return mInputAddress; }

   const std::string& GetNetwork() const { return mNetwork; }

   size_t GetNumChannels() const { return mNumChannels; }

   const std::string& GetInputNetwork() const { return mInputNetwork; }

   const Address& GetInputNetworkAddress() const { return mInputNetworkAddress; }

   const LinkAddress& GetLinkAddresses() const { return mLinkAddresses; }

   const LinkPair& GetLinkPairs() const { return mLinks; }

   void SetAddress(const Address& aAddress) { mAddress = aAddress; }
   void SetNetwork(const std::string& aNetwork) { mNetwork = aNetwork; }

   virtual std::string GetFullName() const;

   virtual bool CanReceive() const { return mReceiveEnabled; }
   virtual bool CanSend() const { return mTransmitEnabled; }

   void SetReceiveEnabled(bool aIsEnabled) { mReceiveEnabled = aIsEnabled; }
   void SetTransmitEnabled(bool aIsEnabled) { mTransmitEnabled = aIsEnabled; }


   router::Router*    GetRouter() const { return mRouterPtr; }
   void               SetRouter(router::Router* aRouterPtr);
   const std::string& GetRouterName() const { return mRouterName; }
   void               SetRouterName(const std::string& aRouterName) { mRouterName = aRouterName; }

   std::vector<ProtocolInterface*> GetSortedProtocols() const;


   MulticastConformanceLevel GetMulticastLevel() const { return mMulticastLevel; }

   virtual void SetMulticastLevel();


   ProtocolStack&       GetProtocolStack() { return mProtocolStack; }
   const ProtocolStack& GetProtocolStack() const { return mProtocolStack; }

 


   virtual bool SendSetup(double aSimTime, Message& aMessage, const Address& aAddress);
 
   virtual bool ReceiveSetup(double aSimTime, Comm* aXmtrPtr, Message& aMessage);


   virtual bool SendActions(double aSimTime, bool aSendStatus, Message& aMessage);
 
   virtual bool ReceiveActions(double aSimTime, bool aReceiveStatus, Comm* aXmtrPtr, Message& aMessage);
 
protected:
   virtual void PrintDebugReception(double aSimTime, const Message& aMessage) const;
 
   // Copy constructor
   Comm(const Comm& aSrc);
 
   // Comm by default has no update interval
   // Override these methods to get regular Update() calls
   void   SetUpdateInterval(double aInterval) override {}
   double GetUpdateInterval() const override { return 0.0; }

   void SetClassId(WsfStringId aClassId) { mClassId = aClassId; }

   virtual bool ValidateGateway();

   ProtocolStack mProtocolStack;



   Address mInputAddress;

   std::string mInputNetwork;

   Address mInputNetworkAddress;

   size_t mNumChannels;
 
 
private:
   CommType mCommTrueType;
 
   // Comm device's current ability to transmit or receive.
   // Initialized to the truth type but can be changed later
   // to reflect the current state of the device.
   bool mReceiveEnabled;  // 'true' if receive enabled
   bool mTransmitEnabled; // 'true' if transmit enabled

   ComponentList mComponents;



   Address mAddress;

   std::string mNetwork;
 
   WsfStringId mClassId; 



   LinkAddress mLinkAddresses;

   LinkPair mLinks;



   std::string mRouterName;

   router::Router* mRouterPtr;

   Gateway mGateway;

   MulticastConformanceLevel mMulticastLevel;
};
 
} // namespace comm
} // namespace wsf
 
UT_MAP_CLASS_TO_SCRIPT_NAME(wsf::comm::Comm, "WsfComm")
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(wsf::comm::Comm, cWSF_COMPONENT_COMM)
WSF_DECLARE_COMPONENT_ROLE_TYPE(wsf::comm::medium::ContainerComponent<wsf::comm::Comm>,
                                cWSF_COMPONENT_COMM_MEDIUM_CONTAINER_COMM);
 
#endif