DpCompressProcComponentAc.cpp

Go to the documentation of this file.

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

#include "Fw/Types/Assert.hpp"
#include "Fw/Types/ExternalString.hpp"
#if FW_ENABLE_TEXT_LOGGING
#include "Fw/Types/String.hpp"
#endif
#include "Svc/DpCompressProc/DpCompressProcComponentAc.hpp"

namespace Svc {

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

  DpCompressProcComponentBase::DpContainer ::
    DpContainer(
        FwDpIdType id,
        const Fw::Buffer& buffer,
        FwDpIdType baseId
    ) :
      Fw::DpContainer(id, buffer),
      m_baseId(baseId)
  {

  }

  DpCompressProcComponentBase::DpContainer ::
    DpContainer() :
      Fw::DpContainer(),
      m_baseId(0)
  {

  }

  Fw::SerializeStatus DpCompressProcComponentBase::DpContainer ::
    serializeRecord_CompressionRecord(
        const U8* array,
        FwSizeType size
    )
  {
    FW_ASSERT(array != nullptr);
    // Compute the size delta
    const FwSizeType sizeDelta =
      sizeof(FwDpIdType) +
      sizeof(FwSizeStoreType) +
      size * sizeof(U8);
    // Serialize the elements if they will fit
    Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;
    if ((this->m_dataBuffer.getSize() + sizeDelta) <= this->m_dataBuffer.getCapacity()) {
      const FwDpIdType id = this->m_baseId + RecordId::CompressionRecord;
      status = this->m_dataBuffer.serializeFrom(id);
      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
      status = this->m_dataBuffer.serializeSize(size);
      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
      status = this->m_dataBuffer.serializeFrom(array, size, Fw::Serialization::OMIT_LENGTH);
      FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
      this->m_dataSize += sizeDelta;
    }
    else {
      status = Fw::FW_SERIALIZE_NO_ROOM_LEFT;
    }
    return status;
  }

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

  void DpCompressProcComponentBase ::
    init(FwEnumStoreType instance)
  {
    // Initialize base class
    Fw::PassiveComponentBase::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 procRequest
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_procRequest_InputPorts());
      port++
    ) {
      this->m_procRequest_InputPort[port].init();
      this->m_procRequest_InputPort[port].addCallComp(
        this,
        m_p_procRequest_in
      );
      this->m_procRequest_InputPort[port].setPortNum(port);

#if FW_OBJECT_NAMES == 1
      Fw::ObjectName portName;
      portName.format(
        "%s_procRequest_InputPort[%" PRI_FwIndexType "]",
        this->m_objName.toChar(),
        port
      );
      this->m_procRequest_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 dpGet
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_dpGet_OutputPorts());
      port++
    ) {
      this->m_dpGet_OutputPort[port].init();

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

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

#if FW_OBJECT_NAMES == 1
      Fw::ObjectName portName;
      portName.format(
        "%s_dpSend_OutputPort[%" PRI_FwIndexType "]",
        this->m_objName.toChar(),
        port
      );
      this->m_dpSend_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 compressChunk
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_compressChunk_OutputPorts());
      port++
    ) {
      this->m_compressChunk_OutputPort[port].init();

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

#if !FW_DIRECT_PORT_CALLS

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

  Fw::InputCmdPort* DpCompressProcComponentBase ::
    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* DpCompressProcComponentBase ::
    get_procRequest_InputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_procRequest_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    return &this->m_procRequest_InputPort[portNum];
  }

#endif

#if !FW_DIRECT_PORT_CALLS

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

  void DpCompressProcComponentBase ::
    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 DpCompressProcComponentBase ::
    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 DpCompressProcComponentBase ::
    set_dpGet_OutputPort(
        FwIndexType portNum,
        Fw::InputDpGetPort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_dpGet_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  void DpCompressProcComponentBase ::
    set_dpSend_OutputPort(
        FwIndexType portNum,
        Fw::InputDpSendPort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_dpSend_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

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

#endif

#if !FW_DIRECT_PORT_CALLS

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

  void DpCompressProcComponentBase ::
    set_compressChunk_OutputPort(
        FwIndexType portNum,
        Svc::InputCompressChunkPort* port
    )
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_compressChunk_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

#endif

#if !FW_DIRECT_PORT_CALLS && FW_PORT_SERIALIZATION

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

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

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

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

#endif

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

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

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

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

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

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

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

  void DpCompressProcComponentBase ::
    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_CHUNK_SIZE;

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

    this->m_paramLock.lock();

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

    this->m_paramLock.unlock();

    _id = _baseId + PARAMID_ENABLE;

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

    this->m_paramLock.lock();

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

    this->m_paramLock.unlock();

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

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

  DpCompressProcComponentBase ::
    DpCompressProcComponentBase(const char* compName) :
      Fw::PassiveComponentBase(compName)
  {
    this->m_DidNotCompressThrottle = 0;
    this->m_InvalidHeaderThrottle = 0;
    this->m_BufferTooSmallForPacketThrottle = 0;
    this->m_ContainerTooLargeThrottle = 0;
  }

  DpCompressProcComponentBase ::
    ~DpCompressProcComponentBase()
  {

  }

#if !FW_DIRECT_PORT_CALLS

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

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

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

  bool DpCompressProcComponentBase ::
    isConnected_dpSend_OutputPort(FwIndexType portNum) const
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_dpSend_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

  bool DpCompressProcComponentBase ::
    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 DpCompressProcComponentBase ::
    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 DpCompressProcComponentBase ::
    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 DpCompressProcComponentBase ::
    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 DpCompressProcComponentBase ::
    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();
  }

#endif

#if !FW_DIRECT_PORT_CALLS

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

  bool DpCompressProcComponentBase ::
    isConnected_compressChunk_OutputPort(FwIndexType portNum) const
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_compressChunk_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

#endif

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

  void DpCompressProcComponentBase ::
    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_CHUNK_SIZE_SET: {
        Fw::CmdResponse _cstat = this->paramSet_CHUNK_SIZE(args);
        this->cmdResponse_out(
          opCode,
          cmdSeq,
          _cstat
        );
        break;
      }

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

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

      case OPCODE_ENABLE_SAVE: {
        Fw::CmdResponse _cstat = this->paramSave_ENABLE();
        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 DpCompressProcComponentBase ::
    procRequest_handlerBase(
        FwIndexType portNum,
        Fw::Buffer& fwBuffer
    )
  {
    // Make sure port number is valid
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_procRequest_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    // Call handler function
    this->procRequest_handler(
      portNum,
      fwBuffer
    );
  }

#if !FW_DIRECT_PORT_CALLS

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

  Svc::CompressionAlgorithm DpCompressProcComponentBase ::
    compressChunk_out(
        FwIndexType portNum,
        Fw::Buffer& buffer,
        FwSizeType min_compression,
        FwSizeType write_offset
    ) const
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_compressChunk_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    FW_ASSERT(
      this->m_compressChunk_OutputPort[portNum].isConnected(),
      static_cast<FwAssertArgType>(portNum)
    );
    return this->m_compressChunk_OutputPort[portNum].invoke(
      buffer,
      min_compression,
      write_offset
    );
  }

#endif

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

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

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

  void DpCompressProcComponentBase ::
    log_DIAGNOSTIC_CompressionComplete(
        FwDpIdType dp_id,
        FwSizeType initial_size,
        FwSizeType final_size
    ) const
  {
    // Get the time
    Fw::Time _logTime;
    if (this->isConnected_timeCaller_OutputPort(0)) {
      this->timeCaller_out(0, _logTime);
    }

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

    // 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(FwDpIdType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(dp_id);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

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

#if FW_AMPCS_COMPATIBLE
      // Serialize the argument size
      _status = _logBuff.serializeFrom(
        static_cast<U8>(sizeof(FwSizeType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(final_size);
      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: Compressed Data Product %" PRIu32 " from %" PRIu64 " to %" PRIu64 " bytes";
#else
      const char* _formatString =
        "%s: Compressed Data Product %" PRIu32 " from %" PRIu64 " to %" PRIu64 " bytes";
#endif

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

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

  void DpCompressProcComponentBase ::
    log_ACTIVITY_LO_DidNotCompress(
        FwDpIdType dp_id,
        FwSizeType data_size
    )
  {
    // Check throttle value
    if (this->m_DidNotCompressThrottle >= EVENTID_DIDNOTCOMPRESS_THROTTLE) {
      return;
    }
    else {
      this->m_DidNotCompressThrottle++;
    }

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

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

    // 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(FwDpIdType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(dp_id);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

#if FW_AMPCS_COMPATIBLE
      // Serialize the argument size
      _status = _logBuff.serializeFrom(
        static_cast<U8>(sizeof(FwSizeType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(data_size);
      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: Unable to reduce size of Data Product %" PRIu32 ". Uncompressed size %" PRIu64 "";
#else
      const char* _formatString =
        "%s: Unable to reduce size of Data Product %" PRIu32 ". Uncompressed size %" PRIu64 "";
#endif

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

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

  void DpCompressProcComponentBase ::
    log_WARNING_HI_InvalidHeader(
        FwSizeType buffer_size,
        U32 error_code
    )
  {
    // Check throttle value
    if (this->m_InvalidHeaderThrottle >= EVENTID_INVALIDHEADER_THROTTLE) {
      return;
    }
    else {
      this->m_InvalidHeaderThrottle++;
    }

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

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

    // 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(FwSizeType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(buffer_size);
      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(error_code);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

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

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Received buffer of size %" PRIu64 "; deserialization of container header failed with error code %" PRIu32 "";
#else
      const char* _formatString =
        "%s: Received buffer of size %" PRIu64 "; deserialization of container header failed with error code %" PRIu32 "";
#endif

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

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

  void DpCompressProcComponentBase ::
    log_WARNING_HI_BufferTooSmallForPacket(
        FwSizeType buffer_size,
        FwSizeType min_size
    )
  {
    // Check throttle value
    if (this->m_BufferTooSmallForPacketThrottle >= EVENTID_BUFFERTOOSMALLFORPACKET_THROTTLE) {
      return;
    }
    else {
      this->m_BufferTooSmallForPacketThrottle++;
    }

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

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

    // 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(FwSizeType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(buffer_size);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

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

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

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Received buffer has size %" PRIu64 "; minimum required size is %" PRIu64 "";
#else
      const char* _formatString =
        "%s: Received buffer has size %" PRIu64 "; minimum required size is %" PRIu64 "";
#endif

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

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

  void DpCompressProcComponentBase ::
    log_WARNING_HI_ContainerTooLarge(
        FwDpIdType dp_id,
        FwSizeType data_size
    )
  {
    // Check throttle value
    if (this->m_ContainerTooLargeThrottle >= EVENTID_CONTAINERTOOLARGE_THROTTLE) {
      return;
    }
    else {
      this->m_ContainerTooLargeThrottle++;
    }

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

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

    // 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(FwDpIdType))
      );
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );
#endif
      _status = _logBuff.serializeFrom(dp_id);
      FW_ASSERT(
        _status == Fw::FW_SERIALIZE_OK,
        static_cast<FwAssertArgType>(_status)
      );

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

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

    // Emit the event on the text log port
#if FW_ENABLE_TEXT_LOGGING
    if (this->isConnected_logTextOut_OutputPort(0)) {
#if FW_OBJECT_NAMES == 1
      const char* _formatString =
        "(%s) %s: Data Product %" PRIu32 " has data size %" PRIu64 ", too large for a record size field";
#else
      const char* _formatString =
        "%s: Data Product %" PRIu32 " has data size %" PRIu64 ", too large for a record size field";
#endif

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

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

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

  void DpCompressProcComponentBase ::
    log_ACTIVITY_LO_DidNotCompress_ThrottleClear()
  {
    // Reset throttle counter
    this->m_DidNotCompressThrottle = 0;
  }

  void DpCompressProcComponentBase ::
    log_WARNING_HI_InvalidHeader_ThrottleClear()
  {
    // Reset throttle counter
    this->m_InvalidHeaderThrottle = 0;
  }

  void DpCompressProcComponentBase ::
    log_WARNING_HI_BufferTooSmallForPacket_ThrottleClear()
  {
    // Reset throttle counter
    this->m_BufferTooSmallForPacketThrottle = 0;
  }

  void DpCompressProcComponentBase ::
    log_WARNING_HI_ContainerTooLarge_ThrottleClear()
  {
    // Reset throttle counter
    this->m_ContainerTooLargeThrottle = 0;
  }

  // ----------------------------------------------------------------------
  // Parameter hook functions
  // ----------------------------------------------------------------------

  void DpCompressProcComponentBase ::
    parameterUpdated(FwPrmIdType id)
  {
    // Do nothing by default
  }

  void DpCompressProcComponentBase ::
    parametersLoaded()
  {
    // Do nothing by default
  }

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

  FwSizeStoreType DpCompressProcComponentBase ::
    paramGet_CHUNK_SIZE(Fw::ParamValid& valid)
  {
    FwSizeStoreType _local{};
    this->m_paramLock.lock();
    valid = this->m_param_CHUNK_SIZE_valid;
    if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
      _local = this->m_CHUNK_SIZE;
    }
    this->m_paramLock.unlock();
    return _local;
  }

  Fw::Enabled DpCompressProcComponentBase ::
    paramGet_ENABLE(Fw::ParamValid& valid)
  {
    Fw::Enabled _local{};
    this->m_paramLock.lock();
    valid = this->m_param_ENABLE_valid;
    if ((valid == Fw::ParamValid::VALID) || (valid == Fw::ParamValid::DEFAULT)) {
      _local = this->m_ENABLE;
    }
    this->m_paramLock.unlock();
    return _local;
  }

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

  void DpCompressProcComponentBase ::
    dpSend(
        DpContainer& container,
        Fw::Time timeTag
    )
  {
    // Update the time tag
    if (timeTag == Fw::ZERO_TIME) {
      // Get the time from the time port
      timeTag = this->getTime();
    }
    container.setTimeTag(timeTag);
    // Serialize the header into the packet
    container.serializeHeader();
    // Update the size of the buffer according to the data size
    const FwSizeType packetSize = container.getPacketSize();
    Fw::Buffer buffer = container.getBuffer();
    FW_ASSERT(packetSize <= buffer.getSize(), static_cast<FwAssertArgType>(packetSize),
        static_cast<FwAssertArgType>(buffer.getSize()));
    buffer.setSize(static_cast<U32>(packetSize));
    // Invalidate the buffer in the container, so it can't be reused
    container.invalidateBuffer();
    // Send the buffer
    this->dpSend_out(0, container.getId(), buffer);
  }

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

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

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

  void DpCompressProcComponentBase ::
    m_p_cmdIn_in(
        Fw::PassiveComponentBase* callComp,
        FwIndexType portNum,
        FwOpcodeType opCode,
        U32 cmdSeq,
        Fw::CmdArgBuffer& args
    )
  {
    FW_ASSERT(callComp != nullptr);
    DpCompressProcComponentBase* compPtr = static_cast<DpCompressProcComponentBase*>(callComp);
    compPtr->cmdIn_handlerBase(
      portNum,
      opCode,
      cmdSeq,
      args
    );
  }

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

  void DpCompressProcComponentBase ::
    m_p_procRequest_in(
        Fw::PassiveComponentBase* callComp,
        FwIndexType portNum,
        Fw::Buffer& fwBuffer
    )
  {
    FW_ASSERT(callComp != nullptr);
    DpCompressProcComponentBase* compPtr = static_cast<DpCompressProcComponentBase*>(callComp);
    compPtr->procRequest_handlerBase(
      portNum,
      fwBuffer
    );
  }

#if !FW_DIRECT_PORT_CALLS

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

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

  Fw::Success DpCompressProcComponentBase ::
    dpGet_out(
        FwIndexType portNum,
        FwDpIdType id,
        FwSizeType dataSize,
        Fw::Buffer& buffer
    ) const
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_dpGet_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    FW_ASSERT(
      this->m_dpGet_OutputPort[portNum].isConnected(),
      static_cast<FwAssertArgType>(portNum)
    );
    return this->m_dpGet_OutputPort[portNum].invoke(
      id,
      dataSize,
      buffer
    );
  }

  void DpCompressProcComponentBase ::
    dpSend_out(
        FwIndexType portNum,
        FwDpIdType id,
        const Fw::Buffer& buffer
    ) const
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_dpSend_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    FW_ASSERT(
      this->m_dpSend_OutputPort[portNum].isConnected(),
      static_cast<FwAssertArgType>(portNum)
    );
    this->m_dpSend_OutputPort[portNum].invoke(
      id,
      buffer
    );
  }

  void DpCompressProcComponentBase ::
    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 DpCompressProcComponentBase ::
    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 DpCompressProcComponentBase ::
    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 DpCompressProcComponentBase ::
    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 DpCompressProcComponentBase ::
    timeCaller_out(
        FwIndexType portNum,
        Fw::Time& time
    ) const
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_timeCaller_OutputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

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

#endif

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

  Fw::CmdResponse DpCompressProcComponentBase ::
    paramSet_CHUNK_SIZE(Fw::SerialBufferBase& val)
  {
    FwSizeStoreType _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_CHUNK_SIZE = _localVal;
    this->m_param_CHUNK_SIZE_valid = Fw::ParamValid::VALID;
    this->m_paramLock.unlock();

    // Call notifier
    this->parameterUpdated(PARAMID_CHUNK_SIZE);
    return Fw::CmdResponse::OK;
  }

  Fw::CmdResponse DpCompressProcComponentBase ::
    paramSet_ENABLE(Fw::SerialBufferBase& val)
  {
    Fw::Enabled _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_ENABLE = _localVal;
    this->m_param_ENABLE_valid = Fw::ParamValid::VALID;
    this->m_paramLock.unlock();

    // Call notifier
    this->parameterUpdated(PARAMID_ENABLE);
    return Fw::CmdResponse::OK;
  }

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

  Fw::CmdResponse DpCompressProcComponentBase ::
    paramSave_CHUNK_SIZE()
  {
    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_CHUNK_SIZE_valid == Fw::ParamValid::VALID) || (this->m_param_CHUNK_SIZE_valid == Fw::ParamValid::DEFAULT)) {
      _stat = _paramBuffer.serializeFrom(m_CHUNK_SIZE);
    }
    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_CHUNK_SIZE),
      _paramBuffer
    );
    // Return the command response
    return Fw::CmdResponse::OK;
  }

  Fw::CmdResponse DpCompressProcComponentBase ::
    paramSave_ENABLE()
  {
    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_ENABLE_valid == Fw::ParamValid::VALID) || (this->m_param_ENABLE_valid == Fw::ParamValid::DEFAULT)) {
      _stat = _paramBuffer.serializeFrom(m_ENABLE);
    }
    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_ENABLE),
      _paramBuffer
    );
    // Return the command response
    return Fw::CmdResponse::OK;
  }

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

  Fw::Success::T DpCompressProcComponentBase ::
    dpGet(
        ContainerId::T containerId,
        FwSizeType dataSize,
        FwDpPriorityType priority,
        DpContainer& container
    )
  {
    const FwDpIdType baseId = this->getIdBase();
    const FwDpIdType globalId = baseId + containerId;
    const FwSizeType size = DpContainer::getPacketSizeForDataSize(dataSize);
    Fw::Buffer buffer;
    const Fw::Success::T status = this->dpGet_out(0, globalId, size, buffer);
    if (status == Fw::Success::SUCCESS) {
      // Assign a fresh DpContainer into container
      // This action clears out all the container state
      container = DpContainer(globalId, buffer, baseId);
      container.setPriority(priority);
    }
    return status;
  }

}