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

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

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

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

  // Connect input port noArgsAliasStringReturnSync
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_noArgsAliasStringReturnSync_InputPorts());
    port++
  ) {
    this->m_noArgsAliasStringReturnSync_InputPort[port].init();
    this->m_noArgsAliasStringReturnSync_InputPort[port].addCallComp(
      this,
      m_p_noArgsAliasStringReturnSync_in
    );
    this->m_noArgsAliasStringReturnSync_InputPort[port].setPortNum(port);

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

  // Connect input port noArgsGuarded
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_noArgsGuarded_InputPorts());
    port++
  ) {
    this->m_noArgsGuarded_InputPort[port].init();
    this->m_noArgsGuarded_InputPort[port].addCallComp(
      this,
      m_p_noArgsGuarded_in
    );
    this->m_noArgsGuarded_InputPort[port].setPortNum(port);

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

  // Connect input port noArgsReturnGuarded
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_noArgsReturnGuarded_InputPorts());
    port++
  ) {
    this->m_noArgsReturnGuarded_InputPort[port].init();
    this->m_noArgsReturnGuarded_InputPort[port].addCallComp(
      this,
      m_p_noArgsReturnGuarded_in
    );
    this->m_noArgsReturnGuarded_InputPort[port].setPortNum(port);

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

  // Connect input port noArgsReturnSync
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_noArgsReturnSync_InputPorts());
    port++
  ) {
    this->m_noArgsReturnSync_InputPort[port].init();
    this->m_noArgsReturnSync_InputPort[port].addCallComp(
      this,
      m_p_noArgsReturnSync_in
    );
    this->m_noArgsReturnSync_InputPort[port].setPortNum(port);

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

  // Connect input port noArgsStringReturnSync
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_noArgsStringReturnSync_InputPorts());
    port++
  ) {
    this->m_noArgsStringReturnSync_InputPort[port].init();
    this->m_noArgsStringReturnSync_InputPort[port].addCallComp(
      this,
      m_p_noArgsStringReturnSync_in
    );
    this->m_noArgsStringReturnSync_InputPort[port].setPortNum(port);

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

  // Connect input port noArgsSync
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_noArgsSync_InputPorts());
    port++
  ) {
    this->m_noArgsSync_InputPort[port].init();
    this->m_noArgsSync_InputPort[port].addCallComp(
      this,
      m_p_noArgsSync_in
    );
    this->m_noArgsSync_InputPort[port].setPortNum(port);

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

  // Connect input port typedAliasGuarded
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedAliasGuarded_InputPorts());
    port++
  ) {
    this->m_typedAliasGuarded_InputPort[port].init();
    this->m_typedAliasGuarded_InputPort[port].addCallComp(
      this,
      m_p_typedAliasGuarded_in
    );
    this->m_typedAliasGuarded_InputPort[port].setPortNum(port);

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

  // Connect input port typedAliasReturnSync
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedAliasReturnSync_InputPorts());
    port++
  ) {
    this->m_typedAliasReturnSync_InputPort[port].init();
    this->m_typedAliasReturnSync_InputPort[port].addCallComp(
      this,
      m_p_typedAliasReturnSync_in
    );
    this->m_typedAliasReturnSync_InputPort[port].setPortNum(port);

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

  // Connect input port typedAliasStringReturnSync
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedAliasStringReturnSync_InputPorts());
    port++
  ) {
    this->m_typedAliasStringReturnSync_InputPort[port].init();
    this->m_typedAliasStringReturnSync_InputPort[port].addCallComp(
      this,
      m_p_typedAliasStringReturnSync_in
    );
    this->m_typedAliasStringReturnSync_InputPort[port].setPortNum(port);

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

  // Connect input port typedGuarded
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedGuarded_InputPorts());
    port++
  ) {
    this->m_typedGuarded_InputPort[port].init();
    this->m_typedGuarded_InputPort[port].addCallComp(
      this,
      m_p_typedGuarded_in
    );
    this->m_typedGuarded_InputPort[port].setPortNum(port);

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

  // Connect input port typedReturnGuarded
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedReturnGuarded_InputPorts());
    port++
  ) {
    this->m_typedReturnGuarded_InputPort[port].init();
    this->m_typedReturnGuarded_InputPort[port].addCallComp(
      this,
      m_p_typedReturnGuarded_in
    );
    this->m_typedReturnGuarded_InputPort[port].setPortNum(port);

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

  // Connect input port typedReturnSync
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedReturnSync_InputPorts());
    port++
  ) {
    this->m_typedReturnSync_InputPort[port].init();
    this->m_typedReturnSync_InputPort[port].addCallComp(
      this,
      m_p_typedReturnSync_in
    );
    this->m_typedReturnSync_InputPort[port].setPortNum(port);

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

  // Connect input port typedSync
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedSync_InputPorts());
    port++
  ) {
    this->m_typedSync_InputPort[port].init();
    this->m_typedSync_InputPort[port].addCallComp(
      this,
      m_p_typedSync_in
    );
    this->m_typedSync_InputPort[port].setPortNum(port);

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

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

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

  // Connect output port eventOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_eventOut_OutputPorts());
    port++
  ) {
    this->m_eventOut_OutputPort[port].init();

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

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

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

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

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

#if FW_ENABLE_TEXT_LOGGING == 1
  // Connect output port textEventOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_textEventOut_OutputPorts());
    port++
  ) {
    this->m_textEventOut_OutputPort[port].init();

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

  // Connect output port timeGetOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_timeGetOut_OutputPorts());
    port++
  ) {
    this->m_timeGetOut_OutputPort[port].init();

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

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

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

  // Connect output port noArgsOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_noArgsOut_OutputPorts());
    port++
  ) {
    this->m_noArgsOut_OutputPort[port].init();

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

  // Connect output port noArgsReturnOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_noArgsReturnOut_OutputPorts());
    port++
  ) {
    this->m_noArgsReturnOut_OutputPort[port].init();

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

  // Connect output port noArgsStringReturnOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_noArgsStringReturnOut_OutputPorts());
    port++
  ) {
    this->m_noArgsStringReturnOut_OutputPort[port].init();

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

  // Connect output port typedAliasOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedAliasOut_OutputPorts());
    port++
  ) {
    this->m_typedAliasOut_OutputPort[port].init();

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

  // Connect output port typedAliasReturnOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedAliasReturnOut_OutputPorts());
    port++
  ) {
    this->m_typedAliasReturnOut_OutputPort[port].init();

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

  // Connect output port typedAliasReturnStringOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedAliasReturnStringOut_OutputPorts());
    port++
  ) {
    this->m_typedAliasReturnStringOut_OutputPort[port].init();

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

  // Connect output port typedOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedOut_OutputPorts());
    port++
  ) {
    this->m_typedOut_OutputPort[port].init();

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

  // Connect output port typedReturnOut
  for (
    FwIndexType port = 0;
    port < static_cast<FwIndexType>(this->getNum_typedReturnOut_OutputPorts());
    port++
  ) {
    this->m_typedReturnOut_OutputPort[port].init();

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

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

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

  return &this->m_cmdIn_InputPort[portNum];
}

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

Ports::InputNoArgsAliasStringReturnPort* PassiveExternalParamsComponentBase ::
  get_noArgsAliasStringReturnSync_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsAliasStringReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_noArgsAliasStringReturnSync_InputPort[portNum];
}

Ports::InputNoArgsPort* PassiveExternalParamsComponentBase ::
  get_noArgsGuarded_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsGuarded_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_noArgsGuarded_InputPort[portNum];
}

Ports::InputNoArgsReturnPort* PassiveExternalParamsComponentBase ::
  get_noArgsReturnGuarded_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsReturnGuarded_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_noArgsReturnGuarded_InputPort[portNum];
}

Ports::InputNoArgsReturnPort* PassiveExternalParamsComponentBase ::
  get_noArgsReturnSync_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_noArgsReturnSync_InputPort[portNum];
}

Ports::InputNoArgsStringReturnPort* PassiveExternalParamsComponentBase ::
  get_noArgsStringReturnSync_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsStringReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_noArgsStringReturnSync_InputPort[portNum];
}

Ports::InputNoArgsPort* PassiveExternalParamsComponentBase ::
  get_noArgsSync_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_noArgsSync_InputPort[portNum];
}

Ports::InputAliasTypedPort* PassiveExternalParamsComponentBase ::
  get_typedAliasGuarded_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasGuarded_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_typedAliasGuarded_InputPort[portNum];
}

Ports::InputAliasTypedReturnPort* PassiveExternalParamsComponentBase ::
  get_typedAliasReturnSync_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_typedAliasReturnSync_InputPort[portNum];
}

Ports::InputAliasTypedReturnStringPort* PassiveExternalParamsComponentBase ::
  get_typedAliasStringReturnSync_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasStringReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_typedAliasStringReturnSync_InputPort[portNum];
}

Ports::InputTypedPort* PassiveExternalParamsComponentBase ::
  get_typedGuarded_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedGuarded_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_typedGuarded_InputPort[portNum];
}

Ports::InputTypedReturnPort* PassiveExternalParamsComponentBase ::
  get_typedReturnGuarded_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedReturnGuarded_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_typedReturnGuarded_InputPort[portNum];
}

Ports::InputTypedReturnPort* PassiveExternalParamsComponentBase ::
  get_typedReturnSync_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_typedReturnSync_InputPort[portNum];
}

Ports::InputTypedPort* PassiveExternalParamsComponentBase ::
  get_typedSync_InputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  return &this->m_typedSync_InputPort[portNum];
}

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

void PassiveExternalParamsComponentBase ::
  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 PassiveExternalParamsComponentBase ::
  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 PassiveExternalParamsComponentBase ::
  set_eventOut_OutputPort(
      FwIndexType portNum,
      Fw::InputLogPort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_eventOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

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

#if FW_ENABLE_TEXT_LOGGING == 1

void PassiveExternalParamsComponentBase ::
  set_textEventOut_OutputPort(
      FwIndexType portNum,
      Fw::InputLogTextPort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_textEventOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

#endif

void PassiveExternalParamsComponentBase ::
  set_timeGetOut_OutputPort(
      FwIndexType portNum,
      Fw::InputTimePort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_timeGetOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

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

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

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

void PassiveExternalParamsComponentBase ::
  set_noArgsOut_OutputPort(
      FwIndexType portNum,
      Ports::InputNoArgsPort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

void PassiveExternalParamsComponentBase ::
  set_noArgsReturnOut_OutputPort(
      FwIndexType portNum,
      Ports::InputNoArgsReturnPort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

void PassiveExternalParamsComponentBase ::
  set_noArgsStringReturnOut_OutputPort(
      FwIndexType portNum,
      Ports::InputNoArgsStringReturnPort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsStringReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

void PassiveExternalParamsComponentBase ::
  set_typedAliasOut_OutputPort(
      FwIndexType portNum,
      Ports::InputAliasTypedPort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

void PassiveExternalParamsComponentBase ::
  set_typedAliasReturnOut_OutputPort(
      FwIndexType portNum,
      Ports::InputAliasTypedReturnPort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

void PassiveExternalParamsComponentBase ::
  set_typedAliasReturnStringOut_OutputPort(
      FwIndexType portNum,
      Ports::InputAliasTypedReturnStringPort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasReturnStringOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

void PassiveExternalParamsComponentBase ::
  set_typedOut_OutputPort(
      FwIndexType portNum,
      Ports::InputTypedPort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

void PassiveExternalParamsComponentBase ::
  set_typedReturnOut_OutputPort(
      FwIndexType portNum,
      Ports::InputTypedReturnPort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

#if FW_PORT_SERIALIZATION

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

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

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

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

#if FW_ENABLE_TEXT_LOGGING == 1

void PassiveExternalParamsComponentBase ::
  set_textEventOut_OutputPort(
      FwIndexType portNum,
      Fw::InputSerializePort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_textEventOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

#endif

void PassiveExternalParamsComponentBase ::
  set_timeGetOut_OutputPort(
      FwIndexType portNum,
      Fw::InputSerializePort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_timeGetOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

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

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

#endif

#if FW_PORT_SERIALIZATION

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

void PassiveExternalParamsComponentBase ::
  set_noArgsOut_OutputPort(
      FwIndexType portNum,
      Fw::InputSerializePort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

void PassiveExternalParamsComponentBase ::
  set_typedAliasOut_OutputPort(
      FwIndexType portNum,
      Fw::InputSerializePort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

void PassiveExternalParamsComponentBase ::
  set_typedOut_OutputPort(
      FwIndexType portNum,
      Fw::InputSerializePort* port
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

#endif

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

void PassiveExternalParamsComponentBase ::
  regCommands()
{
  FW_ASSERT(this->m_cmdRegOut_OutputPort[0].isConnected());

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMI32EXT_SET
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMI32EXT_SAVE
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMF64EXT_SET
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMF64EXT_SAVE
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMSTRINGEXT_SET
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMSTRINGEXT_SAVE
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMENUMEXT_SET
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMENUMEXT_SAVE
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMARRAYEXT_SET
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMARRAYEXT_SAVE
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMSTRUCTEXT_SET
  );

  this->m_cmdRegOut_OutputPort[0].invoke(
    this->getIdBase() + OPCODE_PARAMSTRUCTEXT_SAVE
  );
}

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

void PassiveExternalParamsComponentBase ::
  loadParameters()
{
  Fw::ParamBuffer _buff;
  Fw::SerializeStatus _stat = Fw::FW_SERIALIZE_OK;
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());
  FW_ASSERT(this->m_prmGetOut_OutputPort[0].isConnected());

  FwPrmIdType _id{};

  Fw::ParamValid param_valid;

  _id = _baseId + PARAMID_PARAMI32EXT;

  // Get parameter ParamI32Ext
  param_valid = this->m_prmGetOut_OutputPort[0].invoke(
    _id,
    _buff
  );

  // Get the local ID to pass to the delegate
  _id = PARAMID_PARAMI32EXT;
  // If there was a deserialization issue, mark it invalid
  if (param_valid == Fw::ParamValid::VALID) {
    // Pass the local ID to the delegate
    _id = PARAMID_PARAMI32EXT;

    FW_ASSERT(this->paramDelegatePtr != NULL);
    // Call the delegate deserialize function for m_ParamI32Ext
    _stat = this->paramDelegatePtr->deserializeParam(_baseId, _id, param_valid, _buff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      param_valid = Fw::ParamValid::INVALID;
    }
  }
  else {
    param_valid = Fw::ParamValid::INVALID;
  }

  _id = _baseId + PARAMID_PARAMF64EXT;

  // Get parameter ParamF64Ext
  param_valid = this->m_prmGetOut_OutputPort[0].invoke(
    _id,
    _buff
  );

  // Get the local ID to pass to the delegate
  _id = PARAMID_PARAMF64EXT;
  // If there was a deserialization issue, mark it invalid
  if (param_valid == Fw::ParamValid::VALID) {
    // Pass the local ID to the delegate
    _id = PARAMID_PARAMF64EXT;

    FW_ASSERT(this->paramDelegatePtr != NULL);
    // Call the delegate deserialize function for m_ParamF64Ext
    _stat = this->paramDelegatePtr->deserializeParam(_baseId, _id, param_valid, _buff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      param_valid = Fw::ParamValid::INVALID;
    }
  }
  else {
    param_valid = Fw::ParamValid::INVALID;
  }

  _id = _baseId + PARAMID_PARAMSTRINGEXT;

  // Get parameter ParamStringExt
  param_valid = this->m_prmGetOut_OutputPort[0].invoke(
    _id,
    _buff
  );

  // Get the local ID to pass to the delegate
  _id = PARAMID_PARAMSTRINGEXT;
  // If there was a deserialization issue, mark it invalid
  if (param_valid == Fw::ParamValid::VALID) {
    // Pass the local ID to the delegate
    _id = PARAMID_PARAMSTRINGEXT;

    FW_ASSERT(this->paramDelegatePtr != NULL);
    // Call the delegate deserialize function for m_ParamStringExt
    _stat = this->paramDelegatePtr->deserializeParam(_baseId, _id, param_valid, _buff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      param_valid = Fw::ParamValid::INVALID;
    }
  }
  else {
    param_valid = Fw::ParamValid::INVALID;
  }

  _id = _baseId + PARAMID_PARAMENUMEXT;

  // Get parameter ParamEnumExt
  param_valid = this->m_prmGetOut_OutputPort[0].invoke(
    _id,
    _buff
  );

  // Get the local ID to pass to the delegate
  _id = PARAMID_PARAMENUMEXT;
  // If there was a deserialization issue, mark it invalid
  if (param_valid == Fw::ParamValid::VALID) {
    // Pass the local ID to the delegate
    _id = PARAMID_PARAMENUMEXT;

    FW_ASSERT(this->paramDelegatePtr != NULL);
    // Call the delegate deserialize function for m_ParamEnumExt
    _stat = this->paramDelegatePtr->deserializeParam(_baseId, _id, param_valid, _buff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      param_valid = Fw::ParamValid::INVALID;
    }
  }
  else {
    param_valid = Fw::ParamValid::INVALID;
  }

  _id = _baseId + PARAMID_PARAMARRAYEXT;

  // Get parameter ParamArrayExt
  param_valid = this->m_prmGetOut_OutputPort[0].invoke(
    _id,
    _buff
  );

  // Get the local ID to pass to the delegate
  _id = PARAMID_PARAMARRAYEXT;
  // If there was a deserialization issue, mark it invalid
  if (param_valid == Fw::ParamValid::VALID) {
    // Pass the local ID to the delegate
    _id = PARAMID_PARAMARRAYEXT;

    FW_ASSERT(this->paramDelegatePtr != NULL);
    // Call the delegate deserialize function for m_ParamArrayExt
    _stat = this->paramDelegatePtr->deserializeParam(_baseId, _id, param_valid, _buff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      param_valid = Fw::ParamValid::INVALID;
    }
  }
  else {
    param_valid = Fw::ParamValid::INVALID;
  }

  _id = _baseId + PARAMID_PARAMSTRUCTEXT;

  // Get parameter ParamStructExt
  param_valid = this->m_prmGetOut_OutputPort[0].invoke(
    _id,
    _buff
  );

  // Get the local ID to pass to the delegate
  _id = PARAMID_PARAMSTRUCTEXT;
  // If there was a deserialization issue, mark it invalid
  if (param_valid == Fw::ParamValid::VALID) {
    // Pass the local ID to the delegate
    _id = PARAMID_PARAMSTRUCTEXT;

    FW_ASSERT(this->paramDelegatePtr != NULL);
    // Call the delegate deserialize function for m_ParamStructExt
    _stat = this->paramDelegatePtr->deserializeParam(_baseId, _id, param_valid, _buff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      param_valid = Fw::ParamValid::INVALID;
    }
  }
  else {
    param_valid = Fw::ParamValid::INVALID;
  }

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

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

PassiveExternalParamsComponentBase ::
  PassiveExternalParamsComponentBase(const char* compName) :
    Fw::PassiveComponentBase(compName),
    paramDelegatePtr(NULL)
{

}

PassiveExternalParamsComponentBase ::
  ~PassiveExternalParamsComponentBase()
{

}

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

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_cmdIn_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_cmdIn_InputPort));
}

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

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_noArgsAliasStringReturnSync_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_noArgsAliasStringReturnSync_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_noArgsGuarded_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_noArgsGuarded_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_noArgsReturnGuarded_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_noArgsReturnGuarded_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_noArgsReturnSync_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_noArgsReturnSync_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_noArgsStringReturnSync_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_noArgsStringReturnSync_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_noArgsSync_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_noArgsSync_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedAliasGuarded_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedAliasGuarded_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedAliasReturnSync_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedAliasReturnSync_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedAliasStringReturnSync_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedAliasStringReturnSync_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedGuarded_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedGuarded_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedReturnGuarded_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedReturnGuarded_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedReturnSync_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedReturnSync_InputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedSync_InputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedSync_InputPort));
}

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

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_cmdRegOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_cmdRegOut_OutputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_cmdResponseOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_cmdResponseOut_OutputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_eventOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_eventOut_OutputPort));
}

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

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

#if FW_ENABLE_TEXT_LOGGING == 1

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_textEventOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_textEventOut_OutputPort));
}

#endif

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_timeGetOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_timeGetOut_OutputPort));
}

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

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

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_noArgsOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_noArgsOut_OutputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_noArgsReturnOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_noArgsReturnOut_OutputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_noArgsStringReturnOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_noArgsStringReturnOut_OutputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedAliasOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedAliasOut_OutputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedAliasReturnOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedAliasReturnOut_OutputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedAliasReturnStringOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedAliasReturnStringOut_OutputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedOut_OutputPort));
}

FwIndexType PassiveExternalParamsComponentBase ::
  getNum_typedReturnOut_OutputPorts() const
{
  return static_cast<FwIndexType>(FW_NUM_ARRAY_ELEMENTS(this->m_typedReturnOut_OutputPort));
}

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

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

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

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

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

bool PassiveExternalParamsComponentBase ::
  isConnected_eventOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_eventOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

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

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

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

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

#if FW_ENABLE_TEXT_LOGGING == 1

bool PassiveExternalParamsComponentBase ::
  isConnected_textEventOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_textEventOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

#endif

bool PassiveExternalParamsComponentBase ::
  isConnected_timeGetOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_timeGetOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

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

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

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

bool PassiveExternalParamsComponentBase ::
  isConnected_noArgsOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

bool PassiveExternalParamsComponentBase ::
  isConnected_noArgsReturnOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

bool PassiveExternalParamsComponentBase ::
  isConnected_noArgsStringReturnOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsStringReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

bool PassiveExternalParamsComponentBase ::
  isConnected_typedAliasOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

bool PassiveExternalParamsComponentBase ::
  isConnected_typedAliasReturnOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

bool PassiveExternalParamsComponentBase ::
  isConnected_typedAliasReturnStringOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasReturnStringOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

bool PassiveExternalParamsComponentBase ::
  isConnected_typedOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

bool PassiveExternalParamsComponentBase ::
  isConnected_typedReturnOut_OutputPort(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

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

Fw::String PassiveExternalParamsComponentBase ::
  noArgsAliasStringReturnSync_handlerBase(FwIndexType portNum)
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsAliasStringReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  Fw::String retVal;

  // Call handler function
  retVal = this->noArgsAliasStringReturnSync_handler(portNum);

  return retVal;
}

void PassiveExternalParamsComponentBase ::
  noArgsGuarded_handlerBase(FwIndexType portNum)
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsGuarded_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

  // Call handler function
  this->noArgsGuarded_handler(portNum);

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

U32 PassiveExternalParamsComponentBase ::
  noArgsReturnGuarded_handlerBase(FwIndexType portNum)
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsReturnGuarded_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  U32 retVal;

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

  // Call handler function
  retVal = this->noArgsReturnGuarded_handler(portNum);

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

  return retVal;
}

U32 PassiveExternalParamsComponentBase ::
  noArgsReturnSync_handlerBase(FwIndexType portNum)
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  U32 retVal;

  // Call handler function
  retVal = this->noArgsReturnSync_handler(portNum);

  return retVal;
}

Fw::String PassiveExternalParamsComponentBase ::
  noArgsStringReturnSync_handlerBase(FwIndexType portNum)
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsStringReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  Fw::String retVal;

  // Call handler function
  retVal = this->noArgsStringReturnSync_handler(portNum);

  return retVal;
}

void PassiveExternalParamsComponentBase ::
  noArgsSync_handlerBase(FwIndexType portNum)
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  // Call handler function
  this->noArgsSync_handler(portNum);
}

void PassiveExternalParamsComponentBase ::
  typedAliasGuarded_handlerBase(
      FwIndexType portNum,
      AliasPrim1 u32,
      AliasPrim2 f32,
      AliasBool b,
      const Fw::StringBase& str2,
      const AliasEnum& e,
      const AliasArray& a,
      const AliasStruct& s
  )
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasGuarded_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

  // Call handler function
  this->typedAliasGuarded_handler(
    portNum,
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );

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

AliasPrim2 PassiveExternalParamsComponentBase ::
  typedAliasReturnSync_handlerBase(
      FwIndexType portNum,
      AliasPrim1 u32,
      AliasPrim2 f32,
      AliasBool b,
      const Fw::StringBase& str2,
      const AliasEnum& e,
      const AliasArray& a,
      const AliasStruct& s
  )
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  AliasPrim2 retVal;

  // Call handler function
  retVal = this->typedAliasReturnSync_handler(
    portNum,
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );

  return retVal;
}

Fw::String PassiveExternalParamsComponentBase ::
  typedAliasStringReturnSync_handlerBase(
      FwIndexType portNum,
      AliasPrim1 u32,
      AliasPrim2 f32,
      AliasBool b,
      const Fw::StringBase& str2,
      const AliasEnum& e,
      const AliasArray& a,
      const AnotherAliasStruct& s
  )
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasStringReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  Fw::String retVal;

  // Call handler function
  retVal = this->typedAliasStringReturnSync_handler(
    portNum,
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );

  return retVal;
}

void PassiveExternalParamsComponentBase ::
  typedGuarded_handlerBase(
      FwIndexType portNum,
      U32 u32,
      F32 f32,
      bool b,
      const Fw::StringBase& str1,
      const E& e,
      const A& a,
      const S& s
  )
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedGuarded_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

  // Call handler function
  this->typedGuarded_handler(
    portNum,
    u32,
    f32,
    b,
    str1,
    e,
    a,
    s
  );

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

F32 PassiveExternalParamsComponentBase ::
  typedReturnGuarded_handlerBase(
      FwIndexType portNum,
      U32 u32,
      F32 f32,
      bool b,
      const Fw::StringBase& str2,
      const E& e,
      const A& a,
      const S& s
  )
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedReturnGuarded_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  F32 retVal;

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

  // Call handler function
  retVal = this->typedReturnGuarded_handler(
    portNum,
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );

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

  return retVal;
}

F32 PassiveExternalParamsComponentBase ::
  typedReturnSync_handlerBase(
      FwIndexType portNum,
      U32 u32,
      F32 f32,
      bool b,
      const Fw::StringBase& str2,
      const E& e,
      const A& a,
      const S& s
  )
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedReturnSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  F32 retVal;

  // Call handler function
  retVal = this->typedReturnSync_handler(
    portNum,
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );

  return retVal;
}

void PassiveExternalParamsComponentBase ::
  typedSync_handlerBase(
      FwIndexType portNum,
      U32 u32,
      F32 f32,
      bool b,
      const Fw::StringBase& str1,
      const E& e,
      const A& a,
      const S& s
  )
{
  // Make sure port number is valid
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedSync_InputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  // Call handler function
  this->typedSync_handler(
    portNum,
    u32,
    f32,
    b,
    str1,
    e,
    a,
    s
  );
}

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

void PassiveExternalParamsComponentBase ::
  noArgsOut_out(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

U32 PassiveExternalParamsComponentBase ::
  noArgsReturnOut_out(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

Fw::String PassiveExternalParamsComponentBase ::
  noArgsStringReturnOut_out(FwIndexType portNum)
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_noArgsStringReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

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

void PassiveExternalParamsComponentBase ::
  typedAliasOut_out(
      FwIndexType portNum,
      AliasPrim1 u32,
      AliasPrim2 f32,
      AliasBool b,
      const Fw::StringBase& str2,
      const AliasEnum& e,
      const AliasArray& a,
      const AliasStruct& s
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  FW_ASSERT(
    this->m_typedAliasOut_OutputPort[portNum].isConnected(),
    static_cast<FwAssertArgType>(portNum)
  );
  this->m_typedAliasOut_OutputPort[portNum].invoke(
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );
}

AliasPrim2 PassiveExternalParamsComponentBase ::
  typedAliasReturnOut_out(
      FwIndexType portNum,
      AliasPrim1 u32,
      AliasPrim2 f32,
      AliasBool b,
      const Fw::StringBase& str2,
      const AliasEnum& e,
      const AliasArray& a,
      const AliasStruct& s
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  FW_ASSERT(
    this->m_typedAliasReturnOut_OutputPort[portNum].isConnected(),
    static_cast<FwAssertArgType>(portNum)
  );
  return this->m_typedAliasReturnOut_OutputPort[portNum].invoke(
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );
}

Fw::String PassiveExternalParamsComponentBase ::
  typedAliasReturnStringOut_out(
      FwIndexType portNum,
      AliasPrim1 u32,
      AliasPrim2 f32,
      AliasBool b,
      const Fw::StringBase& str2,
      const AliasEnum& e,
      const AliasArray& a,
      const AnotherAliasStruct& s
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedAliasReturnStringOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  FW_ASSERT(
    this->m_typedAliasReturnStringOut_OutputPort[portNum].isConnected(),
    static_cast<FwAssertArgType>(portNum)
  );
  return this->m_typedAliasReturnStringOut_OutputPort[portNum].invoke(
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );
}

void PassiveExternalParamsComponentBase ::
  typedOut_out(
      FwIndexType portNum,
      U32 u32,
      F32 f32,
      bool b,
      const Fw::StringBase& str1,
      const E& e,
      const A& a,
      const S& s
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  FW_ASSERT(
    this->m_typedOut_OutputPort[portNum].isConnected(),
    static_cast<FwAssertArgType>(portNum)
  );
  this->m_typedOut_OutputPort[portNum].invoke(
    u32,
    f32,
    b,
    str1,
    e,
    a,
    s
  );
}

F32 PassiveExternalParamsComponentBase ::
  typedReturnOut_out(
      FwIndexType portNum,
      U32 u32,
      F32 f32,
      bool b,
      const Fw::StringBase& str2,
      const E& e,
      const A& a,
      const S& s
  )
{
  FW_ASSERT(
    (0 <= portNum) && (portNum < this->getNum_typedReturnOut_OutputPorts()),
    static_cast<FwAssertArgType>(portNum)
  );

  FW_ASSERT(
    this->m_typedReturnOut_OutputPort[portNum].isConnected(),
    static_cast<FwAssertArgType>(portNum)
  );
  return this->m_typedReturnOut_OutputPort[portNum].invoke(
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );
}

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

void PassiveExternalParamsComponentBase ::
  cmdResponse_out(
      FwOpcodeType opCode,
      U32 cmdSeq,
      Fw::CmdResponse response
  )
{
  FW_ASSERT(this->m_cmdResponseOut_OutputPort[0].isConnected());
  this->m_cmdResponseOut_OutputPort[0].invoke(opCode, cmdSeq, response);
}

// ----------------------------------------------------------------------
// Parameter update hook
// ----------------------------------------------------------------------

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

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

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

I32 PassiveExternalParamsComponentBase ::
  paramGet_ParamI32Ext(Fw::ParamValid& valid)
{
  I32 _local{};
  Fw::ParamBuffer _getBuff;
  // Get the base ID
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());
  // Get the local ID to pass to the delegate
  const FwPrmIdType _localId = PARAMID_PARAMI32EXT;

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Get the external parameter from the delegate
  Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff);
  if(_stat == Fw::FW_SERIALIZE_OK) {
    _stat = _getBuff.deserializeTo(_local);
    FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(_stat));
    valid = Fw::ParamValid::VALID;
  } else {
    valid = Fw::ParamValid::INVALID;
  }
  return _local;
}

F64 PassiveExternalParamsComponentBase ::
  paramGet_ParamF64Ext(Fw::ParamValid& valid)
{
  F64 _local{};
  Fw::ParamBuffer _getBuff;
  // Get the base ID
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());
  // Get the local ID to pass to the delegate
  const FwPrmIdType _localId = PARAMID_PARAMF64EXT;

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Get the external parameter from the delegate
  Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff);
  if(_stat == Fw::FW_SERIALIZE_OK) {
    _stat = _getBuff.deserializeTo(_local);
    FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(_stat));
    valid = Fw::ParamValid::VALID;
  } else {
    valid = Fw::ParamValid::INVALID;
  }
  return _local;
}

Fw::ParamString PassiveExternalParamsComponentBase ::
  paramGet_ParamStringExt(Fw::ParamValid& valid)
{
  Fw::ParamString _local{};
  Fw::ParamBuffer _getBuff;
  // Get the base ID
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());
  // Get the local ID to pass to the delegate
  const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT;

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Get the external parameter from the delegate
  Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff);
  if(_stat == Fw::FW_SERIALIZE_OK) {
    _stat = _getBuff.deserializeTo(_local);
    FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(_stat));
    valid = Fw::ParamValid::VALID;
  } else {
    valid = Fw::ParamValid::INVALID;
  }
  return _local;
}

E PassiveExternalParamsComponentBase ::
  paramGet_ParamEnumExt(Fw::ParamValid& valid)
{
  E _local{};
  Fw::ParamBuffer _getBuff;
  // Get the base ID
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());
  // Get the local ID to pass to the delegate
  const FwPrmIdType _localId = PARAMID_PARAMENUMEXT;

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Get the external parameter from the delegate
  Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff);
  if(_stat == Fw::FW_SERIALIZE_OK) {
    _stat = _getBuff.deserializeTo(_local);
    FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(_stat));
    valid = Fw::ParamValid::VALID;
  } else {
    valid = Fw::ParamValid::INVALID;
  }
  return _local;
}

A PassiveExternalParamsComponentBase ::
  paramGet_ParamArrayExt(Fw::ParamValid& valid)
{
  A _local{};
  Fw::ParamBuffer _getBuff;
  // Get the base ID
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());
  // Get the local ID to pass to the delegate
  const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT;

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Get the external parameter from the delegate
  Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff);
  if(_stat == Fw::FW_SERIALIZE_OK) {
    _stat = _getBuff.deserializeTo(_local);
    FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(_stat));
    valid = Fw::ParamValid::VALID;
  } else {
    valid = Fw::ParamValid::INVALID;
  }
  return _local;
}

S PassiveExternalParamsComponentBase ::
  paramGet_ParamStructExt(Fw::ParamValid& valid)
{
  S _local{};
  Fw::ParamBuffer _getBuff;
  // Get the base ID
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());
  // Get the local ID to pass to the delegate
  const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT;

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Get the external parameter from the delegate
  Fw::SerializeStatus _stat = this->paramDelegatePtr->serializeParam(_baseId, _localId, _getBuff);
  if(_stat == Fw::FW_SERIALIZE_OK) {
    _stat = _getBuff.deserializeTo(_local);
    FW_ASSERT(_stat == Fw::FW_SERIALIZE_OK, static_cast<FwAssertArgType>(_stat));
    valid = Fw::ParamValid::VALID;
  } else {
    valid = Fw::ParamValid::INVALID;
  }
  return _local;
}

// ----------------------------------------------------------------------
// External parameter delegate initialization
// ----------------------------------------------------------------------

void PassiveExternalParamsComponentBase ::
  registerExternalParameters(Fw::ParamExternalDelegate* paramExternalDelegatePtr)
{
  FW_ASSERT(paramExternalDelegatePtr != NULL);
  this->paramDelegatePtr = paramExternalDelegatePtr;
}

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

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

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

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

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

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

void PassiveExternalParamsComponentBase ::
  m_p_cmdIn_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum,
      FwOpcodeType opCode,
      U32 cmdSeq,
      Fw::CmdArgBuffer& args
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);

  const U32 idBase = callComp->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_PARAMI32EXT_SET: {
      Fw::CmdResponse _cstat = compPtr->paramSet_ParamI32Ext(args);
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMI32EXT_SAVE: {
      Fw::CmdResponse _cstat = compPtr->paramSave_ParamI32Ext();
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMF64EXT_SET: {
      Fw::CmdResponse _cstat = compPtr->paramSet_ParamF64Ext(args);
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMF64EXT_SAVE: {
      Fw::CmdResponse _cstat = compPtr->paramSave_ParamF64Ext();
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMSTRINGEXT_SET: {
      Fw::CmdResponse _cstat = compPtr->paramSet_ParamStringExt(args);
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMSTRINGEXT_SAVE: {
      Fw::CmdResponse _cstat = compPtr->paramSave_ParamStringExt();
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMENUMEXT_SET: {
      Fw::CmdResponse _cstat = compPtr->paramSet_ParamEnumExt(args);
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMENUMEXT_SAVE: {
      Fw::CmdResponse _cstat = compPtr->paramSave_ParamEnumExt();
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMARRAYEXT_SET: {
      Fw::CmdResponse _cstat = compPtr->paramSet_ParamArrayExt(args);
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMARRAYEXT_SAVE: {
      Fw::CmdResponse _cstat = compPtr->paramSave_ParamArrayExt();
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMSTRUCTEXT_SET: {
      Fw::CmdResponse _cstat = compPtr->paramSet_ParamStructExt(args);
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }

    case OPCODE_PARAMSTRUCTEXT_SAVE: {
      Fw::CmdResponse _cstat = compPtr->paramSave_ParamStructExt();
      compPtr->cmdResponse_out(
        opCode,
        cmdSeq,
        _cstat
      );
      break;
    }
  }
}

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

Fw::String PassiveExternalParamsComponentBase ::
  m_p_noArgsAliasStringReturnSync_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  return compPtr->noArgsAliasStringReturnSync_handlerBase(portNum);
}

void PassiveExternalParamsComponentBase ::
  m_p_noArgsGuarded_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  compPtr->noArgsGuarded_handlerBase(portNum);
}

U32 PassiveExternalParamsComponentBase ::
  m_p_noArgsReturnGuarded_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  return compPtr->noArgsReturnGuarded_handlerBase(portNum);
}

U32 PassiveExternalParamsComponentBase ::
  m_p_noArgsReturnSync_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  return compPtr->noArgsReturnSync_handlerBase(portNum);
}

Fw::String PassiveExternalParamsComponentBase ::
  m_p_noArgsStringReturnSync_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  return compPtr->noArgsStringReturnSync_handlerBase(portNum);
}

void PassiveExternalParamsComponentBase ::
  m_p_noArgsSync_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  compPtr->noArgsSync_handlerBase(portNum);
}

void PassiveExternalParamsComponentBase ::
  m_p_typedAliasGuarded_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum,
      AliasPrim1 u32,
      AliasPrim2 f32,
      AliasBool b,
      const Fw::StringBase& str2,
      const AliasEnum& e,
      const AliasArray& a,
      const AliasStruct& s
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  compPtr->typedAliasGuarded_handlerBase(
    portNum,
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );
}

AliasPrim2 PassiveExternalParamsComponentBase ::
  m_p_typedAliasReturnSync_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum,
      AliasPrim1 u32,
      AliasPrim2 f32,
      AliasBool b,
      const Fw::StringBase& str2,
      const AliasEnum& e,
      const AliasArray& a,
      const AliasStruct& s
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  return compPtr->typedAliasReturnSync_handlerBase(
    portNum,
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );
}

Fw::String PassiveExternalParamsComponentBase ::
  m_p_typedAliasStringReturnSync_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum,
      AliasPrim1 u32,
      AliasPrim2 f32,
      AliasBool b,
      const Fw::StringBase& str2,
      const AliasEnum& e,
      const AliasArray& a,
      const AnotherAliasStruct& s
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  return compPtr->typedAliasStringReturnSync_handlerBase(
    portNum,
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );
}

void PassiveExternalParamsComponentBase ::
  m_p_typedGuarded_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum,
      U32 u32,
      F32 f32,
      bool b,
      const Fw::StringBase& str1,
      const E& e,
      const A& a,
      const S& s
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  compPtr->typedGuarded_handlerBase(
    portNum,
    u32,
    f32,
    b,
    str1,
    e,
    a,
    s
  );
}

F32 PassiveExternalParamsComponentBase ::
  m_p_typedReturnGuarded_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum,
      U32 u32,
      F32 f32,
      bool b,
      const Fw::StringBase& str2,
      const E& e,
      const A& a,
      const S& s
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  return compPtr->typedReturnGuarded_handlerBase(
    portNum,
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );
}

F32 PassiveExternalParamsComponentBase ::
  m_p_typedReturnSync_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum,
      U32 u32,
      F32 f32,
      bool b,
      const Fw::StringBase& str2,
      const E& e,
      const A& a,
      const S& s
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  return compPtr->typedReturnSync_handlerBase(
    portNum,
    u32,
    f32,
    b,
    str2,
    e,
    a,
    s
  );
}

void PassiveExternalParamsComponentBase ::
  m_p_typedSync_in(
      Fw::PassiveComponentBase* callComp,
      FwIndexType portNum,
      U32 u32,
      F32 f32,
      bool b,
      const Fw::StringBase& str1,
      const E& e,
      const A& a,
      const S& s
  )
{
  FW_ASSERT(callComp);
  PassiveExternalParamsComponentBase* compPtr = static_cast<PassiveExternalParamsComponentBase*>(callComp);
  compPtr->typedSync_handlerBase(
    portNum,
    u32,
    f32,
    b,
    str1,
    e,
    a,
    s
  );
}

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

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSet_ParamI32Ext(Fw::SerializeBufferBase& val)
{
  const FwPrmIdType _localId = PARAMID_PARAMI32EXT;
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Call the delegate serialize function for m_ParamI32Ext
  const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam(
    _baseId,
    _localId,
    Fw::ParamValid::VALID,
    val
  );
  if (_stat != Fw::FW_SERIALIZE_OK) {
    return Fw::CmdResponse::VALIDATION_ERROR;
  }

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

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSet_ParamF64Ext(Fw::SerializeBufferBase& val)
{
  const FwPrmIdType _localId = PARAMID_PARAMF64EXT;
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Call the delegate serialize function for m_ParamF64Ext
  const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam(
    _baseId,
    _localId,
    Fw::ParamValid::VALID,
    val
  );
  if (_stat != Fw::FW_SERIALIZE_OK) {
    return Fw::CmdResponse::VALIDATION_ERROR;
  }

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

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSet_ParamStringExt(Fw::SerializeBufferBase& val)
{
  const FwPrmIdType _localId = PARAMID_PARAMSTRINGEXT;
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Call the delegate serialize function for m_ParamStringExt
  const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam(
    _baseId,
    _localId,
    Fw::ParamValid::VALID,
    val
  );
  if (_stat != Fw::FW_SERIALIZE_OK) {
    return Fw::CmdResponse::VALIDATION_ERROR;
  }

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

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSet_ParamEnumExt(Fw::SerializeBufferBase& val)
{
  const FwPrmIdType _localId = PARAMID_PARAMENUMEXT;
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Call the delegate serialize function for m_ParamEnumExt
  const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam(
    _baseId,
    _localId,
    Fw::ParamValid::VALID,
    val
  );
  if (_stat != Fw::FW_SERIALIZE_OK) {
    return Fw::CmdResponse::VALIDATION_ERROR;
  }

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

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSet_ParamArrayExt(Fw::SerializeBufferBase& val)
{
  const FwPrmIdType _localId = PARAMID_PARAMARRAYEXT;
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Call the delegate serialize function for m_ParamArrayExt
  const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam(
    _baseId,
    _localId,
    Fw::ParamValid::VALID,
    val
  );
  if (_stat != Fw::FW_SERIALIZE_OK) {
    return Fw::CmdResponse::VALIDATION_ERROR;
  }

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

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSet_ParamStructExt(Fw::SerializeBufferBase& val)
{
  const FwPrmIdType _localId = PARAMID_PARAMSTRUCTEXT;
  const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

  FW_ASSERT(this->paramDelegatePtr != NULL);
  // Call the delegate serialize function for m_ParamStructExt
  const Fw::SerializeStatus _stat = this->paramDelegatePtr->deserializeParam(
    _baseId,
    _localId,
    Fw::ParamValid::VALID,
    val
  );
  if (_stat != Fw::FW_SERIALIZE_OK) {
    return Fw::CmdResponse::VALIDATION_ERROR;
  }

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

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

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSave_ParamI32Ext()
{
  Fw::ParamBuffer _saveBuff;
  FwPrmIdType _id;
  Fw::SerializeStatus _stat;
  if (this->m_prmSetOut_OutputPort[0].isConnected()) {
    // Get the local and base ID to pass to the delegate
    _id = PARAMID_PARAMI32EXT;
    const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

    FW_ASSERT(this->paramDelegatePtr != NULL);
    _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      return Fw::CmdResponse::VALIDATION_ERROR;
    }

    _id = static_cast<FwPrmIdType>(this->getIdBase() + PARAMID_PARAMI32EXT);

    // Save the parameter
    this->m_prmSetOut_OutputPort[0].invoke(
      _id,
      _saveBuff
    );

    return Fw::CmdResponse::OK;
  }

  return Fw::CmdResponse::EXECUTION_ERROR;
}

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSave_ParamF64Ext()
{
  Fw::ParamBuffer _saveBuff;
  FwPrmIdType _id;
  Fw::SerializeStatus _stat;
  if (this->m_prmSetOut_OutputPort[0].isConnected()) {
    // Get the local and base ID to pass to the delegate
    _id = PARAMID_PARAMF64EXT;
    const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

    FW_ASSERT(this->paramDelegatePtr != NULL);
    _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      return Fw::CmdResponse::VALIDATION_ERROR;
    }

    _id = static_cast<FwPrmIdType>(this->getIdBase() + PARAMID_PARAMF64EXT);

    // Save the parameter
    this->m_prmSetOut_OutputPort[0].invoke(
      _id,
      _saveBuff
    );

    return Fw::CmdResponse::OK;
  }

  return Fw::CmdResponse::EXECUTION_ERROR;
}

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSave_ParamStringExt()
{
  Fw::ParamBuffer _saveBuff;
  FwPrmIdType _id;
  Fw::SerializeStatus _stat;
  if (this->m_prmSetOut_OutputPort[0].isConnected()) {
    // Get the local and base ID to pass to the delegate
    _id = PARAMID_PARAMSTRINGEXT;
    const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

    FW_ASSERT(this->paramDelegatePtr != NULL);
    _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      return Fw::CmdResponse::VALIDATION_ERROR;
    }

    _id = static_cast<FwPrmIdType>(this->getIdBase() + PARAMID_PARAMSTRINGEXT);

    // Save the parameter
    this->m_prmSetOut_OutputPort[0].invoke(
      _id,
      _saveBuff
    );

    return Fw::CmdResponse::OK;
  }

  return Fw::CmdResponse::EXECUTION_ERROR;
}

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSave_ParamEnumExt()
{
  Fw::ParamBuffer _saveBuff;
  FwPrmIdType _id;
  Fw::SerializeStatus _stat;
  if (this->m_prmSetOut_OutputPort[0].isConnected()) {
    // Get the local and base ID to pass to the delegate
    _id = PARAMID_PARAMENUMEXT;
    const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

    FW_ASSERT(this->paramDelegatePtr != NULL);
    _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      return Fw::CmdResponse::VALIDATION_ERROR;
    }

    _id = static_cast<FwPrmIdType>(this->getIdBase() + PARAMID_PARAMENUMEXT);

    // Save the parameter
    this->m_prmSetOut_OutputPort[0].invoke(
      _id,
      _saveBuff
    );

    return Fw::CmdResponse::OK;
  }

  return Fw::CmdResponse::EXECUTION_ERROR;
}

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSave_ParamArrayExt()
{
  Fw::ParamBuffer _saveBuff;
  FwPrmIdType _id;
  Fw::SerializeStatus _stat;
  if (this->m_prmSetOut_OutputPort[0].isConnected()) {
    // Get the local and base ID to pass to the delegate
    _id = PARAMID_PARAMARRAYEXT;
    const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

    FW_ASSERT(this->paramDelegatePtr != NULL);
    _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      return Fw::CmdResponse::VALIDATION_ERROR;
    }

    _id = static_cast<FwPrmIdType>(this->getIdBase() + PARAMID_PARAMARRAYEXT);

    // Save the parameter
    this->m_prmSetOut_OutputPort[0].invoke(
      _id,
      _saveBuff
    );

    return Fw::CmdResponse::OK;
  }

  return Fw::CmdResponse::EXECUTION_ERROR;
}

Fw::CmdResponse PassiveExternalParamsComponentBase ::
  paramSave_ParamStructExt()
{
  Fw::ParamBuffer _saveBuff;
  FwPrmIdType _id;
  Fw::SerializeStatus _stat;
  if (this->m_prmSetOut_OutputPort[0].isConnected()) {
    // Get the local and base ID to pass to the delegate
    _id = PARAMID_PARAMSTRUCTEXT;
    const FwPrmIdType _baseId = static_cast<FwPrmIdType>(this->getIdBase());

    FW_ASSERT(this->paramDelegatePtr != NULL);
    _stat = this->paramDelegatePtr->serializeParam(_baseId, _id, _saveBuff);
    if (_stat != Fw::FW_SERIALIZE_OK) {
      return Fw::CmdResponse::VALIDATION_ERROR;
    }

    _id = static_cast<FwPrmIdType>(this->getIdBase() + PARAMID_PARAMSTRUCTEXT);

    // Save the parameter
    this->m_prmSetOut_OutputPort[0].invoke(
      _id,
      _saveBuff
    );

    return Fw::CmdResponse::OK;
  }

  return Fw::CmdResponse::EXECUTION_ERROR;
}

// ----------------------------------------------------------------------
// Parameter delegates
// ----------------------------------------------------------------------