scriptedTaskManager.h

Go to the documentation of this file.

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

#pragma once

#include "vrfobjcore/vrfobjcoreDefines.h"
#include "vrfobjcore/scriptResourceManager.h"
#include <vrfutil/scriptedTaskMetaData.h>
#include <readerWriter/noArgumentCallbackList.h>
#include "vrfutil/averager.h"
#include <vrfutil/rwTranslatableStringObject.h>
#include <vrftasks/vrfObjectMessageTypeTemplate.h>
#include <tbb/mutex.h>

class DtSimulationServices;
class DtSimMessage;
class DtFilename;
class DtIfScriptedTaskOperation;



const int DtScriptedTaskManagerCallbackInfoAdded = 1;
const int DtScriptedTaskManagerCallbackInfoRemoved = 2;
const int DtScriptedTaskManagerCallbackInfoUpdated = 3;
const int DtScriptedTaskManagerCallbackInfoScriptIdChanged = 4;
const int DtScriptedTaskManagerCallbackInfoScriptChanged = 5;
const int DtScriptedTaskManagerCallbackInfoScriptTypeChanged = 6;

const int DtScriptedTaskManagerCallbackInfoDoctrineChangedBase = 100;

const int DtScriptedTaskManagerCallbackFlagScenarioScriptExists = 0x00000001;

struct DT_DLL_vrfobjcore DtScriptedTaskManagerCallbackInfo
{
   DtScriptedTaskManagerCallbackInfo() : reason(0), flags(0) {};
   DtScriptedTaskManagerCallbackInfo(const DtScriptedTaskManagerCallbackInfo& orig)
      : reason(orig.reason), flags(orig.flags), metaData(orig.metaData), originalData(orig.originalData) {};

   DtScriptedTaskManagerCallbackInfo& operator=(const DtScriptedTaskManagerCallbackInfo& orig)
   {
      reason = orig.reason;
      flags = orig.flags;
      metaData = orig.metaData;
      originalData = orig.originalData;

      return *this;
   }

   int reason;
   int flags;

   DtScriptedTaskMetaData metaData;

   DtScriptedTaskMetaData originalData;
};

typedef DtCallbackList<const DtScriptedTaskManagerCallbackInfo&>::DtCallbackFunctionType DtScriptedTaskManagerCallbackFcn;

class DT_DLL_vrfobjcore DtScriptedTaskManager
{
public:

   struct ScenarioSystemPair
   {
      ScenarioSystemPair() : scenarioScript(0), systemScript(0), monitor(0), references(0), averager(0), myFrameRateMutex(new tbb::spin_mutex) {};
      ScenarioSystemPair(DtScriptedTaskMetaData* sc, DtScriptedTaskMetaData* sy) : scenarioScript(sc), systemScript(sy), monitor(0),
            references(0), averager(0), myFrameRateMutex(new tbb::spin_mutex) {};

      DtScriptedTaskMetaData* scenarioScript;
      DtScriptedTaskMetaData* systemScript;
      DtAverager*             averager;
      int                     monitor;
      int                     references;
      std::string error;
      std::shared_ptr<tbb::spin_mutex>         myFrameRateMutex;
   };

   typedef std::map<std::string, ScenarioSystemPair> ScriptedTaskMetaDataList;
   typedef std::map<std::string, ScriptedTaskMetaDataList> ScriptedTasksByDirectory;

public:
   DtScriptedTaskManager(DtSimulationServices*);

   virtual ~DtScriptedTaskManager();

private:
   DtScriptedTaskManager(const DtScriptedTaskManager & orig);

   DtScriptedTaskManager & operator=(const DtScriptedTaskManager & orig);

public:
   virtual void addAdditionSystemScriptDirectory(const std::string&, bool send = true);

   virtual void removeAllSystemScriptedTasksFromDirectory(const std::string&, bool send = true);

   virtual void removeAllScenarioScripts(bool send = true);

   virtual const ScriptedTasksByDirectory& scriptedTasksByDirectory() const;

   virtual const ScriptedTaskMetaDataList& scenarioScripts() const;

   virtual const ScriptedTaskMetaDataList& allScriptsById() const;

   virtual void sendRequestedScripts(DtU32 responseId = 0,
      const std::vector<std::string>& scriptIds = std::vector<std::string>(), bool sendScripts = false, bool sendUiLayout = false,
      const std::string& language = "", const int scriptType = 1);

   virtual const DtScriptedTaskMetaData* lookupScriptById(const DtGenericMessageType& scriptId) const;
   virtual const DtScriptedTaskMetaData* lookupScriptById(const DtSetMessageType& scriptId) const;
   virtual const DtScriptedTaskMetaData* lookupScriptById(const DtSimTaskMessageType& scriptId) const;
   virtual const DtScriptedTaskMetaData* lookupScriptById(const std::string&) const;

   virtual void modifyScenarioScriptedTask(const DtScriptedTaskMetaData&, const std::string& sourceScriptId = "", bool send = true,
      bool keepScriptInMessage = false, bool keepLayoutInMessage = false);

   virtual bool removeScriptedTask(const std::string& id, bool send = true, bool scenarioOnly = true,
      bool removeSystemScriptFromDisk = false);

   virtual bool loadScenarioScripts(const DtFilename&, bool send = true);
   virtual bool loadScenarioScriptsFromZipFile(const DtFilename& scenarioZipFile, const std::string&, bool send = true);

   virtual bool loadScenarioScripts(const std::string& str, bool send = true);

   virtual bool writeScenarioScripts(const DtFilename&);

   virtual bool writeScenarioScripts(std::string&);

   virtual bool removeScriptById(const std::string& s, bool scenarioOnly = true,
      bool removeSystemScriptFromDisk = false);

   virtual void setSimulationModelSetScriptsDirectory(const std::string& s, bool send = true);

   virtual std::string simulationModelSetScriptsDirectory() const;

   virtual std::vector<DtSimTaskMessageType> tasksValidFor(const DtEntityType&, int force) const;

   virtual std::vector<DtSetMessageType> setsValidFor(const DtEntityType&, int force) const;

   virtual std::vector<DtSimTaskMessageType> reactiveTasksValidFor(const DtEntityType&, int force) const;

   virtual std::vector<std::string> scriptsValidFor(const DtEntityType&, int scriptType, int force) const;


   virtual void addScriptedTaskChangedCallback(DtScriptedTaskManagerCallbackFcn fcn, void* usr);
   virtual void removeScriptedTaskChangedCallback(DtScriptedTaskManagerCallbackFcn fcn, void* usr);

   virtual void reportError(const DtGenericMessageType& scriptId, const std::string& error, bool sendReport = true);
   virtual void reportError(const DtSimTaskMessageType& scriptId, const std::string& error, bool sendReport = true);
   virtual void reportError(const DtSetMessageType& scriptId, const std::string& error, bool sendReport = true);
   virtual void reportError(const std::string& scriptId, const std::string& error, bool sendReport = true);

   virtual std::string findSystemDirectoryFor(const std::string& scriptId) const;

   virtual void clearError(const DtGenericMessageType& scriptId);
   virtual void clearError(const DtSimTaskMessageType& scriptId);
   virtual void clearError(const DtSetMessageType& scriptId);
   virtual void clearError(const std::string& scriptId);
   
   virtual void addSample(const DtGenericMessageType& scriptId, double sample);
   virtual void addSample(const DtSetMessageType& scriptId, double sample);
   virtual void addSample(const DtSimTaskMessageType& scriptId, double sample);
   virtual void addSample(const std::string& scriptId, double sample);

   virtual void monitor(const std::string& scriptId, bool);

   virtual void setMonitorTime(double);

   virtual void addFrameRateReference(const DtGenericMessageType&);
   virtual void addFrameRateReference(const DtSimTaskMessageType&);
   virtual void addFrameRateReference(const DtSetMessageType&);
   virtual void addFrameRateReference(const std::string&);

   virtual void removeFrameRateReference(const DtGenericMessageType& scriptId);
   virtual void removeFrameRateReference(const DtSetMessageType& scriptId);
   virtual void removeFrameRateReference(const DtSimTaskMessageType& scriptId);
   virtual void removeFrameRateReference(const std::string&);


   virtual int scriptType(const DtGenericMessageType& scriptId) const;
   virtual int scriptType(const DtSetMessageType& scriptId) const;
   virtual int scriptType(const DtSimTaskMessageType& scriptId) const;
   virtual int scriptType(const std::string&) const;

   virtual DtGenericMessageType remapScriptId(const DtGenericMessageType& scriptId) const;
   virtual DtSetMessageType remapScriptId(const DtSetMessageType& scriptId) const;
   virtual DtSimTaskMessageType remapScriptId(const DtSimTaskMessageType& scriptId) const;
   virtual std::string remapScriptId(const std::string& scriptId) const;

   virtual void setDoctrines(const std::set<std::string>&);
   virtual void addDoctrine(const std::string&, bool send = true);

   virtual bool removeDoctrine(const std::string&, bool send = true);
   virtual const std::set<std::string>& doctrines() const;
   virtual void clearDoctrines(bool send = true);
   virtual void loadDoctrines(const DtFilename& f, bool send = true);
   virtual void sendDoctrines();
   virtual void sendDoctrineAssignments();
   virtual void updateDoctrines(const DtScriptedTaskMetaData&);
   virtual void saveDoctrines(const DtFilename& f) const;
   virtual ScriptedTaskMetaDataList scriptsValidForDoctrine(const std::string&) const;
   virtual std::string doctrineForForce(int) const;
   virtual void setDoctrineForForce(const std::string&, int);
   virtual void setDoctrineAssignments(const std::map<int, std::string>&);

   virtual void setLanguage(const DtString&);
   const DtString& language() const;

   virtual bool renameDoctrine(const std::string& from, const std::string& to, bool send = true);

   virtual void merge(DtScriptedTaskManager* mgr, std::vector<DtRwTranslatableStringObject>&);

   virtual DtScriptResourceManager* resourceManager(const DtString& type);

   virtual DtScriptResourceManagerMap& resourceManagers();

   DtSimulationServices* simulationServices() const { return mySimulationServices; };
protected:
   virtual void initializeDefaultScripts();

   static void requestScriptedTasks(DtSimMessage*, void*);
   virtual void processRequestScriptedTasks(DtSimMessage*);

   virtual bool loadScenarioScripts(std::istream& ifs, bool send);

   static void scriptedTaskOperation(DtSimMessage*, void*);
   virtual void processScriptedTaskOperation(DtSimMessage*);

   static void doctrinesOperation(DtSimMessage*, void*);
   virtual void processDoctrinesOperation(DtSimMessage*);

   virtual void makeSystemScript(const std::string&);

   virtual void modifySystemScript(const std::string& scriptid, const std::string&);

   virtual void modifySystemLayout(const std::string& scriptid, const std::string&);

   virtual void modifySystemScriptedTask(const DtScriptedTaskMetaData&, const std::string& sourceSciptId = "", bool send = true);

   virtual void modifyScript(const std::string& id, const std::string& script);

   virtual void modifyLayout(const std::string& id, const std::string& script);

   virtual bool changeScriptScriptId(const DtIfScriptedTaskOperation&, bool& needsCompleteResend);

   virtual void addTaskToTaskFactory(const std::string& id);

   virtual void removeTaskFromTaskFactory(const std::string& id);

   virtual void addSetToSetFactory(const std::string& id);

   virtual void removeSetFromSetFactory(const std::string& id);

   virtual void signalNewScriptedTask(const std::string&);

   virtual void loadDefaultScript(DtScriptedTaskMetaData&);

   virtual void loadDefaultUiLayout(DtScriptedTaskMetaData&);

   static void tickCallback(void*);
   virtual void tick();

   virtual void sendMonitorInformation();

   virtual void updateScenarioScripts(std::map<std::string, DtScriptedTaskMetaData>&, bool send);

protected:
   DtSimulationServices* mySimulationServices;
   std::string mySimulationModelSetScriptsDirectory;

   ScriptedTasksByDirectory mySystemScriptedTasks;
   ScriptedTaskMetaDataList myScenarioScripts;
   ScriptedTaskMetaDataList myAllScriptsById;

   mutable tbb::spin_rw_mutex myMutableScriptsByDoctrineMutex;
   mutable std::map<std::string, ScriptedTaskMetaDataList> myMutableScriptsByDoctrine;

   typedef DtCallbackList<const DtScriptedTaskManagerCallbackInfo&> DtScriptedTaskChangedCallbackList;
   DtScriptedTaskChangedCallbackList myScriptedTaskChangedCallbackList;

   double myMonitorTime;
   double myLastMonitorSentTime;
   int myMonitoringAll;
   int myMonitoringScripts;
   bool mySendMonitorMessage;

   std::set<std::string> myDoctrines;
   DtFilename myDoctrinesFile;
   
   typedef std::map<int, std::string> DoctrinesForForce;
   DoctrinesForForce myDoctrinesForForce;

   std::vector<std::string> myScriptPaths;
   DtString myLastLanguageRequested;

   DtScriptResourceManagerMap myScriptResourceManagers;
   std::map<std::string, std::string> myScriptIdToScriptIdMap;

   std::map<int, std::string> myDefaultTemplatesForScriptTypes;

   mutable tbb::mutex myMutex;
};