messageState.h

Go to the documentation of this file.

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


#ifndef messageState_H_
#define messageState_H_

#include "lgrCore.h"
#include "observeEvent.h"
#include <vlutil/vlMachineTypes.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
      };

      virtual ~DtMessageState();

      virtual void startDiff();

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

      virtual void endDiff();

      virtual void updateState(DtMessageBuffer& stateBuffer);


      virtual void updateState(DtPacket* packet);

      virtual void postUpdate();

      virtual void setState(DtMessageBuffer& completeStateBuffer,const DtAbsoluteTime& time);

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

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


      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 setInputInfo(const DtMessageIOInfo* info);

      virtual void setOutputInfo(const DtMessageIOInfo* info);

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

      virtual DtPacket* generateCheckpoint(const DtAbsoluteTime& timestamp) = 0;


      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 modifyMessages(DtMessageBuffer& messages);

      virtual void modifyMessage(DtPacket& packet) = 0;

      virtual bool isCheckpointMessage(const DtPacket& packet) const;

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

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

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

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

      virtual bool removeStateObject(const DtPacket& packet);

   protected:

      DtMessageState(const DtLgrSimManager* simMgr=0);

      DtMessageState(const DtMessageState&);

      DtMessageState& operator=(const DtMessageState&);

      virtual void activateState() = 0;

      virtual void deactivateState() = 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);

   protected:

      typedef std::list<DtStateObject*> DtStateObjectList;

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

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

      DtStateObjectList myObjects;

      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;
   };

}

#endif