component.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
#ifndef CLOE_COMPONENT_HPP_
#define CLOE_COMPONENT_HPP_

#include <cstdint>      // for uint64_t
#include <memory>       // for shared_ptr<>, unique_ptr<>, make_unique<>
#include <string>       // for string
#include <type_traits>  // for decay
#include <utility>      // for move

#include <cloe/model.hpp>  // for Model, ModelFactory
#include <cloe/sync.hpp>   // for Sync
#include <fable/enum.hpp>  // for ENUM_SERIALIZATION

#define DEFINE_COMPONENT_FACTORY(xFactoryType, xConfigType, xName, xDescription)              \
  class xFactoryType : public ::cloe::ComponentFactory {                                      \
   public:                                                                                    \
    xFactoryType() : ComponentFactory(xName, xDescription) {}                                 \
    std::unique_ptr<::cloe::ComponentFactory> clone() const override {                        \
      return std::make_unique<std::decay<decltype(*this)>::type>(*this);                      \
    }                                                                                         \
    std::unique_ptr<::cloe::Component> make(                                                  \
        const ::cloe::Conf&, std::vector<std::shared_ptr<::cloe::Component>>) const override; \
                                                                                              \
   protected:                                                                                 \
    ::cloe::Schema schema_impl() override { return config_.schema(); }                        \
                                                                                              \
   private:                                                                                   \
    xConfigType config_;                                                                      \
  };

#define DEFINE_COMPONENT_FACTORY_MAKE(xFactoryType, xComponentType, xInputType)              \
  std::unique_ptr<::cloe::Component> xFactoryType::make(                                     \
      const ::cloe::Conf& c, std::vector<std::shared_ptr<::cloe::Component>> comp) const {   \
    decltype(config_) conf{config_};                                                         \
    assert(comp.size() == 1);                                                                \
    if (!c->is_null()) {                                                                     \
      conf.from_conf(c);                                                                     \
    }                                                                                        \
    return std::make_unique<xComponentType>(                                                 \
        this->name(), conf, std::dynamic_pointer_cast<xInputType>(std::move(comp.front()))); \
  }

namespace cloe {

class Component : public Model {
 public:
  explicit Component(const std::string& name, const std::string& description = "")
      : Model(name, description), id_(++gid_) {}
  explicit Component(std::string&& name, std::string&& description = "")
      : Model(std::move(name), std::move(description)), id_(++gid_) {}
  virtual ~Component() noexcept = default;

  uint64_t id() const { return id_; }

  template <typename T>
  T* as() {
    return dynamic_cast<T*>(this);
  }

  virtual Json active_state() const = 0;

  Duration process(const Sync& sync) override { return sync.time(); }

  void reset() override {}

  void abort() override {}

 protected:
  friend void to_json(Json& j, const Component& c) {
    j = c.active_state();
    j["id"] = c.id();
    j["name"] = c.name();
  }

 private:
  static uint64_t gid_;
  uint64_t id_;
};

class ComponentFactory : public ModelFactory {
 public:
  static constexpr char const* PLUGIN_TYPE = "component";
  static constexpr char const* PLUGIN_API_VERSION = "2.0";

  using ModelFactory::ModelFactory;
  virtual ~ComponentFactory() noexcept = default;

  virtual std::unique_ptr<ComponentFactory> clone() const = 0;

  virtual std::unique_ptr<Component> make(const Conf& c,
                                          std::vector<std::shared_ptr<Component>>) const = 0;
};

}  // namespace cloe

#endif  // CLOE_COMPONENT_HPP_