WsfCommProtocolStack.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 WSFCOMMPROTOCOLSTACK_HPP
#define WSFCOMMPROTOCOLSTACK_HPP
 
#include "wsf_export.h"
 
#include <memory>
#include <vector>
 
#include "WsfCommLayer.hpp"
#include "WsfCommLayerMessage.hpp"
#include "WsfStringId.hpp"
 
class UtInput;
class WsfPlatform;
 
namespace wsf
{
namespace comm
{
 
class Comm;
class Message;

class WSF_EXPORT ProtocolStack
{
public:
   using LayerType = Layer::LayerType;
 
   using ProtocolVector    = std::vector<std::unique_ptr<Layer>>;
   using RawProtocolVector = std::vector<Layer*>;

   ProtocolStack() = default;
   ProtocolStack(const ProtocolStack& aSrc);
   ProtocolStack& operator=(const ProtocolStack& aRhs) = delete;
   virtual ~ProtocolStack()                            = default;

   Layer* AddLayer(std::unique_ptr<Layer> aLayerPtr);

   bool RemoveLayer(size_t aLayerIndex);

   bool RemoveLayerByID(size_t aLayerID);

   std::unique_ptr<Layer> ReplaceLayer(size_t aLayerIndex, std::unique_ptr<Layer> aLayerPtr);

   Layer* InsertLayer(size_t aLayerIndex, std::unique_ptr<Layer> aLayerPtr);



   Layer*            GetLayer(size_t aLayerIndex) const;
   Layer*            GetLayer(LayerType aLayerType) const;
   RawProtocolVector GetLayers(LayerType aLayerType) const;

   template<typename T>
   T* GetLayer() const
   {
      for (const auto& layer : mProtocolStack)
      {
         auto layerTypePtr = dynamic_cast<T*>(layer->GetCommLayerImp());
         if (layerTypePtr)
         {
            return layerTypePtr;
         }
      }
      return nullptr;
   }

   template<typename T>
   std::vector<T*> GetLayers() const
   {
      std::vector<T*> layers;
      for (const auto& layer : mProtocolStack)
      {
         auto layerTypePtr = dynamic_cast<T*>(layer->GetCommLayerImp());
         if (layerTypePtr)
         {
            layers.push_back(layerTypePtr);
         }
      }
      return layers;
   }
 
   Layer* GetLayerByID(size_t aLayerID) const;
 

   size_t Size() const { return mProtocolStack.size(); }

   void ClearLayers() { mProtocolStack.clear(); }


   virtual bool Initialize(double aSimTime);
   virtual bool Initialize2(double aSimTime);
   virtual bool ProcessInput(UtInput& aInput);
 
   void  SetParent(Comm* aParentCommPtr);
   Comm* GetParent() const { return mParent; }
   void  SetDebugEnabled(bool aDebugEnabled);


   virtual bool Receive(double aSimTime, Comm* aXmtrPtr, Message& aMessage);
   virtual bool Send(double aSimTime, Message& aMessage);


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


   ProtocolVector::iterator       FindLayerByID(size_t aID);
   ProtocolVector::const_iterator FindLayerByID(size_t aID) const;

   ProtocolVector mProtocolStack{};

   Comm* mParent{nullptr};
};
 
} // namespace comm
} // namespace wsf
 
#endif