controller.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 <memory>       // for shared_ptr<>, unique_ptr<>, make_unique<>
#include <type_traits>  // for decay
#include <utility>      // for move
 
#include <cloe/model.hpp>  // for Model, ModelFactory
 
#define DEFINE_CONTROLLER_FACTORY(xFactoryType, xConfigType, xName, xDescription) \
  class xFactoryType : public ::cloe::ControllerFactory {                         \
   public:                                                                        \
    xFactoryType() : ::cloe::ControllerFactory(xName, xDescription) {}            \
    std::unique_ptr<::cloe::ControllerFactory> clone() const override {           \
      return std::make_unique<std::decay<decltype(*this)>::type>(*this);          \
    }                                                                             \
                                                                                  \
    std::unique_ptr<::cloe::Controller> make(const ::fable::Conf&) const override; \
                                                                                  \
   protected:                                                                     \
    ::cloe::Schema schema_impl() override { return config_.schema(); }            \
                                                                                  \
   private:                                                                       \
    xConfigType config_;                                                          \
  };
 
#define DEFINE_CONTROLLER_FACTORY_MAKE(xFactoryType, xControllerType)                   \
  std::unique_ptr<::cloe::Controller> xFactoryType::make(const ::fable::Conf& c) const { \
    decltype(config_) conf{config_};                                                    \
    if (!c->is_null()) {                                                                \
      conf.from_conf(c);                                                                \
    }                                                                                   \
    return std::make_unique<xControllerType>(this->name(), conf);                       \
  }
 
namespace cloe {
 
// Forward declarations:
class Vehicle;  // from cloe/vehicle.hpp
 
class Controller : public Model {
 public:
  using Model::Model;
  virtual ~Controller() noexcept = default;
 
  virtual bool has_vehicle() const { return static_cast<bool>(veh_); }
 
  virtual std::shared_ptr<Vehicle> get_vehicle() const { return veh_; }
 
  virtual void set_vehicle(std::shared_ptr<Vehicle> v) { veh_ = std::move(v); }
 
 protected:
  std::shared_ptr<Vehicle> veh_{nullptr};
};
 
class ControllerFactory : public ModelFactory {
 public:
  static constexpr char const* PLUGIN_TYPE = "controller";
  static constexpr char const* PLUGIN_API_VERSION = "2.0";
 
  using ModelFactory::ModelFactory;
  virtual ~ControllerFactory() noexcept = default;
 
  virtual std::unique_ptr<ControllerFactory> clone() const = 0;
 
  virtual std::unique_ptr<Controller> make(const fable::Conf& c) const = 0;
};
 
}  // namespace cloe