Executing only required service!

[bvbasavaraju]

I have a question!

If 2 component implements the service - based on the requirement, how to invoke the service of the intended implementation!! How it can be decided at runtime which one to invoke!?

In below example, SendByte_t service is invoked from CoreComponent_t as well as TxComponent_t!

how to invoke only TxComponent_t? Could you please help?

//Services - basically like a function prototypes - callback function declaration!!
struct SendByte_t : public cib::callback_meta<uint8_t>
{};

struct GetByte_t : public cib::callback_meta<>
{};

struct SerialPortInit_t : public cib::callback_meta<>
{};

struct Run_t : public cib::callback_meta<>
{};

//components defintion!!
struct CoreComponent_t
{
  constexpr static auto config = cib::config(

    cib::exports<SendByte_t>,
    cib::extend<SendByte_t>([](uint8_t byte){
      std::cout << "From CoreComponent: " << byte << std::endl;
    }),

    cib::extend<GetByte_t>([](){
      uint8_t readByte;
      std::cin >> readByte;

      cib::service<SendByte_t>(readByte); // This invokes both implementation of the SendByte - TxComponent and CoreComponent implementation
    }),
    
    cib::extend<SerialPortInit_t>([](){
      std::cout<<"Initialized\n";
    }),

    cib::extend<Run_t>([](){
      std::cout << "Type Something!!\n";
    })
  );
};

struct TxComponent_t
{
  //tx - feature which implement a function which takes uint8_t argument! - SendByte_t service!!
  constexpr static auto tx = [](uint8_t byte) {
    std::cout << "From TxComponent: " << byte << std::endl;
  };

  constexpr static auto config = cib::config(
    cib::exports<SendByte_t>,
    cib::extend<SendByte_t>(tx)
    );
};

struct ExportComponents_t
{
  constexpr static auto config = cib::exports<GetByte_t, SerialPortInit_t, Run_t>;
};

//Project definition with mutiple components
struct DummySerialPortProject_t
{
  constexpr static auto config = cib::components<CoreComponent_t, TxComponent_t, ExportComponents_t>;
};

static cib::nexus<DummySerialPortProject_t> nexus{};

int main()
{
  nexus.init(); // This is critical!! otherwise accessing service from another service will result in the segmentation fault!!
  nexus.service<SerialPortInit_t>();

  while(true)
  {
    nexus.service<Run_t>();
    nexus.service<GetByte_t>();
  }
  return 0;
}

[lukevalenty]

Services are bound to the struct type name used to declare them. Even if that service is declared in multiple locations, if it has the same name, then it is a single service.

If you want two SendByte services, then give them two different names.

[bvbasavaraju]

Thank you for the answer