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 <vrfExtProtocol/objectType.h>
#include "vrfobjcore/vrfObjectReference.h"

class DtEmbarkationSlotEntry;
class DtVrfObject;
class DtSimManager;

#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();

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

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

protected:
   DtRwInt                          myReservedSlot;
   DtRwVrfObjectReferenceList       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);
   DtEmbarkationSlotManager(const DtSymbolString& name, DtReaderWriterRegistry* 
      parentRegistry = NULL);

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

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

   virtual ~DtEmbarkationSlotManager();

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

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

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

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

   virtual DtEmbarkationSlotInformation entityEmbarkationSlotInformation(const DtVrfObject*) 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 DtVrfObject*) const;
   virtual bool canEmbark(const DtEmbarkationSlotEntry*, const DtObjectType&) 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 DtVrfObject* embarkingObject,
      const DtVrfObject* 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<DtSharedVrfObjectReference>&, DtSimManager*);

   virtual DtVector nextDisembarkPosition(const DtVrfObject* parent, const DtVrfObject* disembarking,
      const DtSimManager* simMgr, 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<DtSharedVrfObjectReference>&, DtSimManager*);

   virtual void calculateGridCellSize(const std::vector<DtSharedVrfObjectReference>&, DtSimManager*);

   virtual DtDcm finalPositionTransformationMatrix(const DtVrfObject* 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);

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

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

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

protected:
   DtEmbarkationSlotEntryMap               mySlots;
   DtRwTemplatedListPtr<DtLoadPoint,true>  myIngressPoints;
   DtRwTemplatedListPtr<DtLoadPoint,true>  myEgressPoints;
   DtRwTemplatedListPtr<DtSlotExclusion,true>   mySlotExclusions;

   DtRwVector                             myDisembarkGridSize;

   DtRwVector                             myDisembarkGridCellSize;

   DtRwInt                                myDisembarkGridCell;

   DtReservedSlotList   myReservedSlots;

   double                                 myScalingFactor;
};

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

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

inline void DtReservedSlot::addReservedBy(const DtUUID& s)
{
   myReservedBy.add(new DtRwVrfObjectReference("reserved-by", s));
}

inline const DtRwVrfObjectReferenceList& DtReservedSlot::reservedBy() const
{
   return myReservedBy;
}