loadOrderOfBattleHandler.h

Go to the documentation of this file.

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

#pragma once

#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfobjcore/loadScenarioData.h"
#include "vrfutil/scenarioLoadManager.h"
#include <mtl/mtl.h>
#include "readerWriter/rwList.h"
#include "vlpi/entityIdentifier.h"
#include <string>
#include <tbb/spin_mutex.h>

class DtLocalObjectManager;
class DtlInputStream;
class DtSimulationServices;
class DtLocalObject;
class DtUUID;
class DtVrfObjectLocalObjectFacade;

class DT_DLL_vrfobjcore DtLoadOrderOfBattleHandler
   : public DtLoadScenarioPieceHandler
   , public DtRwList
{
protected:
   typedef std::pair<DtLocalObject*, DtVrfSimulationObjectGroupGeometry*> PendingObjectInformation;
   typedef std::vector<PendingObjectInformation> PendingObjectsInformation;
   typedef std::vector<PendingObjectsInformation> ObjectsAwaitingDiscovery;

public:
   DtLoadOrderOfBattleHandler(DtSimulationServices*, DtLocalObjectManager*);
   DtLoadOrderOfBattleHandler(const DtLoadOrderOfBattleHandler&);

   virtual ~DtLoadOrderOfBattleHandler() override;

   virtual bool loadScenarioPiece(const DtScenario&, void* userData = 0, bool reinitializingScenario = false) override;
   virtual bool loadScenarioPiece(const std::vector<std::string*>&, void* userData = 0, bool reinitializingScenario = false);

   virtual bool loadSimulationObjectGroupPiece(const DtScenario&, DtlObjPtr* retArgs = 0, void* userData = 0);
   virtual bool loadSimulationObjectGroupPiece(DtlObjPtr args, void* userData = 0);

   virtual void tick();

   virtual bool complete() const;

   const DtLoadScenarioData& loadOrderOfBattleData() const
   {
      return myLoadOrderOfBattleUserData;
   }

   virtual DtLoadScenarioPieceHandler* clone() const override {
      return new DtLoadOrderOfBattleHandler(*this);
   }

   virtual bool recreateObject(const DtUUID& lo, DtLoadScenarioData& data);

protected:
   virtual bool readOrderOfBattleFileFromZipFile(const DtScenario&, DtLoadScenarioData&);

   virtual bool readOrderOfBattleFile(const DtScenario&, DtLoadScenarioData&);

   virtual bool readOrderOfBattleFile(DtlInputStream*, DtLoadScenarioData&);

   virtual DtlObjPtr getData(DtlObjPtr args, const DtReaderWriter::SearchPaths& searchPaths,
      const DtVariableBindingsList& variableBindings) override;

   virtual void reserveGlobalObjectIds(unsigned numToReserve);

   virtual DtEntityIdentifier findEntityIdentifier(DtlObjPtr mtlStream) const;

   virtual bool hasUUIDOrMarkingText(DtlObjPtr args, DtUUID&) const;

   virtual DtLocalObject* createObjectFromMemoryBuffer(const std::string& buffer);

   virtual void clearAllocatedProxies();

   virtual bool loadSimulationObjectGroupOrderOfBattleFromZipFile(const DtScenario& scenario, DtlObjPtr* retArgs, void* userData = 0);
   virtual bool loadSimulationObjectGroupOrderOfBattle(const DtScenario& scenario, DtlObjPtr* retArgs, void* userData = 0);
   virtual bool loadSimulationObjectGroupOrderOfBattle(DtlInputStream* fStream, DtlObjPtr* retArgs, void* userData = 0);

   virtual bool addObjectsReadyForSimulation(PendingObjectsInformation&);

   virtual bool ignoreImportObject(const DtEntityType&) const;
   static void addIgnoreImportObject(const DtEntityType&);
   static void removeIgnoreImportObject(const DtEntityType&);

protected:
   friend class CreateObjectCallback;

   virtual DtLocalObject* createAndInit(DtlObjPtr mtlStream, int flags, int force, const DtVector& geocentricOffsetLocation,
      double offsetRotation = 0.);

   virtual bool finalizeObjectRead(DtLocalObject* newObject);

protected:
   DtLocalObjectManager* myObjectManager;
   DtSimulationServices* mySimulationServices;
   DtLoadScenarioData myLoadOrderOfBattleUserData;

   tbb::spin_mutex myFinalizeObjectMutex;
   typedef std::map<DtUUID, DtVrfObjectLocalObjectFacade*> AllocatedProxies;

   tbb::spin_mutex myAllocatedProxiesMutex;
   AllocatedProxies myAllocatedProxies;

   ObjectsAwaitingDiscovery myObjectsAwaitingDiscovery;
   std::vector<DtLocalObject*> myObjectsAdded;
   static std::vector<DtEntityType> theIgnoreObjectsOnImport;
};