vrfObjectManager.h

Go to the documentation of this file.

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


#pragma once

#include <readerWriter/rwObjectType.h>
#include <readerWriter/noArgumentCallbackList.h>
#include <readerWriter/rwList.h>
#include "vrfobjcore/vrfObjectFilterMapIterator.h"
#include "vrfobjcore/organizationManager.h"
#include "vrfobjcore/managedObjectList.h"
#include "vrfobjcore/filterFunctionPredicate.h"
#include "vrfobjcore/simObjectMapIterator.h"
#include "vrfobjcore/simObjectIterator.h"
#include "vrfobjcore/vrfObject.h"
#include "vrfobjcore/vrfObjectReference.h"
#include "vrfobjcore/simObjectListActivityCallbackInfo.h"
#include "vrfobjparam/vrfObjectParameters.h"
#include <vrfExtProtocol/objectTypeEnums.h>
#include <vrfExtProtocol/simInterfaceContent.h>
#include "vrftasks/extendedAggregateEnums.h"
#include "vrfutil/rwActivities.h"
#include "vrfutil/consoleCommandManager.h"
#include <vrfExtObjects/reflectedExtEntityList.h>
#include "vrfobjcore/simObjectListActivityCallbackList.h"

#include <vlpi/appearance.h>
#include <vlutil/vlFilename.h>
#include <vlutil/vlList.h>
#include <vlutil/vlHashlist.h>
#include <vlutil/vlConfig.h>
#include <vlutil/vlSmartPointers.h>
#include <vrfutil/assembliesReaderWriter.h>
#include "vrfutil/itt.h"
#include <vl/fomMapper.h>

#include <vector>
#include <list>
#include <set>

#include <boost/unordered_map.hpp>
#include <boost/unordered_set.hpp>
#include <tbb/spin_rw_mutex.h>

#define DT_SINGLE_STATE_UPDATE_MESSAGE 0

class DtExerciseConn;
class DtReflectedObject;
class DtReflectedAggregate;
class DtReflectedExtEntity;
class DtReflectedExtAggregate;
class DtReflectedExtEntityList;
class DtReflectedVrfExtEntityList;
class DtReflectedExtAggregateList;
class DtReflectedVrfExtAggregateList;
class DtVrfParameterDb;
class DtSimObjectSubComponentTypes;
class DtVrfSimulationObjectGroupGeometry;
class DtOrbatManager;
class DtVertexList;
class DtAggregateStateRepository;
class DtBaseEntityStateRepository;
class DtManagedObjectListManager;
class DtSimManager;
class DtVrfObjectManagerTickArguments;
class DtVrfEntityIdentifierFactory;
class DtSimTickArguments;
class DtSimMessage;
class DtIfCreateVrfObject;
class DtIfAggregateAs;
class DtVrfObjectStateRepository;
class DtReflectedEnvironmentProcess;
class DtReflectedControlObjectList;
class DtReflectedVrfControlObjectList;
class DtReflectedObject;
class DtEchelonId;
class Coordinate_System;
class DtObjectGeometricModelsManager;
class DtSimInternalCommunicationManager;
class DtVrfObjectPlanAdministrator;
class DtDiGuyCharacterDataManager;
class DtReflectedDesignator;
class DtRemoteComponentAttachmentManager;
class DtReflectedDesignatorList;
class DtReflectedActiveSonar;
class DtReflectedActiveSonarList;
class DtReflectedPropulsionNoise;
class DtReflectedPropulsionNoiseList;
class DtCreateQueueEntry;
class DtModifyQueueEntry;
class DtConsoleCommandOwner;
class DtlInputStream;
class DtReflectedEmitterSystemManager;
class DtVisualMetaDataManager;
class DtRwStringAttributeList;
class DtReflectedIffList;
class DtReflectedIff;

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

typedef std::map<DtEntityIdentifier, DtVrfObject*> DtSimObjectMap;

typedef bool (*DtSimObjectUserInitFcn)(DtVrfObject* object, void* usr);

typedef bool (*DtVrfObjectUserInitFcn)(DtVrfObject* vrfObject, void* usr);

typedef void (*DtVrfObjectManagerCallbackFcn)(const DtVrfObjectManager& objectManager,
   void* usr);

const int DtSimMaxForceTypes = 256;

struct DtVrfObjectManagerCallbackInfo
{
   DtVrfObjectManagerCallbackFcn myCallbackFunction;
   void* myUserData;
};

struct DtImportScenarioData
{
   DtImportScenarioData() : creatingSimulationObjectGroup(false), importFlags(0), importForce(0), offsetRotation(0.) {};
   DtImportScenarioData(const DtImportScenarioData& orig) :
      creatingSimulationObjectGroup(orig.creatingSimulationObjectGroup), deconflictingName(orig.deconflictingName),
      importFlags(orig.importFlags), importForce(orig.importForce), geocentricOffsetLocation(orig.geocentricOffsetLocation),
      offsetRotation(orig.offsetRotation) {};

   bool creatingSimulationObjectGroup;
   DtString deconflictingName;
   unsigned int importFlags;
   int importForce;
   DtVector geocentricOffsetLocation;
   double offsetRotation;
};

struct DtVrfObjectNameChangedCallbackInfo
{
   DtString myOldName;
   DtString myNewName;
   DtVrfObject* myVrfObject;
};

struct DtVrfObjectUUIDChangedCallbackInfo
{
   DtVrfObjectUUIDChangedCallbackInfo() : myOldUUID(DtUUID::nullUUID()), myNewUUID(DtUUID::nullUUID()) {};

   DtUUID myOldUUID;
   DtUUID myNewUUID;
   DtVrfObject* myVrfObject;
};

struct DtVrfObjectAboutToBePublishedCallbackInfo
{
   DtVrfObject* myVrfObject;
   DtEntityIdentifier* myEntityIdentifier;
};

typedef DtCallbackList<const DtVrfObjectNameChangedCallbackInfo&>::DtCallbackFunctionType DtVrfObjectNameChangedCallbackFcn;
typedef DtCallbackList<const DtVrfObjectUUIDChangedCallbackInfo&>::DtCallbackFunctionType DtVrfObjectUUIDChangedCallbackFcn;
typedef DtCallbackList<const DtVrfObjectAboutToBePublishedCallbackInfo&>::DtCallbackFunctionType DtVrfObjectAboutToBePublishedCallbackFcn;
typedef DtCallbackList<DtVrfObject*>::DtCallbackFunctionType DtVrfObjectQueuedForRemocalCallbackFcn;

typedef enum
{
   DtNeverPublishTaskVisualizations = 0,
   DtPublishTaskVisuzalizationsOnRequest,
   DtAlwaysPublishTaskVisualizations
} DtTaskVisualizationPublicationMode;

#include "vrfobjcore/vrfobjcoreDefines.h"

class DT_DLL_vrfobjcore DtVrfObjectManager : public DtRwList
{
public:
   typedef DtCallbackList<const DtOrganizationManagerReadyCallbackInfo&> DtOrganizationReadyCallbackList;

   typedef enum
   {
      DtUseParameterDatabaseAggregateState = 0,
      DtCreateAggregatedEntity,
      DtCreateDisaggregatedEntity
   } DtAggregateCreationMode;

public:

   DtVrfObjectManager(DtSimManager* simManager, int entityAdvisory = 100);

   virtual ~DtVrfObjectManager();

   virtual void clearRemoteComponentAttachmentSystem();

   virtual bool reuseEntityIdentifiersOnScenarioLoad() const;
   virtual void setReuseEntityIdentifiersOnScenarioLoad(bool);

   virtual DtEntityIdentifier nextEntityIdentifier(DtVrfObject*, const DtEntityIdentifier&);
   virtual void addVrfObjectAboutToBePublishedCallback(
      DtVrfObjectAboutToBePublishedCallbackFcn fcn, void* usrData);
   virtual void removeVrfObjectAboutToBePublishedCallback(
      DtVrfObjectAboutToBePublishedCallbackFcn fcn, void* usrData);

   virtual void createRemoteComponentAttachmentManager();

   virtual bool isRemoteComponentAttachment(const DtUUID&) const;

   virtual bool initializeRemoteComponentAttachmentSystem(const DtFilename& fromFile);
  
   DtRemoteComponentAttachmentManager* remoteComponentAttachmentManager();
   const DtRemoteComponentAttachmentManager* remoteComponentAttachmentManager() const;

   virtual bool create();

   virtual bool init();

   virtual bool createDIGuyCharacterManager(const DtFilename & diGuyAnimationsFile);

   virtual DtVisualMetaDataManager* visualMetaDataManager() const;

   virtual DtFilename metaDataFilename(const DtObjectType&) const;

   virtual DtRwStringAttributeList* customizedMarkingsFor(const DtObjectType&) const;

   virtual bool add(DtVrfObject* simObject);

   virtual void completeObjectAddition(DtVrfObject* simObject);

   virtual bool loadingScenarioInformation() const;

private:
   using DtRwList::add;
   using DtRwList::remove;

public:
   virtual void setParameterDatabase(DtVrfParameterDb* parameterDatabase);
   virtual DtVrfParameterDb* parameterDatabase();

   virtual void setSearchPaths(const DtReaderWriter::SearchPaths&);
   virtual const DtReaderWriter::SearchPaths& searchPaths() const;

   virtual bool registerExtendedProperties();

   virtual DtManagedObjectListConstPtr getList(const DtVrfObjectPredicate& predicate,
      bool reevaluateFlag = false, DtTime evaluationPeriod = 0);

   virtual void setImportingScenario(bool);
   virtual bool importingScenario() const;

   virtual void setImportScenarioData(const DtImportScenarioData&);
   virtual const DtImportScenarioData& importScenarioData() const;

   virtual const DtVrfObjectFilterMapIterator& vrfIterator(
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false) const;

   virtual const DtVrfObjectFilterMapIterator& vrfIterator(
      const DtVrfObjectPredicate& predicate) const;

   virtual const DtVrfObjectFilterMapIterator& vrfIterator(DtFilterFcn filter,
      bool invertFilter = false, void* usrData = 0)const;

   virtual void removeAndDelete(const DtUUID& objectName, bool andRemoveFromOrbat);
   virtual void removeAndDelete(DtSharedVrfObjectReference simObject, bool andRemoveFromOrbat);
   virtual void removeAndDelete(const DtEntityIdentifier& key, bool andRemoveFromOrbat);
   virtual void removeAndDelete(DtVrfObject* object, bool andRemoveFromOrbat);

   std::set<DtGlobalObjectDesignator> remoteObjectGlobalIds(bool onlyVrfSimulated = true) const;

   virtual void removeAndDeleteAllLocals(bool andDeleteFromOrbat = false);

   virtual void removeAndDeleteAll(bool andDeleteFromOrbat = false);

   virtual void setExerciseConnection(DtExerciseConn* connection);
   virtual void createRemoteEnvironmentalsList(DtExerciseConn* exConn);

   virtual void setPublishZeroVelocityWhenPaused(bool);
   virtual bool publishZeroVelocityWhenPaused() const;

   virtual void setSetDeadReckoningAlgorithmToStaticOnPause(bool);
   virtual bool setDeadReckoningAlgorithmToStaticOnPause() const;

   virtual void overrideDeadReckoningAlgorithm(DtDeadReckonTypes drAlg);

   virtual bool isDeadReckonAlgorithmOverridden(DtDeadReckonTypes& drAlg) const;
   
   virtual void removeDeadReckoningAlgorithmOverride();

   virtual void setTaskVisualizationPublicationMode(DtTaskVisualizationPublicationMode mode);
   virtual DtTaskVisualizationPublicationMode taskVisualizationPublicationMode() const;

   virtual bool hasPermissionToDisplayTaskVisualizations(const DtUUID& uuid);

   virtual void setMaxObjectsWithTaskVisualizations(unsigned max);
   virtual unsigned maxObjectsWithTaskVisualizations() const;

   virtual void setUseDrawControlForTaskVisualizations(bool);
   virtual bool useDrawControlForTaskVisualizations() const;

   virtual DtReflectedControlObjectList* reflectedEnvironmentProcessList() const;

   virtual DtReflectedControlObjectList* createReflectedControlObjectList(DtExerciseConn* exConn);

   virtual bool objectInRemovalQueue(const DtUUID& uuid);

   virtual void registerInterfaceCallbacks();

   virtual const DtSimManager* simManager() const;
   virtual DtSimManager* simManager();

   virtual void processCreateVrfObject(DtSimMessage* msg);

   typedef DtBoost::shared_ptr<DtCreateQueueEntry> DtCreateQueueEntryPtr;
   typedef std::list<DtCreateQueueEntryPtr> DtVrfObjectCreateQueue; 
   virtual const DtVrfObjectCreateQueue& objectCreateQueue() const;

   virtual void processCreateVrfObject(DtIfCreateVrfObject ifCreateVrfObject);
   
   virtual void processModifyVrfObject(DtSimMessage* msg);

   virtual void processModifyVrfObject(DtIfModifyVrfObject modObj);

   virtual void processModifyVrfOverlay(DtSimMessage* msg);
   virtual void processDeleteVrfObject(DtSimMessage* msg);
   virtual void processDeleteVrfObjectById(DtSimMessage* msg);
   virtual void processVrfObjectDeleted(DtSimMessage* msg);
   virtual void processAutoReorganize(DtSimMessage* msg);
   virtual void processAggregateAs(DtSimMessage* msg);
   virtual void processSkipTask(DtSimMessage* msg);


   virtual void processSetThresholds(DtSimMessage* msg);

   virtual void processDeleteDynamicTerrainServer(DtSimMessage*);

   virtual void processEntityAddedCallback(DtReflectedExtEntity* entity);
   virtual void processAggregateAddedCallback(DtReflectedExtAggregate* aggregate);

   virtual void processEntityRemovedCallback(DtReflectedExtEntity* entity);
   virtual void processAggregateRemovedCallback(DtReflectedExtAggregate* aggregate);

   virtual void processDesignatorAddedCallback(DtReflectedDesignator * des);
   virtual void processDesignatorRemovedCallback(DtReflectedDesignator * des);
   virtual void processDesignatorChangedCallback(DtReflectedDesignator * des);
   DtBoolean processDesignatorDiscoveryCriteria(DtReflectedDesignator * des);

   virtual void processActiveSonarAddedCallback(DtReflectedActiveSonar* des);
   virtual void processActiveSonarRemovedCallback(DtReflectedActiveSonar* des);
   virtual void processActiveSonarChangedCallback(DtReflectedActiveSonar* des);
   DtBoolean processActiveSonarDiscoveryCriteria(DtReflectedActiveSonar* des);

   typedef std::list<DtReflectedActiveSonar*> ReflectedActiveSonars;
   virtual ReflectedActiveSonars findActiveSonarsForHostEntity(
      const DtVrfObject* host) const;

   virtual void processPropulsionNoiseAddedCallback(DtReflectedPropulsionNoise* des);
   virtual void processPropulsionNoiseRemovedCallback(DtReflectedPropulsionNoise* des);
   virtual void processPropulsionNoiseChangedCallback(DtReflectedPropulsionNoise* des);
   DtBoolean processPropulsionNoiseDiscoveryCriteria(DtReflectedPropulsionNoise* des);

   virtual void processIffAddedCallback(DtReflectedIff* des);
   virtual void processIffRemovedCallback(DtReflectedIff* des);
   virtual void processIffChangedCallback(DtReflectedIff* des);
   virtual DtBoolean processIffDiscoveryCriteria(DtReflectedIff*);

   virtual bool hasEnabledActiveSonar(const DtVrfObject* host) const;

   virtual DtReflectedPropulsionNoise* propulsionNoiseForHost(const DtVrfObject* host) const;
   virtual DtReflectedIff* iffForHost(const DtVrfObject* host) const;

   virtual DtReflectedEmitterSystemManager* reflectedEmitterSystemManager();

   virtual void processAggregateChanged(DtReflectedExtAggregate* aggregate);

   virtual void processEnvProcessAddedCallback(
      DtReflectedEnvironmentProcess* envProcess);
   virtual void processEnvProcessRemovedCallback(
      DtReflectedEnvironmentProcess* envProcess);
   virtual bool processEnvProcessDiscoveryCriteria(
      DtReflectedEnvironmentProcess* envProcess);

   virtual void removeObjectSubordinates(DtVrfObject* object, bool andRemoveFromOrbat);

   virtual void queueObjectForRemoval(const DtEntityIdentifier& key, bool andRemoveFromOrbat = false);
   virtual void queueObjectForRemoval(const DtUUID& key, bool andRemoveFromOrbat = false);

   virtual void removeObjectsQueuedForRemoval();

   virtual void tick();

   virtual DtVrfObject* createAndInitVrfObject(
      DtIfCreateVrfObject* creationInfo);

   virtual DtVrfObject* createAndInitVrfObject(
      DtIfAggregateAs* aggInfo);

   virtual DtVrfObject* createAndInitVrfObject(
      DtReflectedEntity* entity);

   virtual DtVrfObject* createAndInitVrfObject(
      DtReflectedAggregate* aggregate,
      int superType = DtObjectTypePseudoAggregate);

   virtual DtVrfObject* createAndInitVrfObject(DtReflectedEnvironmentProcess* envProcess);

   virtual DtVrfObject* createAndInitVrfObject(
      const DtObjectType& objectType,
      bool publishLocalObject = true,
      const DtString& objectName = DtString::nullString(),
      const DtString& objectLabel = DtString::nullString(),
      DtForceType forceType = DtForceOther,
      const DtList* vertices = 0,
      const DtTaitBryan* orientation = 0,
      bool projection = false,
      bool closedFigure = false,
      const DtAppearance& appearance = DtAppearance::nullAppearance(),
      const DtString& readerWriterName = DtString::nullString(),
      DtReaderWriterRegistry* parentRegistry = 0,
      bool createSubObjects = false,
      DtVrfObjectUserInitFcn userInit = 0,
      void* userInitData = 0,
      bool organize = true,
      const DtString& startingFormation = DtDefaultFormationString,
      DtVrfObjectManager::DtAggregateCreationMode initialAggregateState = 
      DtVrfObjectManager::DtUseParameterDatabaseAggregateState,
      unsigned long requestId = 0,
      const DtString& overlayParent = "",
      const DtUUID& uuid = DtUUID::nullUUID(),
      bool addToOrbat = false);

   virtual DtVrfObject* createAndInitVrfObject(
      const DtObjectType& objectType,
      bool publishLocalObject = true,
      const DtString& objectName = DtString::nullString(),
      const DtString& objectLabel = DtString::nullString(),
      DtForceType forceType = DtForceOther,
      const DtVector& position = DtVector::zero(),
      const DtTaitBryan* orientation = 0,
      bool projection = false,
      bool closedFigure = false,
      const DtAppearance& appearance = DtAppearance::nullAppearance(),
      const DtString& readerWriterName = DtString::nullString(),
      DtReaderWriterRegistry* parentRegistry = 0,
      bool createSubObjects = false,
      DtVrfObjectUserInitFcn userInitFcn = 0,
      void* userInitData = 0,
      bool organize = true,
      const DtString& startingFormation = DtDefaultFormationString,
      DtVrfObjectManager::DtAggregateCreationMode initialAggregateState = 
      DtVrfObjectManager::DtUseParameterDatabaseAggregateState,
      unsigned long requestId = 0, const DtString& overlayParent = "",
      const DtUUID& startingUUID = DtUUID::nullUUID(),
      bool addToOrbat = false);

   virtual void createSubObjectsFromParameters(DtVrfObject* parent,
      bool publishSubobjects, unsigned long requestId, const DtString& overlayParent, bool addToOrbat);

   virtual DtVrfObject* createSubObjectFromParameterEntry(
      const DtVrfSubObjectParameterEntry& entry, const DtVector& positionOffsetFromParent,
      const DtVrfObject& parent, 
      const DtString& formationName,
      bool publishSubObject, unsigned long requestId = 0, const DtString& overlayParent = "",
      const DtString& markingText = "", const DtUUID& uuid = DtUUID::nullUUID(),
      bool addToOrbat = true);

   virtual bool readOrderOfBattleFile(const DtFilename & filename);
   virtual bool readOrderOfBattleFile(const std::vector<std::string*>& oob);

   virtual bool readOrderOfBattleFile(DtlInputStream*);
   virtual bool readOrderOfBattleFileFromZipFile(const DtFilename& zipFile, const DtString & filename);
   virtual bool writeOrderOfBattleFile(const DtString & filename);
   virtual bool writeOrderOfBattleFile(std::string& stream, int& numberOfLuaScripts);
   virtual bool writeOrderOfBattleFile(std::vector<std::string*>& vecOfStreams, int& numberOfLuaScripts);

   virtual bool writeSimulationObjectGroupOrderOfBattleFile(const DtString& filename, int flags,
      boost::unordered_set<DtUUID>& uuidsSaved);

   virtual void preallocateLuaScriptHandles(int);

   virtual std::vector<DtVrfObject*> readSimulationObjectGroupOrderOfBattleFile(const DtString& filename, int flags, DtForceType force,
      DtlObjPtr* retArgs = 0, bool* errorLoading = 0);
   virtual std::vector<DtVrfObject*> readSimulationObjectGroupOrderOfBattleFileFromZipFile(
      const DtFilename& scenarioZipFile, const DtString& filename, int flags, DtForceType force,
      DtlObjPtr* retArgs = 0, bool* errorLoading = 0);
   virtual std::vector<DtVrfObject*> readSimulationObjectGroupOrderOfBattleFile(int flags, DtForceType force, DtlObjPtr& args);
   virtual std::vector<DtVrfObject*> readSimulationObjectGroupOrderOfBattleFile(DtlInputStream* fStream, int flags, DtForceType force,
      DtlObjPtr* retArgs = 0, bool* errorLoading = 0);

   virtual bool objectShouldBeSavedToOrderOfBattle(
      const DtVrfObject* vrfObject) const;
   virtual bool objectShouldBeSavedToSimulationObjectGroup(
      const DtVrfObject* vrfObject) const;

   virtual DtVrfObject* createObjectFromMemoryBuffer(const std::string& buffer);

   virtual bool hasUUIDOrMarkingText(DtlObjPtr args, DtUUID&) const;

   virtual DtlObjPtr getData(DtlObjPtr args, 
      const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings);

   static void tickCallback(void* args);

   virtual void addVrfObjectAboutToBeAddedCallback(
      DtVrfObjectListActivityCallbackFcn fcn, void* usrData,
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void addVrfObjectAddedCallback(
      DtVrfObjectListActivityCallbackFcn fcn, void* usrData,
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void addVrfObjectAboutToBeLoadedCallback(
      DtVrfObjectListActivityCallbackFcn fcn, void* usrData,
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void addVrfObjectAboutToBeRemovedCallback(
      DtVrfObjectListActivityCallbackFcn fcn, void* usrData,
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void removeVrfObjectAboutToBeAddedCallback(
      DtVrfObjectListActivityCallbackFcn fcn, void* usrData,
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void removeVrfObjectAboutToBeLoadedCallback(
      DtVrfObjectListActivityCallbackFcn fcn, void* usrData,
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void removeVrfObjectAddedCallback(
      DtVrfObjectListActivityCallbackFcn fcn, void* usrData,
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void removeVrfObjectAboutToBeRemovedCallback(
      DtVrfObjectListActivityCallbackFcn fcn, void* usrData,
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void addObjectManagerAboutToRemoveAllCallback(
      DtVrfObjectManagerCallbackFcn fcn, void* usrData);

   virtual void removeObjectManagerAboutToRemoveAllCallback(
      DtVrfObjectManagerCallbackFcn fcn, void* usrData);

   virtual void addOrganizationManagerReadyCallback(
      DtOrganizationManagerReadyCallbackFcn fcn, void* usrData);

   virtual void removeOrganizationManagerReadyCallback(
      DtOrganizationManagerReadyCallbackFcn fcn, void* usrData);

   virtual void enableAutoReorganization();
   virtual void disableAutoReorganization();
   virtual bool autoReorganizeEnabled() const;

   virtual DtEntityIdentifier mapUUIDToEntityIdentifier(const DtUUID&) const;
   virtual DtGlobalObjectDesignator mapUUIDToGlobalId(const DtUUID&) const;
   virtual DtUUID mapGlobalIdToUUID(const DtGlobalObjectDesignator&) const;

   virtual bool objectNameExists(const DtString&) const;

   virtual DtSharedVrfObjectReference lookupTopLevelVrfObject(DtForceType forceType);

   virtual DtString nextNameWithPrefix(const DtObjectType & objectType,
      const DtString& potentialPrefix);

   virtual DtString nextNameWithPrefix(int maxLength,
      const DtString& potentialPrefix);

   virtual DtVrfObject* createAndInitTopLevelVrfObject(DtForceType forceType);
   virtual DtVrfObject* createAndInitTopLevelVrfObject(DtForceType forceType, 
      const DtString& name);
   virtual DtString topLevelName(DtForceType forceType);

   virtual DtString nextName(const DtObjectType& objectType);
   virtual DtString nextUnorganizedName();
   virtual DtString uniquifyName(const DtString& name, const DtObjectType& objectType);

   virtual unsigned int maxNameLengthForType(const DtObjectType& objectType);

   virtual DtReflectedObject* lookupReflectedObject(
      const DtGlobalObjectDesignator& globalId) const;

   virtual void rediscoverObjects(const std::set<DtGlobalObjectDesignator>& ignore =
      std::set<DtGlobalObjectDesignator>());

   virtual void requestUpdatesForRemoteNonVrfObjects() const;

   virtual void objectNameChanged(DtVrfObject*, const DtString& oldName, 
      const DtString& newName);

   virtual void objectUUIDChanged(const DtUUID& oldUUID, const DtUUID& newUUID);


   virtual void addObjectNameChangedCallback(DtVrfObjectNameChangedCallbackFcn fcn, void* usr);
   virtual void removeObjectNameChangedCallback(DtVrfObjectNameChangedCallbackFcn fcn, void* usr);


   virtual void addObjectUUIDChangedCallback(DtVrfObjectUUIDChangedCallbackFcn fcn, void* usr);
   virtual void removeObjectUUIDChangedCallback(DtVrfObjectUUIDChangedCallbackFcn fcn, void* usr);

   virtual DtVrfObject* aggregateAs(
      const DtObjectType& aggregateType, 
      DtForceType force, 
      const DtVector& dbPosition,
      DtReal heading,
      const std::vector<DtUUID>& subordinates = std::vector<DtUUID>(),
      const DtString& aggregateName = DtString::nullString(),
      bool addToOrbat = true);

   virtual double timeOfDay() const;

   virtual double dateAndTimeOfDay() const;

   virtual void setSimulationDateTimeBasedOnLocation(const DtVector& geocentricLocation, int timeOfDay);

   virtual bool addSubordinatesToAggregate(DtVrfObject* object, 
      const std::vector<DtUUID>& subordinates, DtAggregateState desiredState = DtFullyDisaggregated);

   static void addSubordinatesToAggregateCompleteCallback(void* usr);

   virtual DtOrganizationManager* organizationManager();
   virtual const DtOrganizationManager* organizationManager() const;

   virtual DtOrbatManager* orbatManager();
   virtual const DtOrbatManager* orbatManager() const;

   virtual DtDiGuyCharacterDataManager * diGuyCharacterManager();
   virtual const DtDiGuyCharacterDataManager * diGuyCharacterManager() const;

   virtual void setCoordinateSystem(const Coordinate_System* coordinateSystem);

   virtual unsigned objectCount() const;

   virtual DtSharedVrfObjectReference lookupVrfObjectByEntityIdentifier(const DtEntityIdentifier& key) const;

   virtual DtSharedVrfObjectReference lookupVrfObjectByGlobalId(const DtGlobalObjectDesignator& globalId) const;

   virtual DtSharedVrfObjectReference lookupVrfObjectByUUID(const DtUUID&) const;

   virtual bool uuidExists(const DtUUID&) const;

   virtual bool addNameAlias(const DtString& aliasName, DtVrfObject* object);

   virtual void removeNameAlias(const DtString& alias);

   virtual DtSharedVrfObjectReference lookupVrfObjectByMarkingText(const DtString&) const;

   virtual bool hasObjectType(const DtObjectType&) const;

   virtual bool markingTextExists(const DtString&) const;

   virtual const DtSimulationAddress& simulationAddress() const;

   const DtSimObjectMapIterator& iterator() const;

   virtual bool createSimObjectList();

   virtual const DtSimObjectMap& objectMap() const;

   virtual void createRemoteEntitiesList(DtExerciseConn* exConn);
   virtual void createRemoteAggregatesList(DtExerciseConn* exConn);

   static void entityAddedCallback(DtReflectedExtEntity* entity, void* userData);

   static void entityRemovedCallback(DtReflectedExtEntity* entity,
      void* userData);

   static void aggregateAddedCallback(DtReflectedExtAggregate* entity,
      void* userData);

   static void aggregateRemovedCallback(DtReflectedExtAggregate* entity,
      void* userData);

   static void entityChangedCallback(DtReflectedExtEntity* entity,
      void* userData);

   static void aggregateChangedCallback(DtReflectedExtAggregate* aggregate,
      void* userData);

   virtual void processEntityChanged(DtReflectedExtEntity* entity);

   static bool entityDiscoveryCriteriaCallback(DtReflectedObject* entity,
      void* userData);

   static bool aggregateDiscoveryCriteriaCallback(DtReflectedObject* aggregate,
      void* userData);

   virtual bool processEntityDiscoveryCriteria(
      DtReflectedEntity* entity);

   virtual bool processAggregateDiscoveryCriteria(
      DtReflectedAggregate* aggregate); 

   virtual DtReflectedDesignator * lookupLasedTargetByGlobalId(const DtGlobalObjectDesignator&
      tgtGlobalId);

   virtual bool hostingDynamicTerrainServer() const;

   virtual DtReflectedDesignator* lookupLasedTargetByDesignatorCode(const int code);

   virtual void createRemoteDesignatorsList(DtExerciseConn* exConn);

   virtual void createRemoteActiveSonarList(DtExerciseConn* exConn);
   virtual void createRemotePropulsionNoiseList(DtExerciseConn* exConn);
   virtual void createRemoteEmitterSystemList(DtExerciseConn* exConn);
   virtual void createRemoteIffList(DtExerciseConn* exConn);

#if DtHLA


   virtual void createRemoteExtendedAttributesList(DtExerciseConn* exConn);
#endif

   DtReflectedDesignatorList* reflectedDesignatorList() const;

   DtReflectedActiveSonarList* reflectedActiveSonarList() const;
   DtReflectedPropulsionNoiseList* reflectedPropulsionNoiseList() const;
   DtReflectedIffList* reflectedIffList() const;

   virtual DtVrfParameterDb* objectParametersDB() const;   

   virtual void addSimObjectQueuedForRemovalCallback(
      DtVrfObjectQueuedForRemocalCallbackFcn fcn, void* usr);
   virtual void removeSimObjectQueuedForRemovalCallback(
      DtVrfObjectQueuedForRemocalCallbackFcn fcn, void* usr);
   virtual void invokeSimObjectQueuedForRemovalCallbacks(
      DtVrfObject* object);

   virtual void addSimObjectAboutToBeAddedCallback(
      DtSimObjectListActivityCallbackFcn fcn, void* usrData, 
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void addSimObjectAddedCallback(
      DtSimObjectListActivityCallbackFcn fcn, void* usrData, 
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void addSimObjectAboutToBeRemovedCallback(
      DtSimObjectListActivityCallbackFcn fcn, void* usrData, 
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void addSimObjectAboutToBeLoadedCallback(
      DtSimObjectListActivityCallbackFcn fcn, void* usrData, 
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void removeSimObjectAboutToBeAddedCallback(
      DtSimObjectListActivityCallbackFcn fcn, void* usrData, 
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void removeSimObjectAddedCallback(
      DtSimObjectListActivityCallbackFcn fcn, void* usrData, 
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void removeSimObjectAboutToBeLoadedCallback(
      DtSimObjectListActivityCallbackFcn fcn, void* usrData, 
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void removeSimObjectAboutToBeRemovedCallback(
      DtSimObjectListActivityCallbackFcn fcn, void* usrData,
      const DtObjectType& filter = DtObjectType::anyType(),
      bool invertFilter = false);

   virtual void invokeSimObjectAboutToBeAddedCallbacks(
      DtVrfObject* simObject) const;

   virtual void invokeSimObjectAddedCallbacks(
      DtVrfObject* simObject) const;

   virtual void invokeSimObjectAboutToBeRemovedCallbacks(
      DtVrfObject* simObject) const;

   virtual void invokeSimObjectAboutToBeLoadedCallbacks(
      DtVrfObject* simObject) const;

   virtual DtReflectedExtEntityList* reflectedEntityList() const;

   virtual DtReflectedExtAggregateList* reflectedAggregateList() const;

   virtual void setSimObjectType(const DtString& type);
   virtual const DtString& simObjectType() const;

   virtual void setOrbatEnabled(bool);
   virtual bool orbatEnabled() const;

   virtual void setOrderOfBattleObjectsAddedToOrbatByDefault(bool b);
   virtual bool orderOfBattleObjectsAddedToOrbatByDefault() const;

   virtual void closingScenario();

   virtual bool addUUIDMappingForObject(DtVrfObject* vrfObject);

   virtual void removeUUIDMappingForObject(DtVrfObject* vrfObject);

   virtual DtEntityIdentifier nextId(DtVrfObject* o = NULL);

   virtual DtString generateUniqueName(int maxLength, const DtString&
      root = "Object") const;

   virtual void setRollUpRules(const DtAssembliesReaderWriter::RwRootNode&);

   virtual const DtAssembliesReaderWriter::RwRootNode& rollUpRules() const;

   virtual void setActivities(const DtRwActivities&);

   virtual const DtRwActivities& activities() const;

   virtual bool isLocal(const DtBaseEntityStateRepository& stateRep);

   static int aggregateSuperType(DtAggregateStateRepository* aggregate);

   virtual void objectsEmbarkedOn(DtVrfObjectStateRepository* vrfObjSR, std::vector<DtSharedVrfObjectReference>& list,
      bool includePseudoAggregates = true) const;

   static void designatorAddedCallback(DtReflectedDesignator * des,
      void * userData);

   static void designatorRemovedCallback(DtReflectedDesignator * des,
      void * userData);

   static void designatorChangedCallback(DtReflectedDesignator * des,
      void * userData);

   static DtBoolean designatorDiscoveryCriteriaCallback(DtReflectedObject * des,
      void * userData);

   static void activeSonarAddedCallback(DtReflectedActiveSonar* activeSonar,
      void* userData);
   static void activeSonarRemovedCallback(DtReflectedActiveSonar* activeSonar,
      void* userData);
   static void activeSonarChangedCallback(DtReflectedActiveSonar* activeSonar,
      void* userData);
   static DtBoolean activeSonarDiscoveryCriteriaCallback(
      DtReflectedObject* activeSonar, void* userData);

   static void propulsionNoiseAddedCallback(DtReflectedPropulsionNoise* propNoise,
      void* userData);
   static void propulsionNoiseRemovedCallback(DtReflectedPropulsionNoise* propNoise,
      void* userData);
   static void propulsionNoiseChangedCallback(DtReflectedPropulsionNoise* propNoise,
      void* userData);
   static DtBoolean propulsionNoiseDiscoveryCriteriaCallback(
      DtReflectedObject* propNoise, void* userData);

   static void iffAddedCallback(DtReflectedIff* propNoise,
      void* userData);
   static void iffRemovedCallback(DtReflectedIff* propNoise,
      void* userData);
   static void iffChangedCallback(DtReflectedIff* propNoise,
      void* userData);
   static DtBoolean iffDiscoveryCriteriaCallback(
      DtReflectedObject* iff, void* userData);

   virtual bool canSimulate() const;

   virtual void setCanSimulate(bool);

   virtual void printReflectedObjectCounts() const;

   virtual void addStealthType(const DtEntityType&);
   virtual void removeStealthType(const DtEntityType&);
   virtual bool isStealthType(const DtEntityType&) const;
   std::vector<DtEntityType>& stealthTypes() { return myStealthTypes; };
   const std::vector<DtEntityType>& stealthTypes() const { return myStealthTypes; };

   virtual std::set<DtVrfObject*> objectsOnOverlayLayer(const DtString&) const;

   static void vrfObjectDataChangedCallback(DtVrfObject*, int, void*);
   virtual void processVrfObjectDataChanged(DtVrfObject*, int);
   
   virtual void clearObjectsAwaitingDiscovery();

protected:
   virtual void processOrganizationManagerReady(const DtOrganizationManagerReadyCallbackInfo&);
   virtual void invokeOrganizationManagerReadyCallbacks(const DtOrganizationManagerReadyCallbackInfo&);

protected:
   virtual DtObjectType potentialRandomObjectTypeFrom(const DtObjectType& original);

   virtual void rediscoverNonVRFEntities();

   virtual void remove(DtVrfObject* simObject);
   virtual void remove(DtSharedVrfObjectReference simObject);
   virtual DtVrfObject* remove(const DtEntityIdentifier& key);

   virtual void invokeObjectManagerAboutToRemoveAllCallbacks() const;

   virtual void onQueueObjectForRemoval(DtVrfObject* vrfObject, bool andRemoveFromOrbat = false);

   virtual const Coordinate_System* coordinateSystem() const;
   virtual Coordinate_System* coordinateSystem();

   virtual void modifyInterfaceContentForNewObject(DtSimInterfaceContent*, DtVrfObject*, bool& isLocal) const;

   virtual std::list<DtVector> calculateFormationOffsetsBasedOnFootprints(const DtList&) const;

   virtual std::vector<Dt3dBoundingVolume> boundingVolumesOfChildren(const DtList& subObjects,
      int& totalLeafNodes) const;

protected:
   virtual void checkPendingNameRemoval(const DtString& markingText);

   virtual void removeVrfObject(const DtUUID&, bool queueDeletionOfVrfObject = false);

   virtual DtObjectGeometricModelsManager* createObjectModelsManager() const;

   virtual DtVrfEntityIdentifierFactory* createVrfEntityIdentifierFactory();

   virtual DtVrfObjectPlanAdministrator* createPlanAdministrator();
   
   virtual bool finalizeObjectRead(DtVrfObject*);

   virtual DtEntityIdentifier findEntityIdentifier(DtlObjPtr);

   virtual void deleteVrfObjectsToBeDeleted();

   virtual DtEntityType standardAggregateTypeToVrfAggregateType(const DtEntityType& aggType) const;

public:
   DtObjectGeometricModelsManager* objectModelsManager() const;
   DtVrfEntityIdentifierFactory* vrfEntityIdentifierFactory() const;

#if DtHLA_1516_EVOLVED

   virtual void reserveGlobalObjectIds(unsigned numToReserve);
#endif

   virtual DtGlobalObjectDesignator nextGlobalObjectId();
   
   virtual DtVrfObjectPlanAdministrator* planAdministrator();

   virtual DtSimInternalCommunicationManager* simInternalCommunicationManager();

protected:
   virtual DtSimInternalCommunicationManager* createSimInternalCommunicationManager(
      DtSimManager* simMgr) const;

protected:

   typedef std::pair<DtVrfObject*, DtVrfSimulationObjectGroupGeometry*> PendingObjectInformation;
   typedef std::vector<PendingObjectInformation> PendingObjectsInformation;
   typedef std::vector<PendingObjectsInformation> ObjectsAwaitingDiscovery;

   virtual bool addObjectsReadyForSimulation(PendingObjectsInformation&);

   static void modifyVrfObjectCallback(DtSimMessage* msg, void* usr);
   static void modifyVrfOverlayCallback(DtSimMessage* msg, void* usr);
   static void autoReorganizeCallback(DtSimMessage* msg, void* usr);
   static void skipTaskCallback(DtSimMessage* msg, void* usr);
   static void setThresholdsCallback(DtSimMessage* msg, void* usr);
   static void deleteDynamicTerrainServerCallback(DtSimMessage*, void*);

#if DT_SINGLE_STATE_UPDATE_MESSAGE
   static void vrfObjectStateUpdateCallback(DtSimMessage* msg, void* usr);
#endif

   static void createVrfObjectCallback(DtSimMessage* msg, void* usr);
   static void deleteVrfObjectCallback(DtSimMessage* msg, void* usr);
   static void deleteVrfObjectByIdCallback(DtSimMessage* msg, void* usr);
   static void vrfObjectDeletedCallback(DtSimMessage* msg, void* usr);
   static void orderOfBattleOpCallback(DtSimMessage* msg, void* usr);
   static void aggregateAsCallback(DtSimMessage* msg, void* usr);

   static void extendedLabelsOperationCallback(DtSimMessage* msg, void* usr);
   virtual void processExtendedLabelsOperation(DtSimMessage*);

   static void requestActivitiesCallback(DtSimMessage* msg, void* usr);
   virtual void processRequestActivities(DtSimMessage*);

   static void requestJoystickControlsCallback(DtSimMessage* msg, void* usr);
   virtual void processRequestJoystickControls(DtSimMessage*);

   virtual bool acceptRemoteEnvironmental(const DtEntityType& et) const;

   static void createVrfObjectPostDrainCallback(void* usr);
   static void deleteVrfObjectPostDrainCallback(void* usr);
   static void deleteVrfObjectByIdPostDrainCallback(void* usr);
   static void vrfObjectDeletedPostDrainCallback(void* usr);
   static void aggregateAsPostDrainCallback(void* usr);
   
   static void envProcessAddedCallback(
      DtReflectedEnvironmentProcess* envProcess, void* userData);
   static void envProcessRemovedCallback(
      DtReflectedEnvironmentProcess* envProcess, void* userData);
   static bool envProcessDiscoveryCriteria(
      DtReflectedObject* envProcess, void* userData);

   static void organizationManagerReadyCallback(const DtOrganizationManagerReadyCallbackInfo& info, void* usr);

protected:

   DtVrfObjectManager();

   DtVrfObjectManager(const DtVrfObjectManager& orig);

   DtVrfObjectManager& operator=(const DtVrfObjectManager& orig);
  
   static void postInitFromParamsCallback(DtVrfObject* vrfObject, void* usr);

   virtual DtCreateQueueEntry* createQueueEntryCreator(DtIfCreateVrfObject msg);
      
   virtual DtModifyQueueEntry* modifyQueueEntryCreator(DtIfModifyVrfObject msg);

   virtual DtOrganizationManager* createOrganizationManager();

   virtual DtOrbatManager* createOrbatManager();
      
protected:
   DtRemoteComponentAttachmentManager *myRemoteComponentAttachmentManager;

   DtSimObjectMap mySimObjectList;

   DtReflectedExtEntityList* myRemoteEntitiesList;

   DtReflectedExtAggregateList* myRemoteAggregateEntitiesList;

   DtReflectedDesignatorList* myRemoteDesignatorsList;

   DtReflectedActiveSonarList* myRemoteActiveSonarList;
   DtReflectedPropulsionNoiseList* myRemotePropulsionNoiseList;

   DtReflectedEmitterSystemManager* myReflectedEmitterSystemManager;

   DtReflectedIffList* myReflectedIffList;

#if DtHLA

   makVrfVrlinkExtToolkit::DtReflectedExtendedAttributesObjectList* myRemoteExtendedAttributesObjectsList;
#endif

   DtVrfParameterDb* myParameterDatabase;

   

   DtSimObjectListActivityCallbackList myAboutToBeLoadedSimObjectCallbackList;

   DtSimObjectListActivityCallbackList myAboutToBeAddedSimObjectCallbackList;

   //typedef std::set<DtSimObjectListActivityCallbackInfo*, ObjectCallbackListCmp> AddedList;
   DtSimObjectListActivityCallbackList myAddedSimObjectCallbackList;
   //mutable tbb::spin_rw_mutex myAddedSimObjectCallbackListMutex;

   //typedef std::set<DtSimObjectListActivityCallbackInfo*, ObjectCallbackListCmp> ToBeRemovedList;
   DtSimObjectListActivityCallbackList myAboutToBeRemovedSimObjectCallbackList;
   //mutable tbb::spin_rw_mutex myAboutToBeRemovedSimObjectCallbackListMutex;

   //mutable std::set<DtSimObjectListActivityCallbackInfo*> myRemovalCallbacksRemoved;

   DtString                            mySimObjectType;

   mutable DtSimObjectMapIterator*        myIterator;

   DtExerciseConn*                     myExerciseConn;
  
   int                                 myIndexSize;

   DtManagedObjectListManager*        myFilteredObjectListManager;
   
   mutable DtVrfObjectFilterMapIterator*  myVrfIterator;

   DtSimManager*                       mySimManager;
   
   std::map<DtUUID, bool>                             myObjectsToRemoveQueue;
   std::map<DtString, std::map<DtUUID, bool> >        myObjectsToRemoveByNameQueue;

   DtVrfObjectCreateQueue              myObjectsToCreateQueue;

   typedef DtBoost::shared_ptr<DtModifyQueueEntry> DtModifyQueueEntryPtr;
   typedef std::list<DtModifyQueueEntryPtr> DtVrfObjectModifyQueue; 
   DtVrfObjectModifyQueue              myObjectsToModifyQueue;

   bool myAutoReorganizeFlag;

   DtReflectedControlObjectList*       myRemoteEnvironmentalsList;

   int myNameCounter;

   typedef boost::unordered_map<DtString, DtSharedVrfObjectReference> GlobalIdToObjectMap;
   GlobalIdToObjectMap myGlobalIdToObjectMap;

   DtOrbatManager* myOrbatManager;

   DtOrganizationManager* myOrganizationManager;

   DtDiGuyCharacterDataManager * myCharacterMgr;

   const Coordinate_System* myCoordinateSystemPtr;

   double myTimeToPublishNextStateUpdate;

   DtVrfObject* myDynamicTerrainServer;

   DtObjectGeometricModelsManager*  myObjectModelsManager;

   DtSimInternalCommunicationManager* mySimInternalCommunicationManager;

   DtVrfObjectPlanAdministrator* myPlanAdministrator;

   typedef DtCallbackList<const DtVrfObjectNameChangedCallbackInfo&> DtNameChangedCallbackList;
   DtNameChangedCallbackList myObjectNameChangedCallbackList;

   typedef DtCallbackList<DtVrfObject*> DtObjectQueuedForRemovalCallbackList;
   DtObjectQueuedForRemovalCallbackList myObjectQueuedForRemovalCallbackList;
   mutable tbb::spin_rw_mutex myQueuedForRemovalSimObjectCallbackListMutex;

   typedef DtCallbackList<const DtVrfObjectUUIDChangedCallbackInfo&> DtUUIDChangedCallbackList;
   DtUUIDChangedCallbackList myObjectUUIDChangedCallbackList;

   typedef DtCallbackList<const DtVrfObjectAboutToBePublishedCallbackInfo&> VrfObjectAboutToBePublishedCallbackList;
   VrfObjectAboutToBePublishedCallbackList myVrfObjectAboutToBePublishedCallbackList;

   DtOrganizationReadyCallbackList myOrganizationManagerReadyCallbackList;

   DtConsoleCommandOwner* myConsoleCommands;

   DtRwActivities myActivities;

   bool myImportingScenario;
   bool myCreatedCharacterManager;

   DtAssembliesReaderWriter::RwRootNode myRollUpRules;
   bool myPublishZeroVelocityWhenPaused;
   bool mySetDeadReckoningAlgorithmToStaticOnPause;

   DtTaskVisualizationPublicationMode myTaskVisualizationPublicationMode;
   bool myUseDrawControlForTaskVisualizations;
   std::set<DtUUID> myObjectsWithTaskVisualizations;
   unsigned myMaxObjectsWithTaskVisualizations;
   bool myWarnedAboutTaskVisLimit;

   typedef boost::unordered_map<DtUUID, DtSharedVrfObjectReference> UUIDToObjectMap;
   UUIDToObjectMap myUUIDToObjectMap;

   typedef boost::unordered_map<DtString, DtSharedVrfObjectReference> NameToObjectMap;
   NameToObjectMap myNameToObjectMap;
   mutable NameToObjectMap myAwaitingToBeCreatedMap;

   typedef boost::unordered_map<DtVrfObject*, DtSharedVrfObjectReference> ObjectToObjectMap;
   ObjectToObjectMap myObjectToObjectMap;

   DtImportScenarioData myImportScenarioData;

   std::vector<DtVrfObject*> myJustAdded;

   std::map<int, DtlObjPtr> mySortedByEntityId;
   ObjectsAwaitingDiscovery myObjectsAwaitingDiscovery;
   DtVrfEntityIdentifierFactory* myEntityIdentifierFactory;
   bool myReuseEntityIdentifiersOnScenarioLoad;
   bool myLoadingScenarioInformation;
   bool myCanSimulate;
   bool myOrderOfBattleObjectsAddedToOrbatByDefault;

   DtReaderWriter::SearchPaths mySearchPaths;

#if DtHLA_1516
   std::set<DtGlobalObjectDesignator> myReservedGlobalIds;
#endif
   
   std::vector<DtEntityType> myStealthTypes;

   std::vector<DtVrfObject*> myVrfObjectsToDelete;

private:

   std::vector<DtVrfObjectManagerCallbackInfo> myAboutToRemoveAllCallbackList;

   mutable tbb::spin_rw_mutex myOverlayMapMutex;
   typedef std::map<DtString, std::set<DtVrfObject*> > OverlayMap;
   typedef std::map<DtVrfObject*, DtString> ObjectOverlayMap;

   ObjectOverlayMap myObjectOverlayMap;
   OverlayMap myOverlayMap;

   bool myIsDeadReckonAlgorithmOverridden;
   DtDeadReckonTypes myDeadReckonOverrideAlgorithm;

   __itt_domain* myVTuneDomain;
   __itt_string_handle* myVTuneEntityTickHandle;
   __itt_string_handle* myVTuneComponentTickHandle;
   
   DtTime myNextOrgMgrTickTime;
   static DtTime theOrgMgrTickPeriod;
};

inline DtRemoteComponentAttachmentManager* DtVrfObjectManager::remoteComponentAttachmentManager()
{
   return (myRemoteComponentAttachmentManager);
}

inline const DtRemoteComponentAttachmentManager* DtVrfObjectManager::remoteComponentAttachmentManager() const
{
   return (myRemoteComponentAttachmentManager);
}