simObjectManagerTemplate.h

Go to the documentation of this file.

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

#pragma once

#include "vrfStateData/simObjectReferenceTemplate.h"
#include "vrfStateData/stateDataManager.h"
#include <vrfutil/uuid.h>
#include <tbb/spin_rw_mutex.h>
#include <boost/signals2.hpp>

class DtUUID;
class DtEntityIdentifier;

namespace makVrf
{
   class DtFrameStateInterface;
   class DtStateDataWrapper;

   template <typename T_BaseClass>
   class DtSimObjectManagerTemplate 
   {
   private:
      DtSimObjectManagerTemplate();
      DtSimObjectManagerTemplate(const DtSimObjectManagerTemplate&);
      DtSimObjectManagerTemplate& operator=(const DtSimObjectManagerTemplate&);

   public:
      DtSimObjectManagerTemplate(DtStateDataManager* m);

      virtual ~DtSimObjectManagerTemplate();

      virtual void tick();

      virtual void init();

      virtual void advanceFrame();

      virtual DtSimObjectReferenceTemplate<T_BaseClass> lookup(const DtUUID&) const;
      virtual DtSimObjectReferenceTemplate<T_BaseClass> lookup(const DtEntityIdentifier&) const;

      virtual DtSimObjectReferenceTemplate<T_BaseClass> lookup(unsigned long long) const;
   
      virtual DtStateData* stateDataFor(const DtUUID&) const;
      virtual DtStateData* stateDataFor(unsigned long long) const;
      virtual DtStateData* stateDataFor(const DtEntityIdentifier&) const;
      virtual DtStateData* stateDataForUniqueId(unsigned long long) const;

      mutable boost::signals2::signal<void ()> signal_advancedFrame;

      mutable boost::signals2::signal<void (DtSimObjectReferenceTemplate<T_BaseClass>)> signal_simObjectAdded;

      mutable boost::signals2::signal<void (DtSimObjectReferenceTemplate<T_BaseClass>)> signal_simObjectDeleted;

      mutable boost::signals2::signal<void (const DtUUID& oldUUID, const DtUUID& newUUID)> signal_uuidChanged;

      mutable boost::signals2::signal<void (const DtUUID& oldUUID, const DtUUID& newUUID)> signal_uuidUpgradedTo;

      mutable boost::signals2::signal<void (DtSimObjectReferenceTemplate<T_BaseClass>, const DtString& oldText, const DtString& newText)> signal_simObjectRenamed;
   
      using SimObjects = std::map<unsigned long long, DtSimObjectReferenceTemplate<T_BaseClass>>;

      SimObjects simObjects()
      {
         return mySimObjects;
      }

      const SimObjects& simObjects() const
      {
         return mySimObjects;
      }

      void attachStateDataManager(DtStateDataManager*);
      void detachStateDataManager(DtStateDataManager*);

      virtual DtStateDataWrapper* createSimObject(DtStateData* sd) const = 0;
      virtual DtStateDataWrapper* createSimObject(const DtUUID& uuid) const = 0;
      virtual DtStateDataWrapper* createSimObject(const DtEntityIdentifier& entid) const = 0;

      virtual void clear();

      virtual bool has(const DtUUID&) const;
      virtual bool has(unsigned long long) const;

      typedef std::set<const DtFrameStateInterface*> CurrentFrameStates;
      template <typename T_Component> CurrentFrameStates stateComponents() const
      {
         std::set<const DtFrameStateInterface*> results;

         for (auto& sdm : myStateDataManagers)
         {
            std::set<const DtFrameStateInterface*> comps = myStateDataManager->stateComponents<T_Component>();

            for(const auto& fsi : comps)
            {
               results.insert(fsi);
            }
         }

         return results;
      }

      virtual void referenceAdded(DtSimObjectReferenceTemplate<T_BaseClass> ref);

      typedef boost::signals2::signal<void (DtStateComponent*)> StateComponentAddedSignal;
      typedef boost::signals2::signal<void (DtStateComponent*)> StateComponentRemovedSignal;
      template <typename T_Component> StateComponentAddedSignal& signalWhenStateComponentAdded()
      {
         return myStateDataManager->signalWhenStateComponentAdded(T_Component::ComponentType());
      }
      template <typename T_Component> StateComponentAddedSignal& signalWhenStateComponentRemoved()
      {
         return myStateDataManager->signalWhenStateComponentRemoved(T_Component::ComponentType());
      }

      virtual std::vector<DtSimObjectReferenceTemplate<T_BaseClass>> objectsOfType(const DtEntityType&) const;

   protected:
      virtual void simObjectDeleted(const DtStateDataWrapper*);
      virtual void stateDataDeleted(const DtStateData*);

      virtual DtSimObjectReferenceTemplate<T_BaseClass> getOrCreateSimObjectReference(DtStateData*, bool createOnlyIfNotPresent = false) const;
      virtual void uuidChanged(unsigned long long, const DtUUID& oldUUID, const DtUUID& newUUID);
      virtual void objectRenamed(const DtStateDataWrapper*, const DtString& oldName, const DtString& newName);
      virtual void simObjectAdded(DtStateData*);
      virtual void discoveredObjectReference(const DtString& awaiting);

      bool isDeleted(const DtUUID&) const;

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

   protected:
      DtStateDataManager* myStateDataManager;
      mutable tbb::spin_rw_mutex myMutex;
      boost::signals2::scoped_connection myUUIDUpgradedConnection;

      struct StateDataManagerInformation
      {
         boost::signals2::scoped_connection stateDataAddedConnection;
         boost::signals2::scoped_connection uuidChangedConnection;
      };

      std::vector<DtStateDataManager*> myStateDataManagerOrder;
      std::map<DtStateDataManager*, StateDataManagerInformation> myStateDataManagers;

      mutable SimObjects mySimObjects;

      typedef std::map<DtString, DtSimObjectReferenceTemplate<T_BaseClass>> AwaitingMap;
      mutable AwaitingMap myAwaitingMap;

      SimObjects myAdded;

      struct DeletedObjects
      {
         std::map<DtUUID, DtSimObjectReferenceTemplate<T_BaseClass>> deletedObjects;
         std::map<unsigned long long, DtUUID> deletedUUIDs;

         bool isDeleted(const DtUUID& uuid) const
         {
            if (deletedObjects.find(uuid) != deletedObjects.end())
            {
               return true;
            }

            return false;
         }

         bool isDeleted(unsigned long long id) const
         {
            std::map<unsigned long long, DtUUID>::const_iterator iter = deletedUUIDs.find(id);

            if (iter != deletedUUIDs.end())
            {
               return isDeleted(iter->second);
            }

            return false;
         }

         void track(const DtStateData* so, DtSimObjectReferenceTemplate<T_BaseClass> ref)
         {
            deletedObjects[so->uuid()] = ref;
            deletedUUIDs[so->legionGlobalId()] = so->uuid();
            deletedUUIDs[so->stateId()] = so->uuid();
         }

         void clear() { deletedObjects.clear(); deletedUUIDs.clear(); };
      };

      DeletedObjects myDeleted;

      struct Connections
      {
         boost::signals2::connection objectDeletedConnection;
         boost::signals2::connection objectRenamedConnection;
      };

      typedef std::map<unsigned long long, Connections> SimObjectConnections;
      mutable SimObjectConnections mySimObjectConnections;
   };
}

#include "simObjectManagerTemplate.inl"