vrfObjMgr.h

Go to the documentation of this file.

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


#pragma once

#include "vrfutil/rwObjType.h"
#include "vrfutil/callbackList.h"
#include "vrfutil/rwList.h"
#include "vrfobjcore/vrfObjFiltIter.h"
#include "vrfobjcore/orgManager.h"
#include "vrfobjcore/managedObjList.h"
#include "vrfobjcore/fltrFcnPred.h"
#include "vrfobjcore/simObjIter.h"
#include "vrfobjparam/vrfObjParams.h"
#include <vrfExtProtocol/objTypeEnums.h>
#include "vrftasks/extendedAggregateEnums.h"

#include <vlpi/appearance.h>
#include <vlutil/vlFilename.h>
#include <vlutil/vlList.h>
#include <vlutil/vlConfig.h>
#include <vlutil/vlSmartPointers.h>

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

#define DT_SINGLE_STATE_UPDATE_MESSAGE 0

class DtTerrainDbFactory;

class DtVrfObject;
class DtHashlist;
class DtExerciseConn;
class DtReflectedObject;
class DtReflectedAggregate;
class DtReflectedExtEntity;
class DtReflectedExtAggregate;
class DtReflectedExtEntityList;
class DtReflectedExtAggregateList;
class DtVrfParameterDb;
class DtSimObjectListActivityCallbackInfo;
class DtSimObjectSubComponentTypes;
class DtVertexList;
class DtAggregateStateRepository;
class DtBaseEntityStateRepository;
class DtManagedObjectListManager;
class DtSimManager;
class DtVrfObjectManagerTickArguments;
class DtSimTickArguments;
class DtSimMessage;
class DtIfCreateVrfObject;
class DtIfAggregateAs;
class DtVrfObjectStateRepository;
class DtReflectedEnvironmentProcess;
class DtReflectedControlObjectList;
class DtVrfObjectSubComponentTypes;
class DtReflectedObject;
class DtEchelonIdTable;
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;

typedef void (*DtSimObjectListActivityCallbackFcn)(DtVrfObject* simObject, 
   void* usr);

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

typedef void (*DtVrfObjectListActivityCallbackFcn)(DtVrfObject* vrfObject,
   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 DtVrfObjectNameChangedCallbackInfo
{
   DtString myOldName;
   DtString myNewName;
   DtVrfObject* myVrfObject;
};

typedef DtCallbackList<const DtVrfObjectNameChangedCallbackInfo&>::DtCallbackFunctionType DtVrfObjectNameChangedCallbackFcn;

#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 void createRemoteComponentAttachmentManager();

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

   virtual bool create();

   virtual bool createObjectNameHashlist();

#ifdef DtHLA
   virtual bool createGlobalIdHashlist();
#endif

   virtual bool init();

   virtual void createDIGuyCharacterManager(const DtFilename & diGuyDataFile,
                     const DtFilename & diGuyAnimationsFile);

   virtual bool add(DtVrfObject* simObject);

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

public:

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

   virtual DtVrfObject* lookupVrfObject(const DtEntityIdentifier& key);
   virtual const DtVrfObject* lookupVrfObject(const DtEntityIdentifier& key) const;
   
   virtual DtVrfObject* lookupVrfObjectByGlobalId(
      const DtGlobalObjectDesignator& globalId);
   virtual const DtVrfObject* lookupVrfObjectByGlobalId(
      const DtGlobalObjectDesignator& globalId) const;

   virtual DtVrfObject* lookupVrfObjectByName(const DtString& name, bool
      warnOnFailure = true);
   virtual const DtVrfObject* lookupVrfObjectByName(const DtString& name, bool
      warnOnFailure = true) const;

   virtual const DtVrfObject* lookupVrfObjectByEchelonIdString(
      const DtString& echIdString) const;
   virtual DtVrfObject* lookupVrfObjectByEchelonIdString(
      const DtString& echIdString);

   virtual const DtVrfObject* lookupVrfObjectByEchelonId(
      const DtEchelonId& echId) const;
   virtual DtVrfObject* lookupVrfObjectByEchelonId(
      const DtEchelonId& echId);

   virtual DtVrfObject * lookupVrfObjectByObjectId(const DtObjectId & id) const;


   virtual DtGlobalObjectDesignator lookupGlobalId(const DtObjectId & id) const;

   virtual DtObjectId lookupObjectId(const DtGlobalObjectDesignator & globalId);

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

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

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

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

   virtual void removeAndDelete(const DtString& objectName);
   virtual void removeAndDelete(const DtEntityIdentifier& key);
   virtual void removeAndDelete(DtVrfObject* object);

   virtual void removeAndDeleteAllLocals();

   virtual void removeAndDeleteAll();

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

   virtual DtReflectedControlObjectList* reflectedEnvironmentProcessList() const;

   virtual DtReflectedControlObjectList* createReflectedControlObjectList(DtExerciseConn* exConn);

   virtual void registerInterfaceCallbacks();

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

   virtual void processCreateVrfObject(DtSimMessage* msg);

   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 processOrderOfBattleOp(DtSimMessage* msg);
   virtual void processAutoReorganize(DtSimMessage* msg);
   virtual void processAggregateAs(DtSimMessage* msg);
   virtual void processSkipTask(DtSimMessage* msg);


   virtual void processSetThresholds(DtSimMessage* msg);
   
   virtual void processCreateControlObject(DtSimMessage* msg);
   virtual void processCreateEntity(DtSimMessage* msg);
   virtual void processRemoveEntity(DtSimMessage* msg);
   virtual void processRequestEntityName(DtSimMessage* msg);

   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 bool hasEnabledActiveSonar(const DtVrfObject* host) const;

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

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

   virtual void queueObjectForRemoval(const DtEntityIdentifier& key);

   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 = DtObjectTypeAggregate);

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

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

   virtual void createSubObjectsFromParameters(DtVrfObject* parent,
      bool publishSubobjects);

   virtual DtVrfObject* createSubObjectFromParameterEntry(
      const DtVrfSubObjectParameterEntry& entry, const DtVector& positionOffsetFromParent,
      const DtVrfObject& parent, 
      const DtString& formationName,
      bool publishSubObject);

   virtual bool readOrderOfBattleFile(const DtString & filename);
   virtual bool writeOrderOfBattleFile(const DtString & filename);
   virtual bool objectShouldBeSavedToOrderOfBattle(
      const DtVrfObject* vrfObject);

   virtual DtlObjPtr getData(DtlObjPtr args, const DtFilename& searchPath,
      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 DtVrfObject* lookupTopLevelVrfObject(DtForceType forceType);
   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 void processOverlayOp(DtSimMessage* msg);
   virtual bool readOverlayFile(const DtString& filename);

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

   virtual void rediscoverObjects();

   virtual void requestUpdatesForRemoteNonVrfObjects() const;

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


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

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

   virtual void removeNameAlias(const DtString& alias);

   virtual DtVrfObject* aggregateAs(
      const DtObjectType& aggregateType, 
      DtForceType force, 
      const DtVector& dbPosition,
      DtReal heading,
      DtList* subordinateNames = 0,
      const DtString& aggregateName = DtString::nullString());

   virtual bool addSubordinatesToAggregate(DtVrfObject* object, 
      const DtList* subordinateNames, DtAggregateState desiredState = DtFullyDisaggregated);

   static void addSubordinatesToAggregateCompleteCallback(void* usr);

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

   virtual DtDIGuyCharacterDataManager * diGuyCharacterManager();
   virtual const DtDIGuyCharacterDataManager * diGuyCharacterManager() const;

   virtual void setCoordinateSystem(const Coordinate_System* coordinateSystem);

   virtual unsigned objectCount() const;

   virtual DtVrfObject* lookup(const DtEntityIdentifier& key);
   virtual const DtVrfObject* lookup(const DtEntityIdentifier& key) const;

   virtual DtVrfObject* lookupObjectByGlobalId(const DtGlobalObjectDesignator& globalId);
   virtual const DtVrfObject* lookupObjectByGlobalId(
      const DtGlobalObjectDesignator& globalId) const;

   virtual DtVrfObject* lookupObjectByName(const DtString& objectName);
   virtual const DtVrfObject* lookupObjectByName(const DtString& objectName) const;

   virtual const DtSimulationAddress& simulationAddress() const;

   const DtSimObjectIterator& iterator() const;

   virtual bool createSimObjectList();

   virtual DtHashlist* hashlist() 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 DtReflectedDesignator* lookupLasedTargetByDesignatorCode(const int code);

   virtual void createRemoteDesignatorsList(DtExerciseConn* exConn);

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

   DtReflectedDesignatorList* reflectedDesignatorList() const;

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

   virtual DtVrfParameterDb* objectParametersDB() const;

   virtual void addSimObjectAboutToBeAddedCallback(
      DtSimObjectListActivityCallbackInfo* cbInfo);
   virtual void addSimObjectAddedCallback(
      DtSimObjectListActivityCallbackInfo* cbInfo);
   virtual void addSimObjectAboutToBeRemovedCallback(
      DtSimObjectListActivityCallbackInfo* cbInfo);
   virtual void addSimObjectAboutToBeLoadedCallback(
      DtSimObjectListActivityCallbackInfo* cbInfo);

   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 removeSimObjectAboutToBeRemovedCallback(
      const DtSimObjectListActivityCallbackInfo& cbInfo);

   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 removeSimObjectAboutToBeAddedCallback(
      const DtSimObjectListActivityCallbackInfo& cbInfo);
   virtual void removeSimObjectAddedCallback(
      const DtSimObjectListActivityCallbackInfo& cbInfo);
   virtual void removeSimObjectAboutToBeLoadedCallback(
      const DtSimObjectListActivityCallbackInfo& cbInfo);

   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 const DtEntityIdentifier& nextId();

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

   virtual bool isLocal(const DtBaseEntityStateRepository& stateRep);

   static int aggregateSuperType(DtAggregateStateRepository* aggregate);

   virtual void objectsEmbarkedOn(DtVrfObjectStateRepository* vrfObjSR, std::list<DtString>& list,
      bool includePsuedoAggregates = 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);

   virtual bool canSimulate() const;

   virtual void printReflectedObjectCounts() const;

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

protected:
   virtual void rediscoverNonVRFEntities();

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

   virtual void invokeObjectManagerAboutToRemoveAllCallbacks() const;

   virtual void onQueueObjectForRemoval(DtVrfObject* vrfObject);


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

protected:
   virtual DtObjectGeometricModelsManager* createObjectModelsManager() const;

   virtual DtVrfObjectPlanAdministrator* createPlanAdministrator();
   
public:
   DtObjectGeometricModelsManager* objectModelsManager() const;
   void setTerrainDbFactory(DtTerrainDbFactory*);
   DtTerrainDbFactory* terrainDbFactory();
   
   virtual DtVrfObjectPlanAdministrator* planAdministrator();

   virtual DtSimInternalCommunicationManager* simInternalCommunicationManager();

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

protected:

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

#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 createVrfObjectPostDrainCallback(void* usr);
   static void deleteVrfObjectPostDrainCallback(void* usr);
   static void deleteVrfObjectByIdPostDrainCallback(void* usr);
   static void vrfObjectDeletedPostDrainCallback(void* usr);
   static void orderOfBattleOpPostDrainCallback(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);
      
protected:
   DtRemoteComponentAttachmentManager *pMyRemoteComponentAttachmentManager;

   DtHashlist* mySimObjectList;

   DtReflectedExtEntityList* myRemoteEntitiesList;

   DtReflectedExtAggregateList* myRemoteAggregateEntitiesList;

   DtReflectedDesignatorList* myRemoteDesignatorsList;

   DtReflectedActiveSonarList* myRemoteActiveSonarList;
   DtReflectedPropulsionNoiseList* myRemotePropulsionNoiseList;

   DtVrfParameterDb* myParameterDatabase;

   DtList myAboutToBeLoadedSimObjectCallbackList;

   DtList myAboutToBeAddedSimObjectCallbackList;

   DtList myAddedSimObjectCallbackList;

   DtList myAboutToBeRemovedSimObjectCallbackList;

   DtString                            mySimObjectType;

   mutable DtSimObjectIterator*        myIterator;

   DtExerciseConn*                     myExerciseConn;
  
   int                                 myIndexSize;

   DtManagedObjectListManager*        myFilteredObjectListManager;
   
   mutable DtVrfObjectFilterIterator*  myVrfIterator;

   DtSimManager*                       mySimManager;
   
   DtList                              myObjectsToRemoveQueue;

   typedef DtBoost::shared_ptr<DtCreateQueueEntry> DtCreateQueueEntryPtr;
   typedef std::list<DtCreateQueueEntryPtr> DtVrfObjectCreateQueue; 
   DtVrfObjectCreateQueue              myObjectsToCreateQueue;

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

   bool myAutoReorganizeFlag;

   DtReflectedControlObjectList*       myRemoteEnvironmentalsList;

   int myNameCounter;

   DtHashlist* myObjectNameHashlist;

#ifdef DtHLA
   DtHashlist* myGlobalIdHashlist;
#endif

   DtOrganizationManager* myOrganizationManager;
   DtEchelonIdTable* myEchelonIdTable;

   DtDIGuyCharacterDataManager * myCharacterMgr;

   const Coordinate_System* myCoordinateSystemPtr;

   double myTimeToPublishNextStateUpdate;

   DtObjectGeometricModelsManager*  myObjectModelsManager;

   DtSimInternalCommunicationManager* mySimInternalCommunicationManager;

   DtVrfObjectPlanAdministrator* myPlanAdministrator;

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

   DtOrganizationReadyCallbackList myOrganizationManagerReadyCallbackList;

   DtConsoleCommandOwner* myConsoleCommands;

private:

   std::vector<DtVrfObjectManagerCallbackInfo> myAboutToRemoveAllCallbackList;

   DtTerrainDbFactory*  myTerrainDbFactory;
};

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

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