CfdpManagerComponentAc.cpp

Go to the documentation of this file.

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

#include "Fw/Prm/ParamValid.hpp"
#include "Fw/Types/Assert.hpp"
#include "Fw/Types/ExternalString.hpp"
#if FW_ENABLE_TEXT_LOGGING
#include "Fw/Types/String.hpp"
#endif
#include "Svc/Ccsds/CfdpManager/CfdpManagerComponentAc.hpp"

namespace Svc {

  namespace Ccsds {

    namespace Cfdp {

      namespace {
        enum MsgTypeEnum {
          CFDPMANAGER_COMPONENT_EXIT = Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT,
          DATAIN_BUFFERSEND,
          DATARETURNIN_BUFFERSEND,
          PINGIN_PING,
          RUN1HZ_SCHED,
          CMD_SENDFILE,
          CMD_PLAYBACKDIRECTORY,
          CMD_POLLDIRECTORY,
          CMD_STOPPOLLDIRECTORY,
          CMD_SETCHANNELFLOW,
          CMD_SUSPENDRESUMETRANSACTION,
          CMD_CANCELTRANSACTION,
          CMD_ABANDONTRANSACTION,
          CMD_RESETCOUNTERS,
        };

        // Get the max size by constructing a union of the async input, command, and
        // internal port serialization sizes
        union BuffUnion {
          BYTE dataInPortSize[Fw::BufferSendPortBuffer::CAPACITY];
          BYTE dataReturnInPortSize[Fw::BufferSendPortBuffer::CAPACITY];
          BYTE pingInPortSize[Svc::PingPortBuffer::CAPACITY];
          BYTE run1HzPortSize[Svc::SchedPortBuffer::CAPACITY];
          BYTE cmdPortSize[Fw::CmdPortBuffer::CAPACITY];
        };

        // Define a message buffer class large enough to handle all the
        // asynchronous inputs to the component
        class ComponentIpcSerializableBuffer :
          public Fw::LinearBufferBase
        {

          public:

            enum {
              // Offset into data in buffer: Size of message ID and port number
              DATA_OFFSET = sizeof(FwEnumStoreType) + sizeof(FwIndexType),
              // Max data size
              MAX_DATA_SIZE = sizeof(BuffUnion),
              // Max message size: Size of message id + size of port + max data size
              SERIALIZATION_SIZE = DATA_OFFSET + MAX_DATA_SIZE
            };

            ComponentIpcSerializableBuffer() : Fw::LinearBufferBase(m_buff, sizeof(m_buff)) {

            }

          private:
            // Should be the max of all the input ports serialized sizes...
            U8 m_buff[SERIALIZATION_SIZE];

        };
      }

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

      void CfdpManagerComponentBase ::
        init(
            FwSizeType queueDepth,
            FwEnumStoreType instance
        )
      {
        // Initialize base class
        Fw::ActiveComponentBase::init(instance);

#if !FW_DIRECT_PORT_CALLS
        // Connect input port cmdIn
        for (
          FwIndexType port = 0;
          port < static_cast<FwIndexType>(this->getNum_cmdIn_InputPorts());
          port++
        ) {
          this->m_cmdIn_InputPort[port].init();
          this->m_cmdIn_InputPort[port].addCallComp(
            this,
            m_p_cmdIn_in
          );
          this->m_cmdIn_InputPort[port].setPortNum(port);

#if FW_OBJECT_NAMES == 1
          Fw::ObjectName portName;
          portName.format(
            "%s_cmdIn_InputPort[%" PRI_FwIndexType "]",
            this->m_objName.toChar(),
            port
          );
          this->m_cmdIn_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 input port fileIn
        for (
          FwIndexType port = 0;
          port < static_cast<FwIndexType>(this->getNum_fileIn_InputPorts());
          port++
        ) {
          this->m_fileIn_InputPort[port].init();
          this->m_fileIn_InputPort[port].addCallComp(
            this,
            m_p_fileIn_in
          );
          this->m_fileIn_InputPort[port].setPortNum(port);

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

#if !FW_DIRECT_PORT_CALLS
        // Connect input port pingIn
        for (
          FwIndexType port = 0;
          port < static_cast<FwIndexType>(this->getNum_pingIn_InputPorts());
          port++
        ) {
          this->m_pingIn_InputPort[port].init();
          this->m_pingIn_InputPort[port].addCallComp(
            this,
            m_p_pingIn_in
          );
          this->m_pingIn_InputPort[port].setPortNum(port);

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

#if !FW_DIRECT_PORT_CALLS
        // Connect input port run1Hz
        for (
          FwIndexType port = 0;
          port < static_cast<FwIndexType>(this->getNum_run1Hz_InputPorts());
          port++
        ) {
          this->m_run1Hz_InputPort[port].init();
          this->m_run1Hz_InputPort[port].addCallComp(
            this,
            m_p_run1Hz_in
          );
          this->m_run1Hz_InputPort[port].setPortNum(port);

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

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

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

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

#if FW_OBJECT_NAMES == 1
          Fw::ObjectName portName;
          portName.format(
            "%s_cmdResponseOut_OutputPort[%" PRI_FwIndexType "]",
            this->m_objName.toChar(),
            port
          );
          this->m_cmdResponseOut_OutputPort[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 dataInReturn
        for (
          FwIndexType port = 0;
          port < static_cast<FwIndexType>(this->getNum_dataInReturn_OutputPorts());
          port++
        ) {
          this->m_dataInReturn_OutputPort[port].init();

#if FW_OBJECT_NAMES == 1
          Fw::ObjectName portName;
          portName.format(
            "%s_dataInReturn_OutputPort[%" PRI_FwIndexType "]",
            this->m_objName.toChar(),
            port
          );
          this->m_dataInReturn_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 fileDoneOut
        for (
          FwIndexType port = 0;
          port < static_cast<FwIndexType>(this->getNum_fileDoneOut_OutputPorts());
          port++
        ) {
          this->m_fileDoneOut_OutputPort[port].init();

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

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

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

        // Create the queue
        Os::Queue::Status qStat = this->createQueue(
          queueDepth,
          static_cast<FwSizeType>(ComponentIpcSerializableBuffer::SERIALIZATION_SIZE)
        );
        FW_ASSERT(
          Os::Queue::Status::OP_OK == qStat,
          static_cast<FwAssertArgType>(qStat)
        );
      }

#if !FW_DIRECT_PORT_CALLS

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

      Fw::InputCmdPort* CfdpManagerComponentBase ::
        get_cmdIn_InputPort(FwIndexType portNum)
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_cmdIn_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        return &this->m_cmdIn_InputPort[portNum];
      }

#endif

#if !FW_DIRECT_PORT_CALLS

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

      Fw::InputBufferSendPort* CfdpManagerComponentBase ::
        get_dataIn_InputPort(FwIndexType portNum)
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_dataIn_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        return &this->m_dataIn_InputPort[portNum];
      }

      Fw::InputBufferSendPort* CfdpManagerComponentBase ::
        get_dataReturnIn_InputPort(FwIndexType portNum)
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_dataReturnIn_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        return &this->m_dataReturnIn_InputPort[portNum];
      }

      Svc::InputSendFileRequestPort* CfdpManagerComponentBase ::
        get_fileIn_InputPort(FwIndexType portNum)
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_fileIn_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        return &this->m_fileIn_InputPort[portNum];
      }

      Svc::InputPingPort* CfdpManagerComponentBase ::
        get_pingIn_InputPort(FwIndexType portNum)
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_pingIn_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        return &this->m_pingIn_InputPort[portNum];
      }

      Svc::InputSchedPort* CfdpManagerComponentBase ::
        get_run1Hz_InputPort(FwIndexType portNum)
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_run1Hz_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        return &this->m_run1Hz_InputPort[portNum];
      }

#endif

#if !FW_DIRECT_PORT_CALLS

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

      void CfdpManagerComponentBase ::
        set_cmdRegOut_OutputPort(
            FwIndexType portNum,
            Fw::InputCmdRegPort* port
        )
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_cmdRegOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      void CfdpManagerComponentBase ::
        set_cmdResponseOut_OutputPort(
            FwIndexType portNum,
            Fw::InputCmdResponsePort* port
        )
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_cmdResponseOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      void CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        set_dataInReturn_OutputPort(
            FwIndexType portNum,
            Fw::InputBufferSendPort* port
        )
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_dataInReturn_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

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

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

      void CfdpManagerComponentBase ::
        set_fileDoneOut_OutputPort(
            FwIndexType portNum,
            Svc::InputSendFileCompletePort* port
        )
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_fileDoneOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      void CfdpManagerComponentBase ::
        set_pingOut_OutputPort(
            FwIndexType portNum,
            Svc::InputPingPort* port
        )
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_pingOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

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

      void CfdpManagerComponentBase ::
        set_cmdRegOut_OutputPort(
            FwIndexType portNum,
            Fw::InputSerializePort* port
        )
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_cmdRegOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      void CfdpManagerComponentBase ::
        set_cmdResponseOut_OutputPort(
            FwIndexType portNum,
            Fw::InputSerializePort* port
        )
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_cmdResponseOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      void CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        set_dataInReturn_OutputPort(
            FwIndexType portNum,
            Fw::InputSerializePort* port
        )
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_dataInReturn_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      void CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        set_fileDoneOut_OutputPort(
            FwIndexType portNum,
            Fw::InputSerializePort* port
        )
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_fileDoneOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      void CfdpManagerComponentBase ::
        set_pingOut_OutputPort(
            FwIndexType portNum,
            Fw::InputSerializePort* port
        )
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_pingOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

#endif

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

      void CfdpManagerComponentBase ::
        regCommands()
      {
        FW_ASSERT(this->isConnected_cmdRegOut_OutputPort(0));

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_SENDFILE
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_PLAYBACKDIRECTORY
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_POLLDIRECTORY
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_STOPPOLLDIRECTORY
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_SETCHANNELFLOW
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_SUSPENDRESUMETRANSACTION
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_CANCELTRANSACTION
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_ABANDONTRANSACTION
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_RESETCOUNTERS
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_LOCALEID_SET
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_LOCALEID_SAVE
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_OUTGOINGFILECHUNKSIZE_SET
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_OUTGOINGFILECHUNKSIZE_SAVE
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_RXCRCCALCBYTESPERCYCLE_SET
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_RXCRCCALCBYTESPERCYCLE_SAVE
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_POSTINACTIVITYSENDRETRIES_SET
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_POSTINACTIVITYSENDRETRIES_SAVE
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_FILEINDEFAULTCHANNEL_SET
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_FILEINDEFAULTCHANNEL_SAVE
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_FILEINDEFAULTDESTENTITYID_SET
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_FILEINDEFAULTDESTENTITYID_SAVE
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_FILEINDEFAULTCLASS_SET
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_FILEINDEFAULTCLASS_SAVE
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_FILEINDEFAULTKEEP_SET
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_FILEINDEFAULTKEEP_SAVE
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_FILEINDEFAULTPRIORITY_SET
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_FILEINDEFAULTPRIORITY_SAVE
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_CHANNELCONFIG_SET
        );

        this->cmdRegOut_out(
          0,
          this->getIdBase() + OPCODE_CHANNELCONFIG_SAVE
        );
      }

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

      void CfdpManagerComponentBase ::
        loadParameters()
      {
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK;
        const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());
        FW_ASSERT(this->isConnected_prmGetOut_OutputPort(0));

        FwPrmIdType _id{};
        Fw::ParamBuffer _paramBuffer;

        _id = _baseId + PARAMID_LOCALEID;

        // Get serialized parameter LocalEid
        this->m_param_LocalEid_valid = this->prmGetOut_out(
          0,
          _id,
          _paramBuffer
        );

        this->m_paramLock.lock();

        // Deserialize parameter or use default value
        if (this->m_param_LocalEid_valid == Fw::ParamValid::VALID) {
          _stat = _paramBuffer.deserializeTo(this->m_LocalEid);
          if (_stat != Fw::FW_SERIALIZE_OK) {
            this->m_param_LocalEid_valid = Fw::ParamValid::DEFAULT;
          }
        }
        else {
          this->m_param_LocalEid_valid = Fw::ParamValid::DEFAULT;
        }
        if (this->m_param_LocalEid_valid == Fw::ParamValid::DEFAULT) {
          this->m_LocalEid = 42;
        }

        this->m_paramLock.unlock();
        this->parameterLoaded(PARAMID_LOCALEID, this->m_param_LocalEid_valid);

        _id = _baseId + PARAMID_OUTGOINGFILECHUNKSIZE;

        // Get serialized parameter OutgoingFileChunkSize
        this->m_param_OutgoingFileChunkSize_valid = this->prmGetOut_out(
          0,
          _id,
          _paramBuffer
        );

        this->m_paramLock.lock();

        // Deserialize parameter or use default value
        if (this->m_param_OutgoingFileChunkSize_valid == Fw::ParamValid::VALID) {
          _stat = _paramBuffer.deserializeTo(this->m_OutgoingFileChunkSize);
          if (_stat != Fw::FW_SERIALIZE_OK) {
            this->m_param_OutgoingFileChunkSize_valid = Fw::ParamValid::DEFAULT;
          }
        }
        else {
          this->m_param_OutgoingFileChunkSize_valid = Fw::ParamValid::DEFAULT;
        }
        if (this->m_param_OutgoingFileChunkSize_valid == Fw::ParamValid::DEFAULT) {
          this->m_OutgoingFileChunkSize = 992;
        }

        this->m_paramLock.unlock();
        this->parameterLoaded(PARAMID_OUTGOINGFILECHUNKSIZE, this->m_param_OutgoingFileChunkSize_valid);

        _id = _baseId + PARAMID_RXCRCCALCBYTESPERCYCLE;

        // Get serialized parameter RxCrcCalcBytesPerCycle
        this->m_param_RxCrcCalcBytesPerCycle_valid = this->prmGetOut_out(
          0,
          _id,
          _paramBuffer
        );

        this->m_paramLock.lock();

        // Deserialize parameter or use default value
        if (this->m_param_RxCrcCalcBytesPerCycle_valid == Fw::ParamValid::VALID) {
          _stat = _paramBuffer.deserializeTo(this->m_RxCrcCalcBytesPerCycle);
          if (_stat != Fw::FW_SERIALIZE_OK) {
            this->m_param_RxCrcCalcBytesPerCycle_valid = Fw::ParamValid::DEFAULT;
          }
        }
        else {
          this->m_param_RxCrcCalcBytesPerCycle_valid = Fw::ParamValid::DEFAULT;
        }
        if (this->m_param_RxCrcCalcBytesPerCycle_valid == Fw::ParamValid::DEFAULT) {
          this->m_RxCrcCalcBytesPerCycle = 65536;
        }

        this->m_paramLock.unlock();
        this->parameterLoaded(PARAMID_RXCRCCALCBYTESPERCYCLE, this->m_param_RxCrcCalcBytesPerCycle_valid);

        _id = _baseId + PARAMID_POSTINACTIVITYSENDRETRIES;

        // Get serialized parameter PostInactivitySendRetries
        this->m_param_PostInactivitySendRetries_valid = this->prmGetOut_out(
          0,
          _id,
          _paramBuffer
        );

        this->m_paramLock.lock();

        // Deserialize parameter or use default value
        if (this->m_param_PostInactivitySendRetries_valid == Fw::ParamValid::VALID) {
          _stat = _paramBuffer.deserializeTo(this->m_PostInactivitySendRetries);
          if (_stat != Fw::FW_SERIALIZE_OK) {
            this->m_param_PostInactivitySendRetries_valid = Fw::ParamValid::DEFAULT;
          }
        }
        else {
          this->m_param_PostInactivitySendRetries_valid = Fw::ParamValid::DEFAULT;
        }
        if (this->m_param_PostInactivitySendRetries_valid == Fw::ParamValid::DEFAULT) {
          this->m_PostInactivitySendRetries = 3;
        }

        this->m_paramLock.unlock();
        this->parameterLoaded(PARAMID_POSTINACTIVITYSENDRETRIES, this->m_param_PostInactivitySendRetries_valid);

        _id = _baseId + PARAMID_FILEINDEFAULTCHANNEL;

        // Get serialized parameter FileInDefaultChannel
        this->m_param_FileInDefaultChannel_valid = this->prmGetOut_out(
          0,
          _id,
          _paramBuffer
        );

        this->m_paramLock.lock();

        // Deserialize parameter or use default value
        if (this->m_param_FileInDefaultChannel_valid == Fw::ParamValid::VALID) {
          _stat = _paramBuffer.deserializeTo(this->m_FileInDefaultChannel);
          if (_stat != Fw::FW_SERIALIZE_OK) {
            this->m_param_FileInDefaultChannel_valid = Fw::ParamValid::DEFAULT;
          }
        }
        else {
          this->m_param_FileInDefaultChannel_valid = Fw::ParamValid::DEFAULT;
        }
        if (this->m_param_FileInDefaultChannel_valid == Fw::ParamValid::DEFAULT) {
          this->m_FileInDefaultChannel = 0;
        }

        this->m_paramLock.unlock();
        this->parameterLoaded(PARAMID_FILEINDEFAULTCHANNEL, this->m_param_FileInDefaultChannel_valid);

        _id = _baseId + PARAMID_FILEINDEFAULTDESTENTITYID;

        // Get serialized parameter FileInDefaultDestEntityId
        this->m_param_FileInDefaultDestEntityId_valid = this->prmGetOut_out(
          0,
          _id,
          _paramBuffer
        );

        this->m_paramLock.lock();

        // Deserialize parameter or use default value
        if (this->m_param_FileInDefaultDestEntityId_valid == Fw::ParamValid::VALID) {
          _stat = _paramBuffer.deserializeTo(this->m_FileInDefaultDestEntityId);
          if (_stat != Fw::FW_SERIALIZE_OK) {
            this->m_param_FileInDefaultDestEntityId_valid = Fw::ParamValid::DEFAULT;
          }
        }
        else {
          this->m_param_FileInDefaultDestEntityId_valid = Fw::ParamValid::DEFAULT;
        }
        if (this->m_param_FileInDefaultDestEntityId_valid == Fw::ParamValid::DEFAULT) {
          this->m_FileInDefaultDestEntityId = 100;
        }

        this->m_paramLock.unlock();
        this->parameterLoaded(PARAMID_FILEINDEFAULTDESTENTITYID, this->m_param_FileInDefaultDestEntityId_valid);

        _id = _baseId + PARAMID_FILEINDEFAULTCLASS;

        // Get serialized parameter FileInDefaultClass
        this->m_param_FileInDefaultClass_valid = this->prmGetOut_out(
          0,
          _id,
          _paramBuffer
        );

        this->m_paramLock.lock();

        // Deserialize parameter or use default value
        if (this->m_param_FileInDefaultClass_valid == Fw::ParamValid::VALID) {
          _stat = _paramBuffer.deserializeTo(this->m_FileInDefaultClass);
          if (_stat != Fw::FW_SERIALIZE_OK) {
            this->m_param_FileInDefaultClass_valid = Fw::ParamValid::DEFAULT;
          }
        }
        else {
          this->m_param_FileInDefaultClass_valid = Fw::ParamValid::DEFAULT;
        }
        if (this->m_param_FileInDefaultClass_valid == Fw::ParamValid::DEFAULT) {
          this->m_FileInDefaultClass = Svc::Ccsds::Cfdp::Class::CLASS_2;
        }

        this->m_paramLock.unlock();
        this->parameterLoaded(PARAMID_FILEINDEFAULTCLASS, this->m_param_FileInDefaultClass_valid);

        _id = _baseId + PARAMID_FILEINDEFAULTKEEP;

        // Get serialized parameter FileInDefaultKeep
        this->m_param_FileInDefaultKeep_valid = this->prmGetOut_out(
          0,
          _id,
          _paramBuffer
        );

        this->m_paramLock.lock();

        // Deserialize parameter or use default value
        if (this->m_param_FileInDefaultKeep_valid == Fw::ParamValid::VALID) {
          _stat = _paramBuffer.deserializeTo(this->m_FileInDefaultKeep);
          if (_stat != Fw::FW_SERIALIZE_OK) {
            this->m_param_FileInDefaultKeep_valid = Fw::ParamValid::DEFAULT;
          }
        }
        else {
          this->m_param_FileInDefaultKeep_valid = Fw::ParamValid::DEFAULT;
        }
        if (this->m_param_FileInDefaultKeep_valid == Fw::ParamValid::DEFAULT) {
          this->m_FileInDefaultKeep = Svc::Ccsds::Cfdp::Keep::DELETE;
        }

        this->m_paramLock.unlock();
        this->parameterLoaded(PARAMID_FILEINDEFAULTKEEP, this->m_param_FileInDefaultKeep_valid);

        _id = _baseId + PARAMID_FILEINDEFAULTPRIORITY;

        // Get serialized parameter FileInDefaultPriority
        this->m_param_FileInDefaultPriority_valid = this->prmGetOut_out(
          0,
          _id,
          _paramBuffer
        );

        this->m_paramLock.lock();

        // Deserialize parameter or use default value
        if (this->m_param_FileInDefaultPriority_valid == Fw::ParamValid::VALID) {
          _stat = _paramBuffer.deserializeTo(this->m_FileInDefaultPriority);
          if (_stat != Fw::FW_SERIALIZE_OK) {
            this->m_param_FileInDefaultPriority_valid = Fw::ParamValid::DEFAULT;
          }
        }
        else {
          this->m_param_FileInDefaultPriority_valid = Fw::ParamValid::DEFAULT;
        }
        if (this->m_param_FileInDefaultPriority_valid == Fw::ParamValid::DEFAULT) {
          this->m_FileInDefaultPriority = 0;
        }

        this->m_paramLock.unlock();
        this->parameterLoaded(PARAMID_FILEINDEFAULTPRIORITY, this->m_param_FileInDefaultPriority_valid);

        _id = _baseId + PARAMID_CHANNELCONFIG;

        // Get serialized parameter ChannelConfig
        this->m_param_ChannelConfig_valid = this->prmGetOut_out(
          0,
          _id,
          _paramBuffer
        );

        this->m_paramLock.lock();

        // Deserialize parameter or use default value
        if (this->m_param_ChannelConfig_valid == Fw::ParamValid::VALID) {
          _stat = _paramBuffer.deserializeTo(this->m_ChannelConfig);
          if (_stat != Fw::FW_SERIALIZE_OK) {
            this->m_param_ChannelConfig_valid = Fw::ParamValid::DEFAULT;
          }
        }
        else {
          this->m_param_ChannelConfig_valid = Fw::ParamValid::DEFAULT;
        }
        if (this->m_param_ChannelConfig_valid == Fw::ParamValid::DEFAULT) {
          this->m_ChannelConfig = Svc::Ccsds::Cfdp::ChannelArrayParams(Svc::Ccsds::Cfdp::ChannelParams(10, 10, 2, 120, Fw::Enabled::ENABLED, Fw::String(""), 64, Fw::String("/tmp"), Fw::String("/fail")));
        }

        this->m_paramLock.unlock();
        this->parameterLoaded(PARAMID_CHANNELCONFIG, this->m_param_ChannelConfig_valid);

        // Call notifier
        this->parametersLoaded();
      }

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

      CfdpManagerComponentBase ::
        CfdpManagerComponentBase(const char* compName) :
          Fw::ActiveComponentBase(compName)
      {

      }

      CfdpManagerComponentBase ::
        ~CfdpManagerComponentBase()
      {

      }

#if !FW_DIRECT_PORT_CALLS

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

      bool CfdpManagerComponentBase ::
        isConnected_cmdRegOut_OutputPort(FwIndexType portNum) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_cmdRegOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      bool CfdpManagerComponentBase ::
        isConnected_cmdResponseOut_OutputPort(FwIndexType portNum) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_cmdResponseOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      bool CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        isConnected_dataInReturn_OutputPort(FwIndexType portNum) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_dataInReturn_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      bool CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        isConnected_fileDoneOut_OutputPort(FwIndexType portNum) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_fileDoneOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      bool CfdpManagerComponentBase ::
        isConnected_pingOut_OutputPort(FwIndexType portNum) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_pingOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

#endif

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

      void CfdpManagerComponentBase ::
        cmdIn_handlerBase(
            FwIndexType portNum,
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {

        const U32 idBase = this->getIdBase();
        FW_ASSERT(opCode >= idBase, static_cast<FwAssertArgType>(opCode), static_cast<FwAssertArgType>(idBase));

        // Select base class function based on opcode
        switch (opCode - idBase) {
          case OPCODE_SENDFILE: {
            this->SendFile_cmdHandlerBase(
              opCode,
              cmdSeq,
              args
            );
            break;
          }

          case OPCODE_PLAYBACKDIRECTORY: {
            this->PlaybackDirectory_cmdHandlerBase(
              opCode,
              cmdSeq,
              args
            );
            break;
          }

          case OPCODE_POLLDIRECTORY: {
            this->PollDirectory_cmdHandlerBase(
              opCode,
              cmdSeq,
              args
            );
            break;
          }

          case OPCODE_STOPPOLLDIRECTORY: {
            this->StopPollDirectory_cmdHandlerBase(
              opCode,
              cmdSeq,
              args
            );
            break;
          }

          case OPCODE_SETCHANNELFLOW: {
            this->SetChannelFlow_cmdHandlerBase(
              opCode,
              cmdSeq,
              args
            );
            break;
          }

          case OPCODE_SUSPENDRESUMETRANSACTION: {
            this->SuspendResumeTransaction_cmdHandlerBase(
              opCode,
              cmdSeq,
              args
            );
            break;
          }

          case OPCODE_CANCELTRANSACTION: {
            this->CancelTransaction_cmdHandlerBase(
              opCode,
              cmdSeq,
              args
            );
            break;
          }

          case OPCODE_ABANDONTRANSACTION: {
            this->AbandonTransaction_cmdHandlerBase(
              opCode,
              cmdSeq,
              args
            );
            break;
          }

          case OPCODE_RESETCOUNTERS: {
            this->ResetCounters_cmdHandlerBase(
              opCode,
              cmdSeq,
              args
            );
            break;
          }

          case OPCODE_LOCALEID_SET: {
            Fw::CmdResponse _cstat = this->paramSet_LocalEid(args);
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_LOCALEID_SAVE: {
            Fw::CmdResponse _cstat = this->paramSave_LocalEid();
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_OUTGOINGFILECHUNKSIZE_SET: {
            Fw::CmdResponse _cstat = this->paramSet_OutgoingFileChunkSize(args);
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_OUTGOINGFILECHUNKSIZE_SAVE: {
            Fw::CmdResponse _cstat = this->paramSave_OutgoingFileChunkSize();
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_RXCRCCALCBYTESPERCYCLE_SET: {
            Fw::CmdResponse _cstat = this->paramSet_RxCrcCalcBytesPerCycle(args);
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_RXCRCCALCBYTESPERCYCLE_SAVE: {
            Fw::CmdResponse _cstat = this->paramSave_RxCrcCalcBytesPerCycle();
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_POSTINACTIVITYSENDRETRIES_SET: {
            Fw::CmdResponse _cstat = this->paramSet_PostInactivitySendRetries(args);
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_POSTINACTIVITYSENDRETRIES_SAVE: {
            Fw::CmdResponse _cstat = this->paramSave_PostInactivitySendRetries();
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_FILEINDEFAULTCHANNEL_SET: {
            Fw::CmdResponse _cstat = this->paramSet_FileInDefaultChannel(args);
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_FILEINDEFAULTCHANNEL_SAVE: {
            Fw::CmdResponse _cstat = this->paramSave_FileInDefaultChannel();
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_FILEINDEFAULTDESTENTITYID_SET: {
            Fw::CmdResponse _cstat = this->paramSet_FileInDefaultDestEntityId(args);
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_FILEINDEFAULTDESTENTITYID_SAVE: {
            Fw::CmdResponse _cstat = this->paramSave_FileInDefaultDestEntityId();
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_FILEINDEFAULTCLASS_SET: {
            Fw::CmdResponse _cstat = this->paramSet_FileInDefaultClass(args);
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_FILEINDEFAULTCLASS_SAVE: {
            Fw::CmdResponse _cstat = this->paramSave_FileInDefaultClass();
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_FILEINDEFAULTKEEP_SET: {
            Fw::CmdResponse _cstat = this->paramSet_FileInDefaultKeep(args);
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_FILEINDEFAULTKEEP_SAVE: {
            Fw::CmdResponse _cstat = this->paramSave_FileInDefaultKeep();
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_FILEINDEFAULTPRIORITY_SET: {
            Fw::CmdResponse _cstat = this->paramSet_FileInDefaultPriority(args);
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_FILEINDEFAULTPRIORITY_SAVE: {
            Fw::CmdResponse _cstat = this->paramSave_FileInDefaultPriority();
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_CHANNELCONFIG_SET: {
            Fw::CmdResponse _cstat = this->paramSet_ChannelConfig(args);
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }

          case OPCODE_CHANNELCONFIG_SAVE: {
            Fw::CmdResponse _cstat = this->paramSave_ChannelConfig();
            this->cmdResponse_out(
              opCode,
              cmdSeq,
              _cstat
            );
            break;
          }
          default:
            // Unknown opcode: ignore it
            break;
        }
      }

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

      void CfdpManagerComponentBase ::
        dataIn_handlerBase(
            FwIndexType portNum,
            Fw::Buffer& fwBuffer
        )
      {
        // Make sure port number is valid
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_dataIn_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        // Call pre-message hook
        dataIn_preMsgHook(
          portNum,
          fwBuffer
        );
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize message ID
        _status = msg.serializeFrom(
          static_cast<FwEnumStoreType>(DATAIN_BUFFERSEND)
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Serialize port number
        _status = msg.serializeFrom(portNum);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Serialize argument fwBuffer
        _status = msg.serializeFrom(fwBuffer);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      void CfdpManagerComponentBase ::
        dataReturnIn_handlerBase(
            FwIndexType portNum,
            Fw::Buffer& fwBuffer
        )
      {
        // Make sure port number is valid
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_dataReturnIn_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        // Call pre-message hook
        dataReturnIn_preMsgHook(
          portNum,
          fwBuffer
        );
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize message ID
        _status = msg.serializeFrom(
          static_cast<FwEnumStoreType>(DATARETURNIN_BUFFERSEND)
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Serialize port number
        _status = msg.serializeFrom(portNum);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Serialize argument fwBuffer
        _status = msg.serializeFrom(fwBuffer);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      Svc::SendFileResponse CfdpManagerComponentBase ::
        fileIn_handlerBase(
            FwIndexType portNum,
            const Fw::StringBase& sourceFileName,
            const Fw::StringBase& destFileName,
            U32 offset,
            U32 length
        )
      {
        // Make sure port number is valid
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_fileIn_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        Svc::SendFileResponse retVal;

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

        // Call handler function
        retVal = this->fileIn_handler(
          portNum,
          sourceFileName,
          destFileName,
          offset,
          length
        );

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

        return retVal;
      }

      void CfdpManagerComponentBase ::
        pingIn_handlerBase(
            FwIndexType portNum,
            U32 key
        )
      {
        // Make sure port number is valid
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_pingIn_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        // Call pre-message hook
        pingIn_preMsgHook(
          portNum,
          key
        );
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize message ID
        _status = msg.serializeFrom(
          static_cast<FwEnumStoreType>(PINGIN_PING)
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Serialize port number
        _status = msg.serializeFrom(portNum);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Serialize argument key
        _status = msg.serializeFrom(key);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        if (qStatus == Os::Queue::Status::FULL) {
          this->incNumMsgDropped();
          return;
        }

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      void CfdpManagerComponentBase ::
        run1Hz_handlerBase(
            FwIndexType portNum,
            U32 context
        )
      {
        // Make sure port number is valid
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_run1Hz_InputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        // Call pre-message hook
        run1Hz_preMsgHook(
          portNum,
          context
        );
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize message ID
        _status = msg.serializeFrom(
          static_cast<FwEnumStoreType>(RUN1HZ_SCHED)
        );
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Serialize port number
        _status = msg.serializeFrom(portNum);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Serialize argument context
        _status = msg.serializeFrom(context);
        FW_ASSERT(
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

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

      void CfdpManagerComponentBase ::
        dataIn_preMsgHook(
            FwIndexType portNum,
            Fw::Buffer& fwBuffer
        )
      {
        // Default: no-op
      }

      void CfdpManagerComponentBase ::
        dataReturnIn_preMsgHook(
            FwIndexType portNum,
            Fw::Buffer& fwBuffer
        )
      {
        // Default: no-op
      }

      void CfdpManagerComponentBase ::
        pingIn_preMsgHook(
            FwIndexType portNum,
            U32 key
        )
      {
        // Default: no-op
      }

      void CfdpManagerComponentBase ::
        run1Hz_preMsgHook(
            FwIndexType portNum,
            U32 context
        )
      {
        // Default: no-op
      }

#if !FW_DIRECT_PORT_CALLS

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

      Fw::Buffer CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        dataInReturn_out(
            FwIndexType portNum,
            Fw::Buffer& fwBuffer
        ) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_dataInReturn_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      void CfdpManagerComponentBase ::
        dataOut_out(
            FwIndexType portNum,
            Fw::Buffer& fwBuffer
        ) 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(
          fwBuffer
        );
      }

      void CfdpManagerComponentBase ::
        fileDoneOut_out(
            FwIndexType portNum,
            const Svc::SendFileResponse& resp
        ) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_fileDoneOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      void CfdpManagerComponentBase ::
        pingOut_out(
            FwIndexType portNum,
            U32 key
        ) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_pingOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

#endif

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

      void CfdpManagerComponentBase ::
        cmdResponse_out(
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdResponse response
        )
      {
        FW_ASSERT(this->isConnected_cmdResponseOut_OutputPort(0));
        this->cmdResponseOut_out(0, opCode, cmdSeq, response);
      }

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

      void CfdpManagerComponentBase ::
        SendFile_cmdHandlerBase(
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {
        // Call pre-message hook
        this->SendFile_preMsgHook(opCode,cmdSeq);

        // Defer deserializing arguments to the message dispatcher
        // to avoid deserializing and reserializing just for IPC
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize for IPC
        _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_SENDFILE));
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Fake port number to make message dequeue work
        FwIndexType port = 0;

        _status = msg.serializeFrom(port);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(opCode);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(cmdSeq);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(args);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      void CfdpManagerComponentBase ::
        PlaybackDirectory_cmdHandlerBase(
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {
        // Call pre-message hook
        this->PlaybackDirectory_preMsgHook(opCode,cmdSeq);

        // Defer deserializing arguments to the message dispatcher
        // to avoid deserializing and reserializing just for IPC
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize for IPC
        _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_PLAYBACKDIRECTORY));
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Fake port number to make message dequeue work
        FwIndexType port = 0;

        _status = msg.serializeFrom(port);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(opCode);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(cmdSeq);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(args);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      void CfdpManagerComponentBase ::
        PollDirectory_cmdHandlerBase(
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {
        // Call pre-message hook
        this->PollDirectory_preMsgHook(opCode,cmdSeq);

        // Defer deserializing arguments to the message dispatcher
        // to avoid deserializing and reserializing just for IPC
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize for IPC
        _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_POLLDIRECTORY));
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Fake port number to make message dequeue work
        FwIndexType port = 0;

        _status = msg.serializeFrom(port);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(opCode);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(cmdSeq);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(args);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      void CfdpManagerComponentBase ::
        StopPollDirectory_cmdHandlerBase(
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {
        // Call pre-message hook
        this->StopPollDirectory_preMsgHook(opCode,cmdSeq);

        // Defer deserializing arguments to the message dispatcher
        // to avoid deserializing and reserializing just for IPC
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize for IPC
        _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_STOPPOLLDIRECTORY));
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Fake port number to make message dequeue work
        FwIndexType port = 0;

        _status = msg.serializeFrom(port);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(opCode);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(cmdSeq);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(args);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      void CfdpManagerComponentBase ::
        SetChannelFlow_cmdHandlerBase(
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {
        // Call pre-message hook
        this->SetChannelFlow_preMsgHook(opCode,cmdSeq);

        // Defer deserializing arguments to the message dispatcher
        // to avoid deserializing and reserializing just for IPC
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize for IPC
        _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_SETCHANNELFLOW));
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Fake port number to make message dequeue work
        FwIndexType port = 0;

        _status = msg.serializeFrom(port);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(opCode);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(cmdSeq);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(args);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      void CfdpManagerComponentBase ::
        SuspendResumeTransaction_cmdHandlerBase(
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {
        // Call pre-message hook
        this->SuspendResumeTransaction_preMsgHook(opCode,cmdSeq);

        // Defer deserializing arguments to the message dispatcher
        // to avoid deserializing and reserializing just for IPC
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize for IPC
        _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_SUSPENDRESUMETRANSACTION));
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Fake port number to make message dequeue work
        FwIndexType port = 0;

        _status = msg.serializeFrom(port);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(opCode);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(cmdSeq);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(args);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      void CfdpManagerComponentBase ::
        CancelTransaction_cmdHandlerBase(
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {
        // Call pre-message hook
        this->CancelTransaction_preMsgHook(opCode,cmdSeq);

        // Defer deserializing arguments to the message dispatcher
        // to avoid deserializing and reserializing just for IPC
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize for IPC
        _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_CANCELTRANSACTION));
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Fake port number to make message dequeue work
        FwIndexType port = 0;

        _status = msg.serializeFrom(port);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(opCode);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(cmdSeq);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(args);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      void CfdpManagerComponentBase ::
        AbandonTransaction_cmdHandlerBase(
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {
        // Call pre-message hook
        this->AbandonTransaction_preMsgHook(opCode,cmdSeq);

        // Defer deserializing arguments to the message dispatcher
        // to avoid deserializing and reserializing just for IPC
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize for IPC
        _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_ABANDONTRANSACTION));
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Fake port number to make message dequeue work
        FwIndexType port = 0;

        _status = msg.serializeFrom(port);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(opCode);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(cmdSeq);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(args);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

      void CfdpManagerComponentBase ::
        ResetCounters_cmdHandlerBase(
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {
        // Call pre-message hook
        this->ResetCounters_preMsgHook(opCode,cmdSeq);

        // Defer deserializing arguments to the message dispatcher
        // to avoid deserializing and reserializing just for IPC
        ComponentIpcSerializableBuffer msg;
        Fw::SerializeStatus _status = Fw::FW_SERIALIZE_OK;

        // Serialize for IPC
        _status = msg.serializeFrom(static_cast<FwEnumStoreType>(CMD_RESETCOUNTERS));
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Fake port number to make message dequeue work
        FwIndexType port = 0;

        _status = msg.serializeFrom(port);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(opCode);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(cmdSeq);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        _status = msg.serializeFrom(args);
        FW_ASSERT (
          _status == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_status)
        );

        // Send message
        Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
        Os::Queue::Status qStatus = this->m_queue.send(msg, 0, _block);

        FW_ASSERT(
          qStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(qStatus)
        );
      }

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

      void CfdpManagerComponentBase ::
        SendFile_preMsgHook(
            FwOpcodeType opCode,
            U32 cmdSeq
        )
      {
        // Defaults to no-op; can be overridden
        (void) opCode;
        (void) cmdSeq;
      }

      void CfdpManagerComponentBase ::
        PlaybackDirectory_preMsgHook(
            FwOpcodeType opCode,
            U32 cmdSeq
        )
      {
        // Defaults to no-op; can be overridden
        (void) opCode;
        (void) cmdSeq;
      }

      void CfdpManagerComponentBase ::
        PollDirectory_preMsgHook(
            FwOpcodeType opCode,
            U32 cmdSeq
        )
      {
        // Defaults to no-op; can be overridden
        (void) opCode;
        (void) cmdSeq;
      }

      void CfdpManagerComponentBase ::
        StopPollDirectory_preMsgHook(
            FwOpcodeType opCode,
            U32 cmdSeq
        )
      {
        // Defaults to no-op; can be overridden
        (void) opCode;
        (void) cmdSeq;
      }

      void CfdpManagerComponentBase ::
        SetChannelFlow_preMsgHook(
            FwOpcodeType opCode,
            U32 cmdSeq
        )
      {
        // Defaults to no-op; can be overridden
        (void) opCode;
        (void) cmdSeq;
      }

      void CfdpManagerComponentBase ::
        SuspendResumeTransaction_preMsgHook(
            FwOpcodeType opCode,
            U32 cmdSeq
        )
      {
        // Defaults to no-op; can be overridden
        (void) opCode;
        (void) cmdSeq;
      }

      void CfdpManagerComponentBase ::
        CancelTransaction_preMsgHook(
            FwOpcodeType opCode,
            U32 cmdSeq
        )
      {
        // Defaults to no-op; can be overridden
        (void) opCode;
        (void) cmdSeq;
      }

      void CfdpManagerComponentBase ::
        AbandonTransaction_preMsgHook(
            FwOpcodeType opCode,
            U32 cmdSeq
        )
      {
        // Defaults to no-op; can be overridden
        (void) opCode;
        (void) cmdSeq;
      }

      void CfdpManagerComponentBase ::
        ResetCounters_preMsgHook(
            FwOpcodeType opCode,
            U32 cmdSeq
        )
      {
        // Defaults to no-op; can be overridden
        (void) opCode;
        (void) cmdSeq;
      }

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

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

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

        // 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_LO,
            _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: Unable to allocate a PDU buffer";
#else
          const char* _formatString =
            "%s: Unable to allocate a PDU buffer";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_InvalidChannel(
            U8 channelId,
            U8 maxChannelId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(maxChannelId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Invalid channel ID %" PRIu8 ", maximum channel ID is %" PRIu8 "";
#else
          const char* _formatString =
            "%s: Invalid channel ID %" PRIu8 ", maximum channel ID is %" PRIu8 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_LO_TxFileQueued(
            const Fw::StringBase& sourceFileName,
            U32 transactionSeq
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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

          _status = sourceFileName.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(transactionSeq);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_LO,
            _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: TX file queued for %s (transaction %" PRIu32 ")";
#else
          const char* _formatString =
            "%s: TX file queued for %s (transaction %" PRIu32 ")";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_UnsupportedSendFileArguments(
            U32 offset,
            U32 length
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(offset);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(length);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Invalid send file port request with offset %" PRIu32 ", length %" PRIu32 "";
#else
          const char* _formatString =
            "%s: Invalid send file port request with offset %" PRIu32 ", length %" PRIu32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_SendFileInitiateFail(const Fw::StringBase& sourceFileName) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(1));
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif

          _status = sourceFileName.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 initiate file send transfer for %s";
#else
          const char* _formatString =
            "%s: Failed to initiate file send transfer for %s";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_LO_PlaybackInitiated(const Fw::StringBase& sourceDirectory) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(1));
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif

          _status = sourceDirectory.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_LO,
            _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: Successfully initiated directory playback for %s";
#else
          const char* _formatString =
            "%s: Successfully initiated directory playback for %s";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_LO_PollDirInitiated(
            const Fw::StringBase& sourceDirectory,
            U8 pollId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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

          _status = sourceDirectory.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(pollId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_LO,
            _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: Successfully initiated directory poll for %s (index %" PRIu8 ")";
#else
          const char* _formatString =
            "%s: Successfully initiated directory poll for %s (index %" PRIu8 ")";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_LO_PollDirStopped(
            U8 channelId,
            U8 pollId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(pollId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_LO,
            _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: Successfully stopped directory poll for channel %" PRIu8 ", index %" PRIu8 "";
#else
          const char* _formatString =
            "%s: Successfully stopped directory poll for channel %" PRIu8 ", index %" PRIu8 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_PollDirBusy(
            U8 channelId,
            U8 pollId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(pollId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Cannot start directory poll - channel %" PRIu8 " poll %" PRIu8 " already in use";
#else
          const char* _formatString =
            "%s: Cannot start directory poll - channel %" PRIu8 " poll %" PRIu8 " already in use";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_PollDirNotActive(
            U8 channelId,
            U8 pollId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(pollId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Cannot stop directory poll - channel %" PRIu8 " poll %" PRIu8 " is not active";
#else
          const char* _formatString =
            "%s: Cannot stop directory poll - channel %" PRIu8 " poll %" PRIu8 " is not active";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_LO_SetFlowState(
            U8 channelId,
            const Svc::Ccsds::Cfdp::Flow& flowState
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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>(Svc::Ccsds::Cfdp::Flow::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(flowState);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_LO,
            _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: Set channel %" PRIu8 " to %s";
#else
          const char* _formatString =
            "%s: Set channel %" PRIu8 " to %s";
#endif

          Fw::String flowStateStr;
          flowState.toString(flowStateStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_InvalidChannelPoll(
            U8 pollId,
            U8 maxPollId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(pollId);
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(maxPollId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Invalid poll ID %" PRIu8 ", maximum poll ID is %" PRIu8 "";
#else
          const char* _formatString =
            "%s: Invalid poll ID %" PRIu8 ", maximum poll ID is %" PRIu8 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_InvalidPollInterval(U32 interval) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(1));
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(interval);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Invalid poll interval %" PRIu32 " seconds, must be non-zero";
#else
          const char* _formatString =
            "%s: Invalid poll interval %" PRIu32 " seconds, must be non-zero";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FailKeepFileMove(
            const Fw::StringBase& srcFile,
            const Fw::StringBase& moveDir,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif

          _status = srcFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = moveDir.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 move %s to %s error %" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to move %s to %s error %" PRIi32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FailPollFileMove(
            const Fw::StringBase& srcFile,
            const Fw::StringBase& failDir,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif

          _status = srcFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = failDir.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 move %s to %s error %" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to move %s to %s error %" PRIi32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FailPduHeaderDeserialization(
            U8 channelId,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 deserialize PDU header on channel %" PRIu8 ", status %" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to deserialize PDU header on channel %" PRIu8 ", status %" PRIi32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FailPduSerialization(
            U8 channelId,
            const Svc::Ccsds::Cfdp::PduTypeEnum& pduType,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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>(Svc::Ccsds::Cfdp::PduTypeEnum::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(pduType);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 serialize %" PRIu8 " PDU on channel %s, status %" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to serialize %" PRIu8 " PDU on channel %s, status %" PRIi32 "";
#endif

          Fw::String pduTypeStr;
          pduType.toString(pduTypeStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FailMetadataPduDeserialization(
            U8 channelId,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 deserialize Metadata PDU on channel %" PRIu8 ", status %" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to deserialize Metadata PDU on channel %" PRIu8 ", status %" PRIi32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FailFileDataPduDeserialization(
            U8 channelId,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 deserialize File Data PDU on channel %" PRIu8 ", status %" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to deserialize File Data PDU on channel %" PRIu8 ", status %" PRIi32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FailEofPduDeserialization(
            U8 channelId,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 deserialize EOF PDU on channel %" PRIu8 ", status %" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to deserialize EOF PDU on channel %" PRIu8 ", status %" PRIi32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FailAckPduDeserialization(
            U8 channelId,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 deserialize ACK PDU on channel %" PRIu8 ", status %" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to deserialize ACK PDU on channel %" PRIu8 ", status %" PRIi32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FailFinPduDeserialization(
            U8 channelId,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 deserialize FIN PDU on channel %" PRIu8 ", status %" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to deserialize FIN PDU on channel %" PRIu8 ", status %" PRIi32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FailNakPduDeserialization(
            U8 channelId,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 deserialize NAK PDU on channel %" PRIu8 ", status %" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to deserialize NAK PDU on channel %" PRIu8 ", status %" PRIi32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxAckLimitReached(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s ACK limit reached for transaction %" PRIu32 ":%" PRIu32 ", no fin-ack sent";
#else
          const char* _formatString =
            "%s: RX class %s ACK limit reached for transaction %" PRIu32 ":%" PRIu32 ", no fin-ack sent";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_LO_RxTempFileCreated(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            const Fw::StringBase& filename
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(4));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = filename.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " creating temp file %s without metadata";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " creating temp file %s without metadata";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxFileCreateFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            const Fw::StringBase& filename,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = filename.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to create file %s, error=%" PRIi32 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to create file %s, error=%" PRIi32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxFileCreateFailed ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            filename.toChar(),
            status
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxCrcMismatch(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U32 expected,
            U32 actual
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(expected);
          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(U32))
          );
          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->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " CRC mismatch: expected 0x%" PRIx32 " actual 0x%" PRIx32 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " CRC mismatch: expected 0x%" PRIx32 " actual 0x%" PRIx32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxCrcMismatch ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            expected,
            actual
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxNakLimitReached(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " NAK limit reached";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " NAK limit reached";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxSeekFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U32 offset,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(offset);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to seek to offset %" PRIu32 ", error=%" PRIi32 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to seek to offset %" PRIu32 ", error=%" PRIi32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxSeekFailed ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            offset,
            status
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxWriteFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U32 expected,
            I32 actual
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(expected);
          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(I32))
          );
          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->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " write failed: expected %" PRIu32 " bytes, got %" PRIi32 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " write failed: expected %" PRIu32 " bytes, got %" PRIi32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxWriteFailed ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            expected,
            actual
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxFileDataOutOfBounds(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U32 offset,
            U32 dataSize,
            U32 fileSize
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(6));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(offset);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(dataSize);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(fileSize);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " file data [%" PRIu32 ", +%" PRIu32 "] exceeds file size bound %" PRIu32 ", PDU rejected";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " file data [%" PRIu32 ", +%" PRIu32 "] exceeds file size bound %" PRIu32 ", PDU rejected";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxFileDataOutOfBounds ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            offset,
            dataSize,
            fileSize
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxFileSizeMismatch(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U32 expected,
            U32 actual
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(expected);
          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(U32))
          );
          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->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " EOF file size mismatch: expected %" PRIu32 " got %" PRIu32 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " EOF file size mismatch: expected %" PRIu32 " got %" PRIu32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxFileSizeMismatch ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            expected,
            actual
          );

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_HI_RxEofCancelReceived(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_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: RX class %s transaction %" PRIu32 ":%" PRIu32 " cancelled by sender";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " cancelled by sender";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxEofWithError(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U8 conditionCode
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(4));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(conditionCode);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " received EOF with error condition code %" PRIu8 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " received EOF with error condition code %" PRIu8 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxSeekCrcFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U32 offset,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(offset);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to seek offset %" PRIu32 " during CRC calculation, error=%" PRIi32 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to seek offset %" PRIu32 " during CRC calculation, error=%" PRIi32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxSeekCrcFailed ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            offset,
            status
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxReadCrcFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U32 expected,
            I32 actual
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(expected);
          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(I32))
          );
          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->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to read during CRC calculation: expected %" PRIu32 " bytes, got %" PRIi32 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to read during CRC calculation: expected %" PRIu32 " bytes, got %" PRIi32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxReadCrcFailed ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            expected,
            actual
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxEofMdSizeMismatch(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U32 mdSize,
            U32 eofSize
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(mdSize);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(eofSize);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " EOF/metadata size mismatch: metadata=%" PRIu32 ", EOF=%" PRIu32 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " EOF/metadata size mismatch: metadata=%" PRIu32 ", EOF=%" PRIu32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxEofMdSizeMismatch ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            mdSize,
            eofSize
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxFileRenameFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            const Fw::StringBase& tempFile,
            const Fw::StringBase& finalFile,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(6));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = tempFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = finalFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to rename %s to %s, error=%" PRIi32 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to rename %s to %s, error=%" PRIi32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxFileRenameFailed ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            tempFile.toChar(),
            finalFile.toChar(),
            status
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxFileReopenFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            const Fw::StringBase& filename,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = filename.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to reopen file %s after rename, error=%" PRIi32 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " failed to reopen file %s after rename, error=%" PRIi32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxFileReopenFailed ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            filename.toChar(),
            status
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxInactivityTimeout(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " inactivity timer expired";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " inactivity timer expired";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxInvalidDirectiveCode(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U8 directiveCode,
            U8 substate
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(directiveCode);
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(substate);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX class %s transaction %" PRIu32 ":%" PRIu32 " received invalid directive code %" PRIu8 " for substate %" PRIu8 "";
#else
          const char* _formatString =
            "%s: RX class %s transaction %" PRIu32 ":%" PRIu32 " received invalid directive code %" PRIu8 " for substate %" PRIu8 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxInvalidDirectiveCode ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            directiveCode,
            substate
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxAckLimitReached(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " ACK limit reached, no eof-ack received";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " ACK limit reached, no eof-ack received";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxInactivityTimeout(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " inactivity timer expired";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " inactivity timer expired";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxZeroLengthFile(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            const Fw::StringBase& filename
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(4));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = filename.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " cannot transfer zero-length file %s";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " cannot transfer zero-length file %s";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxFileOpenFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            const Fw::StringBase& filename,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = filename.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " failed to open file %s, error=%" PRIi32 "";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " failed to open file %s, error=%" PRIi32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "TxFileOpenFailed ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            filename.toChar(),
            status
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxFileSeekFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(4));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " failed to seek to beginning of file, error=%" PRIi32 "";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " failed to seek to beginning of file, error=%" PRIi32 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxSendMetadataFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " failed to send metadata PDU";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " failed to send metadata PDU";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxEarlyFinReceived(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " received early FIN, cancelling transfer";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " received early FIN, cancelling transfer";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxInvalidNakPdu(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " received invalid NAK PDU";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " received invalid NAK PDU";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxInvalidSegmentRequests(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U32 badCount
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(4));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(badCount);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " received %" PRIu32 " invalid NAK segment requests";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " received %" PRIu32 " invalid NAK segment requests";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxNonFileDirectivePduReceived(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " received non-file-directive PDU";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " received non-file-directive PDU";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxInvalidDirectiveCode(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 srcEid,
            U32 seqNum,
            U8 directiveCode,
            U8 substate
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(5));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(directiveCode);
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(substate);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX class %s transaction %" PRIu32 ":%" PRIu32 " received invalid directive code %" PRIu8 " for substate %" PRIu8 "";
#else
          const char* _formatString =
            "%s: TX class %s transaction %" PRIu32 ":%" PRIu32 " received invalid directive code %" PRIu8 " for substate %" PRIu8 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "TxInvalidDirectiveCode ",
            cfdpClassStr.toChar(),
            srcEid,
            seqNum,
            directiveCode,
            substate
          );

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_HI_TxFileTransferStarted(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 seqNum,
            U32 srcEid,
            const Fw::StringBase& srcFile,
            U32 destEid,
            const Fw::StringBase& destFile,
            U32 fileSize
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(7));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = srcFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(destEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = destFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(fileSize);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_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: TX %s transaction %" PRIu32 " transfer started, %" PRIu32 ":%s -> %" PRIu32 ":%s, %" PRIu32 " bytes";
#else
          const char* _formatString =
            "%s: TX %s transaction %" PRIu32 " transfer started, %" PRIu32 ":%s -> %" PRIu32 ":%s, %" PRIu32 " bytes";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "TxFileTransferStarted ",
            cfdpClassStr.toChar(),
            seqNum,
            srcEid,
            srcFile.toChar(),
            destEid,
            destFile.toChar(),
            fileSize
          );

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_HI_TxFileTransferCompleted(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 seqNum,
            U32 srcEid,
            const Fw::StringBase& srcFile,
            U32 destEid,
            const Fw::StringBase& destFile,
            U32 fileSize
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(7));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = srcFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(destEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = destFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(fileSize);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_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: TX %s transaction %" PRIu32 " completed, %" PRIu32 ":%s -> %" PRIu32 ":%s, %" PRIu32 " bytes";
#else
          const char* _formatString =
            "%s: TX %s transaction %" PRIu32 " completed, %" PRIu32 ":%s -> %" PRIu32 ":%s, %" PRIu32 " bytes";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "TxFileTransferCompleted ",
            cfdpClassStr.toChar(),
            seqNum,
            srcEid,
            srcFile.toChar(),
            destEid,
            destFile.toChar(),
            fileSize
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TxFileTransferFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 seqNum,
            U32 srcEid,
            const Fw::StringBase& srcFile,
            U32 destEid,
            const Fw::StringBase& destFile,
            U8 conditionCode
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(7));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = srcFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(destEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = destFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(conditionCode);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: TX %s transaction %" PRIu32 " FAILED, %" PRIu32 ":%s -> %" PRIu32 ":%s, error code %" PRIu8 "";
#else
          const char* _formatString =
            "%s: TX %s transaction %" PRIu32 " FAILED, %" PRIu32 ":%s -> %" PRIu32 ":%s, error code %" PRIu8 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "TxFileTransferFailed ",
            cfdpClassStr.toChar(),
            seqNum,
            srcEid,
            srcFile.toChar(),
            destEid,
            destFile.toChar(),
            conditionCode
          );

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_HI_RxFileTransferCompleted(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 seqNum,
            U32 srcEid,
            const Fw::StringBase& srcFile,
            U32 destEid,
            const Fw::StringBase& destFile,
            U32 fileSize
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(7));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = srcFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(destEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = destFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(fileSize);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_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: RX %s transaction %" PRIu32 " completed, %" PRIu32 ":%s -> %" PRIu32 ":%s, %" PRIu32 " bytes";
#else
          const char* _formatString =
            "%s: RX %s transaction %" PRIu32 " completed, %" PRIu32 ":%s -> %" PRIu32 ":%s, %" PRIu32 " bytes";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxFileTransferCompleted ",
            cfdpClassStr.toChar(),
            seqNum,
            srcEid,
            srcFile.toChar(),
            destEid,
            destFile.toChar(),
            fileSize
          );

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxFileTransferFailed(
            const Svc::Ccsds::Cfdp::Class& cfdpClass,
            U32 seqNum,
            U32 srcEid,
            const Fw::StringBase& srcFile,
            U32 destEid,
            const Fw::StringBase& destFile,
            U8 conditionCode
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(7));
          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>(Svc::Ccsds::Cfdp::Class::SERIALIZED_SIZE)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(cfdpClass);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = srcFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(destEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = destFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(conditionCode);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: RX %s transaction %" PRIu32 " FAILED, %" PRIu32 ":%s -> %" PRIu32 ":%s, error code %" PRIu8 "";
#else
          const char* _formatString =
            "%s: RX %s transaction %" PRIu32 " FAILED, %" PRIu32 ":%s -> %" PRIu32 ":%s, error code %" PRIu8 "";
#endif

          Fw::String cfdpClassStr;
          cfdpClass.toString(cfdpClassStr);

          Fw::TextLogString _logString;
          (void) _logString.format(
            _formatString,
#if FW_OBJECT_NAMES == 1
            this->m_objName.toChar(),
#endif
            "RxFileTransferFailed ",
            cfdpClassStr.toChar(),
            seqNum,
            srcEid,
            srcFile.toChar(),
            destEid,
            destFile.toChar(),
            conditionCode
          );

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_LO_MetadataReceived(
            const Fw::StringBase& srcFile,
            const Fw::StringBase& destFile,
            U32 transactionSeq
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(3));
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif

          _status = srcFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          _status = destFile.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(transactionSeq);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_LO,
            _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: Metadata received for source: %s, dest: %s (transaction %" PRIu32 ")";
#else
          const char* _formatString =
            "%s: Metadata received for source: %s, dest: %s (transaction %" PRIu32 ")";
#endif

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

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

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

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

        // 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_LO,
            _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: File data PDU with unsupported segment metadata received";
#else
          const char* _formatString =
            "%s: File data PDU with unsupported segment metadata received";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_ChunklistUnavailable(U32 transactionSeq) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(1));
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(transactionSeq);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Cannot get chunklist, abandoning transaction %" PRIu32 "";
#else
          const char* _formatString =
            "%s: Cannot get chunklist, abandoning transaction %" PRIu32 "";
#endif

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

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

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

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

        // 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_LO,
            _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: Unhandled PDU type received in idle state";
#else
          const char* _formatString =
            "%s: Unhandled PDU type received in idle state";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_RxTransactionLimitReached(
            U32 srcEid,
            U32 transactionSeq
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(transactionSeq);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Dropping packet from %" PRIu32 " transaction %" PRIu32 " due to max RX transactions reached";
#else
          const char* _formatString =
            "%s: Dropping packet from %" PRIu32 " transaction %" PRIu32 " due to max RX transactions reached";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_InvalidDestinationEid(U32 destEid) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(1));
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(destEid);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Dropping packet for invalid destination EID %" PRIu32 "";
#else
          const char* _formatString =
            "%s: Dropping packet for invalid destination EID %" PRIu32 "";
#endif

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

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

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

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

        // 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_LO,
            _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: Maximum number of commanded TX files reached";
#else
          const char* _formatString =
            "%s: Maximum number of commanded TX files reached";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_PlaybackDirOpenFailed(
            const Fw::StringBase& directory,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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

          _status = directory.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 open playback directory %s, error=%" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to open playback directory %s, error=%" PRIi32 "";
#endif

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

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

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

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

        // 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_LO,
            _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: No playback directory slot available";
#else
          const char* _formatString =
            "%s: No playback directory slot available";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_DanglingFileHandleClosed(
            U8 channelId,
            U32 transactionSeq
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          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(U32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(transactionSeq);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Closed dangling file handle for channel %" PRIu8 " transaction %" PRIu32 "";
#else
          const char* _formatString =
            "%s: Closed dangling file handle for channel %" PRIu8 " transaction %" PRIu32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_PlaybackDirReadFailed(
            const Fw::StringBase& directory,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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

          _status = directory.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 read from playback directory %s, error=%" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to read from playback directory %s, error=%" PRIi32 "";
#endif

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

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

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

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

        // 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::DIAGNOSTIC,
            _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: Attempt to reset a transaction that has already been freed";
#else
          const char* _formatString =
            "%s: Attempt to reset a transaction that has already been freed";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_FileRemoveFailed(
            const Fw::StringBase& filename,
            I32 status
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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

          _status = filename.serializeTo(
            _logBuff,
            FW_MIN(static_cast<FwSizeType>(FW_LOG_STRING_MAX_SIZE), 200)
          );
          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(I32))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(status);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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 remove file %s, error=%" PRIi32 "";
#else
          const char* _formatString =
            "%s: Failed to remove file %s, error=%" PRIi32 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_LO_TransactionSuspended(
            Svc::Ccsds::Cfdp::TransactionSeq transactionSeq,
            Svc::Ccsds::Cfdp::EntityId entityId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(Svc::Ccsds::Cfdp::TransactionSeq))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(transactionSeq);
          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(Svc::Ccsds::Cfdp::EntityId))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(entityId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_LO,
            _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: Transaction (%" PRIu32 ", %" PRIu32 ") suspended";
#else
          const char* _formatString =
            "%s: Transaction (%" PRIu32 ", %" PRIu32 ") suspended";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_LO_TransactionResumed(
            Svc::Ccsds::Cfdp::TransactionSeq transactionSeq,
            Svc::Ccsds::Cfdp::EntityId entityId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(Svc::Ccsds::Cfdp::TransactionSeq))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(transactionSeq);
          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(Svc::Ccsds::Cfdp::EntityId))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(entityId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_LO,
            _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: Transaction (%" PRIu32 ", %" PRIu32 ") resumed";
#else
          const char* _formatString =
            "%s: Transaction (%" PRIu32 ", %" PRIu32 ") resumed";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_HI_TransactionCanceled(
            Svc::Ccsds::Cfdp::TransactionSeq transactionSeq,
            Svc::Ccsds::Cfdp::EntityId entityId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(Svc::Ccsds::Cfdp::TransactionSeq))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(transactionSeq);
          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(Svc::Ccsds::Cfdp::EntityId))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(entityId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_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: Transaction (%" PRIu32 ", %" PRIu32 ") canceled";
#else
          const char* _formatString =
            "%s: Transaction (%" PRIu32 ", %" PRIu32 ") canceled";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_HI_TransactionAbandoned(
            Svc::Ccsds::Cfdp::TransactionSeq transactionSeq,
            Svc::Ccsds::Cfdp::EntityId entityId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(Svc::Ccsds::Cfdp::TransactionSeq))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(transactionSeq);
          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(Svc::Ccsds::Cfdp::EntityId))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(entityId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_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: Transaction (%" PRIu32 ", %" PRIu32 ") abandoned";
#else
          const char* _formatString =
            "%s: Transaction (%" PRIu32 ", %" PRIu32 ") abandoned";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_WARNING_LO_TransactionNotFound(
            Svc::Ccsds::Cfdp::TransactionSeq transactionSeq,
            Svc::Ccsds::Cfdp::EntityId entityId
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(Svc::Ccsds::Cfdp::TransactionSeq))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(transactionSeq);
          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(Svc::Ccsds::Cfdp::EntityId))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(entityId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::WARNING_LO,
            _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: Transaction (%" PRIu32 ", %" PRIu32 ") not found";
#else
          const char* _formatString =
            "%s: Transaction (%" PRIu32 ", %" PRIu32 ") not found";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_ACTIVITY_HI_ResetCounters(U8 channelId) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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>(1));
          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(U8))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(channelId);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::ACTIVITY_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: Reset telemetry counters for channel %" PRIu8 "";
#else
          const char* _formatString =
            "%s: Reset telemetry counters for channel %" PRIu8 "";
#endif

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

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

      void CfdpManagerComponentBase ::
        log_DIAGNOSTIC_TxLateFinAcked(
            Svc::Ccsds::Cfdp::EntityId srcEid,
            Svc::Ccsds::Cfdp::TransactionSeq seqNum
        ) const
      {
        // Get the time
        Fw::Time _logTime;
        if (this->isConnected_timeCaller_OutputPort(0)) {
          this->timeCaller_out(0, _logTime);
        }

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

        // Emit the event on the log port
        if (this->isConnected_logOut_OutputPort(0)) {
          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(Svc::Ccsds::Cfdp::EntityId))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(srcEid);
          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(Svc::Ccsds::Cfdp::TransactionSeq))
          );
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );
#endif
          _status = _logBuff.serializeFrom(seqNum);
          FW_ASSERT(
            _status == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_status)
          );

          this->logOut_out(
            0,
            _id,
            _logTime,
            Fw::LogSeverity::DIAGNOSTIC,
            _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: Acknowledged late FIN for transaction %" PRIu32 ":%" PRIu32 "";
#else
          const char* _formatString =
            "%s: Acknowledged late FIN for transaction %" PRIu32 ":%" PRIu32 "";
#endif

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

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

      // ----------------------------------------------------------------------
      // Telemetry serialized write
      // ----------------------------------------------------------------------

      void CfdpManagerComponentBase ::
        tlmWrite(
            FwChanIdType id,
            Fw::TlmBuffer& _tlmBuff,
            Fw::Time _tlmTime
        ) const
      {
        if (this->isConnected_tlmOut_OutputPort(0)) {
          if (
            this->isConnected_timeCaller_OutputPort(0) &&
            (_tlmTime ==  Fw::ZERO_TIME)
          ) {
            this->timeCaller_out(0, _tlmTime);
          }

          FwChanIdType _id;
          _id = this->getIdBase() + id;

          this->tlmOut_out(
            0,
            _id,
            _tlmTime,
            _tlmBuff
          );
        }
      }

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

      void CfdpManagerComponentBase ::
        tlmWrite_ChannelTelemetry(
            const Svc::Ccsds::Cfdp::ChannelTelemetryArray& arg,
            Fw::Time _tlmTime
        ) const
      {
        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_CHANNELTELEMETRY,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      void CfdpManagerComponentBase ::
        tlmWrite_PRM_LOCAL_EID(
            Svc::Ccsds::Cfdp::EntityId arg,
            Fw::Time _tlmTime
        )
      {
        // Check to see if it is the first time
        if (not this->m_first_update_PRM_LOCAL_EID) {
          // Check to see if value has changed. If not, don't write it.
          if (arg == this->m_last_PRM_LOCAL_EID) {
            return;
          }
          else {
            this->m_last_PRM_LOCAL_EID = arg;
          }
        }
        else {
          this->m_first_update_PRM_LOCAL_EID = false;
          this->m_last_PRM_LOCAL_EID = arg;
        }

        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_PRM_LOCAL_EID,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      void CfdpManagerComponentBase ::
        tlmWrite_PRM_OUTGOING_FILE_CHUNK_SIZE(
            U32 arg,
            Fw::Time _tlmTime
        )
      {
        // Check to see if it is the first time
        if (not this->m_first_update_PRM_OUTGOING_FILE_CHUNK_SIZE) {
          // Check to see if value has changed. If not, don't write it.
          if (arg == this->m_last_PRM_OUTGOING_FILE_CHUNK_SIZE) {
            return;
          }
          else {
            this->m_last_PRM_OUTGOING_FILE_CHUNK_SIZE = arg;
          }
        }
        else {
          this->m_first_update_PRM_OUTGOING_FILE_CHUNK_SIZE = false;
          this->m_last_PRM_OUTGOING_FILE_CHUNK_SIZE = arg;
        }

        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_PRM_OUTGOING_FILE_CHUNK_SIZE,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      void CfdpManagerComponentBase ::
        tlmWrite_PRM_RX_CRC_CALC_BYTES_PER_CYCLE(
            U32 arg,
            Fw::Time _tlmTime
        )
      {
        // Check to see if it is the first time
        if (not this->m_first_update_PRM_RX_CRC_CALC_BYTES_PER_CYCLE) {
          // Check to see if value has changed. If not, don't write it.
          if (arg == this->m_last_PRM_RX_CRC_CALC_BYTES_PER_CYCLE) {
            return;
          }
          else {
            this->m_last_PRM_RX_CRC_CALC_BYTES_PER_CYCLE = arg;
          }
        }
        else {
          this->m_first_update_PRM_RX_CRC_CALC_BYTES_PER_CYCLE = false;
          this->m_last_PRM_RX_CRC_CALC_BYTES_PER_CYCLE = arg;
        }

        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_PRM_RX_CRC_CALC_BYTES_PER_CYCLE,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      void CfdpManagerComponentBase ::
        tlmWrite_PRM_POST_INACTIVITY_SEND_RETRIES(
            U8 arg,
            Fw::Time _tlmTime
        )
      {
        // Check to see if it is the first time
        if (not this->m_first_update_PRM_POST_INACTIVITY_SEND_RETRIES) {
          // Check to see if value has changed. If not, don't write it.
          if (arg == this->m_last_PRM_POST_INACTIVITY_SEND_RETRIES) {
            return;
          }
          else {
            this->m_last_PRM_POST_INACTIVITY_SEND_RETRIES = arg;
          }
        }
        else {
          this->m_first_update_PRM_POST_INACTIVITY_SEND_RETRIES = false;
          this->m_last_PRM_POST_INACTIVITY_SEND_RETRIES = arg;
        }

        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_PRM_POST_INACTIVITY_SEND_RETRIES,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      void CfdpManagerComponentBase ::
        tlmWrite_PRM_FILE_IN_DEFAULT_CHANNEL(
            U8 arg,
            Fw::Time _tlmTime
        )
      {
        // Check to see if it is the first time
        if (not this->m_first_update_PRM_FILE_IN_DEFAULT_CHANNEL) {
          // Check to see if value has changed. If not, don't write it.
          if (arg == this->m_last_PRM_FILE_IN_DEFAULT_CHANNEL) {
            return;
          }
          else {
            this->m_last_PRM_FILE_IN_DEFAULT_CHANNEL = arg;
          }
        }
        else {
          this->m_first_update_PRM_FILE_IN_DEFAULT_CHANNEL = false;
          this->m_last_PRM_FILE_IN_DEFAULT_CHANNEL = arg;
        }

        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_PRM_FILE_IN_DEFAULT_CHANNEL,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      void CfdpManagerComponentBase ::
        tlmWrite_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID(
            Svc::Ccsds::Cfdp::EntityId arg,
            Fw::Time _tlmTime
        )
      {
        // Check to see if it is the first time
        if (not this->m_first_update_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID) {
          // Check to see if value has changed. If not, don't write it.
          if (arg == this->m_last_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID) {
            return;
          }
          else {
            this->m_last_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID = arg;
          }
        }
        else {
          this->m_first_update_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID = false;
          this->m_last_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID = arg;
        }

        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_PRM_FILE_IN_DEFAULT_DEST_ENTITY_ID,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      void CfdpManagerComponentBase ::
        tlmWrite_PRM_FILE_IN_DEFAULT_CLASS(
            const Svc::Ccsds::Cfdp::Class& arg,
            Fw::Time _tlmTime
        )
      {
        // Check to see if it is the first time
        if (not this->m_first_update_PRM_FILE_IN_DEFAULT_CLASS) {
          // Check to see if value has changed. If not, don't write it.
          if (arg == this->m_last_PRM_FILE_IN_DEFAULT_CLASS) {
            return;
          }
          else {
            this->m_last_PRM_FILE_IN_DEFAULT_CLASS = arg;
          }
        }
        else {
          this->m_first_update_PRM_FILE_IN_DEFAULT_CLASS = false;
          this->m_last_PRM_FILE_IN_DEFAULT_CLASS = arg;
        }

        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_PRM_FILE_IN_DEFAULT_CLASS,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      void CfdpManagerComponentBase ::
        tlmWrite_PRM_FILE_IN_DEFAULT_KEEP(
            const Svc::Ccsds::Cfdp::Keep& arg,
            Fw::Time _tlmTime
        )
      {
        // Check to see if it is the first time
        if (not this->m_first_update_PRM_FILE_IN_DEFAULT_KEEP) {
          // Check to see if value has changed. If not, don't write it.
          if (arg == this->m_last_PRM_FILE_IN_DEFAULT_KEEP) {
            return;
          }
          else {
            this->m_last_PRM_FILE_IN_DEFAULT_KEEP = arg;
          }
        }
        else {
          this->m_first_update_PRM_FILE_IN_DEFAULT_KEEP = false;
          this->m_last_PRM_FILE_IN_DEFAULT_KEEP = arg;
        }

        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_PRM_FILE_IN_DEFAULT_KEEP,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      void CfdpManagerComponentBase ::
        tlmWrite_PRM_FILE_IN_DEFAULT_PRIORITY(
            U8 arg,
            Fw::Time _tlmTime
        )
      {
        // Check to see if it is the first time
        if (not this->m_first_update_PRM_FILE_IN_DEFAULT_PRIORITY) {
          // Check to see if value has changed. If not, don't write it.
          if (arg == this->m_last_PRM_FILE_IN_DEFAULT_PRIORITY) {
            return;
          }
          else {
            this->m_last_PRM_FILE_IN_DEFAULT_PRIORITY = arg;
          }
        }
        else {
          this->m_first_update_PRM_FILE_IN_DEFAULT_PRIORITY = false;
          this->m_last_PRM_FILE_IN_DEFAULT_PRIORITY = arg;
        }

        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_PRM_FILE_IN_DEFAULT_PRIORITY,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      void CfdpManagerComponentBase ::
        tlmWrite_PRM_CHANNEL_CONFIG(
            const Svc::Ccsds::Cfdp::ChannelArrayParams& arg,
            Fw::Time _tlmTime
        )
      {
        // Check to see if it is the first time
        if (not this->m_first_update_PRM_CHANNEL_CONFIG) {
          // Check to see if value has changed. If not, don't write it.
          if (arg == this->m_last_PRM_CHANNEL_CONFIG) {
            return;
          }
          else {
            this->m_last_PRM_CHANNEL_CONFIG = arg;
          }
        }
        else {
          this->m_first_update_PRM_CHANNEL_CONFIG = false;
          this->m_last_PRM_CHANNEL_CONFIG = arg;
        }

        if (this->isConnected_tlmOut_OutputPort(0)) {
          Fw::TlmBuffer _tlmBuff;
          Fw::SerializeStatus _stat = _tlmBuff.serializeFrom(arg);
          FW_ASSERT(
            _stat == Fw::FW_SERIALIZE_OK,
            static_cast<FwAssertArgType>(_stat)
          );

          this->tlmWrite(
            CHANNELID_PRM_CHANNEL_CONFIG,
            _tlmBuff,
            _tlmTime
          );
        }
      }

      // ----------------------------------------------------------------------
      // Parameter hook functions
      // ----------------------------------------------------------------------

      void CfdpManagerComponentBase ::
        parameterUpdated(FwPrmIdType id)
      {
        // Do nothing by default
      }

      void CfdpManagerComponentBase ::
        parametersLoaded()
      {
        // Do nothing by default
      }

      void CfdpManagerComponentBase ::
        parameterLoaded(
            FwPrmIdType id,
            Fw::ParamValid valid
        )
      {
        if (FW_PARAM_OK(valid)) {
          this->parameterUpdated(id);
        }
      }

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

      Svc::Ccsds::Cfdp::EntityId CfdpManagerComponentBase ::
        paramGet_LocalEid(Fw::ParamValid& valid)
      {
        Svc::Ccsds::Cfdp::EntityId _local{};
        this->m_paramLock.lock();
        valid = this->m_param_LocalEid_valid;
        if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
          _local = this->m_LocalEid;
        }
        this->m_paramLock.unlock();
        return _local;
      }

      U32 CfdpManagerComponentBase ::
        paramGet_OutgoingFileChunkSize(Fw::ParamValid& valid)
      {
        U32 _local{};
        this->m_paramLock.lock();
        valid = this->m_param_OutgoingFileChunkSize_valid;
        if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
          _local = this->m_OutgoingFileChunkSize;
        }
        this->m_paramLock.unlock();
        return _local;
      }

      U32 CfdpManagerComponentBase ::
        paramGet_RxCrcCalcBytesPerCycle(Fw::ParamValid& valid)
      {
        U32 _local{};
        this->m_paramLock.lock();
        valid = this->m_param_RxCrcCalcBytesPerCycle_valid;
        if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
          _local = this->m_RxCrcCalcBytesPerCycle;
        }
        this->m_paramLock.unlock();
        return _local;
      }

      U8 CfdpManagerComponentBase ::
        paramGet_PostInactivitySendRetries(Fw::ParamValid& valid)
      {
        U8 _local{};
        this->m_paramLock.lock();
        valid = this->m_param_PostInactivitySendRetries_valid;
        if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
          _local = this->m_PostInactivitySendRetries;
        }
        this->m_paramLock.unlock();
        return _local;
      }

      U8 CfdpManagerComponentBase ::
        paramGet_FileInDefaultChannel(Fw::ParamValid& valid)
      {
        U8 _local{};
        this->m_paramLock.lock();
        valid = this->m_param_FileInDefaultChannel_valid;
        if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
          _local = this->m_FileInDefaultChannel;
        }
        this->m_paramLock.unlock();
        return _local;
      }

      Svc::Ccsds::Cfdp::EntityId CfdpManagerComponentBase ::
        paramGet_FileInDefaultDestEntityId(Fw::ParamValid& valid)
      {
        Svc::Ccsds::Cfdp::EntityId _local{};
        this->m_paramLock.lock();
        valid = this->m_param_FileInDefaultDestEntityId_valid;
        if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
          _local = this->m_FileInDefaultDestEntityId;
        }
        this->m_paramLock.unlock();
        return _local;
      }

      Svc::Ccsds::Cfdp::Class CfdpManagerComponentBase ::
        paramGet_FileInDefaultClass(Fw::ParamValid& valid)
      {
        Svc::Ccsds::Cfdp::Class _local{};
        this->m_paramLock.lock();
        valid = this->m_param_FileInDefaultClass_valid;
        if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
          _local = this->m_FileInDefaultClass;
        }
        this->m_paramLock.unlock();
        return _local;
      }

      Svc::Ccsds::Cfdp::Keep CfdpManagerComponentBase ::
        paramGet_FileInDefaultKeep(Fw::ParamValid& valid)
      {
        Svc::Ccsds::Cfdp::Keep _local{};
        this->m_paramLock.lock();
        valid = this->m_param_FileInDefaultKeep_valid;
        if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
          _local = this->m_FileInDefaultKeep;
        }
        this->m_paramLock.unlock();
        return _local;
      }

      U8 CfdpManagerComponentBase ::
        paramGet_FileInDefaultPriority(Fw::ParamValid& valid)
      {
        U8 _local{};
        this->m_paramLock.lock();
        valid = this->m_param_FileInDefaultPriority_valid;
        if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
          _local = this->m_FileInDefaultPriority;
        }
        this->m_paramLock.unlock();
        return _local;
      }

      Svc::Ccsds::Cfdp::ChannelArrayParams CfdpManagerComponentBase ::
        paramGet_ChannelConfig(Fw::ParamValid& valid)
      {
        Svc::Ccsds::Cfdp::ChannelArrayParams _local{};
        this->m_paramLock.lock();
        valid = this->m_param_ChannelConfig_valid;
        if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
          _local = this->m_ChannelConfig;
        }
        this->m_paramLock.unlock();
        return _local;
      }

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

      Fw::Time CfdpManagerComponentBase ::
        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);
        }
      }

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

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

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

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

      Fw::QueuedComponentBase::MsgDispatchStatus CfdpManagerComponentBase ::
        doDispatch()
      {
        ComponentIpcSerializableBuffer _msg;
        FwQueuePriorityType _priority = 0;

        Os::Queue::Status _msgStatus = this->m_queue.receive(
          _msg,
          Os::Queue::BLOCKING,
          _priority
        );
        FW_ASSERT(
          _msgStatus == Os::Queue::OP_OK,
          static_cast<FwAssertArgType>(_msgStatus)
        );

        // Reset to beginning of buffer
        _msg.resetDeser();

        FwEnumStoreType _desMsg = 0;
        Fw::SerializeStatus _deserStatus = _msg.deserializeTo(_desMsg);
        FW_ASSERT(
          _deserStatus == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_deserStatus)
        );

        MsgTypeEnum _msgType = static_cast<MsgTypeEnum>(_desMsg);

        if (_msgType == CFDPMANAGER_COMPONENT_EXIT) {
          return MSG_DISPATCH_EXIT;
        }

        FwIndexType portNum = 0;
        _deserStatus = _msg.deserializeTo(portNum);
        FW_ASSERT(
          _deserStatus == Fw::FW_SERIALIZE_OK,
          static_cast<FwAssertArgType>(_deserStatus)
        );

        switch (_msgType) {
          // Handle async input port dataIn
          case DATAIN_BUFFERSEND: {
            // Deserialize argument fwBuffer
            Fw::Buffer fwBuffer;
            _deserStatus = _msg.deserializeTo(fwBuffer);
            FW_ASSERT(
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );
            // Call handler function
            this->dataIn_handler(
              portNum,
              fwBuffer
            );

            break;
          }

          // Handle async input port dataReturnIn
          case DATARETURNIN_BUFFERSEND: {
            // Deserialize argument fwBuffer
            Fw::Buffer fwBuffer;
            _deserStatus = _msg.deserializeTo(fwBuffer);
            FW_ASSERT(
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );
            // Call handler function
            this->dataReturnIn_handler(
              portNum,
              fwBuffer
            );

            break;
          }

          // Handle async input port pingIn
          case PINGIN_PING: {
            // Deserialize argument key
            U32 key;
            _deserStatus = _msg.deserializeTo(key);
            FW_ASSERT(
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );
            // Call handler function
            this->pingIn_handler(
              portNum,
              key
            );

            break;
          }

          // Handle async input port run1Hz
          case RUN1HZ_SCHED: {
            // Deserialize argument context
            U32 context;
            _deserStatus = _msg.deserializeTo(context);
            FW_ASSERT(
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );
            // Call handler function
            this->run1Hz_handler(
              portNum,
              context
            );

            break;
          }

          // Handle command SendFile
          case CMD_SENDFILE: {
            // Deserialize opcode
            FwOpcodeType _opCode = 0;
            _deserStatus = _msg.deserializeTo(_opCode);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command sequence
            U32 _cmdSeq = 0;
            _deserStatus = _msg.deserializeTo(_cmdSeq);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command argument buffer
            Fw::CmdArgBuffer args;
            _deserStatus = _msg.deserializeTo(args);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Reset buffer
            args.resetDeser();

            // Deserialize argument channelId
            U8 channelId;
            _deserStatus = args.deserializeTo(channelId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument destId
            Svc::Ccsds::Cfdp::EntityId destId;
            _deserStatus = args.deserializeTo(destId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument cfdpClass
            Svc::Ccsds::Cfdp::Class cfdpClass;
            _deserStatus = args.deserializeTo(cfdpClass);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument keep
            Svc::Ccsds::Cfdp::Keep keep;
            _deserStatus = args.deserializeTo(keep);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument priority
            U8 priority;
            _deserStatus = args.deserializeTo(priority);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument sourceFileName
            Fw::CmdStringArg sourceFileName;
            _deserStatus = args.deserializeTo(sourceFileName);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument destFileName
            Fw::CmdStringArg destFileName;
            _deserStatus = args.deserializeTo(destFileName);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Make sure there was no data left over.
            // That means the argument buffer size was incorrect.
#if FW_CMD_CHECK_RESIDUAL
            if (args.getDeserializeSizeLeft() != 0) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(_opCode, _cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }
#endif

            // Call handler function
            this->SendFile_cmdHandler(
              _opCode, _cmdSeq,
              channelId,
              destId,
              cfdpClass,
              keep,
              priority,
              sourceFileName,
              destFileName
            );

            break;
          }

          // Handle command PlaybackDirectory
          case CMD_PLAYBACKDIRECTORY: {
            // Deserialize opcode
            FwOpcodeType _opCode = 0;
            _deserStatus = _msg.deserializeTo(_opCode);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command sequence
            U32 _cmdSeq = 0;
            _deserStatus = _msg.deserializeTo(_cmdSeq);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command argument buffer
            Fw::CmdArgBuffer args;
            _deserStatus = _msg.deserializeTo(args);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Reset buffer
            args.resetDeser();

            // Deserialize argument channelId
            U8 channelId;
            _deserStatus = args.deserializeTo(channelId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument destId
            Svc::Ccsds::Cfdp::EntityId destId;
            _deserStatus = args.deserializeTo(destId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument cfdpClass
            Svc::Ccsds::Cfdp::Class cfdpClass;
            _deserStatus = args.deserializeTo(cfdpClass);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument keep
            Svc::Ccsds::Cfdp::Keep keep;
            _deserStatus = args.deserializeTo(keep);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument priority
            U8 priority;
            _deserStatus = args.deserializeTo(priority);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument sourceDirectory
            Fw::CmdStringArg sourceDirectory;
            _deserStatus = args.deserializeTo(sourceDirectory);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument destDirectory
            Fw::CmdStringArg destDirectory;
            _deserStatus = args.deserializeTo(destDirectory);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Make sure there was no data left over.
            // That means the argument buffer size was incorrect.
#if FW_CMD_CHECK_RESIDUAL
            if (args.getDeserializeSizeLeft() != 0) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(_opCode, _cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }
#endif

            // Call handler function
            this->PlaybackDirectory_cmdHandler(
              _opCode, _cmdSeq,
              channelId,
              destId,
              cfdpClass,
              keep,
              priority,
              sourceDirectory,
              destDirectory
            );

            break;
          }

          // Handle command PollDirectory
          case CMD_POLLDIRECTORY: {
            // Deserialize opcode
            FwOpcodeType _opCode = 0;
            _deserStatus = _msg.deserializeTo(_opCode);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command sequence
            U32 _cmdSeq = 0;
            _deserStatus = _msg.deserializeTo(_cmdSeq);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command argument buffer
            Fw::CmdArgBuffer args;
            _deserStatus = _msg.deserializeTo(args);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Reset buffer
            args.resetDeser();

            // Deserialize argument channelId
            U8 channelId;
            _deserStatus = args.deserializeTo(channelId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument pollId
            U8 pollId;
            _deserStatus = args.deserializeTo(pollId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument destId
            Svc::Ccsds::Cfdp::EntityId destId;
            _deserStatus = args.deserializeTo(destId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument cfdpClass
            Svc::Ccsds::Cfdp::Class cfdpClass;
            _deserStatus = args.deserializeTo(cfdpClass);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument priority
            U8 priority;
            _deserStatus = args.deserializeTo(priority);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument interval
            U32 interval;
            _deserStatus = args.deserializeTo(interval);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument sourceDirectory
            Fw::CmdStringArg sourceDirectory;
            _deserStatus = args.deserializeTo(sourceDirectory);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument destDirectory
            Fw::CmdStringArg destDirectory;
            _deserStatus = args.deserializeTo(destDirectory);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Make sure there was no data left over.
            // That means the argument buffer size was incorrect.
#if FW_CMD_CHECK_RESIDUAL
            if (args.getDeserializeSizeLeft() != 0) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(_opCode, _cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }
#endif

            // Call handler function
            this->PollDirectory_cmdHandler(
              _opCode, _cmdSeq,
              channelId,
              pollId,
              destId,
              cfdpClass,
              priority,
              interval,
              sourceDirectory,
              destDirectory
            );

            break;
          }

          // Handle command StopPollDirectory
          case CMD_STOPPOLLDIRECTORY: {
            // Deserialize opcode
            FwOpcodeType _opCode = 0;
            _deserStatus = _msg.deserializeTo(_opCode);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command sequence
            U32 _cmdSeq = 0;
            _deserStatus = _msg.deserializeTo(_cmdSeq);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command argument buffer
            Fw::CmdArgBuffer args;
            _deserStatus = _msg.deserializeTo(args);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Reset buffer
            args.resetDeser();

            // Deserialize argument channelId
            U8 channelId;
            _deserStatus = args.deserializeTo(channelId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument pollId
            U8 pollId;
            _deserStatus = args.deserializeTo(pollId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Make sure there was no data left over.
            // That means the argument buffer size was incorrect.
#if FW_CMD_CHECK_RESIDUAL
            if (args.getDeserializeSizeLeft() != 0) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(_opCode, _cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }
#endif

            // Call handler function
            this->StopPollDirectory_cmdHandler(
              _opCode, _cmdSeq,
              channelId,
              pollId
            );

            break;
          }

          // Handle command SetChannelFlow
          case CMD_SETCHANNELFLOW: {
            // Deserialize opcode
            FwOpcodeType _opCode = 0;
            _deserStatus = _msg.deserializeTo(_opCode);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command sequence
            U32 _cmdSeq = 0;
            _deserStatus = _msg.deserializeTo(_cmdSeq);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command argument buffer
            Fw::CmdArgBuffer args;
            _deserStatus = _msg.deserializeTo(args);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Reset buffer
            args.resetDeser();

            // Deserialize argument channelId
            U8 channelId;
            _deserStatus = args.deserializeTo(channelId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument freeze
            Svc::Ccsds::Cfdp::Flow freeze;
            _deserStatus = args.deserializeTo(freeze);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Make sure there was no data left over.
            // That means the argument buffer size was incorrect.
#if FW_CMD_CHECK_RESIDUAL
            if (args.getDeserializeSizeLeft() != 0) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(_opCode, _cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }
#endif

            // Call handler function
            this->SetChannelFlow_cmdHandler(
              _opCode, _cmdSeq,
              channelId,
              freeze
            );

            break;
          }

          // Handle command SuspendResumeTransaction
          case CMD_SUSPENDRESUMETRANSACTION: {
            // Deserialize opcode
            FwOpcodeType _opCode = 0;
            _deserStatus = _msg.deserializeTo(_opCode);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command sequence
            U32 _cmdSeq = 0;
            _deserStatus = _msg.deserializeTo(_cmdSeq);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command argument buffer
            Fw::CmdArgBuffer args;
            _deserStatus = _msg.deserializeTo(args);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Reset buffer
            args.resetDeser();

            // Deserialize argument channelId
            U8 channelId;
            _deserStatus = args.deserializeTo(channelId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument transactionSeq
            Svc::Ccsds::Cfdp::TransactionSeq transactionSeq;
            _deserStatus = args.deserializeTo(transactionSeq);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument entityId
            Svc::Ccsds::Cfdp::EntityId entityId;
            _deserStatus = args.deserializeTo(entityId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument action
            Svc::Ccsds::Cfdp::SuspendResume action;
            _deserStatus = args.deserializeTo(action);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Make sure there was no data left over.
            // That means the argument buffer size was incorrect.
#if FW_CMD_CHECK_RESIDUAL
            if (args.getDeserializeSizeLeft() != 0) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(_opCode, _cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }
#endif

            // Call handler function
            this->SuspendResumeTransaction_cmdHandler(
              _opCode, _cmdSeq,
              channelId,
              transactionSeq,
              entityId,
              action
            );

            break;
          }

          // Handle command CancelTransaction
          case CMD_CANCELTRANSACTION: {
            // Deserialize opcode
            FwOpcodeType _opCode = 0;
            _deserStatus = _msg.deserializeTo(_opCode);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command sequence
            U32 _cmdSeq = 0;
            _deserStatus = _msg.deserializeTo(_cmdSeq);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command argument buffer
            Fw::CmdArgBuffer args;
            _deserStatus = _msg.deserializeTo(args);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Reset buffer
            args.resetDeser();

            // Deserialize argument channelId
            U8 channelId;
            _deserStatus = args.deserializeTo(channelId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument transactionSeq
            Svc::Ccsds::Cfdp::TransactionSeq transactionSeq;
            _deserStatus = args.deserializeTo(transactionSeq);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument entityId
            Svc::Ccsds::Cfdp::EntityId entityId;
            _deserStatus = args.deserializeTo(entityId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Make sure there was no data left over.
            // That means the argument buffer size was incorrect.
#if FW_CMD_CHECK_RESIDUAL
            if (args.getDeserializeSizeLeft() != 0) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(_opCode, _cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }
#endif

            // Call handler function
            this->CancelTransaction_cmdHandler(
              _opCode, _cmdSeq,
              channelId,
              transactionSeq,
              entityId
            );

            break;
          }

          // Handle command AbandonTransaction
          case CMD_ABANDONTRANSACTION: {
            // Deserialize opcode
            FwOpcodeType _opCode = 0;
            _deserStatus = _msg.deserializeTo(_opCode);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command sequence
            U32 _cmdSeq = 0;
            _deserStatus = _msg.deserializeTo(_cmdSeq);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command argument buffer
            Fw::CmdArgBuffer args;
            _deserStatus = _msg.deserializeTo(args);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Reset buffer
            args.resetDeser();

            // Deserialize argument channelId
            U8 channelId;
            _deserStatus = args.deserializeTo(channelId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument transactionSeq
            Svc::Ccsds::Cfdp::TransactionSeq transactionSeq;
            _deserStatus = args.deserializeTo(transactionSeq);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Deserialize argument entityId
            Svc::Ccsds::Cfdp::EntityId entityId;
            _deserStatus = args.deserializeTo(entityId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Make sure there was no data left over.
            // That means the argument buffer size was incorrect.
#if FW_CMD_CHECK_RESIDUAL
            if (args.getDeserializeSizeLeft() != 0) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(_opCode, _cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }
#endif

            // Call handler function
            this->AbandonTransaction_cmdHandler(
              _opCode, _cmdSeq,
              channelId,
              transactionSeq,
              entityId
            );

            break;
          }

          // Handle command ResetCounters
          case CMD_RESETCOUNTERS: {
            // Deserialize opcode
            FwOpcodeType _opCode = 0;
            _deserStatus = _msg.deserializeTo(_opCode);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command sequence
            U32 _cmdSeq = 0;
            _deserStatus = _msg.deserializeTo(_cmdSeq);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Deserialize command argument buffer
            Fw::CmdArgBuffer args;
            _deserStatus = _msg.deserializeTo(args);
            FW_ASSERT (
              _deserStatus == Fw::FW_SERIALIZE_OK,
              static_cast<FwAssertArgType>(_deserStatus)
            );

            // Reset buffer
            args.resetDeser();

            // Deserialize argument channelId
            U8 channelId;
            _deserStatus = args.deserializeTo(channelId);
            if (_deserStatus != Fw::FW_SERIALIZE_OK) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(
                    _opCode,
                    _cmdSeq,
                    Fw::CmdResponse::FORMAT_ERROR
                );
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }

            // Make sure there was no data left over.
            // That means the argument buffer size was incorrect.
#if FW_CMD_CHECK_RESIDUAL
            if (args.getDeserializeSizeLeft() != 0) {
              if (this->isConnected_cmdResponseOut_OutputPort(0)) {
                this->cmdResponse_out(_opCode, _cmdSeq, Fw::CmdResponse::FORMAT_ERROR);
              }
              // Don't crash the task if bad arguments were passed from the ground
              break;
            }
#endif

            // Call handler function
            this->ResetCounters_cmdHandler(
              _opCode, _cmdSeq,
              channelId
            );

            break;
          }

          default:
            return MSG_DISPATCH_ERROR;
        }

        return MSG_DISPATCH_OK;
      }

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

      void CfdpManagerComponentBase ::
        m_p_cmdIn_in(
            Fw::PassiveComponentBase* callComp,
            FwIndexType portNum,
            FwOpcodeType opCode,
            U32 cmdSeq,
            Fw::CmdArgBuffer& args
        )
      {
        FW_ASSERT(callComp != nullptr);
        CfdpManagerComponentBase* compPtr = static_cast<CfdpManagerComponentBase*>(callComp);
        compPtr->cmdIn_handlerBase(
          portNum,
          opCode,
          cmdSeq,
          args
        );
      }

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

      void CfdpManagerComponentBase ::
        m_p_dataIn_in(
            Fw::PassiveComponentBase* callComp,
            FwIndexType portNum,
            Fw::Buffer& fwBuffer
        )
      {
        FW_ASSERT(callComp != nullptr);
        CfdpManagerComponentBase* compPtr = static_cast<CfdpManagerComponentBase*>(callComp);
        compPtr->dataIn_handlerBase(
          portNum,
          fwBuffer
        );
      }

      void CfdpManagerComponentBase ::
        m_p_dataReturnIn_in(
            Fw::PassiveComponentBase* callComp,
            FwIndexType portNum,
            Fw::Buffer& fwBuffer
        )
      {
        FW_ASSERT(callComp != nullptr);
        CfdpManagerComponentBase* compPtr = static_cast<CfdpManagerComponentBase*>(callComp);
        compPtr->dataReturnIn_handlerBase(
          portNum,
          fwBuffer
        );
      }

      Svc::SendFileResponse CfdpManagerComponentBase ::
        m_p_fileIn_in(
            Fw::PassiveComponentBase* callComp,
            FwIndexType portNum,
            const Fw::StringBase& sourceFileName,
            const Fw::StringBase& destFileName,
            U32 offset,
            U32 length
        )
      {
        FW_ASSERT(callComp != nullptr);
        CfdpManagerComponentBase* compPtr = static_cast<CfdpManagerComponentBase*>(callComp);
        return compPtr->fileIn_handlerBase(
          portNum,
          sourceFileName,
          destFileName,
          offset,
          length
        );
      }

      void CfdpManagerComponentBase ::
        m_p_pingIn_in(
            Fw::PassiveComponentBase* callComp,
            FwIndexType portNum,
            U32 key
        )
      {
        FW_ASSERT(callComp != nullptr);
        CfdpManagerComponentBase* compPtr = static_cast<CfdpManagerComponentBase*>(callComp);
        compPtr->pingIn_handlerBase(
          portNum,
          key
        );
      }

      void CfdpManagerComponentBase ::
        m_p_run1Hz_in(
            Fw::PassiveComponentBase* callComp,
            FwIndexType portNum,
            U32 context
        )
      {
        FW_ASSERT(callComp != nullptr);
        CfdpManagerComponentBase* compPtr = static_cast<CfdpManagerComponentBase*>(callComp);
        compPtr->run1Hz_handlerBase(
          portNum,
          context
        );
      }

#if !FW_DIRECT_PORT_CALLS

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

      void CfdpManagerComponentBase ::
        cmdRegOut_out(
            FwIndexType portNum,
            FwOpcodeType opCode
        ) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_cmdRegOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

      void CfdpManagerComponentBase ::
        cmdResponseOut_out(
            FwIndexType portNum,
            FwOpcodeType opCode,
            U32 cmdSeq,
            const Fw::CmdResponse& response
        ) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_cmdResponseOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        FW_ASSERT(
          this->m_cmdResponseOut_OutputPort[portNum].isConnected(),
          static_cast<FwAssertArgType>(portNum)
        );
        this->m_cmdResponseOut_OutputPort[portNum].invoke(
          opCode,
          cmdSeq,
          response
        );
      }

      void CfdpManagerComponentBase ::
        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 CfdpManagerComponentBase ::
        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

      Fw::ParamValid CfdpManagerComponentBase ::
        prmGetOut_out(
            FwIndexType portNum,
            FwPrmIdType id,
            Fw::ParamBuffer& val
        ) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_prmGetOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        FW_ASSERT(
          this->m_prmGetOut_OutputPort[portNum].isConnected(),
          static_cast<FwAssertArgType>(portNum)
        );
        return this->m_prmGetOut_OutputPort[portNum].invoke(
          id,
          val
        );
      }

      void CfdpManagerComponentBase ::
        prmSetOut_out(
            FwIndexType portNum,
            FwPrmIdType id,
            Fw::ParamBuffer& val
        ) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_prmSetOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

        FW_ASSERT(
          this->m_prmSetOut_OutputPort[portNum].isConnected(),
          static_cast<FwAssertArgType>(portNum)
        );
        this->m_prmSetOut_OutputPort[portNum].invoke(
          id,
          val
        );
      }

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

      void CfdpManagerComponentBase ::
        tlmOut_out(
            FwIndexType portNum,
            FwChanIdType id,
            Fw::Time& timeTag,
            Fw::TlmBuffer& val
        ) const
      {
        FW_ASSERT(
          (0 <= portNum) && (portNum < this->getNum_tlmOut_OutputPorts()),
          static_cast<FwAssertArgType>(portNum)
        );

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

#endif

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

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSet_LocalEid(Fw::SerialBufferBase& val)
      {
        Svc::Ccsds::Cfdp::EntityId _localVal{};
        const Fw::SerializeStatus _stat = val.deserializeTo(_localVal);
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }

        // Assign value only if successfully deserialized
        this->m_paramLock.lock();
        this->m_LocalEid = _localVal;
        this->m_param_LocalEid_valid = Fw::ParamValid::VALID;
        this->m_paramLock.unlock();

        // Call notifier
        this->parameterUpdated(PARAMID_LOCALEID);
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSet_OutgoingFileChunkSize(Fw::SerialBufferBase& val)
      {
        U32 _localVal{};
        const Fw::SerializeStatus _stat = val.deserializeTo(_localVal);
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }

        // Assign value only if successfully deserialized
        this->m_paramLock.lock();
        this->m_OutgoingFileChunkSize = _localVal;
        this->m_param_OutgoingFileChunkSize_valid = Fw::ParamValid::VALID;
        this->m_paramLock.unlock();

        // Call notifier
        this->parameterUpdated(PARAMID_OUTGOINGFILECHUNKSIZE);
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSet_RxCrcCalcBytesPerCycle(Fw::SerialBufferBase& val)
      {
        U32 _localVal{};
        const Fw::SerializeStatus _stat = val.deserializeTo(_localVal);
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }

        // Assign value only if successfully deserialized
        this->m_paramLock.lock();
        this->m_RxCrcCalcBytesPerCycle = _localVal;
        this->m_param_RxCrcCalcBytesPerCycle_valid = Fw::ParamValid::VALID;
        this->m_paramLock.unlock();

        // Call notifier
        this->parameterUpdated(PARAMID_RXCRCCALCBYTESPERCYCLE);
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSet_PostInactivitySendRetries(Fw::SerialBufferBase& val)
      {
        U8 _localVal{};
        const Fw::SerializeStatus _stat = val.deserializeTo(_localVal);
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }

        // Assign value only if successfully deserialized
        this->m_paramLock.lock();
        this->m_PostInactivitySendRetries = _localVal;
        this->m_param_PostInactivitySendRetries_valid = Fw::ParamValid::VALID;
        this->m_paramLock.unlock();

        // Call notifier
        this->parameterUpdated(PARAMID_POSTINACTIVITYSENDRETRIES);
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSet_FileInDefaultChannel(Fw::SerialBufferBase& val)
      {
        U8 _localVal{};
        const Fw::SerializeStatus _stat = val.deserializeTo(_localVal);
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }

        // Assign value only if successfully deserialized
        this->m_paramLock.lock();
        this->m_FileInDefaultChannel = _localVal;
        this->m_param_FileInDefaultChannel_valid = Fw::ParamValid::VALID;
        this->m_paramLock.unlock();

        // Call notifier
        this->parameterUpdated(PARAMID_FILEINDEFAULTCHANNEL);
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSet_FileInDefaultDestEntityId(Fw::SerialBufferBase& val)
      {
        Svc::Ccsds::Cfdp::EntityId _localVal{};
        const Fw::SerializeStatus _stat = val.deserializeTo(_localVal);
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }

        // Assign value only if successfully deserialized
        this->m_paramLock.lock();
        this->m_FileInDefaultDestEntityId = _localVal;
        this->m_param_FileInDefaultDestEntityId_valid = Fw::ParamValid::VALID;
        this->m_paramLock.unlock();

        // Call notifier
        this->parameterUpdated(PARAMID_FILEINDEFAULTDESTENTITYID);
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSet_FileInDefaultClass(Fw::SerialBufferBase& val)
      {
        Svc::Ccsds::Cfdp::Class _localVal{};
        const Fw::SerializeStatus _stat = val.deserializeTo(_localVal);
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }

        // Assign value only if successfully deserialized
        this->m_paramLock.lock();
        this->m_FileInDefaultClass = _localVal;
        this->m_param_FileInDefaultClass_valid = Fw::ParamValid::VALID;
        this->m_paramLock.unlock();

        // Call notifier
        this->parameterUpdated(PARAMID_FILEINDEFAULTCLASS);
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSet_FileInDefaultKeep(Fw::SerialBufferBase& val)
      {
        Svc::Ccsds::Cfdp::Keep _localVal{};
        const Fw::SerializeStatus _stat = val.deserializeTo(_localVal);
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }

        // Assign value only if successfully deserialized
        this->m_paramLock.lock();
        this->m_FileInDefaultKeep = _localVal;
        this->m_param_FileInDefaultKeep_valid = Fw::ParamValid::VALID;
        this->m_paramLock.unlock();

        // Call notifier
        this->parameterUpdated(PARAMID_FILEINDEFAULTKEEP);
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSet_FileInDefaultPriority(Fw::SerialBufferBase& val)
      {
        U8 _localVal{};
        const Fw::SerializeStatus _stat = val.deserializeTo(_localVal);
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }

        // Assign value only if successfully deserialized
        this->m_paramLock.lock();
        this->m_FileInDefaultPriority = _localVal;
        this->m_param_FileInDefaultPriority_valid = Fw::ParamValid::VALID;
        this->m_paramLock.unlock();

        // Call notifier
        this->parameterUpdated(PARAMID_FILEINDEFAULTPRIORITY);
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSet_ChannelConfig(Fw::SerialBufferBase& val)
      {
        Svc::Ccsds::Cfdp::ChannelArrayParams _localVal{};
        const Fw::SerializeStatus _stat = val.deserializeTo(_localVal);
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }

        // Assign value only if successfully deserialized
        this->m_paramLock.lock();
        this->m_ChannelConfig = _localVal;
        this->m_param_ChannelConfig_valid = Fw::ParamValid::VALID;
        this->m_paramLock.unlock();

        // Call notifier
        this->parameterUpdated(PARAMID_CHANNELCONFIG);
        return Fw::CmdResponse::OK;
      }

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

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSave_LocalEid()
      {
        if (!this->isConnected_prmSetOut_OutputPort(0)) {
          return Fw::CmdResponse::EXECUTION_ERROR;
        }
        Fw::ParamBuffer _paramBuffer;
        const FwIdType idBase = this->getIdBase();
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR;
        // Serialize the parameter
        this->m_paramLock.lock();
        if ((this->m_param_LocalEid_valid == Fw::ParamValid::VALID) || (this->m_param_LocalEid_valid == Fw::ParamValid::DEFAULT)) {
          _stat = _paramBuffer.serializeFrom(m_LocalEid);
        }
        this->m_paramLock.unlock();
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }
        // Save the parameter
        this->prmSetOut_out(
          0,
          static_cast<FwPrmIdType>(idBase + PARAMID_LOCALEID),
          _paramBuffer
        );
        // Return the command response
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSave_OutgoingFileChunkSize()
      {
        if (!this->isConnected_prmSetOut_OutputPort(0)) {
          return Fw::CmdResponse::EXECUTION_ERROR;
        }
        Fw::ParamBuffer _paramBuffer;
        const FwIdType idBase = this->getIdBase();
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR;
        // Serialize the parameter
        this->m_paramLock.lock();
        if ((this->m_param_OutgoingFileChunkSize_valid == Fw::ParamValid::VALID) || (this->m_param_OutgoingFileChunkSize_valid == Fw::ParamValid::DEFAULT)) {
          _stat = _paramBuffer.serializeFrom(m_OutgoingFileChunkSize);
        }
        this->m_paramLock.unlock();
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }
        // Save the parameter
        this->prmSetOut_out(
          0,
          static_cast<FwPrmIdType>(idBase + PARAMID_OUTGOINGFILECHUNKSIZE),
          _paramBuffer
        );
        // Return the command response
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSave_RxCrcCalcBytesPerCycle()
      {
        if (!this->isConnected_prmSetOut_OutputPort(0)) {
          return Fw::CmdResponse::EXECUTION_ERROR;
        }
        Fw::ParamBuffer _paramBuffer;
        const FwIdType idBase = this->getIdBase();
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR;
        // Serialize the parameter
        this->m_paramLock.lock();
        if ((this->m_param_RxCrcCalcBytesPerCycle_valid == Fw::ParamValid::VALID) || (this->m_param_RxCrcCalcBytesPerCycle_valid == Fw::ParamValid::DEFAULT)) {
          _stat = _paramBuffer.serializeFrom(m_RxCrcCalcBytesPerCycle);
        }
        this->m_paramLock.unlock();
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }
        // Save the parameter
        this->prmSetOut_out(
          0,
          static_cast<FwPrmIdType>(idBase + PARAMID_RXCRCCALCBYTESPERCYCLE),
          _paramBuffer
        );
        // Return the command response
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSave_PostInactivitySendRetries()
      {
        if (!this->isConnected_prmSetOut_OutputPort(0)) {
          return Fw::CmdResponse::EXECUTION_ERROR;
        }
        Fw::ParamBuffer _paramBuffer;
        const FwIdType idBase = this->getIdBase();
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR;
        // Serialize the parameter
        this->m_paramLock.lock();
        if ((this->m_param_PostInactivitySendRetries_valid == Fw::ParamValid::VALID) || (this->m_param_PostInactivitySendRetries_valid == Fw::ParamValid::DEFAULT)) {
          _stat = _paramBuffer.serializeFrom(m_PostInactivitySendRetries);
        }
        this->m_paramLock.unlock();
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }
        // Save the parameter
        this->prmSetOut_out(
          0,
          static_cast<FwPrmIdType>(idBase + PARAMID_POSTINACTIVITYSENDRETRIES),
          _paramBuffer
        );
        // Return the command response
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSave_FileInDefaultChannel()
      {
        if (!this->isConnected_prmSetOut_OutputPort(0)) {
          return Fw::CmdResponse::EXECUTION_ERROR;
        }
        Fw::ParamBuffer _paramBuffer;
        const FwIdType idBase = this->getIdBase();
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR;
        // Serialize the parameter
        this->m_paramLock.lock();
        if ((this->m_param_FileInDefaultChannel_valid == Fw::ParamValid::VALID) || (this->m_param_FileInDefaultChannel_valid == Fw::ParamValid::DEFAULT)) {
          _stat = _paramBuffer.serializeFrom(m_FileInDefaultChannel);
        }
        this->m_paramLock.unlock();
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }
        // Save the parameter
        this->prmSetOut_out(
          0,
          static_cast<FwPrmIdType>(idBase + PARAMID_FILEINDEFAULTCHANNEL),
          _paramBuffer
        );
        // Return the command response
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSave_FileInDefaultDestEntityId()
      {
        if (!this->isConnected_prmSetOut_OutputPort(0)) {
          return Fw::CmdResponse::EXECUTION_ERROR;
        }
        Fw::ParamBuffer _paramBuffer;
        const FwIdType idBase = this->getIdBase();
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR;
        // Serialize the parameter
        this->m_paramLock.lock();
        if ((this->m_param_FileInDefaultDestEntityId_valid == Fw::ParamValid::VALID) || (this->m_param_FileInDefaultDestEntityId_valid == Fw::ParamValid::DEFAULT)) {
          _stat = _paramBuffer.serializeFrom(m_FileInDefaultDestEntityId);
        }
        this->m_paramLock.unlock();
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }
        // Save the parameter
        this->prmSetOut_out(
          0,
          static_cast<FwPrmIdType>(idBase + PARAMID_FILEINDEFAULTDESTENTITYID),
          _paramBuffer
        );
        // Return the command response
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSave_FileInDefaultClass()
      {
        if (!this->isConnected_prmSetOut_OutputPort(0)) {
          return Fw::CmdResponse::EXECUTION_ERROR;
        }
        Fw::ParamBuffer _paramBuffer;
        const FwIdType idBase = this->getIdBase();
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR;
        // Serialize the parameter
        this->m_paramLock.lock();
        if ((this->m_param_FileInDefaultClass_valid == Fw::ParamValid::VALID) || (this->m_param_FileInDefaultClass_valid == Fw::ParamValid::DEFAULT)) {
          _stat = _paramBuffer.serializeFrom(m_FileInDefaultClass);
        }
        this->m_paramLock.unlock();
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }
        // Save the parameter
        this->prmSetOut_out(
          0,
          static_cast<FwPrmIdType>(idBase + PARAMID_FILEINDEFAULTCLASS),
          _paramBuffer
        );
        // Return the command response
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSave_FileInDefaultKeep()
      {
        if (!this->isConnected_prmSetOut_OutputPort(0)) {
          return Fw::CmdResponse::EXECUTION_ERROR;
        }
        Fw::ParamBuffer _paramBuffer;
        const FwIdType idBase = this->getIdBase();
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR;
        // Serialize the parameter
        this->m_paramLock.lock();
        if ((this->m_param_FileInDefaultKeep_valid == Fw::ParamValid::VALID) || (this->m_param_FileInDefaultKeep_valid == Fw::ParamValid::DEFAULT)) {
          _stat = _paramBuffer.serializeFrom(m_FileInDefaultKeep);
        }
        this->m_paramLock.unlock();
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }
        // Save the parameter
        this->prmSetOut_out(
          0,
          static_cast<FwPrmIdType>(idBase + PARAMID_FILEINDEFAULTKEEP),
          _paramBuffer
        );
        // Return the command response
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSave_FileInDefaultPriority()
      {
        if (!this->isConnected_prmSetOut_OutputPort(0)) {
          return Fw::CmdResponse::EXECUTION_ERROR;
        }
        Fw::ParamBuffer _paramBuffer;
        const FwIdType idBase = this->getIdBase();
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR;
        // Serialize the parameter
        this->m_paramLock.lock();
        if ((this->m_param_FileInDefaultPriority_valid == Fw::ParamValid::VALID) || (this->m_param_FileInDefaultPriority_valid == Fw::ParamValid::DEFAULT)) {
          _stat = _paramBuffer.serializeFrom(m_FileInDefaultPriority);
        }
        this->m_paramLock.unlock();
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }
        // Save the parameter
        this->prmSetOut_out(
          0,
          static_cast<FwPrmIdType>(idBase + PARAMID_FILEINDEFAULTPRIORITY),
          _paramBuffer
        );
        // Return the command response
        return Fw::CmdResponse::OK;
      }

      Fw::CmdResponse CfdpManagerComponentBase ::
        paramSave_ChannelConfig()
      {
        if (!this->isConnected_prmSetOut_OutputPort(0)) {
          return Fw::CmdResponse::EXECUTION_ERROR;
        }
        Fw::ParamBuffer _paramBuffer;
        const FwIdType idBase = this->getIdBase();
        Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_FORMAT_ERROR;
        // Serialize the parameter
        this->m_paramLock.lock();
        if ((this->m_param_ChannelConfig_valid == Fw::ParamValid::VALID) || (this->m_param_ChannelConfig_valid == Fw::ParamValid::DEFAULT)) {
          _stat = _paramBuffer.serializeFrom(m_ChannelConfig);
        }
        this->m_paramLock.unlock();
        if (_stat != Fw::FW_SERIALIZE_OK) {
          return Fw::CmdResponse::VALIDATION_ERROR;
        }
        // Save the parameter
        this->prmSetOut_out(
          0,
          static_cast<FwPrmIdType>(idBase + PARAMID_CHANNELCONFIG),
          _paramBuffer
        );
        // Return the command response
        return Fw::CmdResponse::OK;
      }

    }

  }

}