WsfCommMessage.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 WSFCOMMMESSAGE_HPP
#define WSFCOMMMESSAGE_HPP
 
#include "wsf_export.h"
 
#include <memory>
#include <vector>
 
#include "UtCloneablePtr.hpp"
#include "UtScriptClassDefine.hpp"
#include "WsfAuxDataEnabled.hpp"
#include "WsfCommAddress.hpp"
#include "WsfCommResult.hpp"
#include "WsfMessage.hpp"
#include "script/WsfScriptAuxDataUtil.hpp"
 
namespace wsf
{
namespace comm
{

class WSF_EXPORT MessageHeader
{
public:
   virtual ~MessageHeader()             = default;
   virtual MessageHeader* Clone() const = 0;
};

class WSF_EXPORT MessageTrailer
{
public:
   virtual ~MessageTrailer()             = default;
   virtual MessageTrailer* Clone() const = 0;
};

class WSF_EXPORT Message : public UtScriptAccessible, public WsfAuxDataEnabled
{
public:
   Message(std::unique_ptr<WsfMessage> aMessagePtr);
   WSF_DEPRECATED Message(const WsfMessage& aMessage);
   virtual ~Message();
   Message(const Message& aSrc);
   Message(Message&&)  = default;
   Message&    operator=(const Message& aRhs);
   Message&    operator=(Message&&) = default;
   const char* GetScriptClassName() const override { return "WsfCommMessage"; }
 
   virtual Message* Clone() const;
 
   ut::CloneablePtr<WsfMessage>&       SourceMessage() { return mSrcMessagePtr; }
   const ut::CloneablePtr<WsfMessage>& SourceMessage() const { return mSrcMessagePtr; }
   virtual void                        SetSourceMessage(std::unique_ptr<WsfMessage> aMessagePtr);
 
   MessageHeader* PopHeader();
   void           PushHeader(MessageHeader* aHeader);
 
   MessageTrailer* PopTrailer();
   void            PushTrailer(MessageTrailer* aTrailer);
 
   std::vector<Address>&       GetTraceRoute() { return mTraceRoute; }
   const std::vector<Address>& GetTraceRoute() const { return mTraceRoute; }

   unsigned int& GetTransportFeatures() { return mTransportFeature; }
 
   size_t       GetTTL() const { return mTTL; }
   virtual void SetTTL(size_t aTTL) { mTTL = aTTL; }
 
   Result& GetResult() { return mCommResult; }

   class Identifier
   {
   public:
      Identifier() = default;
      Identifier(const Message& aMessage);
      Identifier(const WsfMessage& aMessage); // No source address via WsfMessage - use SetSource()
      virtual ~Identifier() = default;
 
      void           SetSerialNumber(unsigned int aSerialNumber) { mSerialNumber = aSerialNumber; }
      void           SetSource(const Address& aAddress) { mSource = aAddress; }
      void           SetDestination(const Address& aAddress) { mDestination = aAddress; }
      unsigned int   GetSerialNumber() const { return mSerialNumber; }
      const Address& GetSource() const { return mSource; }
      const Address& GetDestination() const { return mDestination; }
 
      bool operator==(const Identifier& aRhs) const;
      bool operator!=(const Identifier& aRhs) const;
 
   private:
      unsigned int mSerialNumber{};
      Address      mSource{};
      Address      mDestination{};
   };
 
private:
   ut::CloneablePtr<WsfMessage> mSrcMessagePtr; 
 
   // size of sent message - headers + message + trailers
   // ability to split up source message into multiple packets but still reference the same source message
 
   std::vector<MessageHeader*>  mHeaders;
   std::vector<MessageTrailer*> mTrailers;

   std::vector<wsf::comm::Address> mTraceRoute;

   unsigned int mTransportFeature;

   size_t mTTL;

   Result mCommResult;
};
 
class WSF_EXPORT ScriptMessageClass : public UtScriptClass
{
public:
   ScriptMessageClass(const std::string& aClassName, UtScriptTypes* aTypesPtr);
 
   UT_DECLARE_SCRIPT_METHOD(GetTraceRoute);
   UT_DECLARE_SCRIPT_METHOD(GetTTL);
   UT_DECLARE_SCRIPT_METHOD(GetSourceMessage);
 
   UT_DECLARE_AUX_DATA_SCRIPT_METHODS();
};
 
} // namespace comm
} // namespace wsf

namespace std
{
template<>
struct hash<wsf::comm::Message::Identifier>
{
   size_t operator()(const wsf::comm::Message::Identifier& aId) const
   {
      return (aId.GetSerialNumber() * hash<wsf::comm::Address>{}(aId.GetDestination())) ^
             hash<wsf::comm::Address>{}(aId.GetSource());
   }
};
 
} // namespace std
#endif