hlaMessageState.h

Go to the documentation of this file.

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


#ifndef hlaMessageState_H_
#define hlaMessageState_H_

#if DtHLA

#include "lgrSim.h"
#include "messageState.h"
#include "lgrHlaAttribute.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:
      DtLgrHlaMessageState();

      virtual ~DtLgrHlaMessageState();

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

      virtual void modifyMessages(DtMessageBuffer& messages);

      virtual void modifyMessage(DtPacket& packet);

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

      virtual DtPacket* generateCheckpoint(const DtAbsoluteTime& timestamp);

      virtual bool isUpdateMessage(const DtPacket& packet) const;
      virtual bool isRemovalMessage(const DtPacket& packet) const;

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

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

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

      virtual DtStateObject* findObject(DtHlaObject* object);


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

      DtLgrHlaHandle mapObjectHandleInputToOutput(DtLgrHlaHandle handle) const;

      DtLgrHlaHandle mapObjectHandleOutputToInput(DtLgrHlaHandle handle) const;

      DtLgrHlaHandle mapInteractionHandleInputToOutput(DtLgrHlaHandle handle) const;

   protected:

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

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

      DtLgrHlaMessageState(const DtLgrHlaMessageState&);

      DtLgrHlaMessageState& operator=(const DtLgrHlaMessageState&);

      virtual bool mapMessageHandles(DtPacket* packet);

      const DtBaseFomDesc* myInputFom;
      const DtBaseFomDesc* myOutputFom;

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

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

      std::set<std::string> myPrintedMappingFailures;
   };

}

#endif
#endif