packet.h

Go to the documentation of this file.

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


#pragma once

#include <lgrCore/lgrCore.h>
#include <list>
#include <vector>

#include <lgrUtil/smartBuffer.h>
#include <lgrUtil/absoluteTime.h>
#include <lgrCore/lgrEntityTracker.h>

#include <vlutil/vlMutex.h>

namespace MAKLogger
{
   class DT_DLL_LGRCORE DtPacketAttribute
   {
   public:
      DtPacketAttribute(int handle);
      virtual ~DtPacketAttribute();
      inline int handle() const { return myHandle; }

   protected:
      int myHandle;
   };

   typedef DtBoost::shared_ptr<DtPacketAttribute> DtPacketAttributeSP;

   class DT_DLL_LGRCORE DtPacket
   {
   public:

      enum DtPacketType
      {
         Type_Interaction    = 0,
         Type_Update         = 1,
         Type_Removal        = 2,
         Type_Annotation     = 3,
         Type_Pdu            = 4,
         Type_Fom            = 5,
         Type_Audio          = 6,
         Type_Checkpoint     = 7,
         Type_IndexTable     = 8,
         Type_MultiTSUpdates = 9, 


         Type_RecordingData  = 11,
         Type_SimulationData = 12,

         Type_EntityTable    = 13, 
         Type_ConfigData     = 14, 

         Type_UpdateDDM      = 15, 
         Type_InteractionDDM = 16, 

         Type_TapeTimeDate   = 17,
         Type_Pause          = 18,
         Type_Unpause        = 19,

         Type_TapeDescription = 20,

         Type_StartEndTime   = 21,
         Type_InitialState   = 22,

         Type_None           = 0x7FFFFFF0
      };

      enum FilterType
      {
         Unfiltered,
         Filtered,
         Dropped
      };

      static DtPacket* create(DtSmartBuffer data, DtAbsoluteTime time,int type, int id=-1);

      static DtPacket* create(size_t size, DtAbsoluteTime time, int type, int id=-1);

      ~DtPacket();

      void operator delete(void* v,size_t t);

      bool operator <( const DtPacket& ) const;

      char* data();
      const char* data()   const;

      FilterType filter() const;

      size_t size()   const;

      const DtAbsoluteTime& time()   const;


      bool isFromPast() const;
      void setIsFromPast(bool val);


      bool isStateUpdate() const;
      void setIsStateUpdate(bool val);

      int type() const;

      const char* typeString() const;

      DtLgrEntityTracker::EntryHandle entityTrackingId() const;

      void setEntityTrackingId(DtLgrEntityTracker::EntryHandle id);

      DtSmartBuffer& buffer();
      const DtSmartBuffer& buffer() const;

      void  setFilter(FilterType filter);
      void  setTime(DtAbsoluteTime time);
      void  setType(int type);

      void  addAttribute(DtPacketAttributeSP);

      bool removeAttribute(int);

      DtPacketAttributeSP lookupAttribute(int);

      void convertTime(DtAbsoluteTime inputCurrentTime,
         DtAbsoluteTime outputCurrentTime);

   public:

      static DtAbsoluteTime convertTime(
         DtAbsoluteTime inputCurrentTime,
         DtAbsoluteTime outputCurrentTime,
         DtAbsoluteTime arrivalTime);

      static const char* typeToString(DtPacketType packetType);

   protected:

      DtPacket(DtSmartBuffer data, DtAbsoluteTime time, int type, int id);

      DtPacket(size_t size, DtAbsoluteTime time, int type, int id);

      void* operator new(size_t t);

      DtAbsoluteTime myTime;

      bool myIsFromPast;

      bool myIsStateUpdate;

      DtLgrEntityTracker::EntryHandle myEntityTrackingId;

      int myType;

      FilterType myFilterCondition;

      DtSmartBuffer myData;

      std::list<DtPacketAttributeSP> myAttributes;

   private:

      //Internal memory allocation.

      static void deleteChunks();

      static DtPacket* theFirstPacket;
      static DtMutex thePacketListMutex;
      static std::vector<char*> theMemoryChunks;
      static char* currentMemory;
      static char* endMemory;
      DtPacket* next;
   };

}