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
 
#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 <fable/fable_fwd.hpp>  // for Json
 
#include <cloe/model.hpp>    // for Model, ModelFactory
#include <cloe/sync.hpp>     // for Sync
#include <cloe/version.hpp>  // for Version information
 
#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 ::fable::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 ::fable::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 fable::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(fable::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 fable::Conf& c,
                                          std::vector<std::shared_ptr<Component>>) const = 0;
};
 
}  // namespace cloe