fpp/compiler/tools/fpp-to-cpp/test/top/basic/BasicTopologyAc.ref.cpp

// ======================================================================
// \title  BasicTopologyAc.cpp
// \author Generated by fpp-to-cpp
// \brief  cpp file for Basic topology
// ======================================================================

#include "BasicTopologyAc.hpp"

// ----------------------------------------------------------------------
// Component instances
// ----------------------------------------------------------------------

namespace M {
  Active active2;

}

namespace M {

  M::Active active3(FW_OPTIONAL_NAME("active3"));

}

namespace M {

  M::Passive passive1(FW_OPTIONAL_NAME("passive1"));

}

namespace M {

  ConcretePassive passive2(FW_OPTIONAL_NAME("passive2"));

}

M::Active active1(FW_OPTIONAL_NAME("active1"));

namespace M {

  // ----------------------------------------------------------------------
  // Component configuration objects
  // ----------------------------------------------------------------------

  namespace ConfigObjects {

    namespace M_active2 {
      U32 x = 0;
    }

  }

  // ----------------------------------------------------------------------
  // Helper functions
  // ----------------------------------------------------------------------

  void initComponents(const TopologyState& state) {
    M::active2.initSpecial();
    M::active3.init(QueueSizes::M_active3, InstanceIds::M_active3);
    M::passive1.init(InstanceIds::M_passive1);
    M::passive2.init(InstanceIds::M_passive2);
    active1.init(QueueSizes::active1, InstanceIds::active1);
  }

  void configComponents(const TopologyState& state) {
    M::active2.config();
  }

  void setBaseIds() {
    active1.setIdBase(BaseIds::active1);
    M::active2.setIdBase(BaseIds::M_active2);
    M::active3.setIdBase(BaseIds::M_active3);
    M::passive1.setIdBase(BaseIds::M_passive1);
    M::passive2.setIdBase(BaseIds::M_passive2);
  }

  void connectComponents() {

#if !FW_DIRECT_PORT_CALLS

    // C1
    M::passive1.set_p_OutputPort(
        0,
        active1.get_p_InputPort(0)
    );

    // C2
    M::passive2.set_p_OutputPort(
        0,
        M::active2.get_p_InputPort(0)
    );

#endif

  }

  void regCommands() {
    // Nothing to do
  }

  void readParameters() {
    // Nothing to do
  }

  void loadParameters() {
    // Nothing to do
  }

  void startTasks(const TopologyState& state) {
    M::active2.startSpecial();
    M::active3.start(
      Os::Task::TASK_PRIORITY_DEFAULT, // Default priority
      Os::Task::TASK_DEFAULT, // Default stack size
      Os::Task::TASK_DEFAULT, // Default CPU
      static_cast<Os::Task::ParamType>(TaskIds::M_active3)
    );
    active1.start(
      static_cast<FwTaskPriorityType>(Priorities::active1),
      static_cast<Os::Task::ParamType>(StackSizes::active1),
      static_cast<Os::Task::ParamType>(CPUs::active1),
      static_cast<Os::Task::ParamType>(TaskIds::active1)
    );
  }

  void stopTasks(const TopologyState& state) {
    M::active2.stopSpecial();
    M::active3.exit();
    active1.exit();
  }

  void freeThreads(const TopologyState& state) {
    M::active2.freeSpecial();
    (void) M::active3.ActiveComponentBase::join();
    (void) active1.ActiveComponentBase::join();
  }

  void tearDownComponents(const TopologyState& state) {
    M::active2.tearDown();
  }

  // ----------------------------------------------------------------------
  // Setup and teardown functions
  // ----------------------------------------------------------------------

  void setup(const TopologyState& state) {
    initComponents(state);
    configComponents(state);
    setBaseIds();
    connectComponents();
    regCommands();
    readParameters();
    loadParameters();
    startTasks(state);
  }

  void teardown(const TopologyState& state) {
    stopTasks(state);
    freeThreads(state);
    tearDownComponents(state);
  }

}

#if FW_DIRECT_PORT_CALLS

// ----------------------------------------------------------------------
// Topology-dependent component implementation
// ----------------------------------------------------------------------

namespace M {

  bool PassiveComponentBase::isConnected_p_OutputPort(FwIndexType portNum) const {
    FW_ASSERT(
      (0 <= portNum) && (portNum < NUM_P_OUTPUT_PORTS),
      static_cast<FwAssertArgType>(portNum),
      static_cast<FwAssertArgType>(NUM_P_OUTPUT_PORTS)
    );
    bool result = false;
    const auto instance = this->getInstance();
    switch (instance) {
      case ::M::InstanceIds::M_passive1:
        switch (portNum) {
          case 0:
            result = true;
            break;
          default:
            break;
        }
        break;
      case ::M::InstanceIds::M_passive2:
        switch (portNum) {
          case 0:
            result = true;
            break;
          default:
            break;
        }
        break;
      default:
        FW_ASSERT(0, static_cast<FwAssertArgType>(instance));
        break;
    }
    return result;
  }

  void PassiveComponentBase::p_out(FwIndexType portNum) const {
    FW_ASSERT(
      (0 <= portNum) && (portNum < NUM_P_OUTPUT_PORTS),
      static_cast<FwAssertArgType>(portNum),
      static_cast<FwAssertArgType>(NUM_P_OUTPUT_PORTS)
    );
    const auto instance = this->getInstance();
    switch (instance) {
      case ::M::InstanceIds::M_passive1:
        switch (portNum) {
          case 0:
            active1.p_handlerBase(0);
            break;
          default:
            FW_ASSERT(0, static_cast<FwAssertArgType>(portNum));
            break;
        }
        break;
      case ::M::InstanceIds::M_passive2:
        switch (portNum) {
          case 0:
            M::active2.p_handlerBase(0);
            break;
          default:
            FW_ASSERT(0, static_cast<FwAssertArgType>(portNum));
            break;
        }
        break;
      default:
        FW_ASSERT(0, static_cast<FwAssertArgType>(instance));
        break;
    }
  }

}

#endif