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 <vrfutil/scriptedTaskMetaData.h>
#include <vrfutil/noArgumentCallbackList.h>
#include "vrfutil/averager.h"
#include <vrfutil/rwTranslatableStringObject.h>

class DtSimManager;
class DtSimMessage;



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;

struct DT_DLL_vrfobjcore DtScriptedTaskManagerCallbackInfo
{
   int reason;

   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) {};
      ScenarioSystemPair(DtScriptedTaskMetaData* sc, DtScriptedTaskMetaData* sy) : scenarioScript(sc), systemScript(sy), monitor(0),
            references(0), averager(0) {};

      DtScriptedTaskMetaData* scenarioScript;
      DtScriptedTaskMetaData* systemScript;
      DtAverager*             averager;
      int                     monitor;
      int                     references;
      std::string error;
   };

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

public:
   DtScriptedTaskManager(DtSimManager*);

   virtual ~DtScriptedTaskManager();

private:
   DtScriptedTaskManager(const DtScriptedTaskManager & orig);

   DtScriptedTaskManager & operator=(const DtScriptedTaskManager & orig);

public:
   virtual DtSimManager* simManager() const;

   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,
      const std::string& language = "");

   virtual bool lookupScriptById(const std::string&, DtScriptedTaskMetaData&) const;

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

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

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

   virtual bool writeScenarioScripts(const 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::vector<std::string> tasksValidFor(const DtEntityType&, int force) const;

   virtual std::vector<std::string> 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 std::string& scriptId, const std::string& error, bool sendReport = true);

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

   virtual void clearError(const std::string& scriptId);
   


   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 std::string&);

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


   virtual int scriptType(const std::string&) 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>&);
   
protected:
   static void requestScriptedTasks(DtSimMessage*, void*);
   virtual void processRequestScriptedTasks(DtSimMessage*);

   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 modifySystemScriptedTask(const DtScriptedTaskMetaData&, const std::string& sourceSciptId = "", bool send = true);

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

   virtual bool changeScenarioScriptScriptId(const std::string& from, const std::string& to);

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

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

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

   virtual void loadDefaultScript(DtScriptedTaskMetaData&);

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

   virtual void sendMonitorInformation();

protected:
   DtSimManager* mySimManager;
   std::string mySimulationModelSetScriptsDirectory;

   ScriptedTasksByDirectory mySystemScriptedTasks;
   ScriptedTaskMetaDataList myScenarioScripts;
   ScriptedTaskMetaDataList myAllScriptsById;

   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;
};