messageState.h

Go to the documentation of this file.

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


#pragma once

#include <lgrCore/lgrCore.h>
#include <lgrUtil/observeEvent.h>

#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlNetTypes.h>

#include <list>
#include <map>

namespace MAKLogger
{
   class DtMessageBuffer;
   class DtStateObject;
   class DtPacket;
   class DtMessageIOInfo;
   class DtAbsoluteTime;
   class DtLgrSimManager;

   class DT_DLL_LGRCORE DtMessageState
   {
   public:

      enum CheckpointProcessing
      {
         IgnoreCheckpoints,
         ProcessAllCheckpoints,
         ProcessFirstCheckpoint
      };

      enum InteractionProcessing
      {
         IgnoreInteractions,
         IncludeInteractions,
         DrainInteractions
      };

      // Used to create linked checkpoints
      struct NetCheckpointHeader
      {
         DtNetU64 previousCheckpoint;
         DtNetU64 nextCheckpoint;
         DtNetU64 numCheckpoints;
      };

      // Used to create an initial state
      struct NetInitialStateHeader
      {
         DtNetFloat64 offset;
         DtNetU64 numberCheckpoints;
      };

      typedef std::list<DtPacket*> DtPacketList;

      virtual ~DtMessageState();

      virtual const DtLgrSimManager* simMgr() const;

      virtual void startDiff();

      virtual void generateDiff(DtMessageBuffer& stateBuffer, const DtAbsoluteTime& time,
         bool addUpdates, InteractionProcessing processInteractions);

      virtual void endDiff();

      virtual bool isDiffInProgress() const;

      virtual void updateState(DtMessageBuffer& stateBuffer);


      virtual void updateState(DtPacket* packet);

      virtual void postUpdate();

      virtual void setState(DtMessageBuffer& completeStateBuffer,const DtAbsoluteTime& time, DtMessageBuffer* diffBuffer=0);

      virtual void addState(DtMessageBuffer& stateBuffer, const DtAbsoluteTime& time);

      virtual void clearState(DtMessageBuffer& emptyBuffer,
         const DtAbsoluteTime& time);

      virtual void getState(DtMessageBuffer& emptyBuffer,const DtAbsoluteTime* time, bool modifyMessages=true);

      virtual void getStateObjects(DtMessageBuffer& buffer, const DtAbsoluteTime* time, bool modifyMessages=true);

      virtual void getStateInteractions(DtMessageBuffer& buffer, const DtAbsoluteTime* time, bool modifyMessages=true);

      virtual void activate();

      virtual void deactivate();

      virtual DtStateObject* findObject(DtU64 uniqueId);
      virtual const DtStateObject* findObject(DtU64 uniqueId) const;

      virtual DtStateObject* findObjectByName(const DtString& name);
      virtual const DtStateObject* findObjectByName(const DtString& name) const;

      virtual void setLinkCheckpoints(bool enableLinking);
      virtual bool linkCheckpointsEnabled() const;



      virtual void setInputInfo(const DtMessageIOInfo* info);

      virtual void setOutputInfo(const DtMessageIOInfo* info);

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

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

      virtual void decodeLinkedCheckpoint(const DtPacket& packet,DtMessageBuffer& buffer,
         bool includeInteractions) = 0;

      virtual DtPacket* generateInitialState(const DtAbsoluteTime& timestamp,
         const DtAbsoluteTime& currentTime, bool isTransition);

      virtual DtPacket* generateCheckpoint(const DtAbsoluteTime& timestamp,
         bool includeInteractions);


      virtual const std::list<DtStateObject*>& stateObjectList() const;


      virtual DtObserveEvent<DtMessageState>* inputChangedEvent();
      virtual DtObserveEvent<DtMessageState>* outputChangedEvent();
      virtual DtObserveEvent<DtMessageState>* stateModifiedEvent();
      virtual DtObserveEvent<DtMessageState>* stateActivatedEvent();
      virtual DtObserveEvent<DtMessageState>* stateDeactivatedEvent();
      virtual DtObserveEvent<DtMessageState>* endDiffEvent();
      virtual DtObserveEvent<DtStateObject>* objectAddedEvent();
      virtual DtObserveEvent<DtStateObject>* objectToBeRemovedEvent();
      virtual DtObserveEvent<DtStateObject>* objectUpdatedEvent();

      virtual void clearState();

      virtual CheckpointProcessing processCheckpoints();

      virtual void setProcessCheckpoints(CheckpointProcessing value);

      virtual void setInteractionsCollectedForCheckpoints(bool enable);

      virtual bool interactionsCollectedForCheckpoints() const;

      virtual void setInteractionsCollectedFromCheckpoints(bool enable);

      virtual bool interactionsCollectedFromCheckpoints() const;

      virtual void modifyMessages(DtMessageBuffer& messages) const;

      virtual void modifyMessage(DtPacket& packet) const = 0;

      virtual bool isInitialStateMessage(const DtPacket& packet) const;

      virtual bool isCheckpointMessage(const DtPacket& packet) const;

      virtual bool isUpdateMessage(const DtPacket& packet) const = 0;

      virtual bool isRemovalMessage(const DtPacket& packet) const = 0;

      virtual bool isInteractionMessage(const DtPacket& packet) const = 0;

      virtual void createUpdate(const DtStateObject& object,
         const DtAbsoluteTime* time, DtPacketList& packetlist ) const = 0;

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

   protected:

      typedef std::list<DtStateObject*> DtStateObjectList;

      typedef std::map<DtU64,DtStateObject*> DtStateObjectMap;

      typedef std::map<DtString, DtStateObject*> DtStateObjectNameMap;

      DtMessageState(const DtLgrSimManager* simMgr=0);

      DtMessageState(const DtMessageState&);

      DtMessageState& operator=(const DtMessageState&);

      virtual void activateState() = 0;

      virtual void deactivateState() = 0;

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

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

      virtual bool updateStateObjects(const DtPacket& packet);

      virtual DtStateObject* createStateObject(const DtPacket& packet);

      virtual DtStateObject* updateStateObject(const DtPacket& packet);

      virtual DtStateObject* findStateObject(const DtPacket& packet);

      virtual void removeStateObject(const DtStateObject* object);

      virtual void createUpdate(const DtStateObject& object,const DtAbsoluteTime* time,
         DtMessageBuffer& buffer ) const;

      virtual bool removeStateObject(const DtPacket& packet);

      virtual void clearObjectList(DtStateObjectList& objectList, DtMessageBuffer* emptyStateBuffer,
         DtAbsoluteTime time);

      virtual void clearObjectList(DtStateObjectList& objectList);

      virtual void clearInteractionList(DtPacketList& interactionList);

   protected:

      DtStateObjectList myObjects;

      DtPacketList myInteractions;

      DtStateObjectMap myObjectLookupMap;

      DtStateObjectNameMap myObjectLookupNameMap;

      DtStateObjectList mySnapshotOfObjects;

      const DtLgrSimManager* mySimMgr;

      DtObserveEvent<DtMessageState> myInputChangedEvent;
      DtObserveEvent<DtMessageState> myOutputChangedEvent;
      DtObserveEvent<DtMessageState> myStateModifiedEvent;
      DtObserveEvent<DtMessageState> myStateActivatedEvent;
      DtObserveEvent<DtMessageState> myStateDeactivetedEvent;
      DtObserveEvent<DtMessageState> myEndDiffEvent;
      DtObserveEvent<DtStateObject> myObjectAddedEvent;
      DtObserveEvent<DtStateObject> myObjectToBeRemovedEvent;
      DtObserveEvent<DtStateObject> myObjectUpdatedEvent;

      CheckpointProcessing myCheckpointProcessing;

      bool myStateChanged;
      bool myCheckpointInteractions;
      bool myLinkCheckpoints;
      bool myUseDiffTimeForStateObjects;
      bool myCollectInteractionsFromCheckpoint;
      bool myDiffInProgress;
   };

}