WsfTaskManager.hpp

Go to the documentation of this file.

// ****************************************************************************
// CUI
//
// The Advanced Framework for Simulation, Integration, and Modeling (AFSIM)
//
// Copyright 2003-2015 The Boeing Company. All rights reserved.
//
// The use, dissemination or disclosure of data in this file is subject to
// limitation or restriction. See accompanying README and LICENSE for details.
// ****************************************************************************
// ****************************************************************************
// Updated by Infoscitex, a DCS Company
// ****************************************************************************
 
#ifndef WSFTASKMANAGER_HPP
#define WSFTASKMANAGER_HPP
 
#include <list>
#include <map>
#include <memory>
#include <set>
 
#include "UtCallback.hpp"
#include "UtCallbackHolder.hpp"
class UtInput;
class WsfAssociationMessage;
#include "wsf_export.h"
 
#include "WsfEvent.hpp"
class WsfLocalTrack;
class WsfMessage;
class WsfPlatform;
#include "WsfProcessorComponent.hpp"
#include "WsfRandomVariable.hpp"
#include "script/WsfScriptProcessor.hpp"
class WsfSensor;
class WsfStatusMessage;
#include "WsfTask.hpp"
class WsfTaskAssignMessage;
class WsfTaskCancelMessage;
class WsfTaskControlMessage;
class WsfTaskStatusMessage;
#include "WsfTimeDelayQueue.hpp"
class WsfTrack;
class WsfTrackDropMessage;
#include "WsfTrackId.hpp"
class WsfTrackManager;
class WsfTrackMessage;

class WSF_EXPORT WsfTaskManagerComponent : public WsfProcessorComponent
{
public:

   virtual void Update(double aSimTime) {}
   virtual void PlatformDeleted(WsfPlatform* aPlatformPtr) {}
   virtual bool AcquireResource(double aSimTime, WsfTask& aTask, const WsfTrack& aTrack, bool& aStatusOk)
   {
      return false;
   }
   virtual bool ReleaseResource(double aSimTime, WsfTask& aTask) { return false; }
 
   virtual void TaskCorrelated(double aSimTime, WsfTask& aTask) {}
   virtual void TaskCanceled(double aSimTime, WsfTask& aTask) {}
   virtual void TaskCompleted(double aSimTime, WsfTask& aTask) {}
 
   virtual bool AssignTask(double aSimTime, const WsfTrack& aTrack, const WsfTask& aTask, bool aLockTrack = true)
   {
      return false;
   }
 
   virtual void PurgeReceivedTask(double aSimTime, WsfTask& aTask) {}
   virtual void PurgeTransmittedTask(double aSimTime, WsfTask& aTask) {}
 
   virtual void TrackDropped(double aSimTime, const WsfTrackId& aTrackId) {}
 
   virtual bool ProcessAssociationMessage(double aSimTime, const WsfAssociationMessage& aMessage) { return true; }
   virtual bool ProcessTaskStatusMessage(double aSimTime, const WsfTaskStatusMessage& aMessage) { return true; }
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfTaskManagerComponent, cWSF_COMPONENT_TASK_MANAGER_COMPONENT)
 

class WSF_EXPORT WsfTaskManager : public WsfScriptProcessor
{
public:
   using RoleIterator = WsfComponentList::RoleIterator<WsfTaskManagerComponent>;
 
   enum TrackUpdateStrategy
   {
      cDEFAULT,
      cBATCH
   };
 
   using TaskList = std::list<WsfTask>;

   struct PendingMessage
   {
   public:
      PendingMessage(double            aSimTime,
                     WsfTaskManager*   aManagerPtr,
                     const WsfMessage& aMessage,
                     size_t            aReceipientIndex,
                     WsfStringId       aCommName,
                     int               aRetryAttempts);
      PendingMessage(const PendingMessage& aSrc);
      PendingMessage& operator=(const PendingMessage& aRhs);
      ~PendingMessage();
 
      double      mTimeSent;
      WsfMessage* mMessagePtr;
      size_t      mRecipientIndex;
      WsfStringId mCommName;
      int         mRetryAttempts;
      // See the constructor in the source code as to what this is for...
      bool mSuppressTimeoutMessage;
   };
   using PendingMessageList = std::list<PendingMessage>;

   struct ActiveTrack
   {
      WsfTrackId mTaskTrackId;
      WsfStringId mSensorName;
      WsfTrackId mSensorTrackId;
   };
   using TrackList     = std::list<ActiveTrack>;
   using TrackListIter = std::list<ActiveTrack>::iterator;

   struct SensorRequest
   {
      WsfTrackId mSensorTrackId;
      WsfSensor* mSensorPtr;
      WsfStringId mModeNameId;
   };
   using SensorRequestList = std::list<SensorRequest>;
 
   WsfTaskManager(WsfScenario& aScenario, const std::string& aClassName = "WsfTaskManager");
   WsfTaskManager& operator=(const WsfTaskManager&) = delete;
   ~WsfTaskManager() override                       = default;
 
   const char* GetScriptClassName() const override;


   WsfProcessor* Clone() const override;
   const int*    GetComponentRoles() const override;
   void*         QueryInterface(int aRole) override;
 
   bool PreInitialize(double aSimTime) override;
   bool Initialize(double aSimTime) override;
   bool Initialize2(double aSimTime) override;
   bool ProcessInput(UtInput& aInput) override;
 
   void PlatformDeleted(WsfPlatform* aPlatformPtr) override;
   bool ProcessMessage(double aSimTime, const WsfMessage& aMessage) override;
   bool ReceiveMessage(double aSimTime, const WsfMessage& aMessage) override;
   void TurnOff(double aSimTime) override;
   void TurnOn(double aSimTime) override;
   void Update(double aSimTime) override;


   virtual bool AssignTask(double aSimTime, const WsfTrack& aTrack, const WsfTask& aTask, bool aLockTrack = true);
 
   virtual bool AssignTask(double                 aSimTime,
                           const WsfTrack&        aTrack,
                           WsfStringId            aTaskType,
                           const WsfTaskResource& aResource,
                           WsfPlatform*           aAssigneePtr,
                           WsfStringId            aCommName);
 
   virtual bool CancelTask(double aSimTime, unsigned int aTaskId);
 
   virtual void CancelTask(double aSimTime, WsfTask& aTask, bool aSendCancelMessage);
 
   virtual bool CancelTask(double                 aSimTime,
                           const WsfTrackId&      aTrackId,
                           WsfStringId            aTaskType,
                           const WsfTaskResource& aResource,
                           size_t                 aAssigneeIndex);
 
   virtual bool CreateDelayTask(double aSimTime, double aDelayTime, const WsfTrack& aTrack, WsfStringId aTaskType);
 
   virtual bool
   ChangeOperatingLevel(double aSimTime, WsfStringId aName, int aLevel, WsfPlatform* aAssigneePtr, WsfStringId aCommName);


   virtual bool ReportTaskComplete(double            aSimTime,
                                   const WsfTrackId& aTrackId,
                                   WsfStringId       aTaskType,
                                   WsfStringId       aResourceName,
                                   WsfStringId       aSubStatus);
 
   virtual bool ReportTaskProgress(double            aSimTime,
                                   const WsfTrackId& aTrackId,
                                   WsfStringId       aTaskType,
                                   WsfStringId       aResourceName,
                                   WsfStringId       aSubStatus);


   void   AssigneesForTask(const WsfTrackId& aTrackId, WsfStringId aTaskType, std::vector<size_t>& aAssignees) const;
   size_t AssigneeForTask(const WsfTrackId& aTrackId, WsfStringId aTaskType, WsfStringId aResourceName) const;
   int    OperatingLevelFor(WsfStringId aConditionName) const;
   int    TasksAssignedTo(size_t aAssigneeIndex, const WsfTrackId& aTrackId, WsfStringId aTaskType, WsfStringId aResourceName) const;
   int    TasksAssignedFor(const WsfTrackId& aTrackId, WsfStringId aTaskType, WsfStringId aResourceName) const;
   int    TasksReceivedFor(const WsfTrackId& aTrackId, WsfStringId aTaskType, WsfStringId aResourceName) const;
   double TimeTaskAssigned(const WsfTrackId& aTrackId, WsfStringId aTaskType, size_t aAssigneeIndex) const;

   TaskList& AssignedTaskList() { return mXmtdTaskList; }

   TaskList& ReceivedTaskList() { return mRcvdTaskList; }
 
   static TaskList::iterator FindTask(TaskList&         aTaskList,
                                      size_t            aAssigneeIndex,
                                      const WsfTrackId& aTrackId,
                                      WsfStringId       aTaskType,
                                      WsfStringId       aResourceName);
 
   static TaskList::iterator FindTask(TaskList& aTaskList, unsigned int aTaskId);
 
   static TaskList::iterator FindTask(TaskList& aTaskList, unsigned int aTaskId, size_t aAssigneeIndex);

   double TimeLastTaskAssigned() const { return mTimeLastTaskAssigned; }

   double TimeLastTaskReceived() const { return mTimeLastTaskReceived; }




   UtCallbackListN<void(double, WsfTask&, const WsfTrack&)> OnTaskAssigned;

   UtCallbackListN<void(double, WsfTask&)> OnTaskCanceled;

   UtCallbackListN<void(double, WsfTask&)> OnTaskCompleted;

   UtCallbackListN<void(double, WsfTask&, const WsfTrack&)> OnTaskAssignSent;

   UtCallbackListN<void(double, WsfTask&, WsfStringId)> OnTaskCompleteSent;

   UtCallbackListN<void(double, WsfTask&)> OnTaskCancelSent;


   void CheckMessageAcknowledged(double aSimTime, unsigned int aSerialNumber);
 
   bool SendTaskMessage(double aSimTime, const WsfMessage& aMessage, size_t aRecipientIndex, WsfStringId aCommName, bool aReliable);
 
   double SendTrackUpdate(double aSimTime, unsigned int aTaskId);
 
   WsfStringId SelectCommDevice(WsfPlatform* aAssigneePtr, WsfStringId aCommName);

   const TrackList& ActiveTrackList() const { return mActiveTrackList; }
 
   bool ShowTaskMessages() const { return mShowTaskMessages; }



   class WSF_EXPORT EventBase : public WsfEvent
   {
   public:
      EventBase(double aSimTime, WsfTaskManager* aManagerPtr);
      EventDisposition         Execute() override;
      virtual EventDisposition ExecuteEvent(WsfTaskManager* aTaskManagerPtr) = 0;
 
   private:
      WsfTaskManager* mManagerPtr;
      size_t          mPlatformIndex;
   };

   class WSF_EXPORT TaskCompleteEvent : public WsfTaskManager::EventBase
   {
   public:
      TaskCompleteEvent(double          aSimTime,
                        WsfTaskManager* aManagerPtr,
                        WsfTrackId      aTrackId,
                        WsfStringId     aTaskType,
                        WsfStringId     aResourceName,
                        WsfStringId     aSubStatus);
 
      EventDisposition ExecuteEvent(WsfTaskManager* aManagerPtr) override;
 
   private:
      WsfTrackId  mTrackId;
      WsfStringId mTaskType;
      WsfStringId mResourceName;
      WsfStringId mSubStatus;
   };

   class WSF_EXPORT TrackUpdateEvent : public WsfTaskManager::EventBase
   {
   public:
      TrackUpdateEvent(double aSimTime, WsfTaskManager* aManagerPtr, unsigned int aTaskId);
 
      EventDisposition ExecuteEvent(WsfTaskManager* aManagerPtr) override;
 
   private:
      unsigned int mTaskId;
   };

 
protected:
   WsfTaskManager(const WsfTaskManager& aSrc);
 
   virtual bool AcquireResource(double aSimTime, WsfTask& aTask, const WsfTrack& aTrack);
 
   virtual bool ReleaseResource(double aSimTime, WsfTask& aTask);
 
   virtual void TaskCanceled(double aSimTime, WsfTask& aTask);
 
   virtual void TaskCompleted(double aSimTime, WsfTask& aTask);
 
   virtual void TaskAssignSent(double aSimTime, const WsfTrack& aTrack, WsfTask& aTask);
 
   virtual void TaskAssigned(double aSimTime, const WsfTrack& aTrack, WsfTask& aTask);
 
   virtual void TaskCorrelated(double aSimTime, WsfTask& aTask);
 
   virtual void OperatingLevelChanged(double aSimTime, std::string aLevel);
 
   virtual void TrackDropped(double aSimTime, const WsfTrackId& aTrackId);
 
   bool DropFromPurgedTaskList(TaskList& aPurgedTaskList, size_t aAssignerIndex, unsigned int aTaskId);
 
   bool GetMessageSender(const WsfMessage& aMessage, size_t& aSenderIndex, WsfStringId& aRcvrCommName);
 
   void MessageAcknowledged(unsigned int aSerialNumber);


   virtual bool ProcessAssociationMessage(double aSimTime, const WsfAssociationMessage& aMessage);
 
   virtual bool ProcessTaskAssignMessage(double aSimTime, const WsfTaskAssignMessage& aMessage);
 
   virtual bool ProcessTaskCancelMessage(double aSimTime, const WsfTaskCancelMessage& aMessage);
 
   virtual bool ProcessTaskControlMessage(double aSimTime, const WsfTaskControlMessage& aMessage);
 
   virtual bool ProcessTaskStatusMessage(double aSimTime, const WsfTaskStatusMessage& aMessage);

   virtual bool ProcessTrackDropMessage(double aSimTime, const WsfTrackDropMessage& aMessage);
 
   virtual bool ProcessTrackMessage(double aSimTime, const WsfTrackMessage& aMessage);

   WsfTrackManager* mTrackManagerPtr;

   std::unique_ptr<WsfTimeDelayQueue> mThinkerPtr;
 
   PendingMessageList mPendingMessageList;
   TrackList          mActiveTrackList;
   SensorRequestList  mSensorRequestList;

   std::map<WsfStringId, int> mOperatingLevels;

   std::set<WsfSensor*> mSensorsTurnedOn;
 
   WsfScenario* mScenarioPtr;
 
   UtCallbackHolder mCallbacks;

   TaskList mXmtdTaskList;

   TaskList mPurgedXmtdTaskList;

   TaskList mRcvdTaskList;

   TaskList mPurgedRcvdTaskList;

   std::set<WsfTrackId> mPendingRcvdTasks;

   WsfStringId mTrackProcessorName;

   double mTrackUpdateInterval;

   WsfRandomVariable mTimeToRecognizeMessage;

   double mCommRetryInterval;

   int mCommRetryAttempts;

   unsigned int mNextTaskId;

   bool mShowTaskMessages;

   bool mShowUncompletedTasks;

   TrackUpdateStrategy mTrackUpdateStrategy;

   double mTimeLastTaskAssigned;

   double mTimeLastTaskReceived;
 
private:
   virtual void PurgeReceivedTask(double aSimTime, WsfTask& aTask);
 
   virtual void PurgeTransmittedTask(double aSimTime, WsfTask& aTask);
 
   void UpdatePendingReceivedTasks(double aSimTime, const WsfLocalTrack* aLocalTrackPtr);
 
   void UpdateSensorRequestList(double            aSimTime,
                                const WsfTrackId& aTrackId,
                                WsfSensor*        aSensorPtr,
                                WsfStringId       aModeNameId,
                                bool              aAddEntry);
 
   virtual void UpdateTaskCorrelation(double aSimTime, WsfTask& aTask);



   virtual void LocalTrackDropped(double aSimTime, const WsfLocalTrack* aLocalTrackPtr);
 
   virtual void LocalTrackInitiated(double aSimTime, const WsfLocalTrack* aLocalTrackPtr, const WsfTrack* aRawTrackPtr);
 
   virtual void LocalTrackUpdated(double aSimTime, const WsfLocalTrack* aLocalTrackPtr, const WsfTrack* aRawTrackPtr);
 
   void TrackManagerChanged(double aSimTime, WsfTrackManager* aNewManagerPtr);



   UtScript*      mOnTaskAssignScriptPtr;
   UtScript*      mOnTaskCancelScriptPtr;
   UtScript*      mOnTaskCompleteScriptPtr;
   UtScript*      mOnTaskCompleteSentScriptPtr;
   UtScript*      mOnTaskAssignSentScriptPtr;
   UtScript*      mOnTaskCancelSentScriptPtr;
   UtScript*      mOnOperatingLevelChangeScriptPtr;
   UtScriptData*  mTrackVarPtr;
   UtScriptClass* mTaskClassPtr;
   UtScriptClass* mTrackClassPtr;
};
 
WSF_DECLARE_COMPONENT_ROLE_TYPE(WsfTaskManager, cWSF_COMPONENT_TASK_MANAGER)
 
#endif