include/vrfobjcore/taskMgr.h

Go to the documentation of this file.

/*******************************************************************************
** Copyright (c) 2006 MAK Technologies, Inc.
** All rights reserved.
*******************************************************************************/
/*******************************************************************************
** $RCSfile: taskMgr.h,v $ $Revision: 1.20 $ $State: Exp $
*******************************************************************************/



#ifndef DtSimTaskManager_H_
#define DtSimTaskManager_H_

#include "vrfutil/rwBoolean.h"
#include <vector>
#include <map>
#include "vrfobjcore/vrfObject.h"
#include "vrfobjcore/taskMgrFact.h"
#include "vrftasks/taskAndTaskStateDefines.h"
#include <vlutil/vlSmartPointers.h>

class DtControllerComponentList;
class DtSimTask;
class DtSimComponent;
class DtSimInterfaceContent;
class DtVrfObjectMessage;
class DtTaskMessage;
class DtSimMessage;
class DtTaskControllerComponent;

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:

   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(int taskType, 
      DtTaskControllerComponent* taskController);

   virtual void removeTaskProcessor(int taskType, 
      DtTaskControllerComponent* taskController);

   virtual void removeAllReferencesToController(DtTaskControllerComponent* 
      taskController);

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

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

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

   virtual bool taskActive(int taskId) const;

   virtual void registerInterfaceMessageCallbacks();

   virtual void registerRadioMessageCallbacks();

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

   virtual void skipTask(bool fromSuperior = false);

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

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

   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(int taskType1, int taskType2) const;

   virtual bool canExecuteTask(int) const;

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

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

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

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

   static void subordinateRemoved(DtEntityIdentifier childEid, 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);

protected:

   virtual void processClearTask(DtSimMessage * msg);

   virtual void processObjectAboutToBeRemoved(DtVrfObject* object);

   virtual bool clearAllTopLevelTasks();

   virtual void clearConflictingTopLevelTasks(int taskType);

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

   void processSubordinateRemoved(DtEntityIdentifier childEid); 

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

   virtual void processTaskMessage(DtSimMessage* msg);

   virtual std::vector<int> conflictingTaskTypes(int testTaskType) 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();

protected:
   DtVrfObject * myVrfObject;

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

   std::vector<DtOnTaskNotifyCallbackInfo> myOnTaskNotifyCallbacks;

   bool myHaveRegisteredOrgMgrCallback;

   DtTaskProcessorMap myTaskProcessorMap;

   bool mySendSkipTaskMessages;

   int myNumberOfTaskSubscriptions;

   bool mySendTasksNextTick;

   static DtSimTaskManagerFactory* theFactory;
};

#endif