simTaskManager.h

Go to the documentation of this file.

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


#pragma once

#include <readerWriter/rwBoolean.h>
#include <vector>
#include <map>
#include "vrfobjcore/vrfObject.h"
#include "vrfobjcore/simTaskManagerFactory.h"
#include "vrfobjcore/taskVisualization.h"
#include "vrftasks/taskAndTaskStateDefines.h"
#include <vlutil/vlSmartPointers.h>
#include "vrftasks/radioMessageTypes.h"
#include "vrfobjcore/suspendedTaskInfo.h"
#include <set>

class DtControllerComponentList;
class DtSimTask;
class DtSimComponent;
class DtSimInterfaceContent;
class DtVrfObjectMessage;
class DtTaskMessage;
class DtSimMessage;
class DtTaskControllerComponent;
class DtSuspendedTaskInfo;
class DtCurrentTasksAdminContent;
class DtScriptedTaskTask;
class DtScriptReactiveTaskController;
class DtBulkEnvironmentProcessManager;

typedef void (*DtOnTaskNotifyCallbackFcn)(
   const DtSimTask & task, const DtSimComponent &notifier, void* usr);

struct DtOnTaskNotifyCallbackInfo
{
   DtOnTaskNotifyCallbackFcn myCallbackFunction;
   void* myUserData;
};

#include "vrfobjcore/vrfobjcoreDefines.h"
class DT_DLL_vrfobjcore DtSimTaskManager : public DtReaderWriter
{
private:
   DtSimTaskManager();

public:
   typedef DtCallbackList<const DtTaskMessage&> DtTaskCompleteCallbackList;
   typedef std::set<DtSimTaskMessageType> SupportingTasks;
   typedef std::map<int, SupportingTasks> AvailableSupportingTasks;

   DtSimTaskManager(const DtString & name, DtVrfObject * vrfObject, 
      DtReaderWriterRegistry * parentRegistry = 0);

   DtSimTaskManager(const DtSimTaskManager & orig, 
      DtReaderWriterRegistry * parentRegistry = 0);

   const DtSimTaskManager & operator=(const DtSimTaskManager & orig);

   virtual ~DtSimTaskManager();

   virtual bool init();

   virtual void tick();

   virtual void addTaskProcessor(const DtSimTaskMessageType& taskType, 
      DtTaskControllerComponent* taskController);

   virtual void removeTaskProcessor(const DtSimTaskMessageType& taskType, 
      DtTaskControllerComponent* taskController);

   virtual void removeAllReferencesToController(DtTaskControllerComponent* 
      taskController);

   virtual std::vector<DtSimTaskMessageType> capableTaskIds() const;

   virtual AvailableSupportingTasks supportingTasks() const;

   virtual SupportingTasks supportingTasks(int) const;

   virtual void addSupportingTask(int, const DtSimTaskMessageType&);
   virtual void addSupportingTasks(int, const SupportingTasks&);
   virtual void removeSupportingTask(int, const DtSimTaskMessageType&);
   virtual void removeSupportingTasks(int);

   virtual bool executeTask(DtTaskMessage& taskMsg, bool clearConflictingTopLevelTasks = true);
   virtual bool executeTask(DtTaskMessage& taskMsg, DtSimTaskStatePtr taskState, bool clearConflictingTopLevelTasks = true);

   virtual void addBackgroundProcess(const DtString& scriptId, int backgroundProcessId, const DtString& controllerName);
   virtual void removeBackgroundProcess(const DtString& scriptId);

   virtual void addScriptedSet(const DtString& scriptId, int backgroundProcessId, const DtString& controllerName);
   virtual void removeScriptedSet(const DtString& scriptId);

   virtual bool transitionTask(DtTaskMessage& taskMsg, DtSimTaskStatePtr taskState);

   virtual int suspendTasks(std::set<DtString> actionCategories);
   virtual int suspendAllTopLevelTasks();

   virtual DtSuspendedTaskInfo* suspendTask(int taskId);

   virtual bool resumeTasks(int suspendId);
   

   virtual void addTaskCompleteCallback(DtTaskCompleteCallbackList::DtCallbackFunctionType fcn, void* usr);
   virtual void removeTaskCompleteCallback(DtTaskCompleteCallbackList::DtCallbackFunctionType fcn, void* usr);

   virtual bool taskActive(int taskId) const;

   virtual void registerInterfaceMessageCallbacks();

   virtual void registerRadioMessageCallbacks();

   virtual void taskNotify(const DtSimTask & task, const DtSimComponent& notifier,
      bool clearConflictingTopLevelTasks = true);

   virtual void skipTask(bool fromSuperior = false);

   virtual void taskComplete(const DtVrfObjectMessage & radioMsg, bool success, bool affectsIndependentTaskStatus = true);

   virtual void sendTaskCompleted(const DtTaskMessage& taskMsg, bool success);

   void awaitingTask(int taskIdJustCompleted = -1);

   virtual void setTaskedBySuperior();

   virtual bool requestTaskNeeded() const;

   virtual void setRequestTaskNeeded(bool requestTaskNeeded);

   virtual bool independentlyTasked() const;

   virtual void setIndependentlyTasked(bool independentlyTasked);

   virtual bool isPseudoAggregate() const { return false; }

   virtual DtString type() const;

   virtual DtVrfObject * vrfObject() const;

   virtual void setVrfObject(DtVrfObject * vrfObject);


   virtual void setSendSkipTaskMessages(bool sendSkipTaskMessages);
   virtual bool sendSkipTaskMessages();
   //}
   
   virtual void addOnTaskNotifyCallback(
      DtOnTaskNotifyCallbackFcn fcn, void* userData);

   virtual void removeOnTaskNotifyCallback(
      DtOnTaskNotifyCallbackFcn fcn, void* userData);

   virtual void clearSubtask(int subtaskId);

   virtual DtTaskWithTaskStateListPtr topLevelTasks() const;

   virtual bool hasTopLevelTask() const;

   virtual bool taskTypesAreExclusive(const DtSimTaskMessageType& taskType1, const DtSimTaskMessageType& taskType2) const;

   virtual bool taskTypesAreExclusive(const std::list<DtString>& task1Categories, const DtSimTaskMessageType& taskType2) const;

   virtual bool canExecuteTask(const DtSimTaskMessageType&) const;

   virtual void clearTaskByType(const DtSimTaskMessageType& taskType);

   virtual void updateTaskInfo();

   virtual bool canBeExecutedConcurrently(const DtSimTaskMessageType& taskType) const;

   virtual DtScriptReactiveTaskController* reactiveTaskController();
   virtual void setReactiveTaskController(DtScriptReactiveTaskController* reactiveTaskController);

   static void taskedBySuperiorRequestCallback(DtSimMessage * msg, void * 
      usrData);

   static void skipTaskCallback(DtSimMessage * msg, void * usr);

   static void clearTaskCallback(DtSimMessage * msg, void * usr);

   static void taskVisualizationRequestCallback(DtSimMessage * msg, void * usr);

   static void objectAboutToBeRemovedCallback(DtVrfObject* object, void* usr);

   static void subordinateRemoved(const DtUUID& superior, const DtUUID& subordinate, void* usr); 

   static DtSimTaskManager * creator(const DtString & name, 
      DtVrfObject * vrfObject, DtReaderWriterRegistry * parentRegistry);

   static DtSimTaskManagerFactory * factory();
   static void setFactory(DtSimTaskManagerFactory * factory);

   static void addSimTaskManagerCreatorFcn(const DtString & type, 
      DtSimTaskManagerCreatorFcn fcn);

   static DtSimTaskManager * createTaskManager(const DtString & name, 
      const DtString & type, DtVrfObject * vrfObject, 
      DtReaderWriterRegistry * parentRegistry = 0);

   virtual bool hasTopLevelTasks() const;

   virtual bool taskVisualizationsEnabled(bool includeUnTimedOut) const;

   virtual bool taskVisualizationsActivated() const;

protected:

   virtual void processClearTask(DtSimMessage * msg);

   virtual void processTaskVisualizationRequest(DtSimMessage * msg);

   virtual void processObjectAboutToBeRemoved(DtVrfObject* object);

   virtual void resumeTaskTree(DtSuspendedTaskInfo* suspendedTaskInfo);

   virtual bool clearAllTopLevelTasks();

   virtual void clearConflictingTopLevelTasks(const DtSimTaskMessageType& taskType);

   virtual void onTaskNotify(const DtSimTask & task, const DtSimComponent &
      notifier);

   void processSubordinateRemoved(const DtUUID& superior, const DtUUID& subordinate); 

   static void taskMessageCallback(DtSimMessage* msg, void* usr);

   virtual void processTaskMessage(DtSimMessage* msg);

   virtual bool startTaskExecution(DtTaskMessage& taskMsg, DtSimTaskStatePtr taskState,
      bool taskNotify, bool clearConflictingTopLevelTasks = true);

   virtual std::vector<DtSimTaskMessageType> conflictingTaskTypes(const DtSimTaskMessageType& testTaskType) const;

   virtual std::list<DtString> taskGroupsForTask(const DtSimTaskMessageType& taskType) const;

   static void requestCurrentTasksCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processRequestCurrentTasks(const DtVrfObjectMessage* msg);

   static void unsubscribeCurrentTasksCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processUnsubscribeCurrentTasks(const DtVrfObjectMessage* msg);

   virtual void sendCurrentTasks();
   virtual void addSubtasksToCurrentTaskMessage(const DtSuspendedTaskInfoList& subtaskList, int parentTaskId, DtCurrentTasksAdminContent& adminContent);

   virtual void updateTaskVisualizationList();

   virtual void sendCurrentTaskVisualizations();

   virtual void stopCurrentTaskVisualizations();

   static void clearTaskByTrackingNumberCallback(const DtVrfObjectMessage* msg, void* usr);
   virtual void processClearTaskByTrackingNumber(const DtVrfObjectMessage* msg);

   static DtGlobalObjectDesignator nextTaskVisualizationGlobalIdCallback(void* usr);
   virtual DtGlobalObjectDesignator nextTaskVisualizationGlobalId();

   virtual void registerSetDataMessageCallbacks();
   virtual void unregisterSetDataMessageCallbacks();

   virtual void registerTaskMessageCallbacks();
   virtual void unregisterTaskMessageCallbacks();

protected:
   DtVrfObject * myVrfObject;

   typedef std::map<DtSimTaskMessageType, DtTaskControllerComponent*> DtTaskProcessorMap;

   std::vector<DtOnTaskNotifyCallbackInfo> myOnTaskNotifyCallbacks;

   bool myHaveRegisteredOrgMgrCallback;

   DtTaskProcessorMap myTaskProcessorMap;

   bool mySendSkipTaskMessages;

   int myNumberOfTaskSubscriptions;

   bool mySendTasksNextTick;

   std::set<DtSimulationAddress> myTaskVisualizationRequestors;

   DtTime myTaskVisualizationRemovalTime;

   DtTaskCompleteCallbackList myTaskCompleteCallbackList;

   DtScriptReactiveTaskController* myReactiveTaskController;

   static DtSimTaskManagerFactory* theFactory;

   bool myResumingTasks;

   AvailableSupportingTasks myAvailableSupportingTasks;

   struct BackgroundProcessInformation
   {
      int taskId;
      DtString controllerName;
   };

   typedef std::map<DtString, BackgroundProcessInformation> BackgroundProcesses;

   BackgroundProcesses myBackgroundProcesses;
   BackgroundProcesses myScriptedSets;

   DtBoost::shared_ptr<DtBulkEnvironmentProcessManager> myTaskVisualizationManager;

   unsigned myNextTaskVisualizationId;

   std::list<DtTaskVisualizationPtr> myCurrentTaskVisualizations;
   std::list<DtTaskVisualizationPtr> myCurrentInactiveTaskVisualizations;
};