UUIDNetworkManager.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2015 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/



#pragma once

#include "vrfcontrol/vrfcontrolDefines.h"
#include <vlutil/vlString.h>
#include <boost/unordered_map.hpp>
#include <vl/globalObjectDesignator.h>
#include <vrfutil/rwUUID.h>
#include <string>
#include <cstdio>

#if WIN32 && _MSC_VER == 1400 || _MSC_VER == 1500

#ifndef _INTPTR_T_DEFINED
 #define _INTPTR_T_DEFINED
 #ifdef _WIN64
typedef __int64 intptr_t;
 #else /* _WIN64 */
typedef _W64 int intptr_t;
 #endif /* _WIN64 */
#endif /* _INTPTR_T_DEFINED */

#ifndef _UINTPTR_T_DEFINED
 #define _UINTPTR_T_DEFINED
 #ifdef _WIN64
typedef unsigned __int64 uintptr_t;
 #else /* _WIN64 */
typedef _W64 unsigned int uintptr_t;
 #endif /* _WIN64 */
#endif /* _UINTPTR_T_DEFINED */

#else
#include <stdint.h>
#endif

class DtExerciseConn;
class DtReflectedControlObjectList;
class DtReflectedControlObject;
class DtNonVrfUUIDResolver;

class DtReflectedExtEntityList;
class DtReflectedExtEntity;

class DtReflectedExtAggregateList;
class DtReflectedExtAggregate;
class DtReflectedObject;

typedef void (*DtUUIDChangedCallback)(DtReflectedObject*, const DtUUID& uuid, void* usr);

#if DtHLA
namespace makVrfVrlinkExtToolkit
{
   class DtReflectedExtendedAttributesObjectList;
}
#endif

class DT_DLL_vrfcontrol DtUUIDNetworkManager
{
public:

   DtUUIDNetworkManager();

   virtual ~DtUUIDNetworkManager();

   virtual void init(DtExerciseConn* exConn,
      DtReflectedExtEntityList* reel = NULL,
      DtReflectedExtAggregateList* ral = NULL,
      DtReflectedControlObjectList* rel = NULL,
#if DtHLA
      makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList* reaol = NULL,
#endif
      const DtString& uuidMarkingForNonVrForces = "entity-identifier");

   virtual void reinitialize(
      DtReflectedExtEntityList* reel = NULL,
      DtReflectedExtAggregateList* ral = NULL,
      DtReflectedControlObjectList* rel = NULL
#if DtHLA
      , makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList* reaol = NULL
#endif
      );

   virtual void setNonVrfUUIDResolver(DtNonVrfUUIDResolver*);
   virtual DtNonVrfUUIDResolver* nonVrfUUIDResolver() const;

   virtual DtUUID uuidFor(DtReflectedExtEntity*) const;
   virtual DtUUID uuidFor(DtReflectedExtAggregate*) const;
   virtual DtUUID uuidFor(DtReflectedControlObject*) const;
   virtual DtReflectedObject* reflectedObjectFor(const DtUUID&) const;

   DtReflectedControlObjectList* controlObjectList() { return myControlObjectList; };
   DtReflectedExtEntityList* entityList() { return myEntityList; };
   DtReflectedExtAggregateList* aggregateList() { return myAggregateList; };

   virtual void addEntityUUIDChangedCallback(DtUUIDChangedCallback, void* usr);
   virtual void removeEntityUUIDChangedCallback(DtUUIDChangedCallback, void* usr);

   virtual void addAggregateUUIDChangedCallback(DtUUIDChangedCallback, void* usr);
   virtual void removeAggregateUUIDChangedCallback(DtUUIDChangedCallback, void* usr);

   virtual void addEnvironmentalUUIDChangedCallback(DtUUIDChangedCallback, void* usr);
   virtual void removeEnvironmentalUUIDChangedCallback(DtUUIDChangedCallback, void* usr);

protected:
   virtual void initializeEntityList();
   static void entityAddedCallback(DtReflectedExtEntity*, void* usr);
   virtual void processEntityAdded(DtReflectedExtEntity*);
   static void entityRemovedCallback(DtReflectedExtEntity*, void* usr);
   virtual void processEntityRemoved(DtReflectedExtEntity*);
   static void postEntityUpdateCallback(DtReflectedExtEntity*, void* usr);
   virtual void processPostEntityUpdate(DtReflectedExtEntity*);

   virtual void initializeAggregateList();
   static void aggregateAddedCallback(DtReflectedExtAggregate*, void* usr);
   virtual void processAggregateAdded(DtReflectedExtAggregate*);
   static void aggregateRemovedCallback(DtReflectedExtAggregate*, void* usr);
   virtual void processAggregateRemoved(DtReflectedExtAggregate*);
   static void postAggregateUpdateCallback(DtReflectedExtAggregate*, void* usr);
   virtual void processPostAggregateUpdate(DtReflectedExtAggregate*);

   virtual void initializeControlObjectList();
   static void controlObjectAddedCallback(DtReflectedControlObject*, void* usr);
   virtual void processControlObjectAdded(DtReflectedControlObject*);
   static void controlObjectRemovedCallback(DtReflectedControlObject*, void* usr);
   virtual void processControlObjectRemoved(DtReflectedControlObject*);
   static void postControlObjectUpdateCallback(DtReflectedControlObject*, void* usr);
   virtual void processPostControlObjectUpdate(DtReflectedControlObject*);

   virtual void removeObject(const uintptr_t&);

   struct UUIDCallback;

   virtual void invokeUUIDCallbacks(std::vector<UUIDCallback>, DtReflectedObject*, const DtUUID&);

   virtual void addUUIDCallback(std::vector<UUIDCallback>&, DtUUIDChangedCallback, void*);
   virtual void removeUUIDCallback(std::vector<UUIDCallback>&, DtUUIDChangedCallback, void*);

protected:
   DtExerciseConn* myExerciseConnection;
   DtReflectedControlObjectList* myControlObjectList;
   bool myOwnsControlObjectList;

   DtReflectedExtEntityList* myEntityList;
   bool myOwnsEntityList;

   DtReflectedExtAggregateList* myAggregateList;
   bool myOwnsAggregateList;

#if DtHLA
   makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList* myExtAttributesList;
   bool myOwnsExtAttributesList;
#endif

   DtString myNonVrfObjectsUUIDScheme;

   typedef boost::unordered_map<uintptr_t, DtUUID> CurrentDataMap;
   CurrentDataMap myCurrentDataMap;

   typedef boost::unordered_map<DtUUID, DtReflectedObject*> CurrentReflectedObjectMap;
   CurrentReflectedObjectMap myReflectedObjectMap;

   typedef boost::unordered_map<uintptr_t, int> DataUpdateTrackerCount;
   DataUpdateTrackerCount myDataUpdateTrackerCount;

   DtNonVrfUUIDResolver* myNonVrfUUIDResolver;
   bool myOwnsNonVrfUUIDResolver;

   struct UUIDCallback
   {
      DtUUIDChangedCallback callback;
      void* user;
   };

   std::vector<UUIDCallback> myEntityUUIDChangedCallbacks;
   std::vector<UUIDCallback> myAggregateUUIDChangedCallbacks;
   std::vector<UUIDCallback> myEnvironmentalUUIDChangedCallbacks;
};