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

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

#ifndef M_ActiveTestComponentAc_HPP
#define M_ActiveTestComponentAc_HPP

#include "AArrayAc.hpp"
#include "ActiveTest_DataSerializableAc.hpp"
#include "EEnumAc.hpp"
#include "FpConfig.hpp"
#include "Fw/Cmd/CmdPortAc.hpp"
#include "Fw/Cmd/CmdRegPortAc.hpp"
#include "Fw/Cmd/CmdResponsePortAc.hpp"
#include "Fw/Cmd/CmdString.hpp"
#include "Fw/Comp/ActiveComponentBase.hpp"
#include "Fw/Dp/DpContainer.hpp"
#include "Fw/Dp/DpRequestPortAc.hpp"
#include "Fw/Dp/DpResponsePortAc.hpp"
#include "Fw/Dp/DpSendPortAc.hpp"
#include "Fw/Log/LogPortAc.hpp"
#include "Fw/Log/LogString.hpp"
#if FW_ENABLE_TEXT_LOGGING == 1
#include "Fw/Log/LogTextPortAc.hpp"
#endif
#include "Fw/Port/InputSerializePort.hpp"
#include "Fw/Port/OutputSerializePort.hpp"
#include "Fw/Prm/PrmGetPortAc.hpp"
#include "Fw/Prm/PrmSetPortAc.hpp"
#include "Fw/Prm/PrmString.hpp"
#include "Fw/Time/TimePortAc.hpp"
#include "Fw/Tlm/TlmPortAc.hpp"
#include "Fw/Tlm/TlmString.hpp"
#include "Fw/Types/InternalInterfaceString.hpp"
#include "NoArgsPortAc.hpp"
#include "NoArgsReturnPortAc.hpp"
#include "Os/Mutex.hpp"
#include "SSerializableAc.hpp"
#include "TypedPortAc.hpp"
#include "TypedReturnPortAc.hpp"

namespace M {

  //! \class ActiveTestComponentBase
  //! \brief Auto-generated base for ActiveTest component
  //!
  //! An active component
  class ActiveTestComponentBase :
    public Fw::ActiveComponentBase
  {

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

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

    PROTECTED:

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

      //! Enumerations for numbers of special input ports
      enum {
        NUM_CMDIN_INPUT_PORTS = 1,
        NUM_PRODUCTRECVIN_INPUT_PORTS = 1,
      };

      //! Enumerations for numbers of typed input ports
      enum {
        NUM_NOARGSASYNC_INPUT_PORTS = 1,
        NUM_NOARGSGUARDED_INPUT_PORTS = 1,
        NUM_NOARGSRETURNGUARDED_INPUT_PORTS = 1,
        NUM_NOARGSRETURNSYNC_INPUT_PORTS = 3,
        NUM_NOARGSSYNC_INPUT_PORTS = 3,
        NUM_TYPEDASYNC_INPUT_PORTS = 1,
        NUM_TYPEDASYNCASSERT_INPUT_PORTS = 1,
        NUM_TYPEDASYNCBLOCKPRIORITY_INPUT_PORTS = 1,
        NUM_TYPEDASYNCDROPPRIORITY_INPUT_PORTS = 1,
        NUM_TYPEDGUARDED_INPUT_PORTS = 1,
        NUM_TYPEDRETURNGUARDED_INPUT_PORTS = 1,
        NUM_TYPEDRETURNSYNC_INPUT_PORTS = 3,
        NUM_TYPEDSYNC_INPUT_PORTS = 3,
      };

      //! Enumerations for numbers of special output ports
      enum {
        NUM_CMDREGOUT_OUTPUT_PORTS = 1,
        NUM_CMDRESPONSEOUT_OUTPUT_PORTS = 1,
        NUM_EVENTOUT_OUTPUT_PORTS = 1,
        NUM_PRMGETOUT_OUTPUT_PORTS = 1,
        NUM_PRMSETOUT_OUTPUT_PORTS = 1,
        NUM_PRODUCTREQUESTOUT_OUTPUT_PORTS = 1,
        NUM_PRODUCTSENDOUT_OUTPUT_PORTS = 1,
        NUM_TEXTEVENTOUT_OUTPUT_PORTS = 1,
        NUM_TIMEGETOUT_OUTPUT_PORTS = 1,
        NUM_TLMOUT_OUTPUT_PORTS = 1,
      };

      //! Enumerations for numbers of typed output ports
      enum {
        NUM_NOARGSOUT_OUTPUT_PORTS = 1,
        NUM_NOARGSRETURNOUT_OUTPUT_PORTS = 1,
        NUM_TYPEDOUT_OUTPUT_PORTS = 1,
        NUM_TYPEDRETURNOUT_OUTPUT_PORTS = 1,
      };

      //! Command opcodes
      enum {
        OPCODE_CMD_SYNC = 0x0, //!< A sync command with no params
        OPCODE_CMD_SYNC_PRIMITIVE = 0x10, //!< An async command with primitive params
        OPCODE_CMD_SYNC_STRING = 0x11, //!< A sync command with string params
        OPCODE_CMD_SYNC_ENUM = 0x12, //!< A sync command with enum params
        OPCODE_CMD_SYNC_ARRAY = 0x13, //!< A sync command with array params
        OPCODE_CMD_SYNC_STRUCT = 0x14, //!< A sync command with struct params
        OPCODE_CMD_GUARDED = 0x15, //!< A guarded command with no params
        OPCODE_CMD_GUARDED_PRIMITIVE = 0x16, //!< A guarded command with primitive params
        OPCODE_CMD_GUARDED_STRING = 0x17, //!< A guarded command with string params
        OPCODE_CMD_GUARDED_ENUM = 0x18, //!< A guarded command with enum params
        OPCODE_CMD_GUARDED_ARRAY = 0x19, //!< A guarded command with array params
        OPCODE_CMD_GUARDED_STRUCT = 0x1a, //!< A guarded command with struct params
        OPCODE_CMD_ASYNC = 0x1b, //!< An async command with no params
        OPCODE_CMD_PRIORITY = 0x20, //!< A command with priority
        OPCODE_CMD_PARAMS_PRIORITY = 0x21, //!< A command with params and priority
        OPCODE_CMD_DROP = 0x22, //!< A command with queue full behavior
        OPCODE_CMD_PARAMS_PRIORITY_DROP = 0x23, //!< A command with params, priority, and queue full behavior
        OPCODE_PARAMU32_SET = 0x24, //!< Opcode to set parameter ParamU32
        OPCODE_PARAMU32_SAVE = 0x25, //!< Opcode to save parameter ParamU32
        OPCODE_PARAMF64_SET = 0x26, //!< Opcode to set parameter ParamF64
        OPCODE_PARAMF64_SAVE = 0x27, //!< Opcode to save parameter ParamF64
        OPCODE_PARAMSTRING_SET = 0x28, //!< Opcode to set parameter ParamString
        OPCODE_PARAMSTRING_SAVE = 0x29, //!< Opcode to save parameter ParamString
        OPCODE_PARAMENUM_SET = 0x2a, //!< Opcode to set parameter ParamEnum
        OPCODE_PARAMENUM_SAVE = 0x2b, //!< Opcode to save parameter ParamEnum
        OPCODE_PARAMARRAY_SET = 0x2c, //!< Opcode to set parameter ParamArray
        OPCODE_PARAMARRAY_SAVE = 0x35, //!< Opcode to save parameter ParamArray
        OPCODE_PARAMSTRUCT_SET = 0x40, //!< Opcode to set parameter ParamStruct
        OPCODE_PARAMSTRUCT_SAVE = 0x45, //!< Opcode to save parameter ParamStruct
      };

      //! Event IDs
      enum {
        EVENTID_EVENTACTIVITYHIGH = 0x0, //!< An activity high event with no params
        EVENTID_EVENTACTIVITYLOWTHROTTLED = 0x10, //!< An activity low, throttled event with primitive params
        EVENTID_EVENTCOMMAND = 0x11, //!< A command event with string params
        EVENTID_EVENTDIAGNOSTIC = 0x12, //!< A diagnostic event with enum params
        EVENTID_EVENTFATALTHROTTLED = 0x13, //!< A fatal, throttled event with array params
        EVENTID_EVENTWARNINGHIGH = 0x20, //!< A warning high event with struct params
        EVENTID_EVENTWARNINGLOWTHROTTLED = 0x21, //!< A warning low, throttled event with no params
      };

      //! Event throttle values: sets initial value of countdown variables
      enum {
        EVENTID_EVENTACTIVITYLOWTHROTTLED_THROTTLE = 5, //!< Throttle reset count for EventActivityLowThrottled
        EVENTID_EVENTFATALTHROTTLED_THROTTLE = 10, //!< Throttle reset count for EventFatalThrottled
        EVENTID_EVENTWARNINGLOWTHROTTLED_THROTTLE = 10, //!< Throttle reset count for EventWarningLowThrottled
      };

      //! Channel IDs
      enum {
        CHANNELID_CHANNELU32FORMAT = 0x0, //!< Channel ID for ChannelU32Format
        CHANNELID_CHANNELF32FORMAT = 0x1, //!< Channel ID for ChannelF32Format
        CHANNELID_CHANNELSTRINGFORMAT = 0x2, //!< Channel ID for ChannelStringFormat
        CHANNELID_CHANNELENUM = 0x10, //!< Channel ID for ChannelEnum
        CHANNELID_CHANNELARRAYFREQ = 0x11, //!< Channel ID for ChannelArrayFreq
        CHANNELID_CHANNELSTRUCTFREQ = 0x12, //!< Channel ID for ChannelStructFreq
        CHANNELID_CHANNELU32LIMITS = 0x13, //!< Channel ID for ChannelU32Limits
        CHANNELID_CHANNELF32LIMITS = 0x14, //!< Channel ID for ChannelF32Limits
        CHANNELID_CHANNELF64 = 0x15, //!< Channel ID for ChannelF64
        CHANNELID_CHANNELU32ONCHANGE = 0x16, //!< Channel ID for ChannelU32OnChange
        CHANNELID_CHANNELENUMONCHANGE = 0x17, //!< Channel ID for ChannelEnumOnChange
      };

      //! Parameter IDs
      enum {
        PARAMID_PARAMU32 = 0x0, //!< A parameter with U32 data
                                //!< Second line of annotation
        PARAMID_PARAMF64 = 0x1, //!< A parameter with F64 data
        PARAMID_PARAMSTRING = 0x2, //!< A parameter with string data and default value
        PARAMID_PARAMENUM = 0x30, //!< A parameter with enum data
        PARAMID_PARAMARRAY = 0x31, //!< A parameter with array data, default value, and save opcode
        PARAMID_PARAMSTRUCT = 0x32, //!< A parameter with struct data and set/save opcodes
      };

    PROTECTED:

      // ----------------------------------------------------------------------
      // Types for data products
      // ----------------------------------------------------------------------

      //! The container ids
      struct ContainerId {
        enum T : FwDpIdType {
          Container1 = 100,
          Container2 = 200,
          Container3 = 300,
          Container4 = 400,
          Container5 = 500,
        };
      };

      //! The container default priorities
      struct ContainerPriority {
        enum T : FwDpPriorityType {
          Container1 = 10,
          Container2 = 20,
          Container3 = 0,
          Container4 = 0,
          Container5 = 0,
        };
      };

      //! The record ids
      struct RecordId {
        enum T : FwDpIdType {
          U32Record = 100,
          DataRecord = 200,
          U8ArrayRecord = 300,
          U32ArrayRecord = 400,
          DataArrayRecord = 500,
          StringRecord = 600,
          StringArrayRecord = 700,
        };
      };

      //! A data product container
      class DpContainer :
        public Fw::DpContainer
      {

        public:

          //! Constructor with custom initialization
          DpContainer(
              FwDpIdType id, //!< The container id
              const Fw::Buffer& buffer, //!< The packet buffer
              FwDpIdType baseId //!< The component base id
          );

          //! Constructor with default initialization
          DpContainer();

        public:

          //! Serialize a DataArrayRecord record into the packet buffer
          //! \return The serialize status
          Fw::SerializeStatus serializeRecord_DataArrayRecord(
              const M::ActiveTest_Data* array, //!< An array of M::ActiveTest_Data elements
              FwSizeType size //!< The array size
          );

          //! Serialize a DataRecord record into the packet buffer
          //! \return The serialize status
          Fw::SerializeStatus serializeRecord_DataRecord(
              const M::ActiveTest_Data& elt //!< The element
          );

          //! Serialize a StringArrayRecord record into the packet buffer
          //! \return The serialize status
          Fw::SerializeStatus serializeRecord_StringArrayRecord(
              const Fw::StringBase** array, //!< An array of pointers to StringBase objects
              FwSizeType size //!< The array size
          );

          //! Serialize a StringRecord record into the packet buffer
          //! \return The serialize status
          Fw::SerializeStatus serializeRecord_StringRecord(
              const Fw::StringBase& elt //!< The element
          );

          //! Serialize a U32ArrayRecord record into the packet buffer
          //! \return The serialize status
          Fw::SerializeStatus serializeRecord_U32ArrayRecord(
              const U32* array, //!< An array of U32 elements
              FwSizeType size //!< The array size
          );

          //! Serialize a U32Record record into the packet buffer
          //! \return The serialize status
          Fw::SerializeStatus serializeRecord_U32Record(
              U32 elt //!< The element
          );

          //! Serialize a U8ArrayRecord record into the packet buffer
          //! \return The serialize status
          Fw::SerializeStatus serializeRecord_U8ArrayRecord(
              const U8* array, //!< An array of U8 elements
              FwSizeType size //!< The array size
          );

          FwDpIdType getBaseId() const { return this->baseId; }

          void setBaseId(FwDpIdType baseId) { this->baseId = baseId; }

        PRIVATE:

          //! The component base id
          FwDpIdType baseId;

      };

    public:

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

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

    public:

      // ----------------------------------------------------------------------
      // Getters for special input ports
      // ----------------------------------------------------------------------

      //! Get special input port at index
      //!
      //! \return cmdIn[portNum]
      Fw::InputCmdPort* get_cmdIn_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get special input port at index
      //!
      //! \return productRecvIn[portNum]
      Fw::InputDpResponsePort* get_productRecvIn_InputPort(
          FwIndexType portNum //!< The port number
      );

    public:

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

      //! Get typed input port at index
      //!
      //! \return noArgsAsync[portNum]
      Ports::InputNoArgsPort* get_noArgsAsync_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return noArgsGuarded[portNum]
      Ports::InputNoArgsPort* get_noArgsGuarded_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return noArgsReturnGuarded[portNum]
      Ports::InputNoArgsReturnPort* get_noArgsReturnGuarded_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return noArgsReturnSync[portNum]
      Ports::InputNoArgsReturnPort* get_noArgsReturnSync_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return noArgsSync[portNum]
      Ports::InputNoArgsPort* get_noArgsSync_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return typedAsync[portNum]
      Ports::InputTypedPort* get_typedAsync_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return typedAsyncAssert[portNum]
      Ports::InputTypedPort* get_typedAsyncAssert_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return typedAsyncBlockPriority[portNum]
      Ports::InputTypedPort* get_typedAsyncBlockPriority_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return typedAsyncDropPriority[portNum]
      Ports::InputTypedPort* get_typedAsyncDropPriority_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return typedGuarded[portNum]
      Ports::InputTypedPort* get_typedGuarded_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return typedReturnGuarded[portNum]
      Ports::InputTypedReturnPort* get_typedReturnGuarded_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return typedReturnSync[portNum]
      Ports::InputTypedReturnPort* get_typedReturnSync_InputPort(
          FwIndexType portNum //!< The port number
      );

      //! Get typed input port at index
      //!
      //! \return typedSync[portNum]
      Ports::InputTypedPort* get_typedSync_InputPort(
          FwIndexType portNum //!< The port number
      );

    public:

      // ----------------------------------------------------------------------
      // Connect input ports to special output ports
      // ----------------------------------------------------------------------

      //! Connect port to cmdRegOut[portNum]
      void set_cmdRegOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputCmdRegPort* port //!< The input port
      );

      //! Connect port to cmdResponseOut[portNum]
      void set_cmdResponseOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputCmdResponsePort* port //!< The input port
      );

      //! Connect port to eventOut[portNum]
      void set_eventOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputLogPort* port //!< The input port
      );

      //! Connect port to prmGetOut[portNum]
      void set_prmGetOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputPrmGetPort* port //!< The input port
      );

      //! Connect port to prmSetOut[portNum]
      void set_prmSetOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputPrmSetPort* port //!< The input port
      );

      //! Connect port to productRequestOut[portNum]
      void set_productRequestOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputDpRequestPort* port //!< The input port
      );

      //! Connect port to productSendOut[portNum]
      void set_productSendOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputDpSendPort* port //!< The input port
      );

#if FW_ENABLE_TEXT_LOGGING == 1

      //! Connect port to textEventOut[portNum]
      void set_textEventOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputLogTextPort* port //!< The input port
      );

#endif

      //! Connect port to timeGetOut[portNum]
      void set_timeGetOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputTimePort* port //!< The input port
      );

      //! Connect port to tlmOut[portNum]
      void set_tlmOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputTlmPort* port //!< The input port
      );

    public:

      // ----------------------------------------------------------------------
      // Connect typed input ports to typed output ports
      // ----------------------------------------------------------------------

      //! Connect port to noArgsOut[portNum]
      void set_noArgsOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Ports::InputNoArgsPort* port //!< The input port
      );

      //! Connect port to noArgsReturnOut[portNum]
      void set_noArgsReturnOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Ports::InputNoArgsReturnPort* port //!< The input port
      );

      //! Connect port to typedOut[portNum]
      void set_typedOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Ports::InputTypedPort* port //!< The input port
      );

      //! Connect port to typedReturnOut[portNum]
      void set_typedReturnOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Ports::InputTypedReturnPort* port //!< The input port
      );

#if FW_PORT_SERIALIZATION

    public:

      // ----------------------------------------------------------------------
      // Connect serial input ports to special output ports
      // ----------------------------------------------------------------------

      //! Connect port to cmdRegOut[portNum]
      void set_cmdRegOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

      //! Connect port to cmdResponseOut[portNum]
      void set_cmdResponseOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

      //! Connect port to eventOut[portNum]
      void set_eventOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

      //! Connect port to prmSetOut[portNum]
      void set_prmSetOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

      //! Connect port to productRequestOut[portNum]
      void set_productRequestOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

      //! Connect port to productSendOut[portNum]
      void set_productSendOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

#if FW_ENABLE_TEXT_LOGGING == 1

      //! Connect port to textEventOut[portNum]
      void set_textEventOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

#endif

      //! Connect port to timeGetOut[portNum]
      void set_timeGetOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

      //! Connect port to tlmOut[portNum]
      void set_tlmOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

#endif

#if FW_PORT_SERIALIZATION

    public:

      // ----------------------------------------------------------------------
      // Connect serial input ports to typed output ports
      // ----------------------------------------------------------------------

      //! Connect port to noArgsOut[portNum]
      void set_noArgsOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

      //! Connect port to typedOut[portNum]
      void set_typedOut_OutputPort(
          FwIndexType portNum, //!< The port number
          Fw::InputSerializePort* port //!< The port
      );

#endif

    public:

      // ----------------------------------------------------------------------
      // Command registration
      // ----------------------------------------------------------------------

      //! \brief Register commands with the Command Dispatcher
      //!
      //! Connect the dispatcher first
      void regCommands();

    public:

      // ----------------------------------------------------------------------
      // Parameter loading
      // ----------------------------------------------------------------------

      //! \brief Load the parameters from a parameter source
      //!
      //! Connect the parameter first
      void loadParameters();

    PROTECTED:

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

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

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

    PROTECTED:

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

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

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

    PROTECTED:

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    PROTECTED:

      // ----------------------------------------------------------------------
      // Getters for numbers of special output ports
      // ----------------------------------------------------------------------

      //! Get the number of cmdRegOut output ports
      //!
      //! \return The number of cmdRegOut output ports
      FwIndexType getNum_cmdRegOut_OutputPorts() const;

      //! Get the number of cmdResponseOut output ports
      //!
      //! \return The number of cmdResponseOut output ports
      FwIndexType getNum_cmdResponseOut_OutputPorts() const;

      //! Get the number of eventOut output ports
      //!
      //! \return The number of eventOut output ports
      FwIndexType getNum_eventOut_OutputPorts() const;

      //! Get the number of prmGetOut output ports
      //!
      //! \return The number of prmGetOut output ports
      FwIndexType getNum_prmGetOut_OutputPorts() const;

      //! Get the number of prmSetOut output ports
      //!
      //! \return The number of prmSetOut output ports
      FwIndexType getNum_prmSetOut_OutputPorts() const;

      //! Get the number of productRequestOut output ports
      //!
      //! \return The number of productRequestOut output ports
      FwIndexType getNum_productRequestOut_OutputPorts() const;

      //! Get the number of productSendOut output ports
      //!
      //! \return The number of productSendOut output ports
      FwIndexType getNum_productSendOut_OutputPorts() const;

#if FW_ENABLE_TEXT_LOGGING == 1

      //! Get the number of textEventOut output ports
      //!
      //! \return The number of textEventOut output ports
      FwIndexType getNum_textEventOut_OutputPorts() const;

#endif

      //! Get the number of timeGetOut output ports
      //!
      //! \return The number of timeGetOut output ports
      FwIndexType getNum_timeGetOut_OutputPorts() const;

      //! Get the number of tlmOut output ports
      //!
      //! \return The number of tlmOut output ports
      FwIndexType getNum_tlmOut_OutputPorts() const;

    PROTECTED:

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

      //! Get the number of noArgsOut output ports
      //!
      //! \return The number of noArgsOut output ports
      FwIndexType getNum_noArgsOut_OutputPorts() const;

      //! Get the number of noArgsReturnOut output ports
      //!
      //! \return The number of noArgsReturnOut output ports
      FwIndexType getNum_noArgsReturnOut_OutputPorts() const;

      //! Get the number of typedOut output ports
      //!
      //! \return The number of typedOut output ports
      FwIndexType getNum_typedOut_OutputPorts() const;

      //! Get the number of typedReturnOut output ports
      //!
      //! \return The number of typedReturnOut output ports
      FwIndexType getNum_typedReturnOut_OutputPorts() const;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Connection status queries for special output ports
      // ----------------------------------------------------------------------

      //! Check whether port cmdRegOut is connected
      //!
      //! \return Whether port cmdRegOut is connected
      bool isConnected_cmdRegOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

      //! Check whether port cmdResponseOut is connected
      //!
      //! \return Whether port cmdResponseOut is connected
      bool isConnected_cmdResponseOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

      //! Check whether port eventOut is connected
      //!
      //! \return Whether port eventOut is connected
      bool isConnected_eventOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

      //! Check whether port prmGetOut is connected
      //!
      //! \return Whether port prmGetOut is connected
      bool isConnected_prmGetOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

      //! Check whether port prmSetOut is connected
      //!
      //! \return Whether port prmSetOut is connected
      bool isConnected_prmSetOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

      //! Check whether port productRequestOut is connected
      //!
      //! \return Whether port productRequestOut is connected
      bool isConnected_productRequestOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

      //! Check whether port productSendOut is connected
      //!
      //! \return Whether port productSendOut is connected
      bool isConnected_productSendOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

#if FW_ENABLE_TEXT_LOGGING == 1

      //! Check whether port textEventOut is connected
      //!
      //! \return Whether port textEventOut is connected
      bool isConnected_textEventOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

#endif

      //! Check whether port timeGetOut is connected
      //!
      //! \return Whether port timeGetOut is connected
      bool isConnected_timeGetOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

      //! Check whether port tlmOut is connected
      //!
      //! \return Whether port tlmOut is connected
      bool isConnected_tlmOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Connection status queries for typed output ports
      // ----------------------------------------------------------------------

      //! Check whether port noArgsOut is connected
      //!
      //! \return Whether port noArgsOut is connected
      bool isConnected_noArgsOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

      //! Check whether port noArgsReturnOut is connected
      //!
      //! \return Whether port noArgsReturnOut is connected
      bool isConnected_noArgsReturnOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

      //! Check whether port typedOut is connected
      //!
      //! \return Whether port typedOut is connected
      bool isConnected_typedOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

      //! Check whether port typedReturnOut is connected
      //!
      //! \return Whether port typedReturnOut is connected
      bool isConnected_typedReturnOut_OutputPort(
          FwIndexType portNum //!< The port number
      );

    PROTECTED:

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

      //! Handler base-class function for input port productRecvIn
      void productRecvIn_handlerBase(
          FwIndexType portNum, //!< The port number
          FwDpIdType id, //!< The container ID
          const Fw::Buffer& buffer, //!< The buffer
          const Fw::Success& status //!< The status
      );

    PROTECTED:

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

      //! Handler for input port noArgsAsync
      virtual void noArgsAsync_handler(
          FwIndexType portNum //!< The port number
      ) = 0;

      //! Handler for input port noArgsGuarded
      virtual void noArgsGuarded_handler(
          FwIndexType portNum //!< The port number
      ) = 0;

      //! Handler for input port noArgsReturnGuarded
      virtual U32 noArgsReturnGuarded_handler(
          FwIndexType portNum //!< The port number
      ) = 0;

      //! Handler for input port noArgsReturnSync
      virtual U32 noArgsReturnSync_handler(
          FwIndexType portNum //!< The port number
      ) = 0;

      //! Handler for input port noArgsSync
      virtual void noArgsSync_handler(
          FwIndexType portNum //!< The port number
      ) = 0;

      //! Handler for input port typedAsync
      virtual void typedAsync_handler(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      ) = 0;

      //! Handler for input port typedAsyncAssert
      virtual void typedAsyncAssert_handler(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      ) = 0;

      //! Handler for input port typedAsyncBlockPriority
      virtual void typedAsyncBlockPriority_handler(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      ) = 0;

      //! Handler for input port typedAsyncDropPriority
      virtual void typedAsyncDropPriority_handler(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      ) = 0;

      //! Handler for input port typedGuarded
      virtual void typedGuarded_handler(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      ) = 0;

      //! Handler for input port typedReturnGuarded
      virtual F32 typedReturnGuarded_handler(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedReturnPortStrings::StringSize80& str2, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      ) = 0;

      //! Handler for input port typedReturnSync
      virtual F32 typedReturnSync_handler(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedReturnPortStrings::StringSize80& str2, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      ) = 0;

      //! Handler for input port typedSync
      virtual void typedSync_handler(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      ) = 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 noArgsAsync
      void noArgsAsync_handlerBase(
          FwIndexType portNum //!< The port number
      );

      //! Handler base-class function for input port noArgsGuarded
      void noArgsGuarded_handlerBase(
          FwIndexType portNum //!< The port number
      );

      //! Handler base-class function for input port noArgsReturnGuarded
      U32 noArgsReturnGuarded_handlerBase(
          FwIndexType portNum //!< The port number
      );

      //! Handler base-class function for input port noArgsReturnSync
      U32 noArgsReturnSync_handlerBase(
          FwIndexType portNum //!< The port number
      );

      //! Handler base-class function for input port noArgsSync
      void noArgsSync_handlerBase(
          FwIndexType portNum //!< The port number
      );

      //! Handler base-class function for input port typedAsync
      void typedAsync_handlerBase(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Handler base-class function for input port typedAsyncAssert
      void typedAsyncAssert_handlerBase(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Handler base-class function for input port typedAsyncBlockPriority
      void typedAsyncBlockPriority_handlerBase(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Handler base-class function for input port typedAsyncDropPriority
      void typedAsyncDropPriority_handlerBase(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Handler base-class function for input port typedGuarded
      void typedGuarded_handlerBase(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Handler base-class function for input port typedReturnGuarded
      F32 typedReturnGuarded_handlerBase(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedReturnPortStrings::StringSize80& str2, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Handler base-class function for input port typedReturnSync
      F32 typedReturnSync_handlerBase(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedReturnPortStrings::StringSize80& str2, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Handler base-class function for input port typedSync
      void typedSync_handlerBase(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Pre-message hooks for special async input ports
      //
      // Each of these functions is invoked just before processing a message
      // on the corresponding port. By default, they do nothing. You can
      // override them to provide specific pre-message behavior.
      // ----------------------------------------------------------------------

      //! Pre-message hook for async input port productRecvIn
      virtual void productRecvIn_preMsgHook(
          FwIndexType portNum, //!< The port number
          FwDpIdType id, //!< The container ID
          const Fw::Buffer& buffer, //!< The buffer
          const Fw::Success& status //!< The status
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Pre-message hooks for typed async input ports
      //
      // Each of these functions is invoked just before processing a message
      // on the corresponding port. By default, they do nothing. You can
      // override them to provide specific pre-message behavior.
      // ----------------------------------------------------------------------

      //! Pre-message hook for async input port noArgsAsync
      virtual void noArgsAsync_preMsgHook(
          FwIndexType portNum //!< The port number
      );

      //! Pre-message hook for async input port typedAsync
      virtual void typedAsync_preMsgHook(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Pre-message hook for async input port typedAsyncAssert
      virtual void typedAsyncAssert_preMsgHook(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Pre-message hook for async input port typedAsyncBlockPriority
      virtual void typedAsyncBlockPriority_preMsgHook(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Pre-message hook for async input port typedAsyncDropPriority
      virtual void typedAsyncDropPriority_preMsgHook(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Invocation functions for special output ports
      // ----------------------------------------------------------------------

      //! Invoke output port productRequestOut
      void productRequestOut_out(
          FwIndexType portNum, //!< The port number
          FwDpIdType id, //!< The container ID
          FwSizeType dataSize //!< The data size of the requested buffer
      );

      //! Invoke output port productSendOut
      void productSendOut_out(
          FwIndexType portNum, //!< The port number
          FwDpIdType id, //!< The container ID
          const Fw::Buffer& buffer //!< The buffer
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Invocation functions for typed output ports
      // ----------------------------------------------------------------------

      //! Invoke output port noArgsOut
      void noArgsOut_out(
          FwIndexType portNum //!< The port number
      );

      //! Invoke output port noArgsReturnOut
      U32 noArgsReturnOut_out(
          FwIndexType portNum //!< The port number
      );

      //! Invoke output port typedOut
      void typedOut_out(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Invoke output port typedReturnOut
      F32 typedReturnOut_out(
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedReturnPortStrings::StringSize80& str2, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Internal interface handlers
      // ----------------------------------------------------------------------

      //! Internal interface handler for internalArray
      virtual void internalArray_internalInterfaceHandler(
          const A& a //!< An array
      ) = 0;

      //! Internal interface handler for internalEnum
      virtual void internalEnum_internalInterfaceHandler(
          const E& e //!< An enum
      ) = 0;

      //! Internal interface handler for internalPrimitive
      virtual void internalPrimitive_internalInterfaceHandler(
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b //!< A boolean
      ) = 0;

      //! Internal interface handler for internalPriorityDrop
      virtual void internalPriorityDrop_internalInterfaceHandler() = 0;

      //! Internal interface handler for internalString
      virtual void internalString_internalInterfaceHandler(
          const Fw::InternalInterfaceString& str1, //!< A string
          const Fw::InternalInterfaceString& str2 //!< Another string
      ) = 0;

      //! Internal interface handler for internalStruct
      virtual void internalStruct_internalInterfaceHandler(
          const S& s //!< A struct
      ) = 0;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Internal interface base-class functions
      // ----------------------------------------------------------------------

      //! Internal interface base-class function for internalArray
      void internalArray_internalInterfaceInvoke(
          const A& a //!< An array
      );

      //! Internal interface base-class function for internalEnum
      void internalEnum_internalInterfaceInvoke(
          const E& e //!< An enum
      );

      //! Internal interface base-class function for internalPrimitive
      void internalPrimitive_internalInterfaceInvoke(
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b //!< A boolean
      );

      //! Internal interface base-class function for internalPriorityDrop
      void internalPriorityDrop_internalInterfaceInvoke();

      //! Internal interface base-class function for internalString
      void internalString_internalInterfaceInvoke(
          const Fw::InternalInterfaceString& str1, //!< A string
          const Fw::InternalInterfaceString& str2 //!< Another string
      );

      //! Internal interface base-class function for internalStruct
      void internalStruct_internalInterfaceInvoke(
          const S& s //!< A struct
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Command response
      // ----------------------------------------------------------------------

      //! Emit command response
      void cmdResponse_out(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdResponse response //!< The command response
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Command handlers to implement
      // ----------------------------------------------------------------------

      //! Handler for command CMD_SYNC
      //!
      //! A sync command with no params
      virtual void CMD_SYNC_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq //!< The command sequence number
      ) = 0;

      //! Handler for command CMD_SYNC_PRIMITIVE
      //!
      //! An async command with primitive params
      virtual void CMD_SYNC_PRIMITIVE_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b //!< A boolean
      ) = 0;

      //! Handler for command CMD_SYNC_STRING
      //!
      //! A sync command with string params
      virtual void CMD_SYNC_STRING_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          const Fw::CmdStringArg& str1, //!< A string
          const Fw::CmdStringArg& str2 //!< Another string
      ) = 0;

      //! Handler for command CMD_SYNC_ENUM
      //!
      //! A sync command with enum params
      virtual void CMD_SYNC_ENUM_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          E e //!< An enum
      ) = 0;

      //! Handler for command CMD_SYNC_ARRAY
      //!
      //! A sync command with array params
      virtual void CMD_SYNC_ARRAY_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          A a //!< An array
      ) = 0;

      //! Handler for command CMD_SYNC_STRUCT
      //!
      //! A sync command with struct params
      virtual void CMD_SYNC_STRUCT_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          S s //!< A struct
      ) = 0;

      //! Handler for command CMD_GUARDED
      //!
      //! A guarded command with no params
      virtual void CMD_GUARDED_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq //!< The command sequence number
      ) = 0;

      //! Handler for command CMD_GUARDED_PRIMITIVE
      //!
      //! A guarded command with primitive params
      virtual void CMD_GUARDED_PRIMITIVE_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b //!< A boolean
      ) = 0;

      //! Handler for command CMD_GUARDED_STRING
      //!
      //! A guarded command with string params
      virtual void CMD_GUARDED_STRING_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          const Fw::CmdStringArg& str1, //!< A string
          const Fw::CmdStringArg& str2 //!< Another string
      ) = 0;

      //! Handler for command CMD_GUARDED_ENUM
      //!
      //! A guarded command with enum params
      virtual void CMD_GUARDED_ENUM_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          E e //!< An enum
      ) = 0;

      //! Handler for command CMD_GUARDED_ARRAY
      //!
      //! A guarded command with array params
      virtual void CMD_GUARDED_ARRAY_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          A a //!< An array
      ) = 0;

      //! Handler for command CMD_GUARDED_STRUCT
      //!
      //! A guarded command with struct params
      virtual void CMD_GUARDED_STRUCT_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          S s //!< A struct
      ) = 0;

      //! Handler for command CMD_ASYNC
      //!
      //! An async command with no params
      virtual void CMD_ASYNC_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq //!< The command sequence number
      ) = 0;

      //! Handler for command CMD_PRIORITY
      //!
      //! A command with priority
      virtual void CMD_PRIORITY_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq //!< The command sequence number
      ) = 0;

      //! Handler for command CMD_PARAMS_PRIORITY
      //!
      //! A command with params and priority
      virtual void CMD_PARAMS_PRIORITY_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          U32 u32
      ) = 0;

      //! Handler for command CMD_DROP
      //!
      //! A command with queue full behavior
      virtual void CMD_DROP_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq //!< The command sequence number
      ) = 0;

      //! Handler for command CMD_PARAMS_PRIORITY_DROP
      //!
      //! A command with params, priority, and queue full behavior
      virtual void CMD_PARAMS_PRIORITY_DROP_cmdHandler(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          U32 u32
      ) = 0;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Command handler base-class functions
      //
      // Call these functions directly to bypass the command input port
      // ----------------------------------------------------------------------

      //! Base-class handler function for command CMD_SYNC
      //!
      //! A sync command with no params
      void CMD_SYNC_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_SYNC_PRIMITIVE
      //!
      //! An async command with primitive params
      void CMD_SYNC_PRIMITIVE_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_SYNC_STRING
      //!
      //! A sync command with string params
      void CMD_SYNC_STRING_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_SYNC_ENUM
      //!
      //! A sync command with enum params
      void CMD_SYNC_ENUM_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_SYNC_ARRAY
      //!
      //! A sync command with array params
      void CMD_SYNC_ARRAY_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_SYNC_STRUCT
      //!
      //! A sync command with struct params
      void CMD_SYNC_STRUCT_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_GUARDED
      //!
      //! A guarded command with no params
      void CMD_GUARDED_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_GUARDED_PRIMITIVE
      //!
      //! A guarded command with primitive params
      void CMD_GUARDED_PRIMITIVE_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_GUARDED_STRING
      //!
      //! A guarded command with string params
      void CMD_GUARDED_STRING_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_GUARDED_ENUM
      //!
      //! A guarded command with enum params
      void CMD_GUARDED_ENUM_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_GUARDED_ARRAY
      //!
      //! A guarded command with array params
      void CMD_GUARDED_ARRAY_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_GUARDED_STRUCT
      //!
      //! A guarded command with struct params
      void CMD_GUARDED_STRUCT_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_ASYNC
      //!
      //! An async command with no params
      void CMD_ASYNC_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_PRIORITY
      //!
      //! A command with priority
      void CMD_PRIORITY_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_PARAMS_PRIORITY
      //!
      //! A command with params and priority
      void CMD_PARAMS_PRIORITY_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_DROP
      //!
      //! A command with queue full behavior
      void CMD_DROP_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

      //! Base-class handler function for command CMD_PARAMS_PRIORITY_DROP
      //!
      //! A command with params, priority, and queue full behavior
      void CMD_PARAMS_PRIORITY_DROP_cmdHandlerBase(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq, //!< The command sequence number
          Fw::CmdArgBuffer& args //!< The command argument buffer
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Pre-message hooks for async commands
      //
      // Each of these functions is invoked just before processing the
      // corresponding command. By default they do nothing. You can
      // override them to provide specific pre-command behavior.
      // ----------------------------------------------------------------------

      //! Pre-message hook for command CMD_ASYNC
      virtual void CMD_ASYNC_preMsgHook(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq //!< The command sequence number
      );

      //! Pre-message hook for command CMD_PRIORITY
      virtual void CMD_PRIORITY_preMsgHook(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq //!< The command sequence number
      );

      //! Pre-message hook for command CMD_PARAMS_PRIORITY
      virtual void CMD_PARAMS_PRIORITY_preMsgHook(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq //!< The command sequence number
      );

      //! Pre-message hook for command CMD_DROP
      virtual void CMD_DROP_preMsgHook(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq //!< The command sequence number
      );

      //! Pre-message hook for command CMD_PARAMS_PRIORITY_DROP
      virtual void CMD_PARAMS_PRIORITY_DROP_preMsgHook(
          FwOpcodeType opCode, //!< The opcode
          U32 cmdSeq //!< The command sequence number
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Event logging functions
      // ----------------------------------------------------------------------

      //! Log event EventActivityHigh
      //!
      //! An activity high event with no params
      void log_ACTIVITY_HI_EventActivityHigh();

      //! Log event EventActivityLowThrottled
      //!
      //! An activity low, throttled event with primitive params
      void log_ACTIVITY_LO_EventActivityLowThrottled(
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b //!< A boolean
      );

      //! Log event EventCommand
      //!
      //! A command event with string params
      void log_COMMAND_EventCommand(
          const Fw::StringBase& str1, //!< A string
          const Fw::StringBase& str2 //!< Another string
      );

      //! Log event EventDiagnostic
      //!
      //! A diagnostic event with enum params
      void log_DIAGNOSTIC_EventDiagnostic(
          E e //!< An enum
      );

      //! Log event EventFatalThrottled
      //!
      //! A fatal, throttled event with array params
      void log_FATAL_EventFatalThrottled(
          A a //!< An array
      );

      //! Log event EventWarningHigh
      //!
      //! A warning high event with struct params
      void log_WARNING_HI_EventWarningHigh(
          S s //!< A struct
      );

      //! Log event EventWarningLowThrottled
      //!
      //! A warning low, throttled event with no params
      void log_WARNING_LO_EventWarningLowThrottled();

    PROTECTED:

      // ----------------------------------------------------------------------
      // Event throttle reset functions
      // ----------------------------------------------------------------------

      //! Reset throttle value for EventActivityLowThrottled
      void log_ACTIVITY_LO_EventActivityLowThrottled_ThrottleClear();

      //! Reset throttle value for EventFatalThrottled
      void log_FATAL_EventFatalThrottled_ThrottleClear();

      //! Reset throttle value for EventWarningLowThrottled
      void log_WARNING_LO_EventWarningLowThrottled_ThrottleClear();

    PROTECTED:

      // ----------------------------------------------------------------------
      // Telemetry write functions
      // ----------------------------------------------------------------------

      //! Write telemetry channel ChannelU32Format
      //!
      //! A telemetry channel with U32 data and format string
      void tlmWrite_ChannelU32Format(
          U32 arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

      //! Write telemetry channel ChannelF32Format
      //!
      //! A telemetry channel with F32 data and format string
      void tlmWrite_ChannelF32Format(
          F32 arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

      //! Write telemetry channel ChannelStringFormat
      //!
      //! A telemetry channel with string data with format string
      void tlmWrite_ChannelStringFormat(
          const Fw::StringBase& arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

      //! Write telemetry channel ChannelEnum
      //!
      //! A telemetry channel with enum data
      void tlmWrite_ChannelEnum(
          const E& arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

      //! Write telemetry channel ChannelArrayFreq
      //!
      //! A telemetry channel with array data and update frequency
      void tlmWrite_ChannelArrayFreq(
          const A& arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

      //! Write telemetry channel ChannelStructFreq
      //!
      //! A telemetry channel with struct data
      void tlmWrite_ChannelStructFreq(
          const S& arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

      //! Write telemetry channel ChannelU32Limits
      //!
      //! A telemetry channel with U32 data and limits
      void tlmWrite_ChannelU32Limits(
          U32 arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

      //! Write telemetry channel ChannelF32Limits
      //!
      //! A telemetry channel with F32 data and limits
      void tlmWrite_ChannelF32Limits(
          F32 arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

      //! Write telemetry channel ChannelF64
      //!
      //! A telemetry channel F64 data, update frequency, format, and limits
      void tlmWrite_ChannelF64(
          F64 arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

      //! Write telemetry channel ChannelU32OnChange
      //!
      //! A telemetry channel with U32 data and update on change frequency
      void tlmWrite_ChannelU32OnChange(
          U32 arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

      //! Write telemetry channel ChannelEnumOnChange
      //!
      //! A telemetry channel with enum data and update on change frequency
      void tlmWrite_ChannelEnumOnChange(
          const E& arg, //!< The telemetry value
          Fw::Time _tlmTime = Fw::Time() //!< Timestamp. Default: unspecified, request from getTime port
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Parameter update hook
      // ----------------------------------------------------------------------

      //! \brief Called whenever a parameter is updated
      //!
      //! This function does nothing by default. You may override it.
      virtual void parameterUpdated(
          FwPrmIdType id //!< The parameter ID
      );

      // ----------------------------------------------------------------------
      // Parameter load hook
      // ----------------------------------------------------------------------

      //! \brief Called whenever parameters are loaded
      //!
      //! This function does nothing by default. You may override it.
      virtual void parametersLoaded();

    PROTECTED:

      // ----------------------------------------------------------------------
      // Parameter get functions
      // ----------------------------------------------------------------------

      //! Get parameter ParamU32
      //!
      //! \return The parameter value
      //!
      //! A parameter with U32 data
      //! Second line of annotation
      U32 paramGet_ParamU32(
          Fw::ParamValid& valid //!< Whether the parameter is valid
      );

      //! Get parameter ParamF64
      //!
      //! \return The parameter value
      //!
      //! A parameter with F64 data
      F64 paramGet_ParamF64(
          Fw::ParamValid& valid //!< Whether the parameter is valid
      );

      //! Get parameter ParamString
      //!
      //! \return The parameter value
      //!
      //! A parameter with string data and default value
      Fw::ParamString paramGet_ParamString(
          Fw::ParamValid& valid //!< Whether the parameter is valid
      );

      //! Get parameter ParamEnum
      //!
      //! \return The parameter value
      //!
      //! A parameter with enum data
      E paramGet_ParamEnum(
          Fw::ParamValid& valid //!< Whether the parameter is valid
      );

      //! Get parameter ParamArray
      //!
      //! \return The parameter value
      //!
      //! A parameter with array data, default value, and save opcode
      A paramGet_ParamArray(
          Fw::ParamValid& valid //!< Whether the parameter is valid
      );

      //! Get parameter ParamStruct
      //!
      //! \return The parameter value
      //!
      //! A parameter with struct data and set/save opcodes
      S paramGet_ParamStruct(
          Fw::ParamValid& valid //!< Whether the parameter is valid
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Functions for managing data products
      // ----------------------------------------------------------------------

      //! Request a Container1 container
      void dpRequest_Container1(
          FwSizeType size //!< The buffer size (input)
      ) {
        return this->dpRequest(ContainerId::Container1, size);
      }

      //! Request a Container2 container
      void dpRequest_Container2(
          FwSizeType size //!< The buffer size (input)
      ) {
        return this->dpRequest(ContainerId::Container2, size);
      }

      //! Request a Container3 container
      void dpRequest_Container3(
          FwSizeType size //!< The buffer size (input)
      ) {
        return this->dpRequest(ContainerId::Container3, size);
      }

      //! Request a Container4 container
      void dpRequest_Container4(
          FwSizeType size //!< The buffer size (input)
      ) {
        return this->dpRequest(ContainerId::Container4, size);
      }

      //! Request a Container5 container
      void dpRequest_Container5(
          FwSizeType size //!< The buffer size (input)
      ) {
        return this->dpRequest(ContainerId::Container5, size);
      }

      //! Send a data product
      void dpSend(
          DpContainer& container, //!< The data product container
          Fw::Time timeTag = Fw::ZERO_TIME //!< The time tag
      );

    PROTECTED:

      // ----------------------------------------------------------------------
      // Handlers to implement for data products
      // ----------------------------------------------------------------------

      //! Receive a container of type Container1
      virtual void dpRecv_Container1_handler(
          DpContainer& container, //!< The container
          Fw::Success::T status //!< The container status
      ) = 0;

      //! Receive a container of type Container2
      virtual void dpRecv_Container2_handler(
          DpContainer& container, //!< The container
          Fw::Success::T status //!< The container status
      ) = 0;

      //! Receive a container of type Container3
      virtual void dpRecv_Container3_handler(
          DpContainer& container, //!< The container
          Fw::Success::T status //!< The container status
      ) = 0;

      //! Receive a container of type Container4
      virtual void dpRecv_Container4_handler(
          DpContainer& container, //!< The container
          Fw::Success::T status //!< The container status
      ) = 0;

      //! Receive a container of type Container5
      virtual void dpRecv_Container5_handler(
          DpContainer& container, //!< The container
          Fw::Success::T status //!< The container status
      ) = 0;

    PROTECTED:

      // ----------------------------------------------------------------------
      // Time
      // ----------------------------------------------------------------------

      //!  Get the time
      //!
      //! \\return The current time
      Fw::Time getTime();

    PROTECTED:

      // ----------------------------------------------------------------------
      // Mutex operations for guarded ports
      //
      // You can override these operations to provide more sophisticated
      // synchronization
      // ----------------------------------------------------------------------

      //! Lock the guarded mutex
      virtual void lock();

      //! Unlock the guarded mutex
      virtual void unLock();

    PRIVATE:

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

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

    PRIVATE:

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

      //! Callback for port cmdIn
      static void m_p_cmdIn_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          FwOpcodeType opCode, //!< Command Op Code
          U32 cmdSeq, //!< Command Sequence
          Fw::CmdArgBuffer& args //!< Buffer containing arguments
      );

      //! Callback for port productRecvIn
      static void m_p_productRecvIn_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          FwDpIdType id, //!< The container ID
          const Fw::Buffer& buffer, //!< The buffer
          const Fw::Success& status //!< The status
      );

    PRIVATE:

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

      //! Callback for port noArgsAsync
      static void m_p_noArgsAsync_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum //!< The port number
      );

      //! Callback for port noArgsGuarded
      static void m_p_noArgsGuarded_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum //!< The port number
      );

      //! Callback for port noArgsReturnGuarded
      static U32 m_p_noArgsReturnGuarded_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum //!< The port number
      );

      //! Callback for port noArgsReturnSync
      static U32 m_p_noArgsReturnSync_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum //!< The port number
      );

      //! Callback for port noArgsSync
      static void m_p_noArgsSync_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum //!< The port number
      );

      //! Callback for port typedAsync
      static void m_p_typedAsync_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Callback for port typedAsyncAssert
      static void m_p_typedAsyncAssert_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Callback for port typedAsyncBlockPriority
      static void m_p_typedAsyncBlockPriority_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Callback for port typedAsyncDropPriority
      static void m_p_typedAsyncDropPriority_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Callback for port typedGuarded
      static void m_p_typedGuarded_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Callback for port typedReturnGuarded
      static F32 m_p_typedReturnGuarded_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedReturnPortStrings::StringSize80& str2, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Callback for port typedReturnSync
      static F32 m_p_typedReturnSync_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedReturnPortStrings::StringSize80& str2, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

      //! Callback for port typedSync
      static void m_p_typedSync_in(
          Fw::PassiveComponentBase* callComp, //!< The component instance
          FwIndexType portNum, //!< The port number
          U32 u32, //!< A U32
          F32 f32, //!< An F32
          bool b, //!< A boolean
          const Ports::TypedPortStrings::StringSize80& str1, //!< A string
          const E& e, //!< An enum
          const A& a, //!< An array
          const S& s //!< A struct
      );

    PRIVATE:

      // ----------------------------------------------------------------------
      // Parameter set functions
      // ----------------------------------------------------------------------

      //! Set parameter ParamU32
      //!
      //! \return The command response
      Fw::CmdResponse paramSet_ParamU32(
          Fw::SerializeBufferBase& val //!< The serialization buffer
      );

      //! Set parameter ParamF64
      //!
      //! \return The command response
      Fw::CmdResponse paramSet_ParamF64(
          Fw::SerializeBufferBase& val //!< The serialization buffer
      );

      //! Set parameter ParamString
      //!
      //! \return The command response
      Fw::CmdResponse paramSet_ParamString(
          Fw::SerializeBufferBase& val //!< The serialization buffer
      );

      //! Set parameter ParamEnum
      //!
      //! \return The command response
      Fw::CmdResponse paramSet_ParamEnum(
          Fw::SerializeBufferBase& val //!< The serialization buffer
      );

      //! Set parameter ParamArray
      //!
      //! \return The command response
      Fw::CmdResponse paramSet_ParamArray(
          Fw::SerializeBufferBase& val //!< The serialization buffer
      );

      //! Set parameter ParamStruct
      //!
      //! \return The command response
      Fw::CmdResponse paramSet_ParamStruct(
          Fw::SerializeBufferBase& val //!< The serialization buffer
      );

    PRIVATE:

      // ----------------------------------------------------------------------
      // Parameter save functions
      // ----------------------------------------------------------------------

      //! Save parameter ParamU32
      //!
      //! \return The command response
      Fw::CmdResponse paramSave_ParamU32();

      //! Save parameter ParamF64
      //!
      //! \return The command response
      Fw::CmdResponse paramSave_ParamF64();

      //! Save parameter ParamString
      //!
      //! \return The command response
      Fw::CmdResponse paramSave_ParamString();

      //! Save parameter ParamEnum
      //!
      //! \return The command response
      Fw::CmdResponse paramSave_ParamEnum();

      //! Save parameter ParamArray
      //!
      //! \return The command response
      Fw::CmdResponse paramSave_ParamArray();

      //! Save parameter ParamStruct
      //!
      //! \return The command response
      Fw::CmdResponse paramSave_ParamStruct();

    PRIVATE:

      // ----------------------------------------------------------------------
      // Private data product handling functions
      // ----------------------------------------------------------------------

      //! Request a data product container
      void dpRequest(
          ContainerId::T containerId, //!< The component-local container id
          FwSizeType dataSize //!< The data size
      );

      //! Handler implementation for productRecvIn
      void productRecvIn_handler(
          const FwIndexType portNum, //!< The port number
          FwDpIdType id, //!< The container id
          const Fw::Buffer& buffer, //!< The buffer
          const Fw::Success& status //!< The buffer status
      );

    PRIVATE:

      // ----------------------------------------------------------------------
      // Special input ports
      // ----------------------------------------------------------------------

      //! Input port cmdIn
      Fw::InputCmdPort m_cmdIn_InputPort[NUM_CMDIN_INPUT_PORTS];

      //! Input port productRecvIn
      Fw::InputDpResponsePort m_productRecvIn_InputPort[NUM_PRODUCTRECVIN_INPUT_PORTS];

    PRIVATE:

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

      //! Input port noArgsAsync
      Ports::InputNoArgsPort m_noArgsAsync_InputPort[NUM_NOARGSASYNC_INPUT_PORTS];

      //! Input port noArgsGuarded
      Ports::InputNoArgsPort m_noArgsGuarded_InputPort[NUM_NOARGSGUARDED_INPUT_PORTS];

      //! Input port noArgsReturnGuarded
      Ports::InputNoArgsReturnPort m_noArgsReturnGuarded_InputPort[NUM_NOARGSRETURNGUARDED_INPUT_PORTS];

      //! Input port noArgsReturnSync
      Ports::InputNoArgsReturnPort m_noArgsReturnSync_InputPort[NUM_NOARGSRETURNSYNC_INPUT_PORTS];

      //! Input port noArgsSync
      Ports::InputNoArgsPort m_noArgsSync_InputPort[NUM_NOARGSSYNC_INPUT_PORTS];

      //! Input port typedAsync
      Ports::InputTypedPort m_typedAsync_InputPort[NUM_TYPEDASYNC_INPUT_PORTS];

      //! Input port typedAsyncAssert
      Ports::InputTypedPort m_typedAsyncAssert_InputPort[NUM_TYPEDASYNCASSERT_INPUT_PORTS];

      //! Input port typedAsyncBlockPriority
      Ports::InputTypedPort m_typedAsyncBlockPriority_InputPort[NUM_TYPEDASYNCBLOCKPRIORITY_INPUT_PORTS];

      //! Input port typedAsyncDropPriority
      Ports::InputTypedPort m_typedAsyncDropPriority_InputPort[NUM_TYPEDASYNCDROPPRIORITY_INPUT_PORTS];

      //! Input port typedGuarded
      Ports::InputTypedPort m_typedGuarded_InputPort[NUM_TYPEDGUARDED_INPUT_PORTS];

      //! Input port typedReturnGuarded
      Ports::InputTypedReturnPort m_typedReturnGuarded_InputPort[NUM_TYPEDRETURNGUARDED_INPUT_PORTS];

      //! Input port typedReturnSync
      Ports::InputTypedReturnPort m_typedReturnSync_InputPort[NUM_TYPEDRETURNSYNC_INPUT_PORTS];

      //! Input port typedSync
      Ports::InputTypedPort m_typedSync_InputPort[NUM_TYPEDSYNC_INPUT_PORTS];

    PRIVATE:

      // ----------------------------------------------------------------------
      // Special output ports
      // ----------------------------------------------------------------------

      //! Output port cmdRegOut
      Fw::OutputCmdRegPort m_cmdRegOut_OutputPort[NUM_CMDREGOUT_OUTPUT_PORTS];

      //! Output port cmdResponseOut
      Fw::OutputCmdResponsePort m_cmdResponseOut_OutputPort[NUM_CMDRESPONSEOUT_OUTPUT_PORTS];

      //! Output port eventOut
      Fw::OutputLogPort m_eventOut_OutputPort[NUM_EVENTOUT_OUTPUT_PORTS];

      //! Output port prmGetOut
      Fw::OutputPrmGetPort m_prmGetOut_OutputPort[NUM_PRMGETOUT_OUTPUT_PORTS];

      //! Output port prmSetOut
      Fw::OutputPrmSetPort m_prmSetOut_OutputPort[NUM_PRMSETOUT_OUTPUT_PORTS];

      //! Output port productRequestOut
      Fw::OutputDpRequestPort m_productRequestOut_OutputPort[NUM_PRODUCTREQUESTOUT_OUTPUT_PORTS];

      //! Output port productSendOut
      Fw::OutputDpSendPort m_productSendOut_OutputPort[NUM_PRODUCTSENDOUT_OUTPUT_PORTS];

#if FW_ENABLE_TEXT_LOGGING == 1

      //! Output port textEventOut
      Fw::OutputLogTextPort m_textEventOut_OutputPort[NUM_TEXTEVENTOUT_OUTPUT_PORTS];

#endif

      //! Output port timeGetOut
      Fw::OutputTimePort m_timeGetOut_OutputPort[NUM_TIMEGETOUT_OUTPUT_PORTS];

      //! Output port tlmOut
      Fw::OutputTlmPort m_tlmOut_OutputPort[NUM_TLMOUT_OUTPUT_PORTS];

    PRIVATE:

      // ----------------------------------------------------------------------
      // Typed output ports
      // ----------------------------------------------------------------------

      //! Output port noArgsOut
      Ports::OutputNoArgsPort m_noArgsOut_OutputPort[NUM_NOARGSOUT_OUTPUT_PORTS];

      //! Output port noArgsReturnOut
      Ports::OutputNoArgsReturnPort m_noArgsReturnOut_OutputPort[NUM_NOARGSRETURNOUT_OUTPUT_PORTS];

      //! Output port typedOut
      Ports::OutputTypedPort m_typedOut_OutputPort[NUM_TYPEDOUT_OUTPUT_PORTS];

      //! Output port typedReturnOut
      Ports::OutputTypedReturnPort m_typedReturnOut_OutputPort[NUM_TYPEDRETURNOUT_OUTPUT_PORTS];

    PRIVATE:

      // ----------------------------------------------------------------------
      // Counter values for event throttling
      // ----------------------------------------------------------------------

      //! Throttle for EventActivityLowThrottled
      FwIndexType m_EventActivityLowThrottledThrottle;

      //! Throttle for EventFatalThrottled
      FwIndexType m_EventFatalThrottledThrottle;

      //! Throttle for EventWarningLowThrottled
      FwIndexType m_EventWarningLowThrottledThrottle;

    PRIVATE:

      // ----------------------------------------------------------------------
      // First update flags for telemetry channels
      // ----------------------------------------------------------------------

      //! Initialized to true; cleared when channel ChannelU32OnChange is first updated
      bool m_first_update_ChannelU32OnChange;

      //! Initialized to true; cleared when channel ChannelEnumOnChange is first updated
      bool m_first_update_ChannelEnumOnChange;

    PRIVATE:

      // ----------------------------------------------------------------------
      // Last value storage for telemetry channels
      // ----------------------------------------------------------------------

      //! Records the last emitted value for channel ChannelU32OnChange
      U32 m_last_ChannelU32OnChange;

      //! Records the last emitted value for channel ChannelEnumOnChange
      E m_last_ChannelEnumOnChange;

    PRIVATE:

      // ----------------------------------------------------------------------
      // Parameter validity flags
      // ----------------------------------------------------------------------

      //! True if ParamU32 was successfully received
      Fw::ParamValid m_param_ParamU32_valid;

      //! True if ParamF64 was successfully received
      Fw::ParamValid m_param_ParamF64_valid;

      //! True if ParamString was successfully received
      Fw::ParamValid m_param_ParamString_valid;

      //! True if ParamEnum was successfully received
      Fw::ParamValid m_param_ParamEnum_valid;

      //! True if ParamArray was successfully received
      Fw::ParamValid m_param_ParamArray_valid;

      //! True if ParamStruct was successfully received
      Fw::ParamValid m_param_ParamStruct_valid;

    PRIVATE:

      // ----------------------------------------------------------------------
      // Parameter variables
      // ----------------------------------------------------------------------

      //! Parameter ParamU32
      //!
      //! A parameter with U32 data
      //! Second line of annotation
      U32 m_ParamU32;

      //! Parameter ParamF64
      //!
      //! A parameter with F64 data
      F64 m_ParamF64;

      //! Parameter ParamString
      //!
      //! A parameter with string data and default value
      Fw::ParamString m_ParamString;

      //! Parameter ParamEnum
      //!
      //! A parameter with enum data
      E m_ParamEnum;

      //! Parameter ParamArray
      //!
      //! A parameter with array data, default value, and save opcode
      A m_ParamArray;

      //! Parameter ParamStruct
      //!
      //! A parameter with struct data and set/save opcodes
      S m_ParamStruct;

    PRIVATE:

      // ----------------------------------------------------------------------
      // Mutexes
      // ----------------------------------------------------------------------

      //! Mutex for guarded ports
      Os::Mutex m_guardedPortMutex;

      //! Mutex for locking parameters during sets and saves
      Os::Mutex m_paramLock;

  };

}

#endif