plugin.hpp

Go to the documentation of this file.

/*
 * Copyright 2020 Robert Bosch GmbH
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 * SPDX-License-Identifier: Apache-2.0
 */
#pragma once
 
#include <functional>  // for function<>
#include <memory>      // for unique_ptr<>
#include <string>      // for string
 
#include <cloe/core.hpp>    // for Json, Error
#include <cloe/plugin.hpp>  // for PluginManifest
 
namespace cloe {
 
class PluginError : public Error {
 public:
  PluginError(const std::string& path, const std::string& what) : Error(what), plugin_path_(path) {}
  PluginError(const std::string& path, const char* what) : Error(what), plugin_path_(path) {}
 
  template <typename... Args>
  PluginError(const std::string& path, const char* format, const Args&... args)
      : Error(format, args...), plugin_path_(path) {}
 
  virtual ~PluginError() noexcept = default;
 
  const std::string& plugin_path() const { return plugin_path_; }
 
 private:
  std::string plugin_path_;
};
 
class Plugin {
 public:
  explicit Plugin(const std::string& plugin_path, const std::string& name = "");
 
  Plugin(const PluginManifest& m, std::function<ModelFactory*()> fn, const std::string& name = "");
 
  std::string path() const { return path_; }
 
  std::string name() const { return name_; }
 
  std::string type() const { return manifest_.plugin_type; }
 
  std::string type_version() const { return manifest_.plugin_type_version; }
 
  std::string required_type_version() const;
 
  Schema schema() const;
 
  bool is_builtin() const;
 
  bool is_type_known() const;
 
  bool is_compatible() const;
 
  template <typename F>
  std::unique_ptr<F> make() const {
    if (!is_compatible()) {
      throw PluginError(path(), "cannot make factory from incompatible plugin");
    }
 
    auto f = std::unique_ptr<F>(dynamic_cast<F*>(createf_()));
    f->set_name(name());
    return f;
  }
 
  friend void to_json(Json& j, const Plugin& p) {
    j = Json{
        {"path", p.path()},
        {"name", p.name()},
        {"type", p.type()},
        {"type_version", p.type_version()},
        {"is_known_type", p.is_type_known()},
        {"is_compatible", p.is_compatible()},
    };
  }
 
 private:
  std::string path_;
  std::string name_;
  PluginManifest manifest_;
  void* handle_;
  std::function<ModelFactory*()> createf_;
};
 
template <typename F>
std::shared_ptr<Plugin> make_plugin() {
  PluginManifest manifest{
      BASE_CLOE_FACTORY(F)::PLUGIN_TYPE,
      BASE_CLOE_FACTORY(F)::PLUGIN_API_VERSION,
      nullptr,
      0,
  };
  auto fn = []() { return new F(); };
  return std::make_shared<Plugin>(manifest, fn);
}
 
}  // namespace cloe