hlaMessageState.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2016 VT MAK
** All rights reserved.
******************************************************************************/


#pragma once

#if DtHLA

#include <lgrSim/lgrSim.h>
#include <lgrCore/messageState.h>
#include <lgrSim/lgrHlaAttribute.h>
#include <lgrUtil/virtualConstructor.h>
#include <lgrUtil/memoryBuffer.h>

#include <vl/rtiNamespace.h>
#include <list>
#include <string>
#include <set>

class DtHlaObject;

namespace MAKLogger
{
   class DtBaseFomDesc;
   class DtLgrHlaSimulationManager;

   class DT_DLL_LGRSIM DtLgrHlaMessageState : public DtMessageState
   {

   public:

      DT_VIRTUAL_CTR_DEFAULTS( DtLgrHlaMessageState,
         (const DtLgrHlaSimulationManager* simMgr),
         (const DtLgrHlaSimulationManager* simMgr=0) )

      virtual ~DtLgrHlaMessageState();

      virtual void setInputInfo(const DtMessageIOInfo* info);
      virtual void setOutputInfo(const DtMessageIOInfo* info);

      virtual void modifyMessages(DtMessageBuffer& messages) const;

      virtual void modifyMessage(DtPacket& packet) const;

      virtual void decodeInitialState(const DtPacket& packet,DtMessageBuffer& buffer);

      virtual void decodeCheckpoint(const DtPacket& packet, DtMessageBuffer& buffer,
         bool includeInteractions);

      virtual void decodeLinkedCheckpoint(const DtPacket& packet, DtMessageBuffer& messageBuffer,
         bool includeInteractions);

      virtual bool isUpdateMessage(const DtPacket& packet) const;

      virtual bool isRemovalMessage(const DtPacket& packet) const;

      virtual bool isInteractionMessage(const DtPacket& packet) const;

      virtual void createUpdate(const DtStateObject& object, const DtAbsoluteTime* time,
                                std::list<DtPacket*>& packetlist) const;

      virtual DtPacket* createRemoval(const DtStateObject& object,
                                      const DtAbsoluteTime& time) const;

      virtual void setInputFom(const DtBaseFomDesc* inputFom);
      virtual void setOutputFom(const DtBaseFomDesc* outputFom);

      virtual DtStateObject* findObject(const DtHlaObject* object);

      inline const DtBaseFomDesc* inputFom() const  {return myInputFom;}
      inline const DtBaseFomDesc* outputFom() const {return myOutputFom;}

      virtual DtLgrHlaHandle mapObjectHandleInputToOutput(DtLgrHlaHandle handle) const;

      virtual DtLgrHlaHandle mapObjectHandleOutputToInput(DtLgrHlaHandle handle) const;

      virtual DtLgrHlaHandle mapInteractionHandleInputToOutput(DtLgrHlaHandle handle) const;

   protected:

      DtLgrHlaMessageState(const DtLgrHlaMessageState&);

      DtLgrHlaMessageState& operator=(const DtLgrHlaMessageState&);

      virtual size_t decodeState(const char* checkpointBuffer, size_t bufferSize,
         const DtAbsoluteTime& stateTime, DtMessageBuffer& messageBuffer, bool includeInteractions);

      virtual DtPacket* createInitialStatePacket(const DtMessageBuffer& initialStateBuffer,
         const DtAbsoluteTime& timestamp, double offsetTime);

      virtual DtPacket* createCheckpointPacket(const DtMessageBuffer& checkpointBuffer,
         const DtAbsoluteTime& timestamp);

      virtual void fillWithStateData(const DtMessageBuffer& stateBuffer, char* data);

      virtual void printMappingFailure(const std::string& classname, const std::string& message) const;

      virtual void activateState();
      virtual void deactivateState();

      virtual bool mapMessageHandles(DtPacket* packet) const;

   protected:

      const DtBaseFomDesc* myInputFom;
      const DtBaseFomDesc* myOutputFom;

      typedef std::map<DtLgrHlaHandle,DtLgrHlaHandle> HandleMap;

      mutable HandleMap myObjectHandleMap;
      mutable HandleMap myReverseObjectHandleMap;
      mutable HandleMap myInteractionHandleMap;

      mutable std::set<std::string> myMutablePrintedMappingFailures;
   };

}

#endif