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
#ifndef CLOE_CONTROLLER_HPP_
#define CLOE_CONTROLLER_HPP_

#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 ::cloe::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 ::cloe::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 Conf& c) const = 0;
};

}  // namespace cloe

#endif  // CLOE_CONTROLLER_HPP_