SpacePacketFramerComponentAc.cpp

Go to the documentation of this file.

// ======================================================================
// \title  SpacePacketFramerComponentAc.cpp
// \author Generated by fpp-to-cpp
// \brief  cpp file for SpacePacketFramer component base class
// ======================================================================

#include "Fw/Types/Assert.hpp"
#include "Fw/Types/ExternalString.hpp"
#if FW_ENABLE_TEXT_LOGGING
#include "Fw/Types/String.hpp"
#endif
#include "Svc/Ccsds/SpacePacketFramer/SpacePacketFramerComponentAc.hpp"

namespace Svc {

  namespace Ccsds {

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

    void SpacePacketFramerComponentBase ::
      init(FwEnumStoreType instance)
    {
      // Initialize base class
      Fw::PassiveComponentBase::init(instance);

#if !FW_DIRECT_PORT_CALLS
      // Connect input port comStatusIn
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_comStatusIn_InputPorts());
        port++
      ) {
        this->m_comStatusIn_InputPort[port].init();
        this->m_comStatusIn_InputPort[port].addCallComp(
          this,
          m_p_comStatusIn_in
        );
        this->m_comStatusIn_InputPort[port].setPortNum(port);

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_comStatusIn_InputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_comStatusIn_InputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect input port dataIn
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_dataIn_InputPorts());
        port++
      ) {
        this->m_dataIn_InputPort[port].init();
        this->m_dataIn_InputPort[port].addCallComp(
          this,
          m_p_dataIn_in
        );
        this->m_dataIn_InputPort[port].setPortNum(port);

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_dataIn_InputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_dataIn_InputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect input port dataReturnIn
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_dataReturnIn_InputPorts());
        port++
      ) {
        this->m_dataReturnIn_InputPort[port].init();
        this->m_dataReturnIn_InputPort[port].addCallComp(
          this,
          m_p_dataReturnIn_in
        );
        this->m_dataReturnIn_InputPort[port].setPortNum(port);

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_dataReturnIn_InputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_dataReturnIn_InputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port logOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_logOut_OutputPorts());
        port++
      ) {
        this->m_logOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_logOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_logOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS && FW_ENABLE_TEXT_LOGGING
      // Connect output port logTextOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_logTextOut_OutputPorts());
        port++
      ) {
        this->m_logTextOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_logTextOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_logTextOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port prmGetOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_prmGetOut_OutputPorts());
        port++
      ) {
        this->m_prmGetOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_prmGetOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_prmGetOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port prmSetOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_prmSetOut_OutputPorts());
        port++
      ) {
        this->m_prmSetOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_prmSetOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_prmSetOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port timeCaller
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_timeCaller_OutputPorts());
        port++
      ) {
        this->m_timeCaller_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_timeCaller_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_timeCaller_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port tlmOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_tlmOut_OutputPorts());
        port++
      ) {
        this->m_tlmOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_tlmOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_tlmOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port bufferAllocate
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_bufferAllocate_OutputPorts());
        port++
      ) {
        this->m_bufferAllocate_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_bufferAllocate_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_bufferAllocate_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port bufferDeallocate
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_bufferDeallocate_OutputPorts());
        port++
      ) {
        this->m_bufferDeallocate_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_bufferDeallocate_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_bufferDeallocate_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port comStatusOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_comStatusOut_OutputPorts());
        port++
      ) {
        this->m_comStatusOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_comStatusOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_comStatusOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port dataOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_dataOut_OutputPorts());
        port++
      ) {
        this->m_dataOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_dataOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_dataOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port dataReturnOut
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_dataReturnOut_OutputPorts());
        port++
      ) {
        this->m_dataReturnOut_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_dataReturnOut_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_dataReturnOut_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif

#if !FW_DIRECT_PORT_CALLS
      // Connect output port getApidSeqCount
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_getApidSeqCount_OutputPorts());
        port++
      ) {
        this->m_getApidSeqCount_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
        Fw::ObjectName portName;
        portName.format(
          "%s_getApidSeqCount_OutputPort[%" PRI_FwIndexType "]",
          this->m_objName.toChar(),
          port
        );
        this->m_getApidSeqCount_OutputPort[port].setObjName(portName.toChar());
#endif
      }
#endif
    }

#if !FW_DIRECT_PORT_CALLS

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

    Fw::InputSuccessConditionPort* SpacePacketFramerComponentBase ::
      get_comStatusIn_InputPort(FwIndexType portNum)
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_comStatusIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return &this->m_comStatusIn_InputPort[portNum];
    }

    Svc::InputComDataWithContextPort* SpacePacketFramerComponentBase ::
      get_dataIn_InputPort(FwIndexType portNum)
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return &this->m_dataIn_InputPort[portNum];
    }

    Svc::InputComDataWithContextPort* SpacePacketFramerComponentBase ::
      get_dataReturnIn_InputPort(FwIndexType portNum)
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return &this->m_dataReturnIn_InputPort[portNum];
    }

#endif

#if !FW_DIRECT_PORT_CALLS

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

    void SpacePacketFramerComponentBase ::
      set_logOut_OutputPort(
          FwIndexType portNum,
          Fw::InputLogPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_logOut_OutputPort[portNum].addCallPort(port);
    }

#if FW_ENABLE_TEXT_LOGGING == 1

    void SpacePacketFramerComponentBase ::
      set_logTextOut_OutputPort(
          FwIndexType portNum,
          Fw::InputLogTextPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logTextOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_logTextOut_OutputPort[portNum].addCallPort(port);
    }

#endif

    void SpacePacketFramerComponentBase ::
      set_prmGetOut_OutputPort(
          FwIndexType portNum,
          Fw::InputPrmGetPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_prmGetOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_prmGetOut_OutputPort[portNum].addCallPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_prmSetOut_OutputPort(
          FwIndexType portNum,
          Fw::InputPrmSetPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_prmSetOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_prmSetOut_OutputPort[portNum].addCallPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_timeCaller_OutputPort(
          FwIndexType portNum,
          Fw::InputTimePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_timeCaller_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_timeCaller_OutputPort[portNum].addCallPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_tlmOut_OutputPort(
          FwIndexType portNum,
          Fw::InputTlmPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_tlmOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_tlmOut_OutputPort[portNum].addCallPort(port);
    }

#endif

#if !FW_DIRECT_PORT_CALLS

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

    void SpacePacketFramerComponentBase ::
      set_bufferAllocate_OutputPort(
          FwIndexType portNum,
          Fw::InputBufferGetPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_bufferAllocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_bufferAllocate_OutputPort[portNum].addCallPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_bufferDeallocate_OutputPort(
          FwIndexType portNum,
          Fw::InputBufferSendPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_bufferDeallocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_bufferDeallocate_OutputPort[portNum].addCallPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_comStatusOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSuccessConditionPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_comStatusOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_comStatusOut_OutputPort[portNum].addCallPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_dataOut_OutputPort(
          FwIndexType portNum,
          Svc::InputComDataWithContextPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_dataOut_OutputPort[portNum].addCallPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_dataReturnOut_OutputPort(
          FwIndexType portNum,
          Svc::InputComDataWithContextPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_dataReturnOut_OutputPort[portNum].addCallPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_getApidSeqCount_OutputPort(
          FwIndexType portNum,
          Svc::Ccsds::InputApidSequenceCountPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_getApidSeqCount_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_getApidSeqCount_OutputPort[portNum].addCallPort(port);
    }

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

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

    void SpacePacketFramerComponentBase ::
      set_logOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_logOut_OutputPort[portNum].registerSerialPort(port);
    }

#if FW_ENABLE_TEXT_LOGGING == 1

    void SpacePacketFramerComponentBase ::
      set_logTextOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logTextOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_logTextOut_OutputPort[portNum].registerSerialPort(port);
    }

#endif

    void SpacePacketFramerComponentBase ::
      set_prmSetOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_prmSetOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_prmSetOut_OutputPort[portNum].registerSerialPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_timeCaller_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_timeCaller_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_timeCaller_OutputPort[portNum].registerSerialPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_tlmOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_tlmOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_tlmOut_OutputPort[portNum].registerSerialPort(port);
    }

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

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

    void SpacePacketFramerComponentBase ::
      set_bufferDeallocate_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_bufferDeallocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_bufferDeallocate_OutputPort[portNum].registerSerialPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_comStatusOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_comStatusOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_comStatusOut_OutputPort[portNum].registerSerialPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_dataOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_dataOut_OutputPort[portNum].registerSerialPort(port);
    }

    void SpacePacketFramerComponentBase ::
      set_dataReturnOut_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      this->m_dataReturnOut_OutputPort[portNum].registerSerialPort(port);
    }

#endif

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

    SpacePacketFramerComponentBase ::
      SpacePacketFramerComponentBase(const char* compName) :
        Fw::PassiveComponentBase(compName)
    {
      this->m_NoBufferAvailableThrottle = 0;
    }

    SpacePacketFramerComponentBase ::
      ~SpacePacketFramerComponentBase()
    {

    }

#if !FW_DIRECT_PORT_CALLS

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

    bool SpacePacketFramerComponentBase ::
      isConnected_logOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_logOut_OutputPort[portNum].isConnected();
    }

#if FW_ENABLE_TEXT_LOGGING == 1

    bool SpacePacketFramerComponentBase ::
      isConnected_logTextOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logTextOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_logTextOut_OutputPort[portNum].isConnected();
    }

#endif

    bool SpacePacketFramerComponentBase ::
      isConnected_prmGetOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_prmGetOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_prmGetOut_OutputPort[portNum].isConnected();
    }

    bool SpacePacketFramerComponentBase ::
      isConnected_prmSetOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_prmSetOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_prmSetOut_OutputPort[portNum].isConnected();
    }

    bool SpacePacketFramerComponentBase ::
      isConnected_timeCaller_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_timeCaller_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_timeCaller_OutputPort[portNum].isConnected();
    }

    bool SpacePacketFramerComponentBase ::
      isConnected_tlmOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_tlmOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_tlmOut_OutputPort[portNum].isConnected();
    }

#endif

#if !FW_DIRECT_PORT_CALLS

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

    bool SpacePacketFramerComponentBase ::
      isConnected_bufferAllocate_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_bufferAllocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_bufferAllocate_OutputPort[portNum].isConnected();
    }

    bool SpacePacketFramerComponentBase ::
      isConnected_bufferDeallocate_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_bufferDeallocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_bufferDeallocate_OutputPort[portNum].isConnected();
    }

    bool SpacePacketFramerComponentBase ::
      isConnected_comStatusOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_comStatusOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_comStatusOut_OutputPort[portNum].isConnected();
    }

    bool SpacePacketFramerComponentBase ::
      isConnected_dataOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_dataOut_OutputPort[portNum].isConnected();
    }

    bool SpacePacketFramerComponentBase ::
      isConnected_dataReturnOut_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_dataReturnOut_OutputPort[portNum].isConnected();
    }

    bool SpacePacketFramerComponentBase ::
      isConnected_getApidSeqCount_OutputPort(FwIndexType portNum) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_getApidSeqCount_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return this->m_getApidSeqCount_OutputPort[portNum].isConnected();
    }

#endif

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

    void SpacePacketFramerComponentBase ::
      comStatusIn_handlerBase(
          FwIndexType portNum,
          Fw::Success& condition
      )
    {
      // Make sure port number is valid
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_comStatusIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      // Call handler function
      this->comStatusIn_handler(
        portNum,
        condition
      );
    }

    void SpacePacketFramerComponentBase ::
      dataIn_handlerBase(
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      )
    {
      // Make sure port number is valid
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      // Call handler function
      this->dataIn_handler(
        portNum,
        data,
        context
      );
    }

    void SpacePacketFramerComponentBase ::
      dataReturnIn_handlerBase(
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      )
    {
      // Make sure port number is valid
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      // Call handler function
      this->dataReturnIn_handler(
        portNum,
        data,
        context
      );
    }

#if !FW_DIRECT_PORT_CALLS

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

    Fw::Buffer SpacePacketFramerComponentBase ::
      bufferAllocate_out(
          FwIndexType portNum,
          FwSizeType size
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_bufferAllocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_bufferAllocate_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      return this->m_bufferAllocate_OutputPort[portNum].invoke(
        size
      );
    }

    void SpacePacketFramerComponentBase ::
      bufferDeallocate_out(
          FwIndexType portNum,
          Fw::Buffer& fwBuffer
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_bufferDeallocate_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_bufferDeallocate_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_bufferDeallocate_OutputPort[portNum].invoke(
        fwBuffer
      );
    }

    void SpacePacketFramerComponentBase ::
      comStatusOut_out(
          FwIndexType portNum,
          Fw::Success& condition
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_comStatusOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_comStatusOut_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_comStatusOut_OutputPort[portNum].invoke(
        condition
      );
    }

    void SpacePacketFramerComponentBase ::
      dataOut_out(
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_dataOut_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_dataOut_OutputPort[portNum].invoke(
        data,
        context
      );
    }

    void SpacePacketFramerComponentBase ::
      dataReturnOut_out(
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_dataReturnOut_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_dataReturnOut_OutputPort[portNum].invoke(
        data,
        context
      );
    }

    U16 SpacePacketFramerComponentBase ::
      getApidSeqCount_out(
          FwIndexType portNum,
          const ComCfg::Apid& apid,
          U16 sequenceCount
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_getApidSeqCount_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_getApidSeqCount_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      return this->m_getApidSeqCount_OutputPort[portNum].invoke(
        apid,
        sequenceCount
      );
    }

#endif

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

    void SpacePacketFramerComponentBase ::
      log_WARNING_HI_NoBufferAvailable()
    {
      // Check throttle value
      if (this->m_NoBufferAvailableThrottle >= EVENTID_NOBUFFERAVAILABLE_THROTTLE) {
        return;
      }
      else {
        this->m_NoBufferAvailableThrottle++;
      }

      // Get the time
      Fw::Time _logTime;
      if (this->isConnected_timeCaller_OutputPort(0)) {
        this->timeCaller_out(0, _logTime);
      }

      const FwEventIdType _id = this->getIdBase() + EVENTID_NOBUFFERAVAILABLE;

      // Emit the event on the log port
      if (this->isConnected_logOut_OutputPort(0)) {
        Fw::LogBuffer _logBuff;

#if FW_AMPCS_COMPATIBLE
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;
        // Serialize the number of arguments
        _status = _logBuff.serializeFrom(static_cast<U8>(0));
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif

        this->logOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Failed to allocate a packet buffer: packet dropped";
#else
        const char* _formatString =
          "%s: Failed to allocate a packet buffer: packet dropped";
#endif

        Fw::TextLogString _logString;
        (void) _logString.format(
          _formatString,
#if FW_OBJECT_NAMES == 1
          this->m_objName.toChar(),
#endif
          "NoBufferAvailable "
        );

        this->logTextOut_out(
          0,
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logString
        );
      }
#endif
    }

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

    void SpacePacketFramerComponentBase ::
      log_WARNING_HI_NoBufferAvailable_ThrottleClear()
    {
      // Reset throttle counter
      this->m_NoBufferAvailableThrottle = 0;
    }

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

    Fw::Time SpacePacketFramerComponentBase ::
      getTime() const
    {
      if (this->isConnected_timeCaller_OutputPort(0)) {
        Fw::Time _time;
        this->timeCaller_out(0, _time);
        return _time;
      }
      else {
        return Fw::Time(TimeBase::TB_NONE, 0, 0);
      }
    }

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

    void SpacePacketFramerComponentBase ::
      m_p_comStatusIn_in(
          Fw::PassiveComponentBase* callComp,
          FwIndexType portNum,
          Fw::Success& condition
      )
    {
      FW_ASSERT(callComp != nullptr);
      SpacePacketFramerComponentBase* compPtr = static_cast<SpacePacketFramerComponentBase*>(callComp);
      compPtr->comStatusIn_handlerBase(
        portNum,
        condition
      );
    }

    void SpacePacketFramerComponentBase ::
      m_p_dataIn_in(
          Fw::PassiveComponentBase* callComp,
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      )
    {
      FW_ASSERT(callComp != nullptr);
      SpacePacketFramerComponentBase* compPtr = static_cast<SpacePacketFramerComponentBase*>(callComp);
      compPtr->dataIn_handlerBase(
        portNum,
        data,
        context
      );
    }

    void SpacePacketFramerComponentBase ::
      m_p_dataReturnIn_in(
          Fw::PassiveComponentBase* callComp,
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      )
    {
      FW_ASSERT(callComp != nullptr);
      SpacePacketFramerComponentBase* compPtr = static_cast<SpacePacketFramerComponentBase*>(callComp);
      compPtr->dataReturnIn_handlerBase(
        portNum,
        data,
        context
      );
    }

#if !FW_DIRECT_PORT_CALLS

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

    void SpacePacketFramerComponentBase ::
      logOut_out(
          FwIndexType portNum,
          FwEventIdType id,
          Fw::Time& timeTag,
          const Fw::LogSeverity& severity,
          Fw::LogBuffer& args
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_logOut_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_logOut_OutputPort[portNum].invoke(
        id,
        timeTag,
        severity,
        args
      );
    }

#if FW_ENABLE_TEXT_LOGGING

    void SpacePacketFramerComponentBase ::
      logTextOut_out(
          FwIndexType portNum,
          FwEventIdType id,
          Fw::Time& timeTag,
          const Fw::LogSeverity& severity,
          Fw::TextLogString& text
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logTextOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_logTextOut_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_logTextOut_OutputPort[portNum].invoke(
        id,
        timeTag,
        severity,
        text
      );
    }

#endif

    void SpacePacketFramerComponentBase ::
      timeCaller_out(
          FwIndexType portNum,
          Fw::Time& time
      ) const
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_timeCaller_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      FW_ASSERT(
        this->m_timeCaller_OutputPort[portNum].isConnected(),
        static_cast<FwAssertArgType>(portNum)
      );
      this->m_timeCaller_OutputPort[portNum].invoke(
        time
      );
    }

#endif

  }

}