subordinateManager.h

Go to the documentation of this file.

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

#pragma once


#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfobjcore/simObject.h"
#include <vlutil/vlConfig.h> 
#include <map>
#include <set>
#include <vlutil/vlList.h>
#include <vlpi/disEnums.h>
#include <readerWriter/noArgumentCallbackList.h>
#include "vrfobjcore/simObjectReferenceList.h"

#include <tbb/spin_rw_mutex.h>

class DtSimManager;
class DtSimulationServices;
class DtLocalObject;

namespace makVrf
{
   class DtStateData;
}

typedef DtCallbackList<const DtSubordinateManager&> DtSubordinateManagerCallabackList;

class DT_DLL_vrfobjcore DtSubordinateManager
{
private:

   DtSubordinateManager(const DtSubordinateManager& orig);

   const DtSubordinateManager& operator=(const DtSubordinateManager& orig);

public:
   DtSubordinateManager(const DtSimulationServices*, DtLocalObject* owner);

   virtual ~DtSubordinateManager();


   virtual bool addSubordinate(const DtUUID& subordinate, int designator = 0);

   virtual bool addSubordinateBefore (const DtUUID& subordinate, 
      const DtUUID& beforeObject, int designator = 0);

   virtual bool addSubordinateAfter (const DtUUID& subordinate, 
      const DtUUID& afterObject, int designator = 0);

   virtual bool removeSubordinate(const DtUUID& subordinate);

   virtual void removeAllSubordinates();

   virtual int numSubordinates() const;

   virtual void resetDesignatorsToSubordinateOrder();

   virtual DtSimObjectReference firstSubordinate() const;
   virtual DtSimObjectReference lastSubordinate() const;
   virtual DtSimObjectReference firstHealthySubordinate() const;

   virtual bool isSubordinate(const DtUUID& id) const;

   virtual int designatorForSubordinate(const DtUUID& id) const;

   virtual DtSimObjectReference subordinateForDesignator(int designator) const;

   virtual bool setDesignator(const DtUUID& id, int designator);

   virtual int maxUsedDesignator() const;

   virtual void reorderToDesignatorOrder();

   virtual void designatorOrderedList(std::vector<DtUUID>&
      designatorOrderedList) const;

   virtual void setSubordinateOrder(const std::vector<DtUUID>&
      orderedList);

   virtual int nextAvailableDesignator(int cur = 0) const;

   bool needsReorderToDesignatorOrder() const
   {
      return myNeedsReorderToDesignatorOrder;
   }

   const DtSimObjectReferenceList& subordinates() const;
   DtSimObjectReferenceList& nextFrameSubordinates();

   virtual void invalidate();

   virtual bool designatorInUse(int designator) const;

   mutable boost::signals2::signal<void (const DtUUID&)> signal_subordinateRemoved;
   mutable boost::signals2::signal<void (const DtUUID&)> signal_subordinateAdded;
   boost::signals2::signal<void ()> signal_designatorOrderChanged;

protected:
   virtual bool findSubordinateItem(const DtUUID& id) const;

   virtual void subordinateDeleted(const DtUUID&);

protected:
   const DtSimulationServices* mySimulationServices;

   std::map<DtUUID, int> myDesignatorsByUUID;
   std::map<int, DtUUID> myUnitsByDesignator;
   mutable std::set<int> myAvailableDesignators;
   tbb::spin_rw_mutex myMutex;

   bool myNeedsReorderToDesignatorOrder;
   DtSimObjectReferenceList mySubordinates;

   DtLocalObject* myOwner;

   boost::signals2::scoped_connection myLocalObjectDeletedConnection;
   boost::signals2::scoped_connection mySubordinateDeletedConnection;
};

typedef DtSubordinateManager DtVrfSubordinateManager;