ActsExamples/Framework/WhiteBoard.hpp

0001 // This file is part of the ACTS project.
0002 //
0003 // Copyright (C) 2016 CERN for the benefit of the ACTS project
0004 //
0005 // This Source Code Form is subject to the terms of the Mozilla Public
0006 // License, v. 2.0. If a copy of the MPL was not distributed with this
0007 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
0008
0009 #pragma once
0010
0011 #include <Acts/Utilities/Concepts.hpp>
0012 #include <Acts/Utilities/Logger.hpp>
0013
0014 #include <algorithm>
0015 #include <cstddef>
0016 #include <memory>
0017 #include <ostream>
0018 #include <stdexcept>
0019 #include <string>
0020 #include <string_view>
0021 #include <typeinfo>
0022 #include <unordered_map>
0023 #include <utility>
0024 #include <vector>
0025
0026 namespace ActsExamples {
0027
0028 /// A container to store arbitrary objects with ownership transfer.
0029 ///
0030 /// This is an append-only container that takes ownership of the objects
0031 /// added to it. Once an object has been added, it can only be read but not
0032 /// be modified. Trying to replace an existing object is considered an error.
0033 /// Its lifetime is bound to the lifetime of the white board.
0034 class WhiteBoard {
0035  public:
0036   WhiteBoard(
0037       std::unique_ptr<const Acts::Logger> logger =
0038           Acts::getDefaultLogger("WhiteBoard", Acts::Logging::INFO),
0039       std::unordered_multimap<std::string, std::string> objectAliases = {});
0040
0041   WhiteBoard(const WhiteBoard& other) = delete;
0042   WhiteBoard& operator=(const WhiteBoard&) = delete;
0043
0044   WhiteBoard(WhiteBoard&& other) = default;
0045   WhiteBoard& operator=(WhiteBoard&& other) = default;
0046
0047   bool exists(const std::string& name) const;
0048
0049   /// Copies key from another whiteboard to this whiteboard.
0050   /// This is a low overhead operation, since the data holders are
0051   /// shared pointers.
0052   /// Throws an exception if this whiteboard already contains one of
0053   /// the keys in the other whiteboard.
0054   void copyFrom(const WhiteBoard& other);
0055
0056  private:
0057   /// Find similar names for suggestions with levenshtein-distance
0058   std::vector<std::string_view> similarNames(const std::string_view& name,
0059                                              int distThreshold,
0060                                              std::size_t maxNumber) const;
0061
0062   // type-erased value holder for move-constructible types
0063   struct IHolder {
0064     virtual ~IHolder() = default;
0065     virtual const std::type_info& type() const = 0;
0066   };
0067   template <Acts::Concepts::nothrow_move_constructible T>
0068   struct HolderT : public IHolder {
0069     T value;
0070
0071     explicit HolderT(T&& v) : value(std::move(v)) {}
0072     const std::type_info& type() const override { return typeid(T); }
0073   };
0074
0075   /// Store a holder on the white board.
0076   ///
0077   /// @param name Non-empty identifier to store it under
0078   /// @param holder The holder to store
0079   /// @throws std::invalid_argument on empty or duplicate name
0080   void addHolder(const std::string& name,
0081                  const std::shared_ptr<IHolder>& holder);
0082
0083   /// Store an object on the white board and transfer ownership.
0084   ///
0085   /// @param name Non-empty identifier to store it under
0086   /// @param object Movable reference to the transferable object
0087   template <typename T>
0088   void add(const std::string& name, T&& object) {
0089     addHolder(name, std::make_shared<HolderT<T>>(std::forward<T>(object)));
0090   }
0091
0092   /// Get access to a stored object.
0093   ///
0094   /// @param[in] name Identifier for the object
0095   /// @return reference to the stored object
0096   /// @throws std::out_of_range if no object is stored under the requested name
0097   template <typename T>
0098   const T& get(const std::string& name) const;
0099
0100   std::unique_ptr<const Acts::Logger> m_logger;
0101   std::unordered_map<std::string, std::shared_ptr<IHolder>> m_store;
0102   std::unordered_multimap<std::string, std::string> m_objectAliases;
0103
0104   const Acts::Logger& logger() const { return *m_logger; }
0105
0106   static std::string typeMismatchMessage(const std::string& name,
0107                                          const char* req, const char* act);
0108
0109   template <typename T>
0110   friend class WriteDataHandle;
0111
0112   template <typename T>
0113   friend class ReadDataHandle;
0114 };
0115
0116 }  // namespace ActsExamples
0117
0118 inline ActsExamples::WhiteBoard::WhiteBoard(
0119     std::unique_ptr<const Acts::Logger> logger,
0120     std::unordered_multimap<std::string, std::string> objectAliases)
0121     : m_logger(std::move(logger)), m_objectAliases(std::move(objectAliases)) {}
0122
0123 template <typename T>
0124 inline const T& ActsExamples::WhiteBoard::get(const std::string& name) const {
0125   ACTS_VERBOSE("Attempt to get object '" << name << "' of type "
0126                                          << typeid(T).name());
0127   auto it = m_store.find(name);
0128   if (it == m_store.end()) {
0129     const auto names = similarNames(name, 10, 3);
0130
0131     std::stringstream ss;
0132     if (!names.empty()) {
0133       ss << ", similar ones are: [ ";
0134       for (std::size_t i = 0; i < std::min(3ul, names.size()); ++i) {
0135         ss << "'" << names[i] << "' ";
0136       }
0137       ss << "]";
0138     }
0139
0140     throw std::out_of_range("Object '" + name + "' does not exists" + ss.str());
0141   }
0142
0143   const IHolder* holder = it->second.get();
0144
0145   const auto* castedHolder = dynamic_cast<const HolderT<T>*>(holder);
0146   if (castedHolder == nullptr) {
0147     std::string msg =
0148         typeMismatchMessage(name, typeid(T).name(), holder->type().name());
0149     throw std::out_of_range(msg.c_str());
0150   }
0151
0152   ACTS_VERBOSE("Retrieved object '" << name << "'");
0153   return castedHolder->value;
0154 }
0155
0156 inline bool ActsExamples::WhiteBoard::exists(const std::string& name) const {
0157   // TODO remove this function?
0158   return m_store.contains(name);
0159 }