data_broker.hpp

Go to the documentation of this file.

/*
 * Copyright 2023 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_DATA_BROKER_HPP_
#define CLOE_DATA_BROKER_HPP_
 
#include <any>
#include <cassert>
#include <functional>
#include <map>
#include <memory>
#include <regex>
#include <stdexcept>
#include <string_view>
#include <typeindex>
#include <vector>
 
#include <fmt/format.h>
 
#include <sol/sol.hpp>
 
namespace cloe {
 
namespace databroker {
 
namespace detail {
 
template <typename T, typename = void>
struct has_to_lua : std::false_type {};
template <typename T>
struct has_to_lua<
    T, std::void_t<decltype(to_lua(std::declval<sol::state_view>(), std::declval<T*>()))>>
    : std::true_type {};
template <typename T>
constexpr bool has_to_lua_v = has_to_lua<T>::value;
 
template <typename T>
void to_lua(sol::state_view lua) {
  if constexpr (has_to_lua_v<T>) {
    to_lua(lua, static_cast<T*>(nullptr));
  } else {
    // nop
  }
}
 
}  // namespace detail
 
template <typename T, bool condition>
struct type_t_or_int_if {
  using type = T;
};
 
template <typename T>
struct type_t_or_int_if<T, false> {
  using type = int;
};
 
template <typename T>
constexpr bool is_incompatible_type_v = std::is_void_v<T> || std::is_reference_v<T>;
 
template <typename T>
using compatible_base_t = typename type_t_or_int_if<T, !is_incompatible_type_v<T>>::type;
 
template <typename T>
using signal_type_cref_t = databroker::compatible_base_t<T> const&;
 
template <typename T>
using on_value_changed_callback_t = std::function<void(signal_type_cref_t<T>)>;
 
template <typename... TArgs>
class Event {
 public:
  using EventHandler = std::function<void(TArgs...)>;
 
 private:
  std::vector<EventHandler> eventhandlers_{};
 
 public:
  void add(EventHandler handler) { eventhandlers_.emplace_back(std::move(handler)); }
 
  [[nodiscard]] std::size_t count() const { return eventhandlers_.size(); }
 
  void raise(TArgs&&... args) const {
    for (const auto& eventhandler : eventhandlers_) {
      try {
        eventhandler(std::forward<decltype(args)>(args)...);
      } catch (...) {
        throw;
      }
    }
  }
};
 
}  // namespace databroker
 
// Forward declarations:
template <typename T>
class BasicContainer;
class Signal;
class DataBroker;
 
template <typename T>
constexpr void assert_static_type() {
  static_assert(!static_cast<bool>(databroker::is_incompatible_type_v<T>),
                "Incompatible-Datatype-Error.\n"
                "\n"
                "Please find the offending LOC in above line 'require from here'.\n"
                "\n"
                "Explanation/Reasoning:\n"
                "- references & void are fundamentally incompatible");
}
 
using SignalPtr = std::shared_ptr<Signal>;
 
using lua_signal_adapter_t =
    std::function<void(const SignalPtr&, sol::state_view, std::string_view)>;
 
using lua_signal_declarator_t = std::function<void(sol::state_view)>;
 
template <typename T>
using Container = BasicContainer<databroker::compatible_base_t<T>>;
 
template <typename T>
class BasicContainer {
 public:
  using value_type = databroker::compatible_base_t<T>;
 
 private:
  struct access_token {
    explicit access_token(int /*unused*/){};
  };
 
  value_type value_{};
  databroker::on_value_changed_callback_t<value_type> on_value_changed_{};
  Signal* signal_{};
 
 public:
  BasicContainer() = default;
  BasicContainer(Signal* signal,
                 databroker::on_value_changed_callback_t<value_type>
                     on_value_changed,
                 access_token /*unused*/)
      : value_(), on_value_changed_(std::move(on_value_changed)), signal_(signal) {
    update_accessor_functions(this);
  }
  BasicContainer(const BasicContainer&) = delete;
  BasicContainer(BasicContainer<value_type>&& source) { *this = std::move(source); }
 
  ~BasicContainer() { update_accessor_functions(nullptr); }
  BasicContainer& operator=(const BasicContainer&) = delete;
  BasicContainer& operator=(BasicContainer&& rhs) {
    value_ = std::move(rhs.value_);
    on_value_changed_ = std::move(rhs.on_value_changed_);
    signal_ = std::move(rhs.signal_);
    update_accessor_functions(this);
 
    rhs.signal_ = nullptr;
 
    return *this;
  }
  BasicContainer& operator=(databroker::signal_type_cref_t<T> value) {
    value_ = value;
    if (on_value_changed_) {
      on_value_changed_(value_);
    }
    return *this;
  }
 
  const value_type& value() const { return value_; }
  value_type& value() { return value_; }
  void set_value(databroker::signal_type_cref_t<T> value) { *this = value; }
 
  [[nodiscard]] bool has_subscriber() const;
  [[nodiscard]] std::size_t subscriber_count() const;
 
  // mimic std::optional
  constexpr const value_type* operator->() const noexcept { return &value_; }
  constexpr value_type* operator->() noexcept { return &value_; }
  constexpr const value_type& operator*() const noexcept { return value_; }
  constexpr value_type& operator*() noexcept { return value_; }
 
 private:
  void update_accessor_functions(BasicContainer* container);
 
  friend class Signal;
};
 
// Compare two BasicContainer
 
template <typename T, typename U>
constexpr bool operator==(const BasicContainer<T>& lhs, const BasicContainer<U>& rhs) {
  return *lhs == *rhs;
}
template <typename T, typename U>
constexpr bool operator!=(const BasicContainer<T>& lhs, const BasicContainer<U>& rhs) {
  return *lhs != *rhs;
}
template <typename T, typename U>
constexpr bool operator<(const BasicContainer<T>& lhs, const BasicContainer<U>& rhs) {
  return *lhs < *rhs;
}
template <typename T, typename U>
constexpr bool operator<=(const BasicContainer<T>& lhs, const BasicContainer<U>& rhs) {
  return *lhs <= *rhs;
}
template <typename T, typename U>
constexpr bool operator>(const BasicContainer<T>& lhs, const BasicContainer<U>& rhs) {
  return *lhs > *rhs;
}
template <typename T, typename U>
constexpr bool operator>=(const BasicContainer<T>& lhs, const BasicContainer<U>& rhs) {
  return *lhs >= *rhs;
}
 
// Compare BasicContainer with a value
 
template <typename T, typename U>
constexpr bool operator==(const BasicContainer<T>& lhs, const U& rhs) {
  return *lhs == rhs;
}
template <typename T, typename U>
constexpr bool operator==(const T& lhs, const BasicContainer<U>& rhs) {
  return lhs == *rhs;
}
template <typename T, typename U>
constexpr bool operator!=(const BasicContainer<T>& lhs, const U& rhs) {
  return *lhs != rhs;
}
template <typename T, typename U>
constexpr bool operator!=(const T& lhs, const BasicContainer<U>& rhs) {
  return lhs != *rhs;
}
template <typename T, typename U>
constexpr bool operator<(const BasicContainer<T>& lhs, const U& rhs) {
  return *lhs < rhs;
}
template <typename T, typename U>
constexpr bool operator<(const T& lhs, const BasicContainer<U>& rhs) {
  return lhs < *rhs;
}
template <typename T, typename U>
constexpr bool operator<=(const BasicContainer<T>& lhs, const U& rhs) {
  return *lhs <= rhs;
}
template <typename T, typename U>
constexpr bool operator<=(const T& lhs, const BasicContainer<U>& rhs) {
  return lhs <= *rhs;
}
template <typename T, typename U>
constexpr bool operator>(const BasicContainer<T>& lhs, const U& rhs) {
  return *lhs > rhs;
}
template <typename T, typename U>
constexpr bool operator>(const T& lhs, const BasicContainer<U>& rhs) {
  return lhs > *rhs;
}
template <typename T, typename U>
constexpr bool operator>=(const BasicContainer<T>& lhs, const U& rhs) {
  return *lhs >= rhs;
}
template <typename T, typename U>
constexpr bool operator>=(const T& lhs, const BasicContainer<U>& rhs) {
  return lhs >= *rhs;
}
 
class MetaInformation {
 private:
  using metainformation_map_t = std::unordered_map<std::type_index, std::any>;
  metainformation_map_t metainformations_;
 
 public:
  template <typename T>
  struct Tag {
   public:
    using tag_type = T;
  };
 
 public:
  MetaInformation() = default;
  virtual ~MetaInformation() = default;
 
 private:
  template <typename T>
  constexpr void assert_static_type() {
    // prevent usage of references
    static_assert(std::is_reference_v<typename T::tag_type> == false,
                  "References are unsupported.");
  }
 
 public:
  template <typename T>
  void remove() {
    auto tindex = std::type_index(typeid(T));
    auto iter = metainformations_.find(tindex);
    if (iter != metainformations_.end()) {
      metainformations_.erase(iter);
    }
  }
  template <typename T>
  void add_any(std::any metainformation_any) {
    auto tindex = std::type_index(typeid(T));
    auto iter = metainformations_.find(tindex);
    if (iter != metainformations_.end()) {
    }
    metainformations_[tindex] = std::move(metainformation_any);
  }
  template <typename T>
  const std::any* get_any() const {
    auto tindex = std::type_index(typeid(T));
    auto iter = metainformations_.find(tindex);
    if (iter != metainformations_.end()) {
      const std::any& metainformation_any = iter->second;
      return &metainformation_any;
    } else {
      return nullptr;
    }
  }
  template <typename T>
  std::enable_if_t<!std::is_void_v<typename T::tag_type>, const typename T::tag_type>* get() const {
    const std::any* metainformation_any = get_any<T>();
    return (metainformation_any != nullptr)
               ? std::any_cast<typename T::tag_type>(metainformation_any)
               : nullptr;
  }
  template <typename T>
  std::enable_if_t<std::is_void_v<typename T::tag_type>, bool> get() const {
    const std::any* metainformation_any = get_any<T>();
    return (metainformation_any != nullptr);
  }
 
  template <typename T>
  // clang-format off
  std::enable_if_t<
       !std::is_void_v<typename T::tag_type>
    && !std::is_base_of_v< Tag< T >, T >
    &&  std::is_move_constructible_v<typename T::tag_type>
  >
  // clang-format on
  add(typename T::tag_type metainformation) {
    assert_static_type<T>();
 
    std::any metainformation_any = std::move(metainformation);
    add_any<T>(std::move(metainformation_any));
  }
  template <typename T>
  // clang-format off
  std::enable_if_t<
       !std::is_void_v<typename T::tag_type>
    && !std::is_base_of_v< Tag< T >, T >
    &&  std::is_copy_constructible_v<typename T::tag_type>
    && !std::is_move_constructible_v<typename T::tag_type>
  >
  // clang-format on
  add(const typename T::tag_type& metainformation) {
    assert_static_type<T>();
 
    std::any metainformation_any = metainformation;
    add_any<T>(std::move(metainformation_any));
  }
  template <typename T>
  // clang-format off
  std::enable_if_t<
    std::is_void_v<typename T::tag_type>
  >
  // clang-format on
  add() {
    std::any metainformation_any;
    add_any<T>(std::move(metainformation_any));
  }
  template <typename T>
  // clang-format off
  std::enable_if_t<
       std::is_base_of_v< Tag< T >, T >
    && std::is_same_v<T, typename T::tag_type>
  >
  // clang-format on
  add(T metainformation) {
    assert_static_type<T>();
 
    std::any metainformation_any = std::move(metainformation);
    add_any<T>(std::move(metainformation_any));
  }
  template <typename T, typename... TArgs>
  // clang-format off
  std::enable_if_t<
       std::is_base_of_v< Tag< T >, T >
    && std::is_same_v<T, typename T::tag_type>
  >
  // clang-format on
  add(TArgs... args) {
    assert_static_type<T>();
    T metainformation(std::forward<TArgs>(args)...);
    std::any metainformation_any = std::move(metainformation);
    add_any<T>(std::move(metainformation_any));
  }
};
 
struct SignalDocumentation : MetaInformation::Tag<SignalDocumentation> {
  std::string text;
 
  SignalDocumentation(std::string text_) : text{std::move(text_)} {}
 
  friend const std::string& to_string(const SignalDocumentation& doc) { return doc.text; }
};
 
struct LuaAutocompletionTag : MetaInformation::Tag<LuaAutocompletionTag> {
#define LUADATATYPE_LIST \
  X(Class, 0)            \
  X(Number, 1)           \
  X(String, 2)
 
  enum class LuaDatatype {
#define X(name, value) name = value,
    LUADATATYPE_LIST
#undef X
  };
 
  friend std::string to_string(LuaDatatype type) {
    switch (type) {
#define X(name, value)    \
  case LuaDatatype::name: \
    return #name;
      LUADATATYPE_LIST
#undef X
      default:
        return {};
    }
  }
#undef LUADATATYPE_LIST
 
#define PHYSICALQUANTITIES_LIST \
  X(Dimensionless, "[]")        \
  X(Radian, "[rad]")            \
  X(Length, "[m]")              \
  X(Time, "[s]")                \
  X(Mass, "[kg]")               \
  X(Temperature, "[K]")         \
  X(ElectricCurrent, "[A]")     \
  X(Velocity, "[m/s]")          \
  X(Acceleration, "[m/s^2]")    \
  X(Jerk, "[m/s^3]")            \
  X(Jounce, "[m/s^4]")          \
  X(Crackle, "[m/s^5]")
 
  enum class PhysicalQuantity {
#define X(name, value) name,
    PHYSICALQUANTITIES_LIST
#undef X
  };
 
  friend std::string to_string(PhysicalQuantity type) {
    switch (type) {
#define X(name, value)         \
  case PhysicalQuantity::name: \
    return #value;
      PHYSICALQUANTITIES_LIST
#undef X
      default:
        return {};
    }
  }
#undef PHYSICALQUANTITIES_LIST
 
  LuaDatatype datatype;
  PhysicalQuantity unit;
  std::string text;
 
  LuaAutocompletionTag(LuaDatatype datatype_, PhysicalQuantity unit_, std::string text_)
      : datatype{std::move(datatype_)}, unit{std::move(unit_)}, text{std::move(text_)} {}
};
 
class Signal {
 private:
  struct access_token {
    explicit access_token(int /*unused*/){};
  };
 
 public:
  template <typename T>
  using typed_get_value_function_t = std::function<databroker::signal_type_cref_t<T>()>;
  using type_erased_get_value_function_t = std::any;
 
  template <typename T>
  using typed_set_value_function_t = std::function<void(databroker::signal_type_cref_t<T>)>;
  using type_erased_set_value_function_t = std::any;
  template <typename T>
  using typed_value_changed_event_t = databroker::Event<databroker::signal_type_cref_t<T>>;
  using type_erased_value_changed_event_t = std::any;
  template <typename T>
  using typed_on_value_change_event_function_t =
      std::function<void(databroker::signal_type_cref_t<T>)>;
  using type_erased_on_value_change_event_function_t = std::any;
 
 private:
  std::vector<std::string> names_{};
  const std::type_info* type_{nullptr};
  type_erased_get_value_function_t get_value_{};
  type_erased_set_value_function_t set_value_{};
  type_erased_value_changed_event_t value_changed_event_{};
  type_erased_on_value_change_event_function_t on_value_changed_{};
  std::function<std::size_t()> subscriber_count_{};
  MetaInformation metainformations_;
 
  Signal() = default;
 
 public:
  explicit Signal(access_token /*unused*/) : Signal() {}
  Signal(const Signal&) = delete;
  Signal(Signal&&) = default;
  virtual ~Signal() = default;
  Signal& operator=(const Signal&) = delete;
  Signal& operator=(Signal&&) = default;
 
  constexpr const std::type_info* type() const { return type_; }
 
 private:
  template <typename T>
  constexpr void assert_dynamic_type() const {
    const std::type_info* static_type = &typeid(T);
    const std::type_info* dynamic_type = type();
    if ((dynamic_type == nullptr) || (!(*dynamic_type == *static_type))) {
      throw std::logic_error(
          fmt::format("mismatch between dynamic-/actual-type and static-/requested-type; "
                      "signal type: {}, requested type: {}",
                      dynamic_type != nullptr ? dynamic_type->name() : "", static_type->name()));
    }
  }
 
 public:
  template <typename T>
  const typed_get_value_function_t<T>* getter() const {
    assert_static_type<T>();
    assert_dynamic_type<T>();
 
    const typed_get_value_function_t<T>* get_value_fn =
        std::any_cast<typed_get_value_function_t<T>>(&get_value_);
    return get_value_fn;
  }
 
  template <typename T>
  void set_getter(typed_get_value_function_t<T> get_value_fn) {
    assert_static_type<T>();
    assert_dynamic_type<T>();
 
    get_value_ = std::move(get_value_fn);
  }
 
  template <typename T>
  databroker::signal_type_cref_t<T> value() const {
    assert_static_type<T>();
    assert_dynamic_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    const typed_get_value_function_t<T>* getter_fn = getter<compatible_type>();
    if (getter_fn && (*getter_fn)) {
      databroker::signal_type_cref_t<T> value = getter_fn->operator()();
      return value;
    }
    throw std::logic_error(
        fmt::format("unable to get value for signal without getter-function: {}", names_.front()));
  }
 
  template <typename T>
  const typed_set_value_function_t<T>* setter() const {
    assert_static_type<T>();
    assert_dynamic_type<T>();
 
    const typed_set_value_function_t<T>* set_value_fn =
        std::any_cast<typed_set_value_function_t<T>>(&set_value_);
    return set_value_fn;
  }
 
  template <typename T>
  void set_setter(typed_set_value_function_t<T> set_value_fn) {
    assert_static_type<T>();
    assert_dynamic_type<T>();
 
    set_value_ = std::move(set_value_fn);
  }
 
  template <typename T>
  void set_value(databroker::signal_type_cref_t<T> value) const {
    assert_static_type<T>();
    assert_dynamic_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    const typed_set_value_function_t<T>* setter_fn = setter<compatible_type>();
    if (setter_fn && *setter_fn) {
      setter_fn->operator()(value);
      return;
    }
    throw std::logic_error(
        fmt::format("unable to set value for signal without setter-function: {}", names_.front()));
  }
 
  template <typename T>
  const typed_on_value_change_event_function_t<T>& trigger() const {
    assert_static_type<T>();
    assert_dynamic_type<T>();
 
    const typed_on_value_change_event_function_t<T>* trigger_fn =
        std::any_cast<typed_on_value_change_event_function_t<T>>(&on_value_changed_);
    assert(trigger_fn);
    return *trigger_fn;
  }
 
  template <typename T>
  std::enable_if_t<!std::is_void_v<typename T::tag_type>> add(typename T::tag_type metadata) {
    static_assert(std::is_reference_v<typename T::tag_type> == false);
    metainformations_.add<T>(metadata);
  }
  template <typename T, typename... TArgs>
  std::enable_if_t<!std::is_void_v<typename T::tag_type>> add(TArgs&&... args) {
    static_assert(std::is_reference_v<typename T::tag_type> == false);
    metainformations_.add<T>(std::forward<TArgs>(args)...);
  }
 
  template <typename T>
  // clang-format off
  std::enable_if_t<
    std::is_void_v<typename T::tag_type>
  >
  // clang-format on
  add() {
    metainformations_.add<T>();
  }
  template <typename T>
  auto metadata() -> decltype(metainformations_.get<T>()) {
    return metainformations_.get<T>();
  }
  const MetaInformation& metadatas() const { return metainformations_; }
 
 private:
  template <typename T>
  void subscribe_impl(
      const std::function<void(databroker::Event<databroker::signal_type_cref_t<T>>&)>& callback) {
    typed_value_changed_event_t<T>* value_changed_event =
        std::any_cast<typed_value_changed_event_t<T>>(&value_changed_event_);
    if (callback) {
      assert(value_changed_event);
      callback(*value_changed_event);
    }
  }
 
 public:
  template <typename T>
  void subscribe(databroker::on_value_changed_callback_t<T> callback) {
    assert_static_type<T>();
    assert_dynamic_type<T>();
 
    subscribe_impl<T>(
        [callback = std::move(callback)](typed_value_changed_event_t<T>& value_changed_event) {
          value_changed_event.add(std::move(callback));
        });
  }
 
  std::size_t subscriber_count() const { return subscriber_count_(); }
 
  bool has_subscriber() const { return subscriber_count() > 0; }
 
  const std::vector<std::string>& names() const { return names_; }
 
  const std::string& name() const {
    if (names_.empty()) {
      throw std::logic_error("signal does not have a name");
    }
    return names_.front();
  }
 
  std::string name_or(std::string def) const {
    if (names_.empty()) {
      return def;
    }
    return names_.front();
  }
 
  void add_name(std::string_view name) { names_.emplace_back(name); }
 
 private:
  template <typename T>
  static std::unique_ptr<Signal> make() {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    auto signal = std::make_unique<Signal>(access_token(0));
    signal->initialize<compatible_type>();
    return signal;
  }
 
  template <typename T>
  BasicContainer<T> create_container() {
    assert_static_type<T>();
 
    typed_value_changed_event_t<T>* value_changed_event =
        std::any_cast<typed_value_changed_event_t<T>>(&value_changed_event_);
    // Create container
    BasicContainer<T> result = BasicContainer<T>(
        this,
        [value_changed_event](databroker::signal_type_cref_t<T> value) {
          value_changed_event->raise(std::move(value));
        },
        typename BasicContainer<T>::access_token(0));
    return result;
  }
 
 public:
 private:
  template <typename T>
  void initialize() {
    assert_static_type<T>();
 
    type_ = &typeid(T);
    // Create event
    value_changed_event_ = typed_value_changed_event_t<T>();
    typed_value_changed_event_t<T>* value_changed_event =
        &std::any_cast<typed_value_changed_event_t<T>&>(value_changed_event_);
    // Create event-trigger
    typed_on_value_change_event_function_t<T> on_value_changed =
        [value_changed_event](databroker::signal_type_cref_t<T> value) {
          value_changed_event->raise(std::move(value));
        };
    on_value_changed_ = on_value_changed;
    // Create subscriber_count function
    subscriber_count_ = [value_changed_event]() { return value_changed_event->count(); };
  }
 
  template <typename T>
  friend class BasicContainer;
  friend class DataBroker;
};
 
template <typename T>
void BasicContainer<T>::update_accessor_functions(BasicContainer* container) {
  if (signal_ != nullptr) {
    // Create getter-function
    if (container) {
      signal_->template set_getter<T>(
          [container]() -> databroker::signal_type_cref_t<T> { return container->value(); });
      signal_->template set_setter<T>(
          [container](databroker::signal_type_cref_t<T> value) { container->set_value(value); });
    } else {
      signal_->template set_getter<T>(Signal::typed_get_value_function_t<T>());
      signal_->template set_setter<T>(Signal::typed_set_value_function_t<T>());
    }
  }
}
 
template <typename T>
bool BasicContainer<T>::has_subscriber() const {
  return signal_ != nullptr && signal_->has_subscriber();
}
 
template <typename T>
std::size_t BasicContainer<T>::subscriber_count() const {
  return signal_ != nullptr ? signal_->subscriber_count() : 0;
}
 
template <typename T>
class TypedSignal {
 private:
  SignalPtr signal_;
 
 public:
  TypedSignal(SignalPtr signal) : signal_{signal} {}
  ~TypedSignal() = default;
 
  operator SignalPtr&() { return signal_; }
  operator const SignalPtr&() const { return signal_; }
 
  const T& value() const { return signal_->template value<T>(); }
 
  template <typename TSetter>
  void set_setter(TSetter setter) {
    signal_->template set_setter<T>(std::move(setter));
  }
};
 
class DataBroker {
 public:
  using SignalContainer = std::map<std::string, SignalPtr, std::less<>>;
 
 private:
  SignalContainer signals_{};
  std::unordered_map<std::type_index, lua_signal_adapter_t> bindings_{};
  std::unordered_map<std::type_index, bool> lua_declared_types_{};
 
 public:
  DataBroker() = default;
  explicit DataBroker(const sol::state_view& lua) : lua_(lua), signals_object_(*lua_) {}
  DataBroker(const DataBroker&) = delete;
  DataBroker(DataBroker&&) = delete;
  ~DataBroker() = default;
  DataBroker& operator=(const DataBroker&) = delete;
  DataBroker& operator=(DataBroker&&) = delete;
 
 private:
  class SignalsObject {
   private:
    using lua_getter_fn = std::function<sol::object(sol::this_state&)>;
    using lua_setter_fn = std::function<void(sol::stack_object&)>;
    struct lua_accessor {
      lua_getter_fn getter;
      lua_setter_fn setter;
    };
    using accessors = std::unordered_map<std::string, lua_accessor>;
    accessors accessors_;
    sol::usertype<SignalsObject> signals_table_;
 
   public:
    SignalsObject(sol::state_view& lua)
        : accessors_()
        , signals_table_(lua.new_usertype<SignalsObject>(
              "SignalsObject", sol::meta_function::new_index, &SignalsObject::set_property_lua,
              sol::meta_function::index, &SignalsObject::get_property_lua)) {}
 
    sol::object get_property_lua(const char* name, sol::this_state s) {
      auto iter = accessors_.find(name);
      if (iter != accessors_.end()) {
        auto result = iter->second.getter(s);
        return result;
      } else {
        throw std::out_of_range(
            fmt::format("Failure to access signal '{}' from Lua since it is not bound.", name));
      }
    }
    void set_property_lua(const char* name, sol::stack_object object) {
      auto iter = accessors_.find(name);
      if (iter != accessors_.end()) {
        iter->second.setter(object);
      } else {
        throw std::out_of_range(
            fmt::format("Failure to access signal '{}' from Lua since it is not bound.", name));
      }
    }
    template <typename T>
    struct LuaAccessorFactory {
      using type = T;
      using value_type = T;
      static lua_accessor make(const SignalPtr& signal) {
        lua_accessor result;
        result.getter = [signal](sol::this_state& state) -> sol::object {
          const value_type& value = signal->value<value_type>();
          return sol::make_object(state, value);
        };
        result.setter = [signal](sol::stack_object& obj) -> void {
          T value = obj.as<value_type>();
          signal->set_value<value_type>(value);
        };
        return result;
      }
    };
    template <typename T>
    struct LuaAccessorFactory<std::optional<T>> {
      using type = std::optional<T>;
      using value_type = T;
      static lua_accessor make(const SignalPtr& signal) {
        lua_accessor result;
        result.getter = [signal](sol::this_state& state) -> sol::object {
          const type& value = signal->value<type>();
          if (value) {
            return sol::make_object(state, value.value());
          } else {
            return sol::make_object(state, sol::lua_nil);
          }
        };
        result.setter = [signal](sol::stack_object& obj) -> void {
          type value;
          if (obj != sol::lua_nil) {
            value = obj.as<value_type>();
          }
          signal->set_value<type>(value);
        };
        return result;
      }
    };
 
    template <typename T>
    void bind(const SignalPtr& signal, std::string_view lua_name) {
      lua_accessor accessor = LuaAccessorFactory<T>::make(signal);
      auto inserted = accessors_.try_emplace(std::string(lua_name), std::move(accessor));
      if (!inserted.second) {
        throw std::out_of_range(fmt::format(
            "Failure adding lua-accessor for signal {}. Name already exists.", lua_name));
      }
    }
  };
  std::optional<sol::state_view> lua_{};
  std::optional<SignalsObject> signals_object_{};
 
 public:
  template <typename T>
  void declare_type(lua_signal_declarator_t type_declarator) {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    if (lua_.has_value()) {
      std::type_index type{typeid(compatible_type)};
      auto iter = lua_declared_types_.find(type);
      if (iter == lua_declared_types_.end()) {
        lua_declared_types_[type] = true;
        // declare type
        type_declarator(*lua_);
      }
    }
  }
 
 private:
  template <typename T>
  void declare() {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
    if (lua_.has_value()) {
      // Check whether this type was already processed, if not declare it and store an adapter function in bindings_
      std::type_index type{typeid(compatible_type)};
      auto iter = bindings_.find(type);
      if (iter == bindings_.end()) {
        // Check wether this type was already declared to the Lua-VM, if not declare it
        auto declared_types_iter = lua_declared_types_.find(type);
        if (declared_types_iter == lua_declared_types_.end()) {
          lua_declared_types_[type] = true;
          ::cloe::databroker::detail::to_lua<T>(*lua_);
        }
 
        // Create adapter for Lua-VM
        lua_signal_adapter_t adapter = [this](const SignalPtr& signal, sol::state_view state,
                                              std::string_view lua_name) {
          //adapter_impl<T>(signal, state, lua_name);
          // Subscribe to the value-changed event to indicate the signal is used
          signal->subscribe<T>([](const T&) {});
          // Implement the signal as a property in Lua
          signals_object_->bind<T>(signal, lua_name);
        };
        // Store adapter function
        bindings_.emplace(type, std::move(adapter));
      }
    }
  }
 
 public:
  void bind_signal(std::string_view signal_name, std::string_view lua_name) {
    if (!lua_.has_value()) {
      throw std::logic_error(
          "DataBroker: Binding a signal to Lua must not happen, before binding the Lua "
          "context.");
    }
 
    SignalPtr signal = this->signal(signal_name);
    auto type = std::type_index(*signal->type());
 
    auto iter = bindings_.find(type);
    if (iter == bindings_.end()) {
      throw std::runtime_error(
          "DataBroker: <internal logic error>: Lua type binding not implemented");
    }
    const lua_signal_adapter_t& adapter = iter->second;
    adapter(signal, (*lua_), lua_name);
  }
 
  void bind_signal(std::string_view signal_name) { bind_signal(signal_name, signal_name); }
 
  void bind(std::string_view signals_name, sol::table parent) {
    parent[signals_name] = &(*signals_object_);
  }
 
  void bind(std::string_view signals_name) { (*lua_)[signals_name] = &(*signals_object_); }
 
 public:
  [[nodiscard]] const SignalContainer::const_iterator operator[](std::string_view name) const {
    SignalContainer::const_iterator iter = signals_.find(name);
    return iter;
  }
 
  [[nodiscard]] SignalContainer::iterator operator[](std::string_view name) {
    SignalContainer::iterator iter = signals_.find(name);
    return iter;
  }
 
  SignalPtr alias(SignalPtr signal, std::string_view new_name) {
    if (new_name.empty()) {
      throw std::invalid_argument(
          fmt::format("alias for signal must not be empty: {}", signal->name_or("<unnamed>")));
    }
 
    // Mutate signals
    std::pair<SignalContainer::iterator, bool> inserted =
        signals_.try_emplace(std::string(new_name), std::move(signal));
    if (!inserted.second) {
      throw std::out_of_range(fmt::format("cannot alias signal '{}' to '{}': name already exists",
                                          signal->name_or("<unnamed>"), new_name));
    }
    // signals mutated, there is a liability in case of exceptions
    try {
      SignalPtr result = inserted.first->second;
      result->add_name(new_name);
      return result;
    } catch (...) {
      // fullfill exception guarantee (map.erase(iter) does not throw)
      signals_.erase(inserted.first);
      throw;
    }
  }
 
  SignalPtr alias(std::string_view old_name, std::string_view new_name,
                  std::regex::flag_type f = std::regex_constants::ECMAScript) {
    std::regex regex = std::regex(std::string(old_name), f);
    auto it1 = signals().begin();
    auto it2 = signals().begin();
    auto end = signals().end();
    const auto predicate = [&](const auto& item) -> bool {
      std::smatch match;
      return std::regex_match(item.first, match, regex);
    };
    it1 = (it1 != end) ? std::find_if(it1, end, predicate) : end;
    it2 = (it1 != end) ? std::find_if(std::next(it1), end, predicate) : end;
    if (it2 != end) {
      throw std::out_of_range(
          fmt::format("regex pattern matches multiple signals: '{}'; matches: '{}', '{}'", old_name,
                      it1->first, it2->first));
    }
    if (it1 == end) {
      throw std::out_of_range(fmt::format("regex pattern matches zero signals: {}", old_name));
      return nullptr;
    }
    SignalPtr result = alias(it1->second, new_name);
    return result;
  }
 
  template <typename T>
  SignalPtr declare(std::string_view name) {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    declare<compatible_type>();
 
    SignalPtr signal = Signal::make<compatible_type>();
    alias(signal, name);
    return signal;
  }
 
  template <typename T>
  SignalPtr declare(std::string_view name, T* value_ptr) {
    assert(value_ptr != nullptr);
    auto signal = this->declare<T>(name);
    signal->template set_getter<T>([value_ptr]() -> const T& {
      return *value_ptr;
    });
    signal->template set_setter<T>([value_ptr](const T& value) {
      *value_ptr = value;
    });
    return signal;
  }
 
  template <typename T>
  SignalPtr declare(std::string_view name, std::function<T()> getter, std::function<void(T)> setter) {
    auto signal = this->declare<T>(name);
    if (getter) {
      signal->template set_getter<T>(getter);
    }
    if (setter) {
      signal->template set_setter<T>(setter);
    }
    return signal;
  }
 
  template <typename T>
  [[nodiscard]] Container<databroker::compatible_base_t<T>> implement(std::string_view new_name) {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    declare<compatible_type>();
 
    SignalPtr signal = declare<compatible_type>(new_name);
    Container<compatible_type> container = signal->create_container<compatible_type>();
    return container;
  }
  [[nodiscard]] SignalPtr signal(std::string_view name) const {
    auto iter = (*this)[name];
    if (iter != signals_.end()) {
      return iter->second;
    }
    throw std::out_of_range(fmt::format("signal not found: {}", name));
  }
 
  [[nodiscard]] SignalPtr signal(std::string_view name) {
    auto iter = (*this)[name];
    if (iter != signals_.end()) {
      return iter->second;
    }
    throw std::out_of_range(fmt::format("signal not found: {}", name));
  }
 
  [[nodiscard]] const SignalContainer& signals() const { return signals_; }
 
  [[nodiscard]] SignalContainer& signals() {
    // DRY
    return const_cast<SignalContainer&>(const_cast<const DataBroker*>(this)->signals());
  }
 
  template <typename T>
  void subscribe(std::string_view name, databroker::on_value_changed_callback_t<T> callback) {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    signal(name)->template subscribe<compatible_type>(std::move(callback));
  }
 
  template <typename T>
  void set_value(std::string_view name, databroker::signal_type_cref_t<T> value) {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    signal(name)->set_value<compatible_type>(value);
  }
 
  template <typename T>
  databroker::signal_type_cref_t<T> value(std::string_view name) const {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    return signal(name)->value<compatible_type>();
  }
 
  template <typename T>
  const Signal::typed_get_value_function_t<T>& getter(std::string_view name) const {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    const Signal::typed_get_value_function_t<T>* getter_fn =
        signal(name)->getter<compatible_type>();
    if (!getter_fn) {
      throw std::logic_error(fmt::format("getter for signal not provided: {}", name));
    }
    return *getter_fn;
  }
  template <typename T>
  void set_getter(std::string_view name, const Signal::typed_get_value_function_t<T>& getter_fn) {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    signal(name)->set_getter<compatible_type>(getter_fn);
  }
 
  template <typename T>
  const Signal::typed_set_value_function_t<T>& setter(std::string_view name) const {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    const Signal::typed_set_value_function_t<T>* setter_fn =
        signal(name)->setter<compatible_type>();
    if (!setter_fn) {
      throw std::logic_error(fmt::format("setter for signal not provided: {}", name));
    }
    return *setter_fn;
  }
  template <typename T>
  void set_setter(std::string_view name, const Signal::typed_set_value_function_t<T>& setter_fn) {
    assert_static_type<T>();
    using compatible_type = databroker::compatible_base_t<T>;
 
    signal(name)->set_setter<compatible_type>(setter_fn);
  }
};
 
namespace databroker {
 
struct DynamicName {
  static constexpr bool STATIC = false;
 
 private:
  std::string name_;
 
 public:
  DynamicName(std::string name) : name_{name} {}
  const std::string& name() const { return name_; }
};
 
template <const char* NAME>
struct StaticName {
  static constexpr bool STATIC = true;
  static constexpr const char* name() { return NAME; }
};
 
template <typename T, typename TNAME, bool = TNAME::STATIC>
struct SignalDescriptorBase {};
 
template <typename T, typename TNAME>
struct SignalDescriptorBase<T, TNAME, true> : public TNAME {
  using TNAME::name;
  using TNAME::TNAME;
  static auto implement(DataBroker& db) { return db.implement<T>(name()); }
  static void declare(DataBroker& db) { db.declare<T>(name()); }
  static auto signal(const DataBroker& db) { return TypedSignal<T>(db.signal(name())); }
  static auto getter(const DataBroker& db) { return db.getter<T>(name()); }
  static void set_getter(DataBroker& db, Signal::typed_get_value_function_t<T> get_value_fn) {
    db.set_getter<T>(name(), std::move(get_value_fn));
  }
  static auto setter(const DataBroker& db) { return db.setter<T>(name()); }
  static void set_setter(DataBroker& db, Signal::typed_set_value_function_t<T> set_value_fn) {
    db.set_setter<T>(name(), std::move(set_value_fn));
  }
 
  static auto value(DataBroker& db) { return db.value<T>(name()); }
  static auto set_value(DataBroker& db, const T& value) { db.set_value<T>(name(), value); }
};
 
template <typename T, typename TNAME>
struct SignalDescriptorBase<T, TNAME, false> : public TNAME {
  using TNAME::name;
  using TNAME::TNAME;
  auto implement(DataBroker& db) { return db.implement<T>(name()); }
  void declare(DataBroker& db) { db.declare<T>(name()); }
  auto signal(const DataBroker& db) const { return TypedSignal<T>(db.signal(name())); }
  auto getter(const DataBroker& db) const { return db.getter<T>(name()); }
  void set_getter(DataBroker& db, Signal::typed_get_value_function_t<T> get_value_fn) {
    db.set_getter<T>(name(), std::move(get_value_fn));
  }
  auto setter(const DataBroker& db) const { return db.setter<T>(name()); }
  void set_setter(DataBroker& db, Signal::typed_set_value_function_t<T> set_value_fn) {
    db.set_setter<T>(name(), std::move(set_value_fn));
  }
 
  auto value(const DataBroker& db) const { return db.value<T>(name()); }
  auto set_value(DataBroker& db, const T& value) { db.set_value<T>(name(), value); }
};
 
template <typename T, const char* NAME>
struct SignalDescriptorImpl : public SignalDescriptorBase<T, StaticName<NAME>> {
  using SignalDescriptorBase<T, StaticName<NAME>>::SignalDescriptorBase;
};
template <typename T>
struct SignalDescriptorImpl<T, nullptr> : public SignalDescriptorBase<T, DynamicName> {
  using SignalDescriptorBase<T, DynamicName>::SignalDescriptorBase;
};
 
template <typename T, const char* NAME = nullptr>
struct SignalDescriptor : public SignalDescriptorImpl<T, NAME> {
  using SignalDescriptorImpl<T, NAME>::SignalDescriptorImpl;
};
 
template <typename T, const char* NAME>
struct SignalTemplate : public StaticName<NAME> {
 private:
  template <template <typename> class TARGET, typename... ARGS>
  static auto format(ARGS&&... args) {
    auto name = fmt::format(StaticName<NAME>::name(), std::forward<ARGS>(args)...);
    return TARGET<T>(name);
  }
 
 public:
  template <typename... ARGS>
  static auto specialize(ARGS&&... args) {
    return format<SignalDescriptor>(std::forward<ARGS>(args)...);
  }
 
  template <typename... ARGS>
  static auto partial(ARGS&&... args) {
    return format<SignalTemplate>(std::forward<ARGS>(args)...);
  }
};
 
// template <typename T, const char* NAME>
// struct SignalDescriptor : public SignalDescriptor<T, StaticName<NAME>> {
//using type = typename SignalDescriptorImpl<T, NAME>::type;
// };
 
// template <typename T>
// struct IsSignalDescriptor : std::false_type {};
// template <typename T, const char* NAME>
// struct IsSignalDescriptor<SignalDescriptor<T, NAME>> : std::true_type {};
// template <typename T>
// constexpr bool is_signal_descriptor_v() {
//   return IsSignalDescriptor<T>::value;
// }
 
}  // namespace databroker
 
// Design-Goals:
// -g1: Prepare for mass usage of Signals, Containers & Databroker
//      ==> Allow instantiation of all templates for relevant datatypes
// -g2: Pre-Instantiate these templates for datatypes which are already known to be relevant
 
#define CLOE_DATABROKER_TEMPLATE_INSTANTIATION(elem)                                               \
  extern template class BasicContainer<elem>;                                                      \
  extern template const Signal::typed_get_value_function_t<elem>* Signal::getter<elem>() const;    \
  extern template void Signal::set_getter<elem>(Signal::typed_get_value_function_t<elem>);         \
  extern template databroker::signal_type_cref_t<elem> Signal::value<elem>() const;                \
  extern template const Signal::typed_set_value_function_t<elem>* Signal::setter<elem>() const;    \
  extern template void Signal::set_setter<elem>(Signal::typed_set_value_function_t<elem>);         \
  extern template void Signal::set_value<elem>(databroker::signal_type_cref_t<elem> value) const;  \
  extern template const Signal::typed_on_value_change_event_function_t<elem>&                      \
  Signal::trigger<elem>() const;                                                                   \
  extern template void Signal::subscribe_impl<elem>(                                               \
      const std::function<void(databroker::Event<databroker::signal_type_cref_t<elem>>&)>&);       \
  extern template void Signal::subscribe<elem>(databroker::on_value_changed_callback_t<elem>);     \
  extern template std::unique_ptr<Signal> Signal::make<elem>();                                    \
  extern template BasicContainer<elem> Signal::create_container<elem>();                           \
  extern template void Signal::initialize<elem>();                                                 \
  extern template SignalPtr DataBroker::declare<elem>(std::string_view);                           \
  extern template BasicContainer<elem> DataBroker::implement<elem>(std::string_view);              \
  extern template void DataBroker::subscribe<elem>(std::string_view,                               \
                                                   databroker::on_value_changed_callback_t<elem>); \
  extern template databroker::signal_type_cref_t<elem> DataBroker::value<elem>(std::string_view);  \
  extern template const Signal::typed_get_value_function_t<elem>& DataBroker::getter<elem>(        \
      std::string_view name);                                                                      \
  extern template void DataBroker::set_value<elem>(std::string_view,                               \
                                                   databroker::signal_type_cref_t<elem>);          \
  extern template const Signal::typed_set_value_function_t<elem>& DataBroker::setter<elem>(        \
      std::string_view name);
 
#define CLOE_DATABROKER_TEMPLATE_INSTANTATION_TYPES()
 
CLOE_DATABROKER_TEMPLATE_INSTANTATION_TYPES()
 
// Goal g1 implies that the preprocessor macros are not undefined.
 
}  // namespace cloe
 
#endif  // CLOE_DATA_BROKER_HPP_