lgrCheckpointPolicy.h

Go to the documentation of this file.

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


#ifndef lgrCheckpointPolicy_H_
#define lgrCheckpointPolicy_H_

#include <lgrCore/lgrCore.h>

#include <lgrUtil/absoluteTime.h>
#include <lgrUtil/filePosition.h>
#include <lgrUtil/observe.h>
#include <lgrUtil/virtualConstructor.h>

namespace MAKLogger
{   
   class DtLgrFileOutput;
   class DtPacket;
   class DtMessageState;

   class DT_DLL_LGRCORE DtCheckpointPolicy
   {
   public:
      DT_PURE_VIRTUAL_CTR(DtCheckpointPolicy,())

      
      virtual ~DtCheckpointPolicy();


      enum Policy
      {
         ByCount,
         BySize,
         ByTime
      };


   private:
      DtCheckpointPolicy(const DtCheckpointPolicy&);
      DtCheckpointPolicy& operator=(const DtCheckpointPolicy&);
   public:

      virtual bool timeForCheckpoint() const = 0;

      virtual void reset() = 0;

      virtual void checkpointWritten() = 0;

      virtual void packetWritten(const DtPacket&) = 0;

      virtual void connectFileOutput(DtMessageState*,DtLgrFileOutput*);

      virtual bool interactionsCheckpointed() const;

      virtual void setInteractionsCheckpointed(bool enable);

   protected:

      void onPacketWritten(const DtPacket&);

      typedef DtObserverFunctor<DtCheckpointPolicy,DtPacket> PacketObserverFunctor;

      PacketObserverFunctor myPacketWrittenObserver;


      //DtObserverFunctor<DtCheckpointPolicy,DtPacket> myPacketWrittenObserver;
      DtMessageState* myMessageState;
      DtLgrFileOutput* myLgrFileOutput;
      bool myCheckpointInteractions;
   };   

   class DT_DLL_LGRCORE DtCheckpointBySize : public DtCheckpointPolicy
   {
   public:
      DT_VIRTUAL_CTR(DtCheckpointBySize,(size_t size))
      DT_VIRTUAL_BASE_CTR(DtCheckpointPolicy,(size_t size))

      
      virtual ~DtCheckpointBySize();
      
   private:
      DtCheckpointBySize(const DtCheckpointBySize&);
      DtCheckpointBySize& operator=(const DtCheckpointBySize&);
   public:      

      virtual bool timeForCheckpoint() const;

      virtual void reset();

      virtual size_t sizeBetweenCheckpoints() const;

      virtual void checkpointWritten();

      virtual void packetWritten(const DtPacket&);

   protected:

      size_t myCheckpointSize;

      size_t myCurrentDataSize;
   };

   class DT_DLL_LGRCORE DtCheckpointByCount : public DtCheckpointPolicy
   {
   public:
      DT_VIRTUAL_CTR(DtCheckpointByCount,(int count))
      DT_VIRTUAL_BASE_CTR(DtCheckpointPolicy,(int count))

      
      virtual ~DtCheckpointByCount();

      virtual bool timeForCheckpoint() const;

      virtual void reset();

      virtual void checkpointWritten();

      virtual void packetWritten(const DtPacket&);

   protected:
      int myCheckpointCount;

      int myCurrentPacketsCount;
   };

   class DT_DLL_LGRCORE DtCheckpointByTime : public DtCheckpointPolicy
   {
   public:
      DT_VIRTUAL_CTR(DtCheckpointByTime,(DtRelativeTime time))
      DT_VIRTUAL_BASE_CTR(DtCheckpointPolicy,(DtRelativeTime time))

      
      virtual ~DtCheckpointByTime();

      virtual bool timeForCheckpoint() const;

      virtual void reset();

      virtual void checkpointWritten();

      virtual void packetWritten(const DtPacket&);

   protected:

      DtRelativeTime myCheckpointTime;

      DtAbsoluteTime myLastCheckpointTime;
      DtAbsoluteTime myLastPacketTime;
   };
}

#endif