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 "vrfobjcore/orbatManagerNode.h"
#include "vrfobjcore/simObject.h"
#include <vector>
#include "vrfmsgs/ifOrbatOperation.h"

#include <tbb/spin_mutex.h>
#include <mutex>
#include <boost/signals2.hpp>

class DtSimMessage;
class DtOrbatManagerNode;
class DtlInputStream;
class DtIsOrbatEnabledCommand;
class DtSetIsOrbatEnabledCommand;
class DtSimulationServices;
class DtLocalObject;
class DtLocalObjectManager;

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

public:
   class LockedOrbatManagerNode
   {
   public:
      LockedOrbatManagerNode(DtOrbatManagerNode* node)
      : myLock(node ? new std::lock_guard<std::recursive_mutex>(node->mutex()) : 0)
      , myNode(node)
      {
      }

      LockedOrbatManagerNode(const LockedOrbatManagerNode& orig)
      : myLock(orig.myLock)
      , myNode(orig.myNode)
      {
      }

      operator DtOrbatManagerNode*() { return myNode; };
      operator const DtOrbatManagerNode*() const { return myNode; };

      DtOrbatManagerNode* operator->() { return myNode; };
      const DtOrbatManagerNode* operator->() const { return myNode; };

      bool isValid() const { return (myLock.get() != 0); };
      void release() { myLock.reset(); };

   protected:
      std::shared_ptr<std::lock_guard<std::recursive_mutex>> myLock;
      DtOrbatManagerNode* myNode;
   };

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

   struct OrbatInformation
   {
      virtual ~OrbatInformation()
      {
         subordinateChangedCallback.disconnect();
      }

      DtOrbatManagerNode* node;
      boost::signals2::connection subordinateChangedCallback;
   };

   typedef boost::unordered_map<DtUUID, OrbatInformation> OrbatMap;

   DtOrbatManager(DtSimulationServices *objMgr, DtLocalObjectManager*);
   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,
      int operation = DtIfOrbatOperation::Update, bool* success = nullptr);

   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 LockedOrbatManagerNode addNode(const DtRwOrbatData&);

   virtual bool hasNode(const DtUUID&) const;
   virtual LockedOrbatManagerNode lookupNodeByUUID(const DtUUID& id) const;

   virtual LockedOrbatManagerNode lookupNodeByMarkingText(const DtString&) const;

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

   virtual DtOrbatDataList modifyOrbatObjects(const DtOrbatDataList&, int operation = DtIfOrbatOperation::Update);

   virtual DtOrbatDataList modifyOrbatObject(const DtRwOrbatData&, int operation = DtIfOrbatOperation::Update);

   virtual const DtLocalObject* createOrReturnSuperiorOf(const DtUUID&, const DtVector& locationOfSuperior = DtVector::zero(),
      int operation = DtIfOrbatOperation::Update, bool forceCreate = false);

   virtual void createSubordinatesOfObject(const DtUUID&);

   virtual void tick();

   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 void processOrbatResponse(DtSimMessage* msg);
   static void orbatResponseCallback(DtSimMessage* msg, void* usr);

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

   virtual bool loadOrbat(DtlInputStream*, bool send);

   virtual DtString generateMarkingText(const DtEntityType&);

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

   virtual void processSimObjectAdded(DtSimObjectReference ref, int flags = 0);
   virtual void processSimObjectRemoved(DtSimObjectReference ref);
   virtual bool objectShouldBeSavedToSimulationObjectGroup(const DtSimObject* obj) const;

   virtual void processSuperiorChanged(const DtSimObject*, const DtUUID& oldSuperior, const DtUUID& newSuperior);
   virtual void processAddSuperior(const DtSimObject*, const DtUUID& superior);
   virtual void processRemoveSuperior(const DtSimObject*, const DtUUID& superior);

   virtual void reorderOrbatNodesExcluding(LockedOrbatManagerNode);

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

   virtual LockedOrbatManagerNode rootNodeForForce(int);

   virtual void processObjectDataChanged(const DtLocalObject*, int flag);

   virtual DtOrbatDataList setForceToSubordinatesOf(int force, const LockedOrbatManagerNode&) const;

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

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

protected:
   bool myIsOrbatEnabled;

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

   mutable std::recursive_mutex myOrbatNodesMutex;
   UnparentedOrbatNodes myUnparentedOrbatNodes;
   OrbatMap myOrbatNodes;

   DtSimulationServices* mySimulationServices;
   DtLocalObjectManager* myObjectManager;

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

   UUIDMap myModifiedNodes;

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

   DtIsOrbatEnabledCommand* myIsOrbatEnabledCommand;
   DtSetIsOrbatEnabledCommand* mySetIsOrbatEnabledCommand;

   boost::signals2::scoped_connection mySimObjectAddedConnection;
   boost::signals2::scoped_connection mySimObjectDeletedConnection;
   boost::signals2::scoped_connection myUUIDChangedConnection;

   tbb::spin_mutex myModifiedNodesMutex;
   std::set<DtUUID> myAddToOrbatOnNextAdd;
};