simulator.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_SIMULATOR_HPP_
#define CLOE_SIMULATOR_HPP_

#include <memory>       // for shared_ptr<>, unique_ptr<>, make_unique<>
#include <string>       // for string
#include <type_traits>  // for decay

#include <cloe/model.hpp>  // for Model, ModelFactory

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

#define DEFINE_SIMULATOR_FACTORY_MAKE(xFactoryType, xSimulatorType)                    \
  std::unique_ptr<::cloe::Simulator> xFactoryType::make(const ::cloe::Conf& c) const { \
    decltype(config_) conf{config_};                                                   \
    if (!c->is_null()) {                                                               \
      conf.from_conf(c);                                                               \
    }                                                                                  \
    return std::make_unique<xSimulatorType>(this->name(), conf);                       \
  }

namespace cloe {

// Forward declarations:
class Sync;     // from cloe/sync.hpp
class Vehicle;  // from cloe/vehicle.hpp

class Simulator : public Model {
 public:
  using Model::Model;
  virtual ~Simulator() noexcept = default;

  virtual size_t num_vehicles() const = 0;

  virtual std::shared_ptr<Vehicle> get_vehicle(size_t i) const = 0;

  virtual std::shared_ptr<Vehicle> get_vehicle(const std::string& key) const = 0;

  Duration process(const Sync&) override = 0;
};

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

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

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

  virtual std::unique_ptr<Simulator> make(const Conf& c) const = 0;
};

}  // namespace cloe

#endif  // CLOE_SIMULATOR_HPP_