UUIDNetworkManager.h

Go to the documentation of this file.

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



#pragma once

#include "vrlinkNetworkInterface/vrlinkNetworkInterfaceDefines.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 DtReflectedExtEntityList;
class DtReflectedExtEntity;

class DtReflectedExtAggregateList;
class DtReflectedExtAggregate;
class DtReflectedObject;

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

namespace makVrf
{
   class DtNonVrfUUIDResolver;
   typedef void (*DtUUIDChangedCallback)(DtReflectedObject*, const DtUUID& uuid, void* usr);

   class DT_DLL_vrlinkNetworkInterface 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 entityReflectedListDeleted();
      virtual void aggregateReflectedListDeleted();
      virtual void controlObjectReflectedListDeleted();

      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;
   };
}