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/simTaskManagerFactory.h"
#include "vrftasks/taskAndTaskStateDefines.h"
#include <vlutil/vlSmartPointers.h>
#include "vrftasks/radioMessageTypes.h"
#include "vrfobjcore/suspendedTaskInfo.h"
#include "vrfobjcore/organizationManagerNode.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;

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
{
private:
   DtSimTaskManager();

   DtSimTaskManager(const DtSimTaskManager & orig);

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

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

   DtSimTaskManager(const DtString & name, DtLocalObject* vrfObject);

   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, bool doNotAbandonPlan = false);
   virtual bool executeTask(DtTaskMessage& taskMsg, DtSimTaskStatePtr taskState, bool clearConflictingTopLevelTasks = true, bool doNotAbandonPlan = false);

   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 int suspendSubtask(int taskId, int subtaskId);

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

   virtual void setTaskVisualizationsActive(bool);

   static DtSimTaskManager * creator(const DtString & name, DtLocalObject* vrfObject);

   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, DtLocalObject* vrfObject);

   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 resumeTaskTree(DtSuspendedTaskInfo* suspendedTaskInfo, DtSuspendedTaskInfo* parentTaskInfo = 0);

   virtual bool clearAllTopLevelTasks();

   virtual void clearConflictingTopLevelTasks(const DtSimTaskMessageType& taskType);

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

   void processSubordinateRemoved(const DtUUID& info); 

   virtual void processSimObjectDeleted(const DtSimObject*);

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

   virtual void processTaskMessage(DtSimMessage* msg);

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

   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, int status, DtCurrentTasksAdminContent& adminContent);

   virtual void updateTaskVisualizationList(bool includeTimeout = true);

   virtual void stopCurrentTaskVisualizations();

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

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

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

protected:
   DtLocalObject* myLocalObject;

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

   std::vector<DtOnTaskNotifyCallbackInfo> myOnTaskNotifyCallbacks;

   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;

   bool myTaskVisualizationsActive;
   bool myFirstTick;

   boost::signals2::scoped_connection mySimObjectDeletedConnection;
   boost::signals2::scoped_connection mySubordinateRemovedConnection;

   struct DelayTaskExecution
   {
      DelayTaskExecution() : doTaskNotify(false), clearConflictingTopLevelTasks(true), doNotAbandonPlan(false) {};
      DelayTaskExecution(const DtTaskMessage& msg, DtSimTaskStatePtr ptr, bool d, bool c, bool p)
      : taskMessage(dynamic_cast<DtTaskMessage*>(msg.clone()))
      , taskState(ptr)
      , doTaskNotify(d)
      , clearConflictingTopLevelTasks(c)
      , doNotAbandonPlan(p)
      {
      }

      DelayTaskExecution(const DelayTaskExecution& orig)
      : taskMessage(orig.taskMessage)
      , taskState(orig.taskState)
      , doTaskNotify(orig.doTaskNotify)
      , clearConflictingTopLevelTasks(orig.clearConflictingTopLevelTasks)
      , doNotAbandonPlan(orig.doNotAbandonPlan)
      {
      }

      std::shared_ptr<DtTaskMessage> taskMessage;
      DtSimTaskStatePtr taskState;
      bool doTaskNotify;
      bool clearConflictingTopLevelTasks;
      bool doNotAbandonPlan;
   };

   typedef std::vector<DelayTaskExecution> DelayedTaskExecution;
   DelayedTaskExecution myDelayedTaskExecution;
};