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 DT_DLL_LGRCORE DtMessageState
   {
   public:

      enum CheckpointProcessing
      {
         IgnoreCheckpoints,
         ProcessAllCheckpoints,
         ProcessFirstCheckpoint
      };

      virtual ~DtMessageState();

      DtAbsoluteTime convertTime(DtAbsoluteTime inputCurrentTime,
         DtAbsoluteTime inputTime,DtAbsoluteTime outputCurrentTime);

      virtual void startDiff();

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

      virtual void endDiff();

      void updateState(DtMessageBuffer& stateBuffer);


      void updateState(DtPacket* packet);

      virtual void postUpdate();

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



      DtObserveEvent<DtMessageState>* inputChangedEvent();
      DtObserveEvent<DtMessageState>* outputChangedEvent();
      DtObserveEvent<DtMessageState>* stateModifiedEvent();
      DtObserveEvent<DtMessageState>* stateActivatedEvent();
      DtObserveEvent<DtMessageState>* stateDeactivatedEvent();
      DtObserveEvent<DtMessageState>* endDiffEvent();
      DtObserveEvent<DtStateObject>* objectAddedEvent();
      DtObserveEvent<DtStateObject>* objectToBeRemovedEvent();
      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;

   protected:

      virtual void activateState() = 0;

      virtual void deactivateState() = 0;

      DtMessageState();

      DtMessageState(const DtMessageState&);

      DtMessageState& operator=(const DtMessageState&);

      virtual bool updateStateObjects(DtPacket& packet);

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

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


      virtual DtStateObject* createStateObject(DtPacket& packet);

      virtual DtStateObject* updateStateObject(DtPacket& packet);

      virtual DtStateObject* findStateObject(DtPacket& packet);

      virtual bool removeStateObject(DtPacket& packet);

      void removeStateObject( DtStateObject* object );

      typedef std::list<DtStateObject*> DtStateObjectList;

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

      DtStateObjectList myObjects;

      DtStateObjectMap myObjectLookupMap;

      DtStateObjectList mySnapshotOfObjects;


      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