WsfMessage.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing 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.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company
// ****************************************************************************
 
#ifndef WSFMESSAGE_HPP
#define WSFMESSAGE_HPP
 
#include "wsf_export.h"
 
#include <iosfwd>
#include <vector>
 
#include "UtReferenceTracked.hpp"
#include "UtScriptAccessible.hpp"
#include "WsfAuxDataEnabled.hpp"
#include "WsfCommAddress.hpp"
class WsfPlatform;
class WsfSimulation;
#include "WsfStringId.hpp"

class WSF_EXPORT WsfMessage : public UtScriptAccessible, public UtReferenceTracked, public WsfAuxDataEnabled
{
public:
   // Although this isn't guaranteed, it's fixed for simulation purposes.
   static constexpr size_t cBITS_IN_BYTE = 8U;
 
   WsfMessage(WsfStringId aType); // For XIO Serialization
 
   WsfMessage(WsfStringId aType, const wsf::comm::Address& aSrcAddr, WsfSimulation& aSimulation);
   WsfMessage(WsfPlatform* aPlatformPtr);
   WsfMessage(WsfStringId aType, WsfPlatform* aPlatformPtr);
   WsfMessage(WsfStringId aType, WsfStringId aSubType, WsfPlatform* aPlatformPtr);
   WsfMessage(WsfSimulation& aSimulation);
   WsfMessage& operator=(const WsfMessage& aRhs) = default;
   ~WsfMessage() override;
 
   virtual WsfMessage* Clone() const;
 
   const char* GetScriptClassName() const override;
 
   static WsfStringId GetTypeId();

   WsfSimulation* GetSimulation() const { return mSimulationPtr; }

   void SetSimulation(WsfSimulation* aSimulationPtr) { mSimulationPtr = aSimulationPtr; }

   WsfStringId GetOriginator() const { return mOriginator; }

   void SetOriginator(WsfPlatform* aPlatformPtr);

   size_t GetOriginatorIndex() const { return mOriginatorIndex; }

   int GetSizeBits() const { return mSizeBits; }

   void SetSizeBits(int aSizeBits) { mSizeBits = aSizeBits; }

   int GetSizeBytes() const { return (mSizeBits / cBITS_IN_BYTE); }

   void SetSizeBytes(int aSizeBytes) { mSizeBits = aSizeBytes * cBITS_IN_BYTE; }

   unsigned int GetSerialNumber() const { return mSerialNumber; }

   void SetSerialNumber(unsigned int aSerialNumber) { mSerialNumber = aSerialNumber; }

   double GetDataTag() const { return mDataTag; }

   void SetDataTag(double aDataTag) { mDataTag = aDataTag; }

   WsfStringId GetStaticType() const { return mStaticType; }

   WsfStringId GetType() const { return mType; }

   void SetType(WsfStringId aType) { mType = aType; }

   WsfStringId GetSubType() const { return mSubType; }

   void SetSubType(WsfStringId aSubType) { mSubType = aSubType; }

   int GetPriority() const { return mPriority; }

   void SetPriority(int aPriority) { mPriority = aPriority; }

   const wsf::comm::Address& GetSrcAddr() const { return mSrcAddr; }

   /*void SetSrcAddr(const WsfCommAddress& aSrcAddr);*/
   void SetSrcAddr(const wsf::comm::Address& aSrcAddr);

   const wsf::comm::Address& GetDstAddr() const { return mDstAddr; }

   void SetDstAddr(const wsf::comm::Address& aDstAddr) { mDstAddr = aDstAddr; }

   const wsf::comm::Address& GetNextHopAddr() const { return mNextHopAddr; }

   /*void SetNextHopAddr(const WsfCommAddress& aNextHopAddr);*/
   void SetNextHopAddr(const wsf::comm::Address& aNextHopAddr);
 
   virtual bool CanBeReplacedBy(const WsfMessage& aMessage) const;



   virtual WsfStringId GetComponentNameId() const { return WsfStringId(); }
   virtual WsfStringId GetComponentTypeId() const { return WsfStringId(); }
   virtual WsfStringId GetComponentModeId() const { return WsfStringId(); }


   WsfStringId GetGroup() const { return mGroup; }

   void SetGroup(WsfStringId aGroup) const { mGroup = aGroup; }
 
   friend WSF_EXPORT std::ostream& operator<<(std::ostream& aOut, const WsfMessage& aMessage);

   void PrintDataTagPrecise(std::ostream& aStream, std::streamsize aPrecision) const;

   template<typename T>
   void Serialize(T& aBuff)
   {
      aBuff& mStaticType& mType& mSubType& mDataTag& mSerialNumber& mSizeBits& mPriority;
      aBuff& mOriginator&                                                      mOriginatorIndex;
      aBuff& mSrcAddr& mDstAddr&                                               mNextHopAddr;
      aBuff&                                                                   mGroup;
      WsfAuxDataEnabled::Serialize(aBuff);
   }
 
protected:
   WsfMessage(const WsfMessage& aSrc) = default;
 
private:
   WsfSimulation* mSimulationPtr; 
   WsfStringId    mStaticType;    
 
   WsfStringId  mType;         
   WsfStringId  mSubType;      
   double       mDataTag;      
   unsigned int mSerialNumber; 
   int          mSizeBits;     
   int          mPriority;     
 
   WsfStringId mOriginator;      
   size_t      mOriginatorIndex; 
 
   wsf::comm::Address mSrcAddr;     
   wsf::comm::Address mDstAddr;     
   wsf::comm::Address mNextHopAddr; 
 
   // Provided for legacy support of communications - expected removal for AFSIM 3.0.
   mutable WsfStringId mGroup; 
};
 
#endif