ComAggregatorComponentAc.cpp

Go to the documentation of this file.

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

namespace Svc {

  namespace {

    // Constant definitions for the state machine signal buffer
    namespace SmSignalBuffer {

      // Union for computing the max size of a signal type
      union SignalTypeUnion {
        BYTE size_of_Fw_Success[Fw::Success::SERIALIZED_SIZE];
        BYTE size_of_Svc_ComDataContextPair[Svc::ComDataContextPair::SERIALIZED_SIZE];
      };

      // The serialized size
      static constexpr FwSizeType SERIALIZED_SIZE =
        2 * sizeof(FwEnumStoreType) +
        sizeof(SignalTypeUnion);

    }

    enum MsgTypeEnum {
      COMAGGREGATOR_COMPONENT_EXIT = Fw::ActiveComponentBase::ACTIVE_COMPONENT_EXIT,
      INTERNAL_STATE_MACHINE_SIGNAL,
    };

    // Get the max size by constructing a union of the async input, command, and
    // internal port serialization sizes
    union BuffUnion {
      // Size of buffer for internal state machine signals
      // The internal SmSignalBuffer stores the state machine id, the
      // signal id, and the signal data
      BYTE internalSmBufferSize[SmSignalBuffer::SERIALIZED_SIZE];
    };

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

        Fw::Serializable::SizeType getCapacity() const {
          return sizeof(m_buff);
        }

        U8* getBuffAddr() {
          return m_buff;
        }

        const U8* getBuffAddr() const {
          return m_buff;
        }

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

    };
  }

  // ----------------------------------------------------------------------
  // Types for internal state machines
  // ----------------------------------------------------------------------

  ComAggregatorComponentBase::Svc_AggregationMachine ::
    Svc_AggregationMachine(ComAggregatorComponentBase& component) :
      m_component(component)
  {

  }

  void ComAggregatorComponentBase::Svc_AggregationMachine ::
    init(ComAggregatorComponentBase::SmId smId)
  {
    this->initBase(static_cast<FwEnumStoreType>(smId));
  }

  ComAggregatorComponentBase::SmId ComAggregatorComponentBase::Svc_AggregationMachine ::
    getId() const
  {
    return static_cast<ComAggregatorComponentBase::SmId>(this->m_id);
  }

  void ComAggregatorComponentBase::Svc_AggregationMachine ::
    action_doClear(Signal signal)
  {
    this->m_component.Svc_AggregationMachine_action_doClear(this->getId(), signal);
  }

  void ComAggregatorComponentBase::Svc_AggregationMachine ::
    action_doFill(
        Signal signal,
        const Svc::ComDataContextPair& value
    )
  {
    this->m_component.Svc_AggregationMachine_action_doFill(this->getId(), signal, value);
  }

  void ComAggregatorComponentBase::Svc_AggregationMachine ::
    action_doSend(Signal signal)
  {
    this->m_component.Svc_AggregationMachine_action_doSend(this->getId(), signal);
  }

  void ComAggregatorComponentBase::Svc_AggregationMachine ::
    action_doHold(
        Signal signal,
        const Svc::ComDataContextPair& value
    )
  {
    this->m_component.Svc_AggregationMachine_action_doHold(this->getId(), signal, value);
  }

  void ComAggregatorComponentBase::Svc_AggregationMachine ::
    action_assertNoStatus(Signal signal)
  {
    this->m_component.Svc_AggregationMachine_action_assertNoStatus(this->getId(), signal);
  }

  bool ComAggregatorComponentBase::Svc_AggregationMachine ::
    guard_isFull(
        Signal signal,
        const Svc::ComDataContextPair& value
    ) const
  {
    return this->m_component.Svc_AggregationMachine_guard_isFull(this->getId(), signal, value);
  }

  bool ComAggregatorComponentBase::Svc_AggregationMachine ::
    guard_isNotEmpty(Signal signal) const
  {
    return this->m_component.Svc_AggregationMachine_guard_isNotEmpty(this->getId(), signal);
  }

  bool ComAggregatorComponentBase::Svc_AggregationMachine ::
    guard_isGood(
        Signal signal,
        const Fw::Success& value
    ) const
  {
    return this->m_component.Svc_AggregationMachine_guard_isGood(this->getId(), signal, value);
  }

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

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

    // Initialize state machine instances
    this->m_stateMachine_aggregationMachine.init(SmId::aggregationMachine);

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

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

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

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

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

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

    // Connect input port timeout
    for (
      FwIndexType port = 0;
      port < static_cast<FwIndexType>(this->getNum_timeout_InputPorts());
      port++
    ) {
      this->m_timeout_InputPort[port].init();
      this->m_timeout_InputPort[port].addCallComp(
        this,
        m_p_timeout_in
      );
      this->m_timeout_InputPort[port].setPortNum(port);

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

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

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

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

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

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

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

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

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

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

    return &this->m_comStatusIn_InputPort[portNum];
  }

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

    return &this->m_dataIn_InputPort[portNum];
  }

  Svc::InputComDataWithContextPort* ComAggregatorComponentBase ::
    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::InputSchedPort* ComAggregatorComponentBase ::
    get_timeout_InputPort(FwIndexType portNum)
  {
    FW_ASSERT(
      (0 <= portNum) && (portNum < this->getNum_timeout_InputPorts()),
      static_cast<FwAssertArgType>(portNum)
    );

    return &this->m_timeout_InputPort[portNum];
  }

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

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

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

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

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

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

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

#if FW_PORT_SERIALIZATION

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

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

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

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

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

#endif

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

  ComAggregatorComponentBase ::
    ComAggregatorComponentBase(const char* compName) :
      Fw::ActiveComponentBase(compName),
      m_stateMachine_aggregationMachine(*this)
  {

  }

  ComAggregatorComponentBase ::
    ~ComAggregatorComponentBase()
  {

  }

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

  // ----------------------------------------------------------------------
  // State getter functions
  // ----------------------------------------------------------------------

  ComAggregatorComponentBase::Svc_AggregationMachine::State ComAggregatorComponentBase ::
    aggregationMachine_getState() const
  {
    return this->m_stateMachine_aggregationMachine.getState();
  }

  // ----------------------------------------------------------------------
  // Signal send functions
  // ----------------------------------------------------------------------

  void ComAggregatorComponentBase ::
    aggregationMachine_sendSignal_timeout()
  {
    ComponentIpcSerializableBuffer buffer;
    // Serialize the message type, port number, state ID, and signal
    this->sendSignalStart(SmId::aggregationMachine, static_cast<FwEnumStoreType>(Svc_AggregationMachine::Signal::timeout), buffer);
    // Send the message and handle overflow
    this->aggregationMachine_sendSignalFinish(buffer);
  }

  void ComAggregatorComponentBase ::
    aggregationMachine_sendSignal_fill(const Svc::ComDataContextPair& value)
  {
    ComponentIpcSerializableBuffer buffer;
    // Serialize the message type, port number, state ID, and signal
    this->sendSignalStart(SmId::aggregationMachine, static_cast<FwEnumStoreType>(Svc_AggregationMachine::Signal::fill), buffer);
    // Serialize the signal data
    const Fw::SerializeStatus status = buffer.serializeFrom(value);
    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
    // Send the message and handle overflow
    this->aggregationMachine_sendSignalFinish(buffer);
  }

  void ComAggregatorComponentBase ::
    aggregationMachine_sendSignal_status(const Fw::Success& value)
  {
    ComponentIpcSerializableBuffer buffer;
    // Serialize the message type, port number, state ID, and signal
    this->sendSignalStart(SmId::aggregationMachine, static_cast<FwEnumStoreType>(Svc_AggregationMachine::Signal::status), buffer);
    // Serialize the signal data
    const Fw::SerializeStatus status = buffer.serializeFrom(value);
    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
    // Send the message and handle overflow
    this->aggregationMachine_sendSignalFinish(buffer);
  }

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

  Fw::QueuedComponentBase::MsgDispatchStatus ComAggregatorComponentBase ::
    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 == COMAGGREGATOR_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 signals to internal state machines
      case INTERNAL_STATE_MACHINE_SIGNAL:
        this->smDispatch(_msg);
        break;

      default:
        return MSG_DISPATCH_ERROR;
    }

    return MSG_DISPATCH_OK;
  }

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

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

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

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

  void ComAggregatorComponentBase ::
    m_p_timeout_in(
        Fw::PassiveComponentBase* callComp,
        FwIndexType portNum,
        U32 context
    )
  {
    FW_ASSERT(callComp);
    ComAggregatorComponentBase* compPtr = static_cast<ComAggregatorComponentBase*>(callComp);
    compPtr->timeout_handlerBase(
      portNum,
      context
    );
  }

  // ----------------------------------------------------------------------
  // Send signal helper functions
  // ----------------------------------------------------------------------

  void ComAggregatorComponentBase ::
    sendSignalStart(
        SmId smId,
        FwEnumStoreType signal,
        Fw::SerialBufferBase& buffer
    )
  {
    Fw::SerializeStatus status = Fw::FW_SERIALIZE_OK;

    // Serialize the message type
    status = buffer.serializeFrom(static_cast<FwEnumStoreType>(INTERNAL_STATE_MACHINE_SIGNAL));
    FW_ASSERT (status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));

    // Serialize the port number
    status = buffer.serializeFrom(static_cast<FwIndexType>(0));
    FW_ASSERT (status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));

    // Serialize the state machine ID
    status = buffer.serializeFrom(static_cast<FwEnumStoreType>(smId));
    FW_ASSERT (status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));

    // Serialize the signal
    status = buffer.serializeFrom(static_cast<FwEnumStoreType>(signal));
    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
  }

  void ComAggregatorComponentBase ::
    aggregationMachine_sendSignalFinish(Fw::LinearBufferBase& buffer)
  {
    // Send message
    Os::Queue::BlockingType _block = Os::Queue::NONBLOCKING;
    Os::Queue::Status qStatus = this->m_queue.send(buffer, 0, _block);

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

  // ----------------------------------------------------------------------
  // Helper functions for state machine dispatch
  // ----------------------------------------------------------------------

  void ComAggregatorComponentBase ::
    smDispatch(Fw::SerialBufferBase& buffer)
  {
    // Deserialize the state machine ID and signal
    FwEnumStoreType storedSmId;
    FwEnumStoreType storedSignal;
    ComAggregatorComponentBase::deserializeSmIdAndSignal(buffer, storedSmId, storedSignal);

    // Select the target state machine instance
    const SmId smId = static_cast<SmId>(storedSmId);
    switch (smId) {
      case SmId::aggregationMachine: {
        const Svc_AggregationMachine::Signal signal = static_cast<Svc_AggregationMachine::Signal>(storedSignal);
        this->Svc_AggregationMachine_smDispatch(buffer, this->m_stateMachine_aggregationMachine, signal);
        break;
      }
      default:
        FW_ASSERT(0, static_cast<FwAssertArgType>(smId));
        break;
    }
  }

  void ComAggregatorComponentBase ::
    deserializeSmIdAndSignal(
        Fw::SerialBufferBase& buffer,
        FwEnumStoreType& smId,
        FwEnumStoreType& signal
    )
  {
    // Move deserialization beyond the message type and port number
    Fw::SerializeStatus status =
      buffer.moveDeserToOffset(ComponentIpcSerializableBuffer::DATA_OFFSET);
    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));

    // Deserialize the state machine ID
    status = buffer.deserializeTo(smId);
    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));

    // Deserialize the signal
    status = buffer.deserializeTo(signal);
    FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
  }

  void ComAggregatorComponentBase ::
    Svc_AggregationMachine_smDispatch(
        Fw::SerialBufferBase& buffer,
        Svc_AggregationMachine& sm,
        Svc_AggregationMachine::Signal signal
    )
  {
    switch (signal) {
      case Svc_AggregationMachine::Signal::timeout: {
        // Assert no data left in buffer
        FW_ASSERT(buffer.getDeserializeSizeLeft() == 0, static_cast<FwAssertArgType>(buffer.getDeserializeSizeLeft()));
        // Call the sendSignal function for sm and timeout
        sm.sendSignal_timeout();
        break;
      }
      case Svc_AggregationMachine::Signal::fill: {
        // Deserialize the data
        Svc::ComDataContextPair value;
        const Fw::SerializeStatus status = buffer.deserializeTo(value);
        FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
        // Assert no data left in buffer
        FW_ASSERT(buffer.getDeserializeSizeLeft() == 0, static_cast<FwAssertArgType>(buffer.getDeserializeSizeLeft()));
        // Call the sendSignal function for sm and fill
        sm.sendSignal_fill(value);
        break;
      }
      case Svc_AggregationMachine::Signal::status: {
        // Deserialize the data
        Fw::Success value;
        const Fw::SerializeStatus status = buffer.deserializeTo(value);
        FW_ASSERT(status == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(status));
        // Assert no data left in buffer
        FW_ASSERT(buffer.getDeserializeSizeLeft() == 0, static_cast<FwAssertArgType>(buffer.getDeserializeSizeLeft()));
        // Call the sendSignal function for sm and status
        sm.sendSignal_status(value);
        break;
      }
      default:
        FW_ASSERT(0, static_cast<FwAssertArgType>(signal));
        break;
    }
  }

}