WsfTrackStateController.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.
// ****************************************************************************
 
#ifndef WSFTRACKSTATECONTROLLER_HPP
#define WSFTRACKSTATECONTROLLER_HPP
 
#include "wsf_export.h"
 
#include <map>
#include <string>
#include <vector>
 
#include "UtCallbackHolder.hpp"
#include "UtGenericMappedList.hpp"
#include "WsfLocalTrackStatus.hpp"
class WsfMessage;
class WsfPlatform;
class WsfProcessor;
#include "WsfRandomVariable.hpp"
class WsfScriptContext;
#include "script/WsfScriptStateMachine.hpp"
class WsfTimeDelayQueue;
#include "WsfTrackId.hpp"
#include "WsfTrackList.hpp"
class WsfTrackManager;

 
class WSF_EXPORT WsfTrackStateController
{
public:
   WsfTrackStateController();
   WsfTrackStateController(WsfScriptContext& aContext);
   WsfTrackStateController(const WsfTrackStateController& aSrc, WsfScriptContext& aContext);
   virtual ~WsfTrackStateController();

   WsfPlatform* GetPlatform() const { return mPlatformPtr; }

   WsfProcessor* GetProcessor() const { return mProcessorPtr; }


 
   virtual bool Initialize(double             aSimTime,
                           WsfProcessor*      aProcessorPtr,
                           WsfTimeDelayQueue* aThinkerPtr,
                           WsfTrackManager*   aTrackManagerPtr);
   virtual bool ProcessInput(const WsfScenario& aScenario, UtInput& aInput);
   virtual bool ProcessMessage(double aSimTime, const WsfMessage& aMessage);
 
   bool         IsTurnedOn() const { return mIsTurnedOn; }
   virtual void TurnOff(double aSimTime);
   virtual void TurnOn(double aSimTime);
 
   void ConnectCallbacks();
 


   void SetEvaluationInterval(double aEvaluationInterval) { mEvaluationInterval = aEvaluationInterval; }

   void SetTransitionTime(double aTransitionTime) { mTransitionTime = aTransitionTime; }
 
   virtual void EnterState(double aSimTime, const WsfTrackId& aTrackId, WsfStringId aNewStateName);
 
   virtual void TracksInState(WsfStringId aStateName, std::vector<WsfLocalTrack*>& aTrackList);
 
   virtual int TracksInState(WsfStringId aStateName);
 
   virtual WsfStringId StateOfTrack(const WsfTrackId& aLocalTrackId);
 
   WsfSimulation* GetSimulation() const;


 
   virtual void EnterState(int aStateIndex);
   virtual void ExitState(int aStateIndex);
 
   virtual double EvaluationComplete(double aSimTime, const WsfTrackId& aLocalTrackId, unsigned int aEvaluationEpoch);
 
   virtual void RequestEvaluation(double aSimTime, const WsfTrackId& aLocalTrackId, unsigned int aEvaluationEpoch);
 
   class TrackStateMachine : public WsfScriptStateMachine
   {
   public:
      TrackStateMachine()
         : mControllerPtr(nullptr)
      {
      }
 
      TrackStateMachine(WsfScriptContext& aContext, WsfTrackStateController* aControllerPtr)
         : WsfScriptStateMachine(aContext)
         , mControllerPtr(aControllerPtr)
      {
      }
      TrackStateMachine(const TrackStateMachine& aSrc, WsfScriptContext& aContext, WsfTrackStateController* aControllerPtr)
         : WsfScriptStateMachine(aSrc, aContext)
         , mControllerPtr(aControllerPtr)
      {
      }
      void EnterStateNotify(int aStateIndex) override { mControllerPtr->EnterState(aStateIndex); }
      void ExitStateNotify(int aStateIndex) override { mControllerPtr->ExitState(aStateIndex); }
 
   private:
      WsfTrackStateController* mControllerPtr;
   };

 
protected:
   void PreConstruct();
 
   void DeleteTrack(double aSimTime, const WsfTrackId& aLocalTrackId);
 
   void DiscoverTrack(double aSimTime, const WsfLocalTrack* aTrackPtr);
 
   bool EvaluateTrack(double aSimTime, WsfLocalTrackStatus* aStatusPtr);
 
   void SubmitRequest(double aSimTime, WsfLocalTrackStatus* aStatusPtr);
 
   void CandidateTrackPromoted(double aSimTime, const WsfLocalTrack* aLocalTrackPtr);
 
   void LocalTrackInitiated(double aSimTime, const WsfLocalTrack* aLocalTrackPtr, const WsfTrack* aRawTrackPtr);
 
   void LocalTrackDropped(double aSimTime, const WsfLocalTrack* aLocalTrackPtr);
 
   void TrackManagerChanged(double aSimTime, WsfTrackManager* aNewManagerPtr);
 
   WsfPlatform*                                  mPlatformPtr;
   WsfProcessor*                                 mProcessorPtr;
   WsfTimeDelayQueue*                            mThinkerPtr;
   WsfScriptContext*                             mContextPtr;
   UtScript*                                     mOnTrackDropScriptPtr;
   TrackStateMachine*                            mStateMachinePtr;
   WsfTrackManager*                              mTrackManagerPtr;
   UtCallbackHolder                              mCallbacks;
   WsfLocalTrackList*                            mTrackListPtr;
   UtMappedList<WsfLocalTrackStatus, WsfTrackId> mTrackStatusList;

   std::map<WsfStringId, WsfRandomVariable> mTimeToEvalByName;
   std::vector<WsfRandomVariable> mTimeToEvalByIndex;

   std::map<WsfStringId, WsfRandomVariable> mEvalIntervalByName;
   std::vector<WsfRandomVariable> mEvalIntervalByIndex;

   std::vector<int> mTracksInState;
 
   bool mEvaluateCandidateTracks;
   bool mShowStateTransitions;
   bool mClearSignalOnStateExit;
   bool mIsTurnedOn;

   double mEvaluationInterval;

   double mTransitionTime;

   double         mEvaluationSimTime;
   WsfTrackId     mEvaluationTrackId;
   WsfLocalTrack* mEvaluationTrackPtr;
 
   UtScriptData* mSignalVarPtr;
   UtScriptData* mStatusVarPtr;
   UtScriptData* mTrackVarPtr;
};
 
#endif