orbatManager.h

Go to the documentation of this file.

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

#pragma once


#include "vrfobjcore/vrfobjcoreDefines.h"
#include <vector>
#include "vrfobjcore/organizationManager.h"
#include "vrfmsgs/ifOrbatOperation.h"

class DtSimMessage;
class DtOrbatManagerNode;
class DtlInputStream;
class DtIsOrbatEnabledCommand;
class DtSetIsOrbatEnabledCommand;
struct DtVrfObjectCallbackData;

class DT_DLL_vrfobjcore DtOrbatManager
{
private:
   DtOrbatManager();
   DtOrbatManager(const DtOrbatManager& orig);
   DtOrbatManager& operator=(const DtOrbatManager& orig);

public:
   typedef boost::unordered_map<DtUUID, DtOrbatManagerNode*> UUIDMap;

   DtOrbatManager(DtVrfObjectManager *objMgr);
   virtual ~DtOrbatManager();

   virtual bool init();

   virtual void closingScenario();

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

   virtual DtOrbatDataList addOrUpdateObjectsInOrbat(const DtOrbatDataList&, int flags = DtIfOrbatOperation::IterateChildrenOnAdd);

   virtual DtOrbatDataList removeObjectsFromOrbat(const DtOrbatDataList&);

   virtual DtOrbatDataList removeObjectFromOrbat(const DtRwOrbatData&, bool onlyPublished = false);

   virtual void sendOrbatList(int requestId = 0);

   virtual void clearOrbat(bool send = false);

   virtual void mergeFrom(const DtOrbatManager& fromOm, bool sendNewList = false);

   virtual bool loadOrbat(const DtFilename&, bool send = false, bool clearOnLoad = true);
   virtual bool loadOrbatFromZipFile(const DtFilename& scenarioZipFile, const std::string&, bool send = false, bool clearOnLoad = true);

   virtual bool loadOrbat(const std::string& str, bool send = false, bool clearOnLoad = true);

   virtual bool writeOrbat(const DtFilename&);

   virtual bool writeOrbat(std::string&);

   virtual DtOrbatManagerNode* addNode(const DtRwOrbatData&);

   virtual DtOrbatManagerNode* lookupNodeByUUID(const DtUUID& id) const;

   virtual DtOrbatManagerNode* lookupNodeByMarkingText(const DtString&) const;

   const UUIDMap& nodes() const { return myOrbatNodes; };

   virtual DtOrbatDataList modifyOrbatObjects(const DtOrbatDataList&);

   virtual DtOrbatDataList modifyOrbatObject(const DtRwOrbatData&);

   virtual const DtVrfObject* createOrReturnSuperiorOf(const DtUUID&, const DtVector& locationOfSuperior = DtVector::zero());

   virtual void createSubordinatesOfObject(const DtUUID&);

   virtual void tick();

   virtual void aboutToDeleteObjectManager();

   virtual void processVrfObjectAdded(const DtVrfObject*, int flags = 0);

   virtual void makeAllSimulationObjectsPartOfOrbat();

protected:
   virtual DtString trimNameForLength(int maxLength, const DtString&) const;

   virtual DtOrbatManagerNode* createOrbatManagerNode() const;

   virtual void processOrbatOperation(DtSimMessage* msg);
   static void orbatOperationCallback(DtSimMessage* msg, void* usr);

   virtual DtOrbatDataList createOrbatNodes(const DtRwOrbatData&, int flags = DtIfOrbatOperation::IterateChildrenOnAdd);

   virtual bool loadOrbat(DtlInputStream*, bool send);

   virtual DtString generateMarkingText(const DtEntityType&);

   static void vrfObjectAdded(const DtVrfObject*, void* usr);

   static void vrfObjectAboutToBeRemoved(const DtVrfObject*, void* usr);
   virtual void processVrfObjectAboutToBeRemoved(const DtVrfObject*);

   static void organizationManagerNodeAdded(const DtUUID&, void*);
   virtual void processOrganizationManagerNodeAdded(const DtUUID&);
   virtual void processOrganizationManagerNodeAdded(DtOrganizationManagerNode*);

   virtual void removeWatchedNode(const DtUUID&);

   static void childAddedCallback(const DtUUID& superior, const DtUUID& subordinate, void* usr);
   virtual void processChildAdded(const DtUUID& superior, const DtUUID& subordinate);

   static void childRemovedCallback(const DtUUID& superior, const DtUUID& subordinate, void* usr);
   virtual void processChildRemoved(const DtUUID& superior, const DtUUID& subordinate);

   static void organizationManagerNodeAboutToBeRemoved(const DtUUID&, void*);
   virtual void processOrganizationManagerNodeAboutToBeRemoved(const DtUUID&);

   static void orbatNodeRemovedCallback(const DtUUID&, const DtUUID&, void*);
   virtual void processOrbatNodeRemoved(const DtUUID&, const DtUUID&);

   virtual void reorderOrbatNodesExcluding(DtOrbatManagerNode*);

   virtual void setOrbatNodeOrder(DtOrbatManagerNode*, int order, bool inserting = false);
   virtual void insertOrbatNodeInOrder(DtOrbatManagerNode*, int order);

   virtual DtOrbatManagerNode* rootNodeForForce(int);

   static void objectDataChangedCallback(const DtVrfObjectCallbackData&, void* usr);
   virtual void processObjectDataChanged(const DtVrfObject*, int flag);

   virtual DtOrbatDataList setForceToSubordinatesOf(int force, DtOrbatManagerNode*) const;

protected:
   bool myIsOrbatEnabled;

   typedef std::vector<DtOrbatManagerNode*> OrbatNodeList;
   typedef std::map<DtUUID, OrbatNodeList> UnparentedOrbatNodes;

   UnparentedOrbatNodes myUnparentedOrbatNodes;
   UUIDMap myOrbatNodes;

   DtVrfObjectManager* myObjectManager;

   std::map<std::string, int> myEntityTypeCounts;

   typedef std::map<DtUUID, DtOrganizationManagerNode*> WatchedNodes;
   WatchedNodes myWatchedNodes;

   UUIDMap myModifiedNodes;

   typedef std::map<int, DtOrbatManagerNode*> RootNodesByForce;
   RootNodesByForce myRootNodesByForce;

   DtIsOrbatEnabledCommand* myIsOrbatEnabledCommand;
   DtSetIsOrbatEnabledCommand* mySetIsOrbatEnabledCommand;
};