embarkationSlotManager.h

Go to the documentation of this file.

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


#pragma once

#include <vlutil/vlConfig.h>
#include <map>
#include "vrfobjparam/loadPoint.h"
#include "vrfobjparam/slotExclusion.h"
#include "vrfutil/rwTemplatedList.h"
#include <readerWriter/rwString.h>
#include <readerWriter/rwInt.h>
#include <vlpi/entityType.h>
#include "vrfobjcore/simObject.h"
#include "vrfobjcore/simObjectReferenceList.h"
#include <tbb/spin_rw_mutex.h>

class DtEmbarkationSlotEntry;
class DtSimulationServices;

#include "vrfobjcore/vrfobjcoreDefines.h"
class DT_DLL_vrfobjcore DtReservedEmbarkationSlotEntry
{
public:
   const DtEmbarkationSlotEntry* myEntry;
   std::vector<DtUUID>             myReservedBy;

   void addReservedBy(const DtUUID&);
   void removeReservedBy(const DtUUID&);
   bool reservedBy(const DtUUID&) const;

};

class DT_DLL_vrfobjcore DtEmbarkationSlotInformation
{
public:
   DtEmbarkationSlotInformation() : myEntry(NULL), mySlot(-1) {};

   DtEmbarkationSlotInformation& operator=(const DtEmbarkationSlotInformation& orig)
   {
      myEntry = orig.myEntry;
      mySlot = orig.mySlot;
      myLoadPath = orig.myLoadPath;

      return *this;
   }

public:
   const DtEmbarkationSlotEntry* myEntry;
   int                           mySlot;
   std::vector<DtVector>         myLoadPath;
};

class DT_DLL_vrfobjcore DtReservedSlot : public DtReaderWriter
{
public:
   DtReservedSlot(const DtString& name, DtReaderWriterRegistry* 
      parentRegistry = NULL);
   DtReservedSlot(const DtSymbolString& name, DtReaderWriterRegistry* 
      parentRegistry = NULL);

   DtReservedSlot(const DtString& name, const 
      DtReservedSlot& orig, DtReaderWriterRegistry* 
      parentRegistry = NULL);

   DtReservedSlot(const DtSymbolString& name, const 
      DtReservedSlot& orig, DtReaderWriterRegistry* 
      parentRegistry = NULL);

   virtual ~DtReservedSlot() override;

   int reservedSlot() const;
   void setReservedSlot(int);

   const DtRwSimObjectReferenceList& reservedBy() const;
   void addReservedBy(const DtUUID&);

protected:
   DtRwInt                          myReservedSlot;
   DtRwSimObjectReferenceList       myReservedBy;
};

typedef std::map<int, DtReservedEmbarkationSlotEntry>   DtEmbarkationSlotEntryMap;
typedef std::vector<DtLoadPoint> DtLoadPathPoints;

class DT_DLL_vrfobjcore DtEmbarkationSlotManager : public DtReaderWriter
{
public:
   typedef DtRwTemplatedListPtr<DtReservedSlot, true> DtReservedSlotList;

   DtEmbarkationSlotManager(const DtString& name, DtReaderWriterRegistry* 
      parentRegistry = NULL, DtSimulationServices* services = nullptr);
   DtEmbarkationSlotManager(const DtSymbolString& name, DtReaderWriterRegistry* 
      parentRegistry = NULL, DtSimulationServices* services = nullptr);

   DtEmbarkationSlotManager(const DtString& name, const 
      DtEmbarkationSlotManager& orig, DtReaderWriterRegistry* 
      parentRegistry = NULL);

   DtEmbarkationSlotManager(const DtSymbolString& name, const 
      DtEmbarkationSlotManager& orig, DtReaderWriterRegistry* 
      parentRegistry = NULL);

   virtual ~DtEmbarkationSlotManager() override;

   virtual void addSlot(int iSlot, const DtEmbarkationSlotEntry*);

   virtual DtEmbarkationSlotInformation slotFor(const DtSimObject* embarkingObject,
      const DtSimObject* hostObject) const;

   virtual DtEmbarkationSlotInformation slotFor(int slot,
      const DtSimObject* embarkingObject,
      const DtSimObject* hostObject) const;

   virtual DtEmbarkationSlotInformation slotFor(const DtString& slotName, const DtString& slotType,
      const DtSimObject* embarkingObject,
      const DtSimObject* hostObject) const;

   virtual DtEmbarkationSlotInformation entityEmbarkationSlotInformation(const DtUUID&) const;

   virtual std::vector<DtEmbarkationSlotInformation> slotInformationFor(const DtEntityType&) const;

   virtual bool blocked(int iSlot) const;
   virtual void addSlotExclusion(const DtSlotExclusion&);

   virtual bool canEmbark(const DtEmbarkationSlotEntry*, const DtSimObject*) const;
   virtual bool canEmbark(const DtEmbarkationSlotEntry*, const DtEntityType&) const;

   virtual bool available(int, const DtUUID& uuid = DtUUID::nullUUID()) const;

   virtual bool reserved(int) const;

   virtual bool reserveSlot(int iSlot, const DtUUID&);

   virtual void addIngressPoint(const DtLoadPoint&);
   virtual void ingressPoints(int iSlot, const DtSimObject* embarkingObject,
      const DtSimObject* hostObject, DtEmbarkationSlotInformation& info) const;

   virtual void addEgressPoint(const DtLoadPoint&);
   virtual void egressPoints(int iSlot, DtEmbarkationSlotInformation& info) const;

   virtual void giveUpSlot(int, const DtUUID&);

   virtual DtEmbarkationSlotManager* clone(const DtString& name, DtReaderWriterRegistry* 
      parentRegistry = NULL);

   virtual void calculateDisembarkPositions(const std::vector<DtSimObjectReference>&);

   virtual DtVector nextDisembarkPosition(const DtSimObject* parent, const DtSimObject* disembarking,
      const DtVector& lastBodyPos, bool tasked, bool flipBodyX = false,
      bool flipBodyY = false);

   virtual void setScalingFactor(double);
   virtual double scalingFactor() const;

   const DtEmbarkationSlotEntryMap& slots() const { return mySlots; };
   const DtRwTemplatedListPtr<DtLoadPoint,true>& ingressPoints() const { return myIngressPoints; };
   const DtRwTemplatedListPtr<DtLoadPoint,true>&  egressPoints() const { return myEgressPoints; };
   const DtRwTemplatedListPtr<DtSlotExclusion,true>& slotExclustions() const { return mySlotExclusions; };

protected:
   virtual void calculateGridSize(const std::vector<DtSimObjectReference>&);

   virtual void calculateGridCellSize(const std::vector<DtSimObjectReference>&);

   virtual DtDcm finalPositionTransformationMatrix(const DtSimObject* parent, const DtVector& lastBodyPos) const;

protected:
   virtual bool matchesNameAndType(const DtString& name, const DtString& type, const DtEmbarkationSlotEntry*) const;

   virtual bool slotMatches(const DtLoadPoint*, int iSlot) const;

   virtual void putData(std::string& fp, int indentLevel = 0) override;

   virtual bool blocked(int iSlot, const DtSlotExclusion&) const;

   virtual const DtLoadPoint* bestIngressFor(const DtLoadPoint* ingressA, 
      const DtLoadPoint* ingressB, const DtSimObject* embarkingObject,
      const DtSimObject* hostObject) const;

   virtual DtVector bodyPositionToLocalPosition(const DtVector& bodyPosition,
      const DtSimObject* body) const;

protected:
   mutable tbb::spin_rw_mutex                      mySlotsMutex;
   DtEmbarkationSlotEntryMap               mySlots;
   DtRwTemplatedListPtr<DtLoadPoint,true>  myIngressPoints;
   DtRwTemplatedListPtr<DtLoadPoint,true>  myEgressPoints;
   DtRwTemplatedListPtr<DtSlotExclusion,true>   mySlotExclusions;

   DtRwVector                             myDisembarkGridSize;

   DtRwVector                             myDisembarkGridCellSize;

   DtRwInt                                myDisembarkGridCell;

   DtReservedSlotList   myReservedSlots;

   double                                 myScalingFactor;
   DtSimulationServices*                  mySimulationServices;
};

inline int DtReservedSlot::reservedSlot() const
{
   return myReservedSlot;
}

inline void DtReservedSlot::setReservedSlot(int s)
{
   myReservedSlot = s;
}