messagePipeline.h

Go to the documentation of this file.

/******************************************************************************
** Copyright (c) 1992-2024 MAK Technologies, Inc
** All rights reserved.
******************************************************************************/


#ifndef messagePipeline_H_
#define messagePipeline_H_

#include <lgrCore/lgrCore.h>
#include <lgrUtil/absoluteTime.h>
#include <list>
#include <vlutil/vlTime.h>

namespace MAKLogger
{
   class DtAbsoluteTime;
   class DtMessageState;
   class DtMessageOutput;
   class DtMessageInput;
   class DtLgrMessageOutputListener;

   class DT_DLL_LGRCORE DtMessagePipeline
   {
   public:
      DtMessagePipeline();

      virtual ~DtMessagePipeline();

      virtual void tick();

      virtual void bufferInputAndDiff(const DtAbsoluteTime& time, bool inclusive,
         bool includeInteractions);

      virtual void reset();

      virtual void activate();

      virtual void deactivate();

      virtual void activateOutput();

      virtual void deactivateOutput();

      virtual bool wasListeningOnIdle();

      virtual bool isListeningOnIdle();

      virtual bool inputFlag()  const;
      virtual bool outputFlag() const;
      virtual bool stateFlag()  const;

      virtual void setInputFlag(bool onOff);
      virtual void setOutputFlag(bool onOff);
      virtual void setStateFlag(bool onOff);

      virtual const DtMessageInput*  input() const;
      virtual DtMessageInput*  input();

      virtual const DtMessageOutput* output() const;
      virtual DtMessageOutput* output();

      virtual const DtMessageState*  state() const;
      virtual DtMessageState*  state();

      virtual DtRelativeTime startTime();
      virtual DtRelativeTime endTime();

      virtual void setInput(DtMessageInput *input);
      virtual void setOutput(DtMessageOutput *output);
      virtual void setState(DtMessageState *state);

      virtual void addOutputListener(DtLgrMessageOutputListener* listener);

      virtual void removeOutputListener(DtLgrMessageOutputListener* listener);

      virtual void setPlaybackReadTimeLimit(double limit);

      virtual double playbackReadTimeLimit() const;

   protected:

      DtMessagePipeline(const DtMessagePipeline&);

      DtMessagePipeline& operator=(const DtMessagePipeline&);

      bool myInputFlag;
      bool myOutputFlag;
      bool myStateFlag;

      DtMessageInput* myInput;

      DtMessageOutput* myOutput;

      DtMessageState* myState;


      bool myPriorInputFlag;
      bool myPriorOutputFlag;
      bool myPriorStateFlag;

      typedef std::list<DtLgrMessageOutputListener*> OutputListeners;
      OutputListeners myListeners;

      double myPlaybackReadTimeLimit;
      DtClock myLimitClock;

      DtRelativeTime myStartTime;
      DtRelativeTime myEndTime;
   };
}

#endif