Method Initialize

src/plugins/proxy_plugin/proxy_plugin.cc:72–157

namespace aimrt::plugins::proxy_plugin {

bool ProxyPlugin::Initialize(runtime::core::AimRTCore* core_ptr) noexcept {
  try {
    core_ptr_ = core_ptr;

    YAML::Node plugin_options_node = core_ptr_->GetPluginManager().GetPluginOptionsNode(Name());

    if (plugin_options_node && !plugin_options_node.IsNull()) {
      options_ = plugin_options_node.as<Options>();
      AIMRT_TRACE("Load plugin options.");
    }

    init_flag_ = true;
    // type support
    for (auto& type_support_pkg : options_.type_support_pkgs) {
      // check duplicate pkg
      auto finditr = std::find_if(
          options_.type_support_pkgs.begin(), options_.type_support_pkgs.end(),
          [&type_support_pkg](const auto& op) {
            if (&type_support_pkg == &op) return false;
            return op.path == type_support_pkg.path;
          });
      AIMRT_CHECK_ERROR_THROW(finditr == options_.type_support_pkgs.end(),
                              "Duplicate pkg path {}", type_support_pkg.path);
      InitTypeSupport(type_support_pkg);
    }
    AIMRT_TRACE("Load {} pkg and {} type.",
                type_support_pkg_loader_vec_.size(), type_support_map_.size());

    // proxy action
    for (auto& proxy_action : options_.proxy_actions) {
      // check duplicate proxy action name
      auto finditr = std::find_if(
          options_.proxy_actions.begin(), options_.proxy_actions.end(),
          [&proxy_action](const auto& op) {
            if (&proxy_action == &op) return false;
            return op.name == proxy_action.name;
          });
      AIMRT_CHECK_ERROR_THROW(finditr == options_.proxy_actions.end(),
                              "Duplicate proxy action name {}", proxy_action.name);

      auto action_ptr = std::make_unique<ProxyAction>();

      action_ptr->RegisterGetExecutorFunc([this](std::string_view name) -> aimrt::executor::ExecutorRef {
        return core_ptr_->GetExecutorManager().GetExecutor(name);
      });
      action_ptr->RegisterGetTypeSupportFunc([this](std::string_view name) -> aimrt::util::TypeSupportRef {
        auto finditr = type_support_map_.find(name);
        AIMRT_CHECK_ERROR_THROW(finditr != type_support_map_.end(),
                                "Can not find type support for msg type '{}'.", name);
        return finditr->second.type_support_ref;
      });
      action_ptr->Initialize(proxy_action.options);

      proxy_action_map_.emplace(proxy_action.name, std::move(action_ptr));
    }

    core_ptr_->RegisterHookFunc(
        runtime::core::AimRTCore::State::kPostInitLog,