lgrEntityTracker.h

Go to the documentation of this file.

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


#pragma once

#include <lgrCore/lgrCore.h>
#include <lgrUtil/filePosition.h>
#include <lgrUtil/virtualConstructor.h>

#include <vlutil/vlNetTypes.h>
#include <vlutil/vlString.h>
#include <vlpi/disEnums.h>

#include <vector>
#include <map>
#include <set>

namespace MAKLogger
{
   class DtPacket;
   class DtMessageBuffer;
   class DtAbsoluteTime;
   class DtLgrBaseSimManager;

   class DT_DLL_LGRCORE DtLgrEntityTracker
   {
   public:

      typedef int TrackerUpdateId;
      typedef int EntryHandle;
      typedef std::set<DtLgrEntityTracker::EntryHandle> EntryHandleSet;

      struct TrackerEntry
      {
         bool temporary;
         double firstTime;
         double lastTime;
         DtForceType force;
         DtString name;
         DtString type;
         DtString marking;
      };


   public:

      DT_PURE_VIRTUAL_CTR( DtLgrEntityTracker, () )

      
      virtual ~DtLgrEntityTracker();

   private:

      DtLgrEntityTracker(const DtLgrEntityTracker&);
      DtLgrEntityTracker& operator=(const DtLgrEntityTracker&);

   public:

      virtual void simInitialize(DtLgrBaseSimManager* simMgr);

      virtual EntryHandle begin() const;

      virtual EntryHandle end() const;

      virtual DtLgrEntityTracker::TrackerUpdateId lastUpdateId() const;

      virtual EntryHandle addEntry(double firstTime, double lastTime,
         const DtString& name, const DtString& type, DtForceType force, const DtString& marking,
         DtLgrEntityTracker::EntryHandle handle = -1);

      virtual EntryHandle addEntry(const TrackerEntry& entry,
         DtLgrEntityTracker::EntryHandle handle = -1);

      virtual EntryHandle addTemporaryEntry(const DtString& name);

      virtual EntryHandle addTemporaryMarking(const DtString& marking);

      virtual EntryHandle findEntry(const DtString& name) const;

      virtual int entityCount() const;

      virtual void clearEntries();

      virtual bool isPermanentEntry(EntryHandle handle) const;

      virtual const TrackerEntry& entry(DtLgrEntityTracker::EntryHandle handle) const;

      virtual double entityFirstTime(EntryHandle handle) const;

      virtual double entityLastTime(EntryHandle handle) const;

      virtual DtString entityName(EntryHandle handle) const;

      virtual DtString entityType(EntryHandle handle) const;

      virtual DtForceType entityForce(EntryHandle handle) const;

      virtual DtString entityMarking(EntryHandle handle) const;

      virtual void parsePacket(const DtPacket& packet, const DtAbsoluteTime* time=0);

      virtual void parsePackets(const DtMessageBuffer& packetBuffer, const DtAbsoluteTime* time=0);

      virtual EntryHandle entityId(const DtPacket& packet) const;



      virtual DtLgrEntityTracker* createFromPacket(const DtPacket& packet) = 0;

      virtual DtString entityName(const DtPacket& packet) const = 0;

      virtual DtString entityType(const DtPacket& packet) const = 0;

      virtual DtForceType entityForce(const DtPacket& packet) const = 0;

      virtual DtString entityMarking(const DtPacket& packet) const = 0;


      virtual int encodedSize() const;

      virtual DtPacket* encodePacket() const;

      virtual void decodePacket(const DtPacket*);

      virtual void deserializeFromString(const DtString& data);

      virtual DtString serialize();

      virtual DtString serializeAdded();

   protected:

      enum TrackedDataIndex
      {
         DtTrackName       = 0,
         DtTrackType       = 1,
         DtTrackMarking    = 2
      };

      struct NetTrackerEntryHeader
      {
         DtNetFloat64 firstTime;
         DtNetFloat64 lastTime;
         DtNetU32 entrySize;
         DtNetU32 force;
         DtNetU16 dataSize[1];
      };

      struct NetTrackerTable
      {
         DtNetU32 numEntries;
         DtNetU32 unused;
      };


      typedef std::vector<TrackerEntry> TrackerEntryList;
      typedef std::map<DtString, EntryHandle> TrackerEntryIndex;

   protected:

      virtual TrackerEntry makeInvalidEntry() const;

      virtual unsigned encodedEntrySize(const TrackerEntry& entry, bool includePadding=true) const;

      virtual char* encodeEntry(char* entryData, const TrackerEntry& entry) const;

      virtual const char* decodeEntry(const char* entryData);

      virtual void advanceToNextToken(const char*& data, const char* dataEnd);

      bool getFloat(const char*& token, const char* dataEnd, const DtString& tokenName, float& value);
      bool getInt(const char*& token, const char* dataEnd, const DtString& tokenName, int& value);
      bool getString(const char*& token, const char* dataEnd, const DtString& tokenName, DtString& value);

      virtual void deserializeEntryFromString(const char** data, const char* dataEnd);

      virtual void serializeEntry(DtString& serialized, unsigned index, const TrackerEntry& entry);

   protected:

      DtLgrBaseSimManager* mySimMgr;

      TrackerEntryList myTrackedEntities;

      std::map<unsigned int, TrackerEntry> myAddedEntities;

      TrackerEntryIndex myEntityIndex;

      TrackerUpdateId myLastUpdateId;

      int myNumberTrackedData;

      int myAlignmentSize;

      const TrackerEntry myInvalidEntry;


      const char myFieldSeparator;
      const DtString myFieldSeparatorString;

      static DtString theSerializeLabel;
   };
}