reflectedObjectListDIS.h

Go to the documentation of this file.

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



#pragma once

#if DtDIS


#include <vlutil/vlMachineTypes.h>
#include <vlutil/vlTime.h>
#include "reflectedObjectCallbackInfo.h"
#include <vlutil/vlHashlist.h>
#include <vl/attributePdu.h>
#include <set>

class DT_DLL_VL DtExerciseConn;
class DT_DLL_VL DtHlaObject;
class DT_DLL_VL DtStateMsg;
class DT_DLL_VL DtReflectedObject;
class DT_DLL_VL DtBaseHashKey;
class DtAttributeRecordSet;
class DtEntityIdentifierHashKey;

typedef bool (*DtDiscoveryCondition)(DtReflectedObject* refObj, void* usr);
typedef std::map<DtSimulationAddress, DtAttributeRecordSet*> DtRecordSetBySimulationAddressMap;
typedef std::map<DtObjectId, DtRecordSetBySimulationAddressMap> DtAttributesByObjectIdMap;
class DT_DLL_VL DtReflectedObjectList
{

public:

   DtReflectedObjectList(DtExerciseConn* exConn, int numBucketsPrimeNumber = 503); // 10007 default for hashtable is 127 upped to 503

   virtual ~DtReflectedObjectList();

   virtual void initializeAttributePduKindsOfInterest(const std::set<DtPduKind>& pduKinds);

   virtual DtReflectedObject* firstObj() const;
   virtual DtReflectedObject* lastObj() const;

  virtual int count() const;

   virtual DtReflectedObject* lookupObj(const DtBaseHashKey& key) const;

   virtual DtExerciseConn* exerciseConn() const;

   virtual void addObjectAdditionCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);
   virtual void removeObjectAdditionCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);

   virtual void addObjectRemovalCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);
   virtual void removeObjectRemovalCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);

   virtual void print() const;

   virtual void setTimeoutProcessing(bool onOff);

   virtual void setTimeoutInterval(DtTime time);
   virtual DtTime timeoutInterval();

   virtual void setDiscoveryCondition(DtDiscoveryCondition fn, void* usr);

   virtual void clearDiscoveryCondition();

   virtual void removeAndDelete(DtReflectedObject* obj, char* msg = NULL);

   virtual void removeObject(DtReflectedObject* obj);

   virtual DtTime timeoutCheckInterval() const { return myTimeoutCheckInterval; }
   virtual void setTimeoutCheckInterval(DtTime interval) { myTimeoutCheckInterval = interval; }

   virtual void addWaitlistAdditionCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);
   virtual void removeWaitlistAdditionCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);

   virtual void addWaitlistRemovalCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);
   virtual void removeWaitlistRemovalCallback(
      DtReflectedObjectCallbackFunction cb, void* userData);

private:

   DtReflectedObjectList(const DtReflectedObjectList& orig);

   DtReflectedObjectList& operator=(const DtReflectedObjectList& orig);

protected:

   virtual DtReflectedObject* newReflectedObj(const DtStateMsg& msg) = 0;

   virtual DtReflectedObject* processStateMessage(const DtStateMsg& msg);

   virtual void doTimeouts();

   virtual void objectAdded(DtReflectedObject* object);

   virtual bool shouldBeTimedOut(DtReflectedObject* object);

   void emptyLists();
   void emptyCallbackLists();

   virtual void processObjectAdditionCallbacks(
      DtReflectedObject* object);
   virtual void processObjectRemovalCallbacks(
      DtReflectedObject* object);

   virtual void processWaitlistAdditionCallbacks(
      DtReflectedObject* object);
   virtual void processWaitlistRemovalCallbacks(
      DtReflectedObject* object);

   virtual const DtBaseHashKey&
      hashKeyFromStateMessage(const DtStateMsg* msg) = 0;

   virtual DtBaseHashKey*
      hashKeyFromAttributeRecordSet(const DtAttributeRecordSet& recordSet);

   virtual int acceptPdu(const DtStateMsg&) const;

  virtual bool readyToAdd(DtReflectedObject* obj);

protected:

   static void doTimeoutsPostDrainCb(void* usr);
   
   static void processAttributePduCb(DtAttributeInteraction *inter, void *usr);
   virtual void processAttributePduCb(DtAttributeInteraction *inter);
   virtual void processAttributePduRecordSet(const DtAttributeRecordSet& recordSet, const DtSimulationAddress& simAddr, DtReflectedObject* obj = 0);

   static void processAttributePduWaitListCb(DtReflectedObject* obj, void* userData);
   virtual void processAttributePduWaitListCb(DtReflectedObject* obj);
   virtual void deleteRecordSetBySimulationAddressMap(DtRecordSetBySimulationAddressMap& recordSetMap, const DtSimulationAddress& simAddr = DtSimulationAddress()) const;

protected:

   DtExerciseConn* myExConn;
   DtIntrusiveList myObjectAddedCallbacks;
   DtIntrusiveList myObjectRemovedCallbacks;
   DtIntrusiveList myWaitlistAddedCallbacks;
   DtIntrusiveList myWaitlistRemovedCallbacks;
   DtIntrusiveList myObjectList;
   DtIntrusiveList myWaitList;
   DtHashlist myObjectHashlist;
   DtHashlist myWaitHashlist;
   DtAttributesByObjectIdMap myAttributeWaitHashlist;
   DtTime myTimeoutInterval;
   DtTime myNextTimeoutCheck;
   DtTime myTimeoutCheckInterval;
   bool myTimeoutProcessingFlag;
   DtDiscoveryCondition myDiscoveryCondition;
   void* myDiscoveryConditionParameter;
   std::set<DtPduKind> myPduKindSet;
};

#endif