WsfScriptStateMachine.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 WSFSCRIPTSTATEMACHINE_HPP
#define WSFSCRIPTSTATEMACHINE_HPP
 
#include "wsf_export.h"
 
#include <memory>
#include <string>
#include <vector>
 
#include "UtCloneablePtr.hpp"
#include "WsfAdvancedBehaviorTree.hpp"
#include "WsfStringId.hpp"
 
class UtInput;
class UtScript;
class UtScriptClass;
class UtScriptTypes;
class WsfBehaviorTree;
class WsfScriptContext;
class WsfScriptProcessor;
class WsfScenario;

 
class WSF_EXPORT WsfScriptStateMachine
{
public:
   class WSF_EXPORT Transition
   {
   public:
      Transition() = default;
      explicit Transition(WsfStringId aNextStateName);
      Transition(const Transition& aSrc);
      virtual ~Transition() = default;
 
      virtual Transition* Clone() const;
 
      virtual bool Evaluate(WsfScriptContext& aContext);
 
      int GetNextStateIndex() const { return mNextStateIndex; }
 
      void SetNextStateIndex(int aNextStateIndex) { mNextStateIndex = aNextStateIndex; }
 
      WsfStringId GetNextStateName() const { return mNextStateName; }
 
      virtual bool Initialize(double aSimTime, WsfScriptContext& aContext);
 
      virtual bool ProcessInput(UtInput& aInput, WsfScriptContext& aContext, WsfStringId aNameSpace);
 
   protected:
      WsfStringId mNextStateName;

      int mNextStateIndex{0};

      WsfStringId mScriptName;

      UtScript* mScriptPtr{nullptr};
   };

   using TransitionList = std::vector<std::unique_ptr<Transition>>;

   class WSF_EXPORT State
   {
   public:
      State() = default;
      explicit State(WsfStringId aStateName, WsfScriptContext& aContext);
      State(const State& aSrc) = delete;
      const State& operator=(const State& aRhs) = delete;
      virtual ~State();
 
      virtual State* Clone(WsfScriptContext& aContext) const;
 
      virtual std::unique_ptr<Transition> CreateTransition(WsfStringId aNextStateName) const;
      virtual void                        RemoveTransition(WsfStringId aNextStateName);
 
      TransitionList& GetTransitions() { return mTransitionList; }
 
      virtual void EnterState();
 
      virtual int Evaluate(bool aShowStateEvaluations);
 
      virtual void ExitState();

      int GetStateIndex() const { return mStateIndex; }

      void SetStateIndex(int aStateIndex) { mStateIndex = aStateIndex; }

      WsfStringId GetStateName() const { return mStateName; }
 
      virtual bool Initialize(double aSimTime, WsfScriptStateMachine& aStateMachine, WsfScriptContext& aContext);
 
      virtual bool       ProcessInput(UtInput& aInput, WsfStringId aNameSpace = nullptr);
      const WsfScenario* GetScenario() const;
 
      WsfScriptStateMachine* ChildStateMachine() { return mChildFiniteStateMachinePtr; }
      int                    ChildStateIndex() { return mChildStateIndex; }
      void                   SetChildStateIndex(int stateIndex);
 
      WsfAdvancedBehaviorTree* AdvancedBehaviorTree() const { return mAdvancedBehaviorTreePtr.get(); }
 
   protected:
      State(const State& aSrc, WsfScriptContext& aContext);

      WsfStringId mStateName;

      int mStateIndex{0};

      WsfScriptContext* mContextPtr{nullptr};

      UtScript*   mOnEntryScriptPtr{nullptr};
      WsfStringId mOnEntryScriptName;

      UtScript*   mOnExitScriptPtr{nullptr};
      WsfStringId mOnExitScriptName;

      TransitionList mTransitionList;
 
      WsfBehaviorTree* mBehaviorTreePtr{nullptr};
 
      ut::CloneablePtr<WsfAdvancedBehaviorTree> mAdvancedBehaviorTreePtr{nullptr};
 
      // child state machine
      WsfScriptStateMachine* mChildFiniteStateMachinePtr{nullptr};
      int                    mChildStateIndex{0};
   };

   using StateList = std::vector<std::unique_ptr<State>>;
 
   WsfScriptStateMachine() = default;
   WsfScriptStateMachine(WsfScriptContext&   aContext,
                         WsfScriptProcessor* aParentProcPtr   = nullptr,
                         WsfStringId         aParentNameSpace = nullptr);
   WsfScriptStateMachine(const WsfScriptStateMachine& aSrc,
                         WsfScriptContext&            aContext,
                         WsfScriptProcessor*          aParentProcPtr = nullptr);
   virtual ~WsfScriptStateMachine()     = default;
   const WsfScriptStateMachine& operator=(const WsfScriptStateMachine& aRhs) = delete;
   WsfScriptStateMachine(const WsfScriptStateMachine& aSrc)                  = delete;
 
   static std::unique_ptr<UtScriptClass> CreateScriptClass(const std::string& aClassName, UtScriptTypes* aScriptTypesPtr);

   const size_t Id() const { return mId; }

   virtual void EnterStateNotify(int aStateIndex) {}

   virtual void ExitStateNotify(int aStateIndex) {}
 
   virtual int Evaluate(int aCurrentStateIndex);
 
   virtual int EvaluateState(int aCurrentStateIndex, bool aDoNewStateEntry = true);
 
   virtual void EnterState(int aStateIndex);
 
   virtual void ExitState(int aStateIndex);
 
   State* FindState(WsfStringId aStateName) const;
 
   int GetInitialStateIndex() const;
 
   State* GetState(int aStateIndex) const;

   int GetStateCount() const { return static_cast<int>(mStateList.size()); }
 
   int GetStateIndex(WsfStringId aStateName) const;
 
   WsfStringId GetStateName(int aStateIndex) const;
 
   virtual bool Initialize(double aSimTime);
 
   virtual bool ProcessInput(UtInput& aInput);
 
   void ShowStateEvaluations(bool aShowStateEvaluations) { mShowStateEvaluations = aShowStateEvaluations; }
   bool ShowStateEvaluations() const { return mShowStateEvaluations; }
 
   void ShowStateTransitions(bool aShowStateTransitions) { mShowStateTransitions = aShowStateTransitions; }
   bool ShowStateTransitions() const { return mShowStateTransitions; }
 
   void                SetProcessor(WsfScriptProcessor* aProcessor) { mParentProcessorPtr = aProcessor; }
   WsfScriptProcessor* Processor() { return mParentProcessorPtr; }
 
protected:
   virtual void EnterState(State* aStatePtr);
   virtual void ExitState(State* aStatePtr);
 
   virtual std::unique_ptr<State> CreateState(WsfStringId aStateName, WsfScriptContext& aContext);

   WsfScriptContext* mContextPtr{nullptr};
   WsfStringId       mParentNameSpace;

   StateList mStateList;
 
   bool mShowStateEvaluations{false};
   bool mShowStateTransitions{false};
 
   WsfScriptProcessor* mParentProcessorPtr{nullptr};
   size_t              mId; 
private:
   static size_t GetUniqueId() { return ++mNextUniqueId; }
 
   static size_t mNextUniqueId;          
   bool mTransitionToSelfMessage{false}; 
};
 
#endif