WsfCommRouter.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 WSFCOMMROUTER_HPP
#define WSFCOMMROUTER_HPP
 
#include "wsf_export.h"
 
#include <memory>
 
#include "UtCallbackHolder.hpp"
class UtInput;
class UtInputBlock;
#include "WsfCommAddress.hpp"
#include "WsfCommMediumContainer.hpp"
#include "WsfCommMessage.hpp"
#include "WsfCommRouterComponent.hpp"
#include "WsfComponentList.hpp"
#include "WsfEvent.hpp"
#include "WsfPlatformPart.hpp"
class WsfScenario;
class WsfSimulation;
 
namespace wsf
{
namespace comm
{
 
class Comm;
class Network;
class NetworkManager;
 
namespace router
{
 
class ProtocolInterface;

class WSF_EXPORT Router : public WsfPlatformPart
{
public:
   class SendData
   {
   public:
      SendData()          = default;
      virtual ~SendData() = default;
 
      Comm*                 GetXmtr() const { return mXmtrPtr; }
      void                  SetXmtr(Comm* aXmtrPtr) { mXmtrPtr = aXmtrPtr; }
      std::vector<Message>& GetMessages() { return mMessages; }
      bool                  GetAbortProcessing() const { return mAbortProcessing; }
      void                  SetAbortProcessing(bool aAbort) { mAbortProcessing = aAbort; }
 
   private:
      Comm*                mXmtrPtr{nullptr};
      std::vector<Message> mMessages{};
      bool                 mAbortProcessing{false};
   };
 
   struct Gateway;
   using CommVector = std::vector<Comm*>;


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

   bool AddComponent(RouterComponent* aComponentPtr);
   bool RemoveComponent(RouterComponent* aComponentPtr);


   virtual bool Receive(double aSimTime, Comm* aXmtrPtr, Comm* aRcvrPtr, Message& aMessage, bool& aOverrideForward);
 
   virtual bool Send(double aSimTime, SendData& aData);
 
   Router(const WsfScenario& aScenario);
   Router* Clone() const override;
   Router& operator=(const Router& aRhs) = delete;
   Router(Router&& aSrc)                 = delete;
   Router& operator=(Router&& aRhs) = delete;
 
   ~Router() override = default;


   WsfComponent* CloneComponent() const override { return Clone(); }
   void*         QueryInterface(int aRole) override;
   const int*    GetComponentRoles() const override;
   WsfStringId   GetComponentName() const override { return GetNameId(); }
   int           GetComponentInitializationOrder() const override { return cWSF_INITIALIZE_ORDER_ROUTER; }


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


   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;
 
   // Router 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; }


   virtual void      AddInterface(double aSimTime, Comm* aCommPtr);
   void              AddInterface(double aSimTime, const Address& aAddress);
   virtual void      RemoveInterface(double aSimTime, Comm* aCommPtr);
   void              RemoveInterface(double aSimTime, const Address& aAddress);
   bool              HasInterface(Comm* aCommPtr) const;
   bool              HasInterface(const Address& aAddress) const;
   void              ClearInterfaces() { mComms.clear(); }
   const CommVector& GetInterfaces() const { return mComms; }

   bool IsActive() const;

   virtual void InitializeCallbacks();


   virtual bool AddLink(double             aSimTime,
                        const Address&     aSender,
                        const Address&     aDestination,
                        ProtocolInterface& aProtocol,
                        bool               aNotifyObserver = true);
 
   virtual bool RemoveLink(double             aSimTime,
                           const Address&     aSender,
                           const Address&     aDestination,
                           ProtocolInterface& aProtocol,
                           bool               aNotifyObserver = true);
 
   virtual bool AddNode(double aSimTime, const Address& aNodeAddress, ProtocolInterface& aProtocol, bool aNotifyObserver = true);
 
   virtual bool
   RemoveNode(double aSimTime, const Address& aNodeAddress, ProtocolInterface& aProtocol, bool aNotifyObserver = true);
 
   virtual bool EnableLink(double             aSimTime,
                           const Address&     aSender,
                           const Address&     aDestination,
                           ProtocolInterface& aProtocol,
                           bool               aNotifyObserver = true);
 
   virtual bool DisableLink(double             aSimTime,
                            const Address&     aSender,
                            const Address&     aDestination,
                            ProtocolInterface& aProtocol,
                            bool               aNotifyObserver = true);
 
   virtual bool EnableNode(double aSimTime, const Address& aNodeAddress, ProtocolInterface& aProtocol);
 
   virtual bool DisableNode(double aSimTime, const Address& aNodeAddress, ProtocolInterface& aProtocol);

   const Address&  GetGateway() const { return mGateway.mAddress; }
   void            SetGateway(const Address& aAddress);
   size_t          GetHopLimit() const { return mHopLimit; }
   NetworkManager* GetNetworkManager() const { return mNetworkManager; }
 
   void SetHopLimit(size_t aHopLimit) { mHopLimit = aHopLimit; }

   struct Gateway
   {
      Address     mAddress;
      std::string mGatewayCommName;
 
      Gateway()                    = default;
      Gateway(const Gateway& aSrc) = default;
   };

   virtual bool Broadcast(double aSimTime, SendData& aData);

   std::vector<ProtocolInterface*> GetSortedProtocols() const;
 
protected:
   Router(const Router& aSrc);

   virtual bool ValidateGateway();


   virtual bool AutomateAddedLinkage(double aSimTime, Comm* aCommPtr);


   virtual void PerfectCommAdded(double aSimTime, Comm* aCommPtr);
   virtual void PerfectCommRemoved(double aSimTime, Comm* aCommPtr);
   virtual void PerfectNetworkAdded(double aSimTime, Network* aNetworkPtr);
   virtual void PerfectNetworkRemoved(double aSimTime, Network* aNetworkPtr);
   virtual void PerfectCommEnabled(double aSimTime, Comm* aCommPtr);
   virtual void PerfectCommDisabled(double aSimTime, Comm* aCommPtr);
   virtual void PerfectConnectionAdded(double aSimTime, const Address& aSourceAddress, const Address& aDestinationAddress);
   virtual void PerfectConnectionRemoved(double aSimTime, const Address& aSourceAddress, const Address& aDestinationAddress);
   virtual void PerfectConnectionEnabled(double aSimTime, const Address& aSourceAddress, const Address& aDestinationAddress);
   virtual void PerfectConnectionDisabled(double aSimTime, const Address& aSourceAddress, const Address& aDestinationAddress);
 
private:
   NetworkManager* mNetworkManager;

   Gateway mGateway;

   size_t mHopLimit;

   ComponentList mComponents;
 
   const WsfScenario& mScenario;
   UtCallbackHolder   mCallbacks;

   CommVector mComms;

   bool mAutomatedInterfaceLinking;

   bool mUseLegacyProtocol;

   bool mUseMulticastProtocol;

};
 
} // namespace router
} // namespace comm
} // namespace wsf
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(wsf::comm::router::Router, cWSF_COMPONENT_COMM_ROUTER)
WSF_DECLARE_COMPONENT_ROLE_TYPE(wsf::comm::medium::ContainerComponent<wsf::comm::router::Router>,
                                cWSF_COMPONENT_COMM_MEDIUM_CONTAINER_ROUTER);
 
#endif