vehicle.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 <map>          // for map<>
#include <memory>       // for shared_ptr<>
#include <string>       // for string
#include <type_traits>  // for enable_if_t<>, is_enum<>
 
#include <cloe/component.hpp>  // for Component
#include <cloe/core.hpp>       // for Json
#include <cloe/model.hpp>      // for Model
 
namespace cloe {
 
class UnknownComponent : public Error {
 public:
  UnknownComponent(const std::string& vehicle,
                   const std::string& key,
                   const std::vector<std::string>& available_components);
 
  const std::string& vehicle() const { return vehicle_; }
  const std::string& unknown_component() const { return unknown_; }
  const std::vector<std::string>& available_components() const;
 
 private:
  std::string vehicle_;
  std::string unknown_;
  std::vector<std::string> available_;
};
 
class BadComponentCast : public Error {
 public:
  BadComponentCast(const std::string& vehicle, const std::string& key);
 
  const std::string& vehicle() const { return vehicle_; }
  const std::string& component_name() const { return component_; }
 
 private:
  std::string vehicle_;
  std::string component_;
};
 
class CannotAddComponent : public Error {
 public:
  CannotAddComponent(const std::string& msg, const std::string& vehicle, const std::string& key);
 
  const std::string& vehicle() const { return vehicle_; }
  const std::string& component_name() const { return component_; }
 
 private:
  std::string vehicle_;
  std::string component_;
};
 
class Vehicle : public Model {
 public:
  Vehicle(uint64_t id, const std::string& name) : Model(name), id_(id) {}
  virtual ~Vehicle() noexcept = default;
 
  std::shared_ptr<Vehicle> clone(uint64_t id, const std::string& name);
 
  uint64_t id() const { return id_; }
 
  size_t size() const { return this->components_.size(); }
 
  bool has(const std::string& key) const { return this->components_.count(key) != 0; }
 
  template <typename Enum, std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
  bool has(Enum c) const {
    return this->has(to_string(c));
  }
 
  template <typename T>
  std::shared_ptr<const T> get(const std::string& key) const {
    auto ptr = std::dynamic_pointer_cast<const T>(at(key));
    if (ptr == nullptr) {
      throw BadComponentCast(name(), key);
    }
    return ptr;
  }
 
  template <typename T>
  std::shared_ptr<T> get(const std::string& key) {
    return std::const_pointer_cast<T>(const_cast<const Vehicle&>(*this).get<T>(key));
  }
 
  template <typename T, typename Enum, std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
  std::shared_ptr<const T> get(Enum c) const {
    return get<T>(to_string(c));
  }
 
  template <typename T, typename Enum, std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
  std::shared_ptr<T> get(Enum c) {
    return get<T>(to_string(c));
  }
 
 public:  // Component Management
  template <typename... Arguments>
  void new_component(Component* ptr, const Arguments&... aliases) {
    auto sp = std::shared_ptr<Component>(ptr);
    this->add_component(sp, aliases...);
  }
 
  template <typename First, typename... Arguments>
  void add_component(std::shared_ptr<Component> sp, const First& alias,
                     const Arguments&... aliases) {
    this->add_component(sp, alias);
    this->add_component(sp, aliases...);
  }
 
  template <typename Enum, std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
  void add_component(std::shared_ptr<Component> sp, Enum c) {
    this->add_component(sp, to_string(c));
  }
 
  void add_component(std::shared_ptr<Component> sp, const std::string& alias) {
    if (this->has(alias)) {
      throw CannotAddComponent("component already exists", name(), alias);
    }
    this->set_component(alias, sp);
  }
 
  template <typename First, typename... Arguments>
  void emplace_component(std::shared_ptr<Component> sp, const First& alias,
                         const Arguments&... aliases) {
    this->emplace_component(sp, alias);
    this->emplace_component(sp, aliases...);
  }
 
  template <typename Enum, std::enable_if_t<std::is_enum<Enum>::value, int> = 0>
  void emplace_component(std::shared_ptr<Component> sp, Enum c) {
    this->emplace_component(sp, to_string(c));
  }
 
  void emplace_component(std::shared_ptr<Component> sp, const std::string& alias) {
    this->set_component(alias, sp);
  }
 
  void set_component(const std::string& key, std::shared_ptr<Component> component) {
    this->components_[key] = component;
  }
 
  std::vector<std::string> component_names() const {
    std::vector<std::string> results;
    results.reserve(components_.size());
    for (const auto& kv : components_) {
      results.emplace_back(kv.first);
    }
    return results;
  }
 
 public:  // Overrides
  Duration process(const Sync& sync) override;
  void connect() override;
  void disconnect() override;
 
  void enroll(Registrar& r) override;
  void reset() override;
  void abort() override;
 
  friend void to_json(Json& j, const Vehicle& v) {
    j = Json{
        {"id", v.id()},
        {"name", v.name()},
        {"components", v.components_},
    };
  }
 
 protected:  // Useful methods
  std::shared_ptr<const Component> at(const std::string& key) const;
  std::shared_ptr<Component> at(const std::string& key);
 
 private:
  uint64_t id_;
 
  std::map<std::string, std::shared_ptr<Component>> components_;
};
 
}  // namespace cloe