plugin.hpp

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