fpp/compiler/tools/fpp-to-cpp/test/component/base/SmStateQueuedComponentAc.ref.hpp

// ======================================================================
// \title  SmStateQueuedComponentAc.hpp
// \author Generated by fpp-to-cpp
// \brief  hpp file for SmStateQueued component base class
// ======================================================================

#ifndef FppTest_SmStateQueuedComponentAc_HPP
#define FppTest_SmStateQueuedComponentAc_HPP

#include <FpConfig.hpp>

#include "Fw/Comp/ActiveComponentBase.hpp"
#include "Fw/Port/InputSerializePort.hpp"
#include "Fw/Port/OutputSerializePort.hpp"
#include "SmStateQueued_BasicStateMachineAc.hpp"
#include "Svc/Sched/SchedPortAc.hpp"
#include "state-machine/state/BasicGuardStateMachineAc.hpp"
#include "state-machine/state/BasicGuardStringStateMachineAc.hpp"
#include "state-machine/state/BasicGuardTestAbsTypeStateMachineAc.hpp"
#include "state-machine/state/BasicGuardTestArrayStateMachineAc.hpp"
#include "state-machine/state/BasicGuardTestEnumStateMachineAc.hpp"
#include "state-machine/state/BasicGuardTestStructStateMachineAc.hpp"
#include "state-machine/state/BasicGuardU32StateMachineAc.hpp"
#include "state-machine/state/BasicInternalStateMachineAc.hpp"
#include "state-machine/state/BasicSelfStateMachineAc.hpp"
#include "state-machine/state/BasicStateMachineAc.hpp"
#include "state-machine/state/BasicStringStateMachineAc.hpp"
#include "state-machine/state/BasicTestAbsTypeStateMachineAc.hpp"
#include "state-machine/state/BasicTestArrayStateMachineAc.hpp"
#include "state-machine/state/BasicTestEnumStateMachineAc.hpp"
#include "state-machine/state/BasicTestStructStateMachineAc.hpp"
#include "state-machine/state/BasicU32StateMachineAc.hpp"
#include "state-machine/state/InternalStateMachineAc.hpp"
#include "state-machine/state/PolymorphismStateMachineAc.hpp"
#include "state-machine/state/StateToChildStateMachineAc.hpp"
#include "state-machine/state/StateToChoiceStateMachineAc.hpp"
#include "state-machine/state/StateToSelfStateMachineAc.hpp"
#include "state-machine/state/StateToStateStateMachineAc.hpp"

namespace FppTest {

  //! \class SmStateQueuedComponentBase
  //! \brief Auto-generated base for SmStateQueued component
  class SmStateQueuedComponentBase :
    public Fw::QueuedComponentBase
  {

      // ----------------------------------------------------------------------
      // Friend classes
      // ----------------------------------------------------------------------

      //! Friend class for white-box testing
      friend class SmStateQueuedComponentBaseFriend;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Constants
      // ----------------------------------------------------------------------

      //! Enumerations for numbers of typed input ports
      enum {
        NUM_SCHEDIN_INPUT_PORTS = 1,
      };

      //! State machine identifiers
      enum class SmId : FwEnumStoreType {
        basic1,
        basic2,
        smStateBasic1,
        smStateBasic2,
        smStateBasicGuard,
        smStateBasicGuardString,
        smStateBasicGuardTestAbsType,
        smStateBasicGuardTestArray,
        smStateBasicGuardTestEnum,
        smStateBasicGuardTestStruct,
        smStateBasicGuardU32,
        smStateBasicInternal,
        smStateBasicSelf,
        smStateBasicString,
        smStateBasicTestAbsType,
        smStateBasicTestArray,
        smStateBasicTestEnum,
        smStateBasicTestStruct,
        smStateBasicU32,
        smStateInternal,
        smStatePolymorphism,
        smStateStateToChild,
        smStateStateToChoice,
        smStateStateToSelf,
        smStateStateToState,
      };

    PROTECTED:

      // ----------------------------------------------------------------------
      // Types for internal state machines
      // ----------------------------------------------------------------------

      //! Implementation of state machine FppTest_SmState_Basic
      class FppTest_SmState_Basic :
        public FppTest::SmState::BasicStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_Basic(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicGuard
      class FppTest_SmState_BasicGuard :
        public FppTest::SmState::BasicGuardStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicGuard(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

        PRIVATE:

          //! Implementation for guard g
          bool guard_g(
              Signal signal //!< The signal
          ) const;

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicGuardString
      class FppTest_SmState_BasicGuardString :
        public FppTest::SmState::BasicGuardStringStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicGuardString(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal, //!< The signal
              const Fw::StringBase& value //!< The value
          );

        PRIVATE:

          //! Implementation for guard g
          bool guard_g(
              Signal signal, //!< The signal
              const Fw::StringBase& value //!< The value
          ) const;

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicGuardTestAbsType
      class FppTest_SmState_BasicGuardTestAbsType :
        public FppTest::SmState::BasicGuardTestAbsTypeStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicGuardTestAbsType(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestAbsType& value //!< The value
          );

        PRIVATE:

          //! Implementation for guard g
          bool guard_g(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestAbsType& value //!< The value
          ) const;

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicGuardTestArray
      class FppTest_SmState_BasicGuardTestArray :
        public FppTest::SmState::BasicGuardTestArrayStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicGuardTestArray(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestArray& value //!< The value
          );

        PRIVATE:

          //! Implementation for guard g
          bool guard_g(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestArray& value //!< The value
          ) const;

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicGuardTestEnum
      class FppTest_SmState_BasicGuardTestEnum :
        public FppTest::SmState::BasicGuardTestEnumStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicGuardTestEnum(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestEnum& value //!< The value
          );

        PRIVATE:

          //! Implementation for guard g
          bool guard_g(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestEnum& value //!< The value
          ) const;

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicGuardTestStruct
      class FppTest_SmState_BasicGuardTestStruct :
        public FppTest::SmState::BasicGuardTestStructStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicGuardTestStruct(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestStruct& value //!< The value
          );

        PRIVATE:

          //! Implementation for guard g
          bool guard_g(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestStruct& value //!< The value
          ) const;

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicGuardU32
      class FppTest_SmState_BasicGuardU32 :
        public FppTest::SmState::BasicGuardU32StateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicGuardU32(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal, //!< The signal
              U32 value //!< The value
          );

        PRIVATE:

          //! Implementation for guard g
          bool guard_g(
              Signal signal, //!< The signal
              U32 value //!< The value
          ) const;

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicInternal
      class FppTest_SmState_BasicInternal :
        public FppTest::SmState::BasicInternalStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicInternal(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicSelf
      class FppTest_SmState_BasicSelf :
        public FppTest::SmState::BasicSelfStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicSelf(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicString
      class FppTest_SmState_BasicString :
        public FppTest::SmState::BasicStringStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicString(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

          //! Implementation for action b
          void action_b(
              Signal signal, //!< The signal
              const Fw::StringBase& value //!< The value
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicTestAbsType
      class FppTest_SmState_BasicTestAbsType :
        public FppTest::SmState::BasicTestAbsTypeStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicTestAbsType(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

          //! Implementation for action b
          void action_b(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestAbsType& value //!< The value
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicTestArray
      class FppTest_SmState_BasicTestArray :
        public FppTest::SmState::BasicTestArrayStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicTestArray(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

          //! Implementation for action b
          void action_b(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestArray& value //!< The value
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicTestEnum
      class FppTest_SmState_BasicTestEnum :
        public FppTest::SmState::BasicTestEnumStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicTestEnum(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

          //! Implementation for action b
          void action_b(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestEnum& value //!< The value
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicTestStruct
      class FppTest_SmState_BasicTestStruct :
        public FppTest::SmState::BasicTestStructStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicTestStruct(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

          //! Implementation for action b
          void action_b(
              Signal signal, //!< The signal
              const FppTest::SmHarness::TestStruct& value //!< The value
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_BasicU32
      class FppTest_SmState_BasicU32 :
        public FppTest::SmState::BasicU32StateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_BasicU32(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

          //! Implementation for action b
          void action_b(
              Signal signal, //!< The signal
              U32 value //!< The value
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_Internal
      class FppTest_SmState_Internal :
        public FppTest::SmState::InternalStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_Internal(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_Polymorphism
      class FppTest_SmState_Polymorphism :
        public FppTest::SmState::PolymorphismStateMachineBase
      {

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

      };

      //! Implementation of state machine FppTest_SmState_StateToChild
      class FppTest_SmState_StateToChild :
        public FppTest::SmState::StateToChildStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_StateToChild(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action exitS2
          void action_exitS2(
              Signal signal //!< The signal
          );

          //! Implementation for action exitS3
          void action_exitS3(
              Signal signal //!< The signal
          );

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS2
          void action_enterS2(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS3
          void action_enterS3(
              Signal signal //!< The signal
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_StateToChoice
      class FppTest_SmState_StateToChoice :
        public FppTest::SmState::StateToChoiceStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_StateToChoice(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action exitS1
          void action_exitS1(
              Signal signal //!< The signal
          );

          //! Implementation for action exitS2
          void action_exitS2(
              Signal signal //!< The signal
          );

          //! Implementation for action exitS3
          void action_exitS3(
              Signal signal //!< The signal
          );

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS1
          void action_enterS1(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS2
          void action_enterS2(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS3
          void action_enterS3(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS4
          void action_enterS4(
              Signal signal //!< The signal
          );

        PRIVATE:

          //! Implementation for guard g
          bool guard_g(
              Signal signal //!< The signal
          ) const;

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_StateToSelf
      class FppTest_SmState_StateToSelf :
        public FppTest::SmState::StateToSelfStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_StateToSelf(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action exitS1
          void action_exitS1(
              Signal signal //!< The signal
          );

          //! Implementation for action exitS2
          void action_exitS2(
              Signal signal //!< The signal
          );

          //! Implementation for action exitS3
          void action_exitS3(
              Signal signal //!< The signal
          );

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS1
          void action_enterS1(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS2
          void action_enterS2(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS3
          void action_enterS3(
              Signal signal //!< The signal
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmState_StateToState
      class FppTest_SmState_StateToState :
        public FppTest::SmState::StateToStateStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmState_StateToState(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action exitS1
          void action_exitS1(
              Signal signal //!< The signal
          );

          //! Implementation for action exitS2
          void action_exitS2(
              Signal signal //!< The signal
          );

          //! Implementation for action exitS3
          void action_exitS3(
              Signal signal //!< The signal
          );

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS1
          void action_enterS1(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS2
          void action_enterS2(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS3
          void action_enterS3(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS4
          void action_enterS4(
              Signal signal //!< The signal
          );

          //! Implementation for action enterS5
          void action_enterS5(
              Signal signal //!< The signal
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

      //! Implementation of state machine FppTest_SmStateQueued_Basic
      class FppTest_SmStateQueued_Basic :
        public FppTest::SmStateQueued_BasicStateMachineBase
      {

        public:

          //! Constructor
          FppTest_SmStateQueued_Basic(
              SmStateQueuedComponentBase& component //!< The enclosing component
          );

        public:

          //! Initialize the state machine
          void init(
              SmStateQueuedComponentBase::SmId smId //!< The state machine id
          );

        public:

          //! Get the state machine id
          SmStateQueuedComponentBase::SmId getId() const;

        PRIVATE:

          //! Implementation for action a
          void action_a(
              Signal signal //!< The signal
          );

        PRIVATE:

          //! The enclosing component
          SmStateQueuedComponentBase& m_component;

      };

    public:

      // ----------------------------------------------------------------------
      // Component initialization
      // ----------------------------------------------------------------------

      //! Initialize SmStateQueuedComponentBase object
      void init(
          FwSizeType queueDepth, //!< The queue depth
          FwEnumStoreType instance = 0 //!< The instance number
      );

    public:

      // ----------------------------------------------------------------------
      // Getters for typed input ports
      // ----------------------------------------------------------------------

      //! Get typed input port at index
      //!
      //! \return schedIn[portNum]
      Svc::InputSchedPort* get_schedIn_InputPort(
          FwIndexType portNum //!< The port number
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Component construction and destruction
      // ----------------------------------------------------------------------

      //! Construct SmStateQueuedComponentBase object
      SmStateQueuedComponentBase(
          const char* compName = "" //!< The component name
      );

      //! Destroy SmStateQueuedComponentBase object
      virtual ~SmStateQueuedComponentBase();

    PROTECTED:

      // ----------------------------------------------------------------------
      // Getters for numbers of typed input ports
      // ----------------------------------------------------------------------

      //! Get the number of schedIn input ports
      //!
      //! \return The number of schedIn input ports
      FwIndexType getNum_schedIn_InputPorts() const;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Handlers to implement for typed input ports
      // ----------------------------------------------------------------------

      //! Handler for input port schedIn
      virtual void schedIn_handler(
          FwIndexType portNum, //!< The port number
          U32 context //!< The call order
      ) = 0;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Port handler base-class functions for typed input ports
      //
      // Call these functions directly to bypass the corresponding ports
      // ----------------------------------------------------------------------

      //! Handler base-class function for input port schedIn
      void schedIn_handlerBase(
          FwIndexType portNum, //!< The port number
          U32 context //!< The call order
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // State getter functions
      // ----------------------------------------------------------------------

      //! Get the state of state machine instance basic1
      FppTest_SmStateQueued_Basic::State basic1_getState() const;

      //! Get the state of state machine instance basic2
      FppTest_SmStateQueued_Basic::State basic2_getState() const;

      //! Get the state of state machine instance smStateBasic1
      FppTest_SmState_Basic::State smStateBasic1_getState() const;

      //! Get the state of state machine instance smStateBasic2
      FppTest_SmState_Basic::State smStateBasic2_getState() const;

      //! Get the state of state machine instance smStateBasicGuard
      FppTest_SmState_BasicGuard::State smStateBasicGuard_getState() const;

      //! Get the state of state machine instance smStateBasicGuardString
      FppTest_SmState_BasicGuardString::State smStateBasicGuardString_getState() const;

      //! Get the state of state machine instance smStateBasicGuardTestAbsType
      FppTest_SmState_BasicGuardTestAbsType::State smStateBasicGuardTestAbsType_getState() const;

      //! Get the state of state machine instance smStateBasicGuardTestArray
      FppTest_SmState_BasicGuardTestArray::State smStateBasicGuardTestArray_getState() const;

      //! Get the state of state machine instance smStateBasicGuardTestEnum
      FppTest_SmState_BasicGuardTestEnum::State smStateBasicGuardTestEnum_getState() const;

      //! Get the state of state machine instance smStateBasicGuardTestStruct
      FppTest_SmState_BasicGuardTestStruct::State smStateBasicGuardTestStruct_getState() const;

      //! Get the state of state machine instance smStateBasicGuardU32
      FppTest_SmState_BasicGuardU32::State smStateBasicGuardU32_getState() const;

      //! Get the state of state machine instance smStateBasicInternal
      FppTest_SmState_BasicInternal::State smStateBasicInternal_getState() const;

      //! Get the state of state machine instance smStateBasicSelf
      FppTest_SmState_BasicSelf::State smStateBasicSelf_getState() const;

      //! Get the state of state machine instance smStateBasicString
      FppTest_SmState_BasicString::State smStateBasicString_getState() const;

      //! Get the state of state machine instance smStateBasicTestAbsType
      FppTest_SmState_BasicTestAbsType::State smStateBasicTestAbsType_getState() const;

      //! Get the state of state machine instance smStateBasicTestArray
      FppTest_SmState_BasicTestArray::State smStateBasicTestArray_getState() const;

      //! Get the state of state machine instance smStateBasicTestEnum
      FppTest_SmState_BasicTestEnum::State smStateBasicTestEnum_getState() const;

      //! Get the state of state machine instance smStateBasicTestStruct
      FppTest_SmState_BasicTestStruct::State smStateBasicTestStruct_getState() const;

      //! Get the state of state machine instance smStateBasicU32
      FppTest_SmState_BasicU32::State smStateBasicU32_getState() const;

      //! Get the state of state machine instance smStateInternal
      FppTest_SmState_Internal::State smStateInternal_getState() const;

      //! Get the state of state machine instance smStatePolymorphism
      FppTest_SmState_Polymorphism::State smStatePolymorphism_getState() const;

      //! Get the state of state machine instance smStateStateToChild
      FppTest_SmState_StateToChild::State smStateStateToChild_getState() const;

      //! Get the state of state machine instance smStateStateToChoice
      FppTest_SmState_StateToChoice::State smStateStateToChoice_getState() const;

      //! Get the state of state machine instance smStateStateToSelf
      FppTest_SmState_StateToSelf::State smStateStateToSelf_getState() const;

      //! Get the state of state machine instance smStateStateToState
      FppTest_SmState_StateToState::State smStateStateToState_getState() const;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Signal send functions
      // ----------------------------------------------------------------------

      //! Send signal s to state machine basic1
      void basic1_sendSignal_s();

      //! Send signal s to state machine basic2
      void basic2_sendSignal_s();

      //! Send signal s to state machine smStateBasic1
      void smStateBasic1_sendSignal_s();

      //! Send signal s to state machine smStateBasic2
      void smStateBasic2_sendSignal_s();

      //! Send signal s to state machine smStateBasicGuard
      void smStateBasicGuard_sendSignal_s();

      //! Send signal s to state machine smStateBasicGuardString
      void smStateBasicGuardString_sendSignal_s(
          const Fw::StringBase& value //!< The value
      );

      //! Send signal s to state machine smStateBasicGuardTestAbsType
      void smStateBasicGuardTestAbsType_sendSignal_s(
          const FppTest::SmHarness::TestAbsType& value //!< The value
      );

      //! Send signal s to state machine smStateBasicGuardTestArray
      void smStateBasicGuardTestArray_sendSignal_s(
          const FppTest::SmHarness::TestArray& value //!< The value
      );

      //! Send signal s to state machine smStateBasicGuardTestEnum
      void smStateBasicGuardTestEnum_sendSignal_s(
          const FppTest::SmHarness::TestEnum& value //!< The value
      );

      //! Send signal s to state machine smStateBasicGuardTestStruct
      void smStateBasicGuardTestStruct_sendSignal_s(
          const FppTest::SmHarness::TestStruct& value //!< The value
      );

      //! Send signal s to state machine smStateBasicGuardU32
      void smStateBasicGuardU32_sendSignal_s(
          U32 value //!< The value
      );

      //! Send signal s to state machine smStateBasicInternal
      void smStateBasicInternal_sendSignal_s();

      //! Send signal s to state machine smStateBasicSelf
      void smStateBasicSelf_sendSignal_s();

      //! Send signal s to state machine smStateBasicString
      void smStateBasicString_sendSignal_s(
          const Fw::StringBase& value //!< The value
      );

      //! Send signal s to state machine smStateBasicTestAbsType
      void smStateBasicTestAbsType_sendSignal_s(
          const FppTest::SmHarness::TestAbsType& value //!< The value
      );

      //! Send signal s to state machine smStateBasicTestArray
      void smStateBasicTestArray_sendSignal_s(
          const FppTest::SmHarness::TestArray& value //!< The value
      );

      //! Send signal s to state machine smStateBasicTestEnum
      void smStateBasicTestEnum_sendSignal_s(
          const FppTest::SmHarness::TestEnum& value //!< The value
      );

      //! Send signal s to state machine smStateBasicTestStruct
      void smStateBasicTestStruct_sendSignal_s(
          const FppTest::SmHarness::TestStruct& value //!< The value
      );

      //! Send signal s to state machine smStateBasicU32
      void smStateBasicU32_sendSignal_s(
          U32 value //!< The value
      );

      //! Send signal S1_internal to state machine smStateInternal
      void smStateInternal_sendSignal_S1_internal();

      //! Send signal S2_to_S3 to state machine smStateInternal
      void smStateInternal_sendSignal_S2_to_S3();

      //! Send signal poly to state machine smStatePolymorphism
      void smStatePolymorphism_sendSignal_poly();

      //! Send signal S2_to_S3 to state machine smStatePolymorphism
      void smStatePolymorphism_sendSignal_S2_to_S3();

      //! Send signal S1_to_S2 to state machine smStateStateToChild
      void smStateStateToChild_sendSignal_S1_to_S2();

      //! Send signal S2_to_S3 to state machine smStateStateToChild
      void smStateStateToChild_sendSignal_S2_to_S3();

      //! Send signal S1_to_S4 to state machine smStateStateToChoice
      void smStateStateToChoice_sendSignal_S1_to_S4();

      //! Send signal S1_to_C to state machine smStateStateToChoice
      void smStateStateToChoice_sendSignal_S1_to_C();

      //! Send signal S2_to_S3 to state machine smStateStateToChoice
      void smStateStateToChoice_sendSignal_S2_to_S3();

      //! Send signal S1_to_S1 to state machine smStateStateToSelf
      void smStateStateToSelf_sendSignal_S1_to_S1();

      //! Send signal S2_to_S3 to state machine smStateStateToSelf
      void smStateStateToSelf_sendSignal_S2_to_S3();

      //! Send signal S1_to_S4 to state machine smStateStateToState
      void smStateStateToState_sendSignal_S1_to_S4();

      //! Send signal S1_to_S5 to state machine smStateStateToState
      void smStateStateToState_sendSignal_S1_to_S5();

      //! Send signal S2_to_S3 to state machine smStateStateToState
      void smStateStateToState_sendSignal_S2_to_S3();

    PROTECTED:

      // ----------------------------------------------------------------------
      // Overflow hooks for internal state machine instances
      //
      // When sending a signal to a state machine instance, if
      // the queue overflows and the instance is marked with 'hook' behavior,
      // the corresponding function here is called.
      // ----------------------------------------------------------------------

      //! Overflow hook for state machine smStateBasicGuardTestAbsType
      virtual void smStateBasicGuardTestAbsType_stateMachineOverflowHook(
          SmId smId, //!< The state machine ID
          FwEnumStoreType signal, //!< The signal
          Fw::SerializeBufferBase& buffer //!< The message buffer
      ) = 0;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Functions to implement for internal state machine actions
      // ----------------------------------------------------------------------

      //! Implementation for action a of state machine FppTest_SmState_Basic
      //!
      //! Action a
      virtual void FppTest_SmState_Basic_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_Basic::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicGuard
      //!
      //! Action a
      virtual void FppTest_SmState_BasicGuard_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuard::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicGuardString
      //!
      //! Action a
      virtual void FppTest_SmState_BasicGuardString_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardString::Signal signal, //!< The signal
          const Fw::StringBase& value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicGuardTestAbsType
      //!
      //! Action a
      virtual void FppTest_SmState_BasicGuardTestAbsType_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardTestAbsType::Signal signal, //!< The signal
          const FppTest::SmHarness::TestAbsType& value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicGuardTestArray
      //!
      //! Action a
      virtual void FppTest_SmState_BasicGuardTestArray_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardTestArray::Signal signal, //!< The signal
          const FppTest::SmHarness::TestArray& value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicGuardTestEnum
      //!
      //! Action a
      virtual void FppTest_SmState_BasicGuardTestEnum_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardTestEnum::Signal signal, //!< The signal
          const FppTest::SmHarness::TestEnum& value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicGuardTestStruct
      //!
      //! Action a
      virtual void FppTest_SmState_BasicGuardTestStruct_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardTestStruct::Signal signal, //!< The signal
          const FppTest::SmHarness::TestStruct& value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicGuardU32
      //!
      //! Action a
      virtual void FppTest_SmState_BasicGuardU32_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardU32::Signal signal, //!< The signal
          U32 value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicInternal
      //!
      //! Action a
      virtual void FppTest_SmState_BasicInternal_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicInternal::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicSelf
      //!
      //! Action a
      virtual void FppTest_SmState_BasicSelf_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicSelf::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicString
      //!
      //! Action a
      virtual void FppTest_SmState_BasicString_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicString::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action b of state machine FppTest_SmState_BasicString
      //!
      //! Action b
      virtual void FppTest_SmState_BasicString_action_b(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicString::Signal signal, //!< The signal
          const Fw::StringBase& value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicTestAbsType
      //!
      //! Action a
      virtual void FppTest_SmState_BasicTestAbsType_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicTestAbsType::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action b of state machine FppTest_SmState_BasicTestAbsType
      //!
      //! Action b
      virtual void FppTest_SmState_BasicTestAbsType_action_b(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicTestAbsType::Signal signal, //!< The signal
          const FppTest::SmHarness::TestAbsType& value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicTestArray
      //!
      //! Action a
      virtual void FppTest_SmState_BasicTestArray_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicTestArray::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action b of state machine FppTest_SmState_BasicTestArray
      //!
      //! Action b
      virtual void FppTest_SmState_BasicTestArray_action_b(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicTestArray::Signal signal, //!< The signal
          const FppTest::SmHarness::TestArray& value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicTestEnum
      //!
      //! Action a
      virtual void FppTest_SmState_BasicTestEnum_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicTestEnum::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action b of state machine FppTest_SmState_BasicTestEnum
      //!
      //! Action b
      virtual void FppTest_SmState_BasicTestEnum_action_b(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicTestEnum::Signal signal, //!< The signal
          const FppTest::SmHarness::TestEnum& value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicTestStruct
      //!
      //! Action a
      virtual void FppTest_SmState_BasicTestStruct_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicTestStruct::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action b of state machine FppTest_SmState_BasicTestStruct
      //!
      //! Action b
      virtual void FppTest_SmState_BasicTestStruct_action_b(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicTestStruct::Signal signal, //!< The signal
          const FppTest::SmHarness::TestStruct& value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_BasicU32
      //!
      //! Action a
      virtual void FppTest_SmState_BasicU32_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicU32::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action b of state machine FppTest_SmState_BasicU32
      //!
      //! Action b
      virtual void FppTest_SmState_BasicU32_action_b(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicU32::Signal signal, //!< The signal
          U32 value //!< The value
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_Internal
      //!
      //! Action a
      virtual void FppTest_SmState_Internal_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_Internal::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS2 of state machine FppTest_SmState_StateToChild
      //!
      //! Exit S2
      virtual void FppTest_SmState_StateToChild_action_exitS2(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChild::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS3 of state machine FppTest_SmState_StateToChild
      //!
      //! Exit S3
      virtual void FppTest_SmState_StateToChild_action_exitS3(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChild::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_StateToChild
      //!
      //! Action a
      virtual void FppTest_SmState_StateToChild_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChild::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS2 of state machine FppTest_SmState_StateToChild
      //!
      //! Enter S2
      virtual void FppTest_SmState_StateToChild_action_enterS2(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChild::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS3 of state machine FppTest_SmState_StateToChild
      //!
      //! Enter S3
      virtual void FppTest_SmState_StateToChild_action_enterS3(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChild::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS1 of state machine FppTest_SmState_StateToChoice
      //!
      //! Exit S1
      virtual void FppTest_SmState_StateToChoice_action_exitS1(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChoice::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS2 of state machine FppTest_SmState_StateToChoice
      //!
      //! Exit S2
      virtual void FppTest_SmState_StateToChoice_action_exitS2(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChoice::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS3 of state machine FppTest_SmState_StateToChoice
      //!
      //! Exit S3
      virtual void FppTest_SmState_StateToChoice_action_exitS3(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChoice::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_StateToChoice
      //!
      //! Action a
      virtual void FppTest_SmState_StateToChoice_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChoice::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS1 of state machine FppTest_SmState_StateToChoice
      //!
      //! Enter S1
      virtual void FppTest_SmState_StateToChoice_action_enterS1(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChoice::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS2 of state machine FppTest_SmState_StateToChoice
      //!
      //! Enter S2
      virtual void FppTest_SmState_StateToChoice_action_enterS2(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChoice::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS3 of state machine FppTest_SmState_StateToChoice
      //!
      //! Enter S3
      virtual void FppTest_SmState_StateToChoice_action_enterS3(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChoice::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS4 of state machine FppTest_SmState_StateToChoice
      //!
      //! Enter S4
      virtual void FppTest_SmState_StateToChoice_action_enterS4(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChoice::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS1 of state machine FppTest_SmState_StateToSelf
      //!
      //! Exit S1
      virtual void FppTest_SmState_StateToSelf_action_exitS1(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToSelf::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS2 of state machine FppTest_SmState_StateToSelf
      //!
      //! Exit S2
      virtual void FppTest_SmState_StateToSelf_action_exitS2(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToSelf::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS3 of state machine FppTest_SmState_StateToSelf
      //!
      //! Exit S3
      virtual void FppTest_SmState_StateToSelf_action_exitS3(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToSelf::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_StateToSelf
      //!
      //! Action a
      virtual void FppTest_SmState_StateToSelf_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToSelf::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS1 of state machine FppTest_SmState_StateToSelf
      //!
      //! Enter S1
      virtual void FppTest_SmState_StateToSelf_action_enterS1(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToSelf::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS2 of state machine FppTest_SmState_StateToSelf
      //!
      //! Enter S2
      virtual void FppTest_SmState_StateToSelf_action_enterS2(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToSelf::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS3 of state machine FppTest_SmState_StateToSelf
      //!
      //! Enter S3
      virtual void FppTest_SmState_StateToSelf_action_enterS3(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToSelf::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS1 of state machine FppTest_SmState_StateToState
      //!
      //! Exit S1
      virtual void FppTest_SmState_StateToState_action_exitS1(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToState::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS2 of state machine FppTest_SmState_StateToState
      //!
      //! Exit S2
      virtual void FppTest_SmState_StateToState_action_exitS2(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToState::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action exitS3 of state machine FppTest_SmState_StateToState
      //!
      //! Exit S3
      virtual void FppTest_SmState_StateToState_action_exitS3(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToState::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmState_StateToState
      //!
      //! Action a
      virtual void FppTest_SmState_StateToState_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToState::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS1 of state machine FppTest_SmState_StateToState
      //!
      //! Enter S1
      virtual void FppTest_SmState_StateToState_action_enterS1(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToState::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS2 of state machine FppTest_SmState_StateToState
      //!
      //! Enter S2
      virtual void FppTest_SmState_StateToState_action_enterS2(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToState::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS3 of state machine FppTest_SmState_StateToState
      //!
      //! Enter S3
      virtual void FppTest_SmState_StateToState_action_enterS3(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToState::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS4 of state machine FppTest_SmState_StateToState
      //!
      //! Enter S4
      virtual void FppTest_SmState_StateToState_action_enterS4(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToState::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action enterS5 of state machine FppTest_SmState_StateToState
      //!
      //! Enter S5
      virtual void FppTest_SmState_StateToState_action_enterS5(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToState::Signal signal //!< The signal
      ) = 0;

      //! Implementation for action a of state machine FppTest_SmStateQueued_Basic
      //!
      //! Action a
      virtual void FppTest_SmStateQueued_Basic_action_a(
          SmId smId, //!< The state machine id
          FppTest_SmStateQueued_Basic::Signal signal //!< The signal
      ) = 0;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Functions to implement for internal state machine guards
      // ----------------------------------------------------------------------

      //! Implementation for guard g of state machine FppTest_SmState_BasicGuard
      //!
      //! Guard g
      virtual bool FppTest_SmState_BasicGuard_guard_g(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuard::Signal signal //!< The signal
      ) const = 0;

      //! Implementation for guard g of state machine FppTest_SmState_BasicGuardString
      //!
      //! Guard g
      virtual bool FppTest_SmState_BasicGuardString_guard_g(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardString::Signal signal, //!< The signal
          const Fw::StringBase& value //!< The value
      ) const = 0;

      //! Implementation for guard g of state machine FppTest_SmState_BasicGuardTestAbsType
      //!
      //! Guard g
      virtual bool FppTest_SmState_BasicGuardTestAbsType_guard_g(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardTestAbsType::Signal signal, //!< The signal
          const FppTest::SmHarness::TestAbsType& value //!< The value
      ) const = 0;

      //! Implementation for guard g of state machine FppTest_SmState_BasicGuardTestArray
      //!
      //! Guard g
      virtual bool FppTest_SmState_BasicGuardTestArray_guard_g(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardTestArray::Signal signal, //!< The signal
          const FppTest::SmHarness::TestArray& value //!< The value
      ) const = 0;

      //! Implementation for guard g of state machine FppTest_SmState_BasicGuardTestEnum
      //!
      //! Guard g
      virtual bool FppTest_SmState_BasicGuardTestEnum_guard_g(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardTestEnum::Signal signal, //!< The signal
          const FppTest::SmHarness::TestEnum& value //!< The value
      ) const = 0;

      //! Implementation for guard g of state machine FppTest_SmState_BasicGuardTestStruct
      //!
      //! Guard g
      virtual bool FppTest_SmState_BasicGuardTestStruct_guard_g(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardTestStruct::Signal signal, //!< The signal
          const FppTest::SmHarness::TestStruct& value //!< The value
      ) const = 0;

      //! Implementation for guard g of state machine FppTest_SmState_BasicGuardU32
      //!
      //! Guard g
      virtual bool FppTest_SmState_BasicGuardU32_guard_g(
          SmId smId, //!< The state machine id
          FppTest_SmState_BasicGuardU32::Signal signal, //!< The signal
          U32 value //!< The value
      ) const = 0;

      //! Implementation for guard g of state machine FppTest_SmState_StateToChoice
      //!
      //! Guard g
      virtual bool FppTest_SmState_StateToChoice_guard_g(
          SmId smId, //!< The state machine id
          FppTest_SmState_StateToChoice::Signal signal //!< The signal
      ) const = 0;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Message dispatch functions
      // ----------------------------------------------------------------------

      //! Called in the message loop to dispatch a message from the queue
      virtual MsgDispatchStatus doDispatch();

    PRIVATE:

      // ----------------------------------------------------------------------
      // Calls for messages received on typed input ports
      // ----------------------------------------------------------------------

      //! Callback for port schedIn
      static void m_p_schedIn_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          U32 context //!< The call order
      );

    PRIVATE:

      // ----------------------------------------------------------------------
      // Send signal helper functions
      // ----------------------------------------------------------------------

      //! Start sending a signal to a state machine
      void sendSignalStart(
          SmId smId, //!< The state machine ID (input)
          FwEnumStoreType signal, //!< The signal (input)
          Fw::SerializeBufferBase& buffer //!< The message buffer (output)
      );

      //! Finish sending a signal to a state machine
      void basic1_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void basic2_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasic1_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasic2_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicGuard_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicGuardString_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicGuardTestAbsType_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicGuardTestArray_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicGuardTestEnum_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicGuardTestStruct_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicGuardU32_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicInternal_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicSelf_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicString_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicTestAbsType_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicTestArray_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicTestEnum_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicTestStruct_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateBasicU32_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateInternal_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStatePolymorphism_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateStateToChild_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateStateToChoice_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateStateToSelf_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

      //! Finish sending a signal to a state machine
      void smStateStateToState_sendSignalFinish(
          Fw::SerializeBufferBase& buffer //!< The buffer with the data to send
      );

    PRIVATE:

      // ----------------------------------------------------------------------
      // Helper functions for state machine dispatch
      // ----------------------------------------------------------------------

      //! Dispatch a signal to a state machine instance
      void smDispatch(
          Fw::SerializeBufferBase& buffer //!< The message buffer
      );

      //! Deserialize the state machine ID and signal from the message buffer
      static void deserializeSmIdAndSignal(
          Fw::SerializeBufferBase& buffer, //!< The message buffer (input and output)
          FwEnumStoreType& smId, //!< The state machine ID (output)
          FwEnumStoreType& signal //!< The signal (output)
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_Basic
      void FppTest_SmState_Basic_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_Basic& sm, //!< The state machine
          FppTest_SmState_Basic::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicGuard
      void FppTest_SmState_BasicGuard_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicGuard& sm, //!< The state machine
          FppTest_SmState_BasicGuard::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicGuardString
      void FppTest_SmState_BasicGuardString_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicGuardString& sm, //!< The state machine
          FppTest_SmState_BasicGuardString::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicGuardTestAbsType
      void FppTest_SmState_BasicGuardTestAbsType_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicGuardTestAbsType& sm, //!< The state machine
          FppTest_SmState_BasicGuardTestAbsType::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicGuardTestArray
      void FppTest_SmState_BasicGuardTestArray_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicGuardTestArray& sm, //!< The state machine
          FppTest_SmState_BasicGuardTestArray::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicGuardTestEnum
      void FppTest_SmState_BasicGuardTestEnum_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicGuardTestEnum& sm, //!< The state machine
          FppTest_SmState_BasicGuardTestEnum::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicGuardTestStruct
      void FppTest_SmState_BasicGuardTestStruct_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicGuardTestStruct& sm, //!< The state machine
          FppTest_SmState_BasicGuardTestStruct::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicGuardU32
      void FppTest_SmState_BasicGuardU32_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicGuardU32& sm, //!< The state machine
          FppTest_SmState_BasicGuardU32::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicInternal
      void FppTest_SmState_BasicInternal_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicInternal& sm, //!< The state machine
          FppTest_SmState_BasicInternal::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicSelf
      void FppTest_SmState_BasicSelf_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicSelf& sm, //!< The state machine
          FppTest_SmState_BasicSelf::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicString
      void FppTest_SmState_BasicString_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicString& sm, //!< The state machine
          FppTest_SmState_BasicString::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicTestAbsType
      void FppTest_SmState_BasicTestAbsType_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicTestAbsType& sm, //!< The state machine
          FppTest_SmState_BasicTestAbsType::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicTestArray
      void FppTest_SmState_BasicTestArray_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicTestArray& sm, //!< The state machine
          FppTest_SmState_BasicTestArray::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicTestEnum
      void FppTest_SmState_BasicTestEnum_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicTestEnum& sm, //!< The state machine
          FppTest_SmState_BasicTestEnum::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicTestStruct
      void FppTest_SmState_BasicTestStruct_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicTestStruct& sm, //!< The state machine
          FppTest_SmState_BasicTestStruct::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_BasicU32
      void FppTest_SmState_BasicU32_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_BasicU32& sm, //!< The state machine
          FppTest_SmState_BasicU32::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_Internal
      void FppTest_SmState_Internal_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_Internal& sm, //!< The state machine
          FppTest_SmState_Internal::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_Polymorphism
      void FppTest_SmState_Polymorphism_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_Polymorphism& sm, //!< The state machine
          FppTest_SmState_Polymorphism::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_StateToChild
      void FppTest_SmState_StateToChild_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_StateToChild& sm, //!< The state machine
          FppTest_SmState_StateToChild::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_StateToChoice
      void FppTest_SmState_StateToChoice_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_StateToChoice& sm, //!< The state machine
          FppTest_SmState_StateToChoice::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_StateToSelf
      void FppTest_SmState_StateToSelf_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_StateToSelf& sm, //!< The state machine
          FppTest_SmState_StateToSelf::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmState_StateToState
      void FppTest_SmState_StateToState_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmState_StateToState& sm, //!< The state machine
          FppTest_SmState_StateToState::Signal signal //!< The signal
      );

      //! Dispatch a signal to a state machine instance of type FppTest_SmStateQueued_Basic
      void FppTest_SmStateQueued_Basic_smDispatch(
          Fw::SerializeBufferBase& buffer, //!< The message buffer
          FppTest_SmStateQueued_Basic& sm, //!< The state machine
          FppTest_SmStateQueued_Basic::Signal signal //!< The signal
      );

    PRIVATE:

      // ----------------------------------------------------------------------
      // Typed input ports
      // ----------------------------------------------------------------------

      //! Input port schedIn
      Svc::InputSchedPort m_schedIn_InputPort[NUM_SCHEDIN_INPUT_PORTS];

    PRIVATE:

      // ----------------------------------------------------------------------
      // State machine instances
      // ----------------------------------------------------------------------

      //! State machine basic1
      FppTest_SmStateQueued_Basic m_stateMachine_basic1;

      //! State machine basic2
      FppTest_SmStateQueued_Basic m_stateMachine_basic2;

      //! State machine smStateBasic1
      FppTest_SmState_Basic m_stateMachine_smStateBasic1;

      //! State machine smStateBasic2
      FppTest_SmState_Basic m_stateMachine_smStateBasic2;

      //! State machine smStateBasicGuard
      FppTest_SmState_BasicGuard m_stateMachine_smStateBasicGuard;

      //! State machine smStateBasicGuardString
      FppTest_SmState_BasicGuardString m_stateMachine_smStateBasicGuardString;

      //! State machine smStateBasicGuardTestAbsType
      FppTest_SmState_BasicGuardTestAbsType m_stateMachine_smStateBasicGuardTestAbsType;

      //! State machine smStateBasicGuardTestArray
      FppTest_SmState_BasicGuardTestArray m_stateMachine_smStateBasicGuardTestArray;

      //! State machine smStateBasicGuardTestEnum
      FppTest_SmState_BasicGuardTestEnum m_stateMachine_smStateBasicGuardTestEnum;

      //! State machine smStateBasicGuardTestStruct
      FppTest_SmState_BasicGuardTestStruct m_stateMachine_smStateBasicGuardTestStruct;

      //! State machine smStateBasicGuardU32
      FppTest_SmState_BasicGuardU32 m_stateMachine_smStateBasicGuardU32;

      //! State machine smStateBasicInternal
      FppTest_SmState_BasicInternal m_stateMachine_smStateBasicInternal;

      //! State machine smStateBasicSelf
      FppTest_SmState_BasicSelf m_stateMachine_smStateBasicSelf;

      //! State machine smStateBasicString
      FppTest_SmState_BasicString m_stateMachine_smStateBasicString;

      //! State machine smStateBasicTestAbsType
      FppTest_SmState_BasicTestAbsType m_stateMachine_smStateBasicTestAbsType;

      //! State machine smStateBasicTestArray
      FppTest_SmState_BasicTestArray m_stateMachine_smStateBasicTestArray;

      //! State machine smStateBasicTestEnum
      FppTest_SmState_BasicTestEnum m_stateMachine_smStateBasicTestEnum;

      //! State machine smStateBasicTestStruct
      FppTest_SmState_BasicTestStruct m_stateMachine_smStateBasicTestStruct;

      //! State machine smStateBasicU32
      FppTest_SmState_BasicU32 m_stateMachine_smStateBasicU32;

      //! State machine smStateInternal
      FppTest_SmState_Internal m_stateMachine_smStateInternal;

      //! State machine smStatePolymorphism
      FppTest_SmState_Polymorphism m_stateMachine_smStatePolymorphism;

      //! State machine smStateStateToChild
      FppTest_SmState_StateToChild m_stateMachine_smStateStateToChild;

      //! State machine smStateStateToChoice
      FppTest_SmState_StateToChoice m_stateMachine_smStateStateToChoice;

      //! State machine smStateStateToSelf
      FppTest_SmState_StateToSelf m_stateMachine_smStateStateToSelf;

      //! State machine smStateStateToState
      FppTest_SmState_StateToState m_stateMachine_smStateStateToState;

  };

}

#endif