SpacePacketDeframerComponentAc.cpp

Go to the documentation of this file.

// ======================================================================
// \title  SpacePacketDeframerComponentAc.cpp
// \author Generated by fpp-to-cpp
// \brief  cpp file for SpacePacketDeframer 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/SpacePacketDeframer/SpacePacketDeframerComponentAc.hpp"

namespace Svc {

  namespace Ccsds {

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

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

      // 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
      }

      // 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
      }

      // 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
      }

#if FW_ENABLE_TEXT_LOGGING == 1
      // 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

      // 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
      }

      // 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
      }

      // 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
      }

      // 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
      }

      // 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
      }

      // 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
      }

      // Connect output port errorNotify
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_errorNotify_OutputPorts());
        port++
      ) {
        this->m_errorNotify_OutputPort[port].init();

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

      // Connect output port validateApidSeqCount
      for (
        FwIndexType port = 0;
        port < static_cast<FwIndexType>(this->getNum_validateApidSeqCount_OutputPorts());
        port++
      ) {
        this->m_validateApidSeqCount_OutputPort[port].init();

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

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

    Svc::InputComDataWithContextPort* SpacePacketDeframerComponentBase ::
      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* SpacePacketDeframerComponentBase ::
      get_dataReturnIn_InputPort(FwIndexType portNum)
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_dataReturnIn_InputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

      return &this->m_dataReturnIn_InputPort[portNum];
    }

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

    void SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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);
    }

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

    void SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      set_errorNotify_OutputPort(
          FwIndexType portNum,
          Svc::Ccsds::InputErrorNotifyPort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_errorNotify_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

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

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

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

#if FW_PORT_SERIALIZATION

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

    void SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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_PORT_SERIALIZATION

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

    void SpacePacketDeframerComponentBase ::
      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 SpacePacketDeframerComponentBase ::
      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);
    }

    void SpacePacketDeframerComponentBase ::
      set_errorNotify_OutputPort(
          FwIndexType portNum,
          Fw::InputSerializePort* port
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_errorNotify_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

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

#endif

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

    SpacePacketDeframerComponentBase ::
      SpacePacketDeframerComponentBase(const char* compName) :
        Fw::PassiveComponentBase(compName)
    {

    }

    SpacePacketDeframerComponentBase ::
      ~SpacePacketDeframerComponentBase()
    {

    }

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

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_dataIn_InputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_dataIn_InputPort));
    }

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_dataReturnIn_InputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_dataReturnIn_InputPort));
    }

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

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_logOut_OutputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_logOut_OutputPort));
    }

#if FW_ENABLE_TEXT_LOGGING == 1

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_logTextOut_OutputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_logTextOut_OutputPort));
    }

#endif

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_prmGetOut_OutputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_prmGetOut_OutputPort));
    }

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_prmSetOut_OutputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_prmSetOut_OutputPort));
    }

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_timeCaller_OutputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_timeCaller_OutputPort));
    }

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_tlmOut_OutputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_tlmOut_OutputPort));
    }

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

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_dataOut_OutputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_dataOut_OutputPort));
    }

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_dataReturnOut_OutputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_dataReturnOut_OutputPort));
    }

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_errorNotify_OutputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_errorNotify_OutputPort));
    }

    FwIndexType SpacePacketDeframerComponentBase ::
      getNum_validateApidSeqCount_OutputPorts() const
    {
      return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_validateApidSeqCount_OutputPort));
    }

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

    bool SpacePacketDeframerComponentBase ::
      isConnected_logOut_OutputPort(FwIndexType portNum)
    {
      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 SpacePacketDeframerComponentBase ::
      isConnected_logTextOut_OutputPort(FwIndexType portNum)
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_logTextOut_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

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

#endif

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

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

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

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

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

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

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

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

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

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

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

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

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

    bool SpacePacketDeframerComponentBase ::
      isConnected_errorNotify_OutputPort(FwIndexType portNum)
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_errorNotify_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

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

    bool SpacePacketDeframerComponentBase ::
      isConnected_validateApidSeqCount_OutputPort(FwIndexType portNum)
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_validateApidSeqCount_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

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

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

    void SpacePacketDeframerComponentBase ::
      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)
      );

      // Lock guard mutex before calling
      this->lock();

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

      // Unlock guard mutex
      this->unLock();
    }

    void SpacePacketDeframerComponentBase ::
      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
      );
    }

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

    void SpacePacketDeframerComponentBase ::
      dataOut_out(
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      )
    {
      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 SpacePacketDeframerComponentBase ::
      dataReturnOut_out(
          FwIndexType portNum,
          Fw::Buffer& data,
          const ComCfg::FrameContext& context
      )
    {
      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
      );
    }

    void SpacePacketDeframerComponentBase ::
      errorNotify_out(
          FwIndexType portNum,
          const Svc::Ccsds::FrameError& errorCode
      )
    {
      FW_ASSERT(
        (0 <= portNum) && (portNum < this->getNum_errorNotify_OutputPorts()),
        static_cast<FwAssertArgType>(portNum)
      );

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

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

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

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

    void SpacePacketDeframerComponentBase ::
      log_WARNING_HI_InvalidLength(
          U16 transmitted,
          FwSizeType actual
      ) const
    {
      // Get the time
      Fw::Time _logTime;
      if (this->m_timeCaller_OutputPort[0].isConnected()) {
        this->m_timeCaller_OutputPort[0].invoke(_logTime);
      }

      FwEventIdType _id = static_cast<FwEventIdType>(0);

      _id = this->getIdBase() + EVENTID_INVALIDLENGTH;

      // Emit the event on the log port
      if (this->m_logOut_OutputPort[0].isConnected()) {
        Fw::LogBuffer _logBuff;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

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

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(U16))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(transmitted);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

#if FW_AMPCS_COMPATIBLE
        // Serialize the argument size
        _status = _logBuff.serializeFrom(
          static_cast<U8>(sizeof(FwSizeType))
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );
#endif
        _status = _logBuff.serializeFrom(actual);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        this->m_logOut_OutputPort[0].invoke(
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logBuff
        );
      }

      // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
      if (this->m_logTextOut_OutputPort[0].isConnected()) {
#if FW_OBJECT_NAMES == 1
        const char* _formatString =
          "(%s) %s: Invalid length received. Header specified packet byte size of %" PRIu16 " | Actual received data length: %" PRIu64 "";
#else
        const char* _formatString =
          "%s: Invalid length received. Header specified packet byte size of %" PRIu16 " | Actual received data length: %" PRIu64 "";
#endif

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

        this->m_logTextOut_OutputPort[0].invoke(
          _id,
          _logTime,
          Fw::LogSeverity::WARNING_HI,
          _logString
        );
      }
#endif
    }

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

    Fw::Time SpacePacketDeframerComponentBase ::
      getTime() const
    {
      if (this->m_timeCaller_OutputPort[0].isConnected()) {
        Fw::Time _time;
        this->m_timeCaller_OutputPort[0].invoke(_time);
        return _time;
      }
      else {
        return Fw::Time(TimeBase::TB_NONE, 0, 0);
      }
    }

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

    void SpacePacketDeframerComponentBase ::
      lock()
    {
      this->m_guardedPortMutex.lock();
    }

    void SpacePacketDeframerComponentBase ::
      unLock()
    {
      this->m_guardedPortMutex.unLock();
    }

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

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

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

  }

}