InterfaceList.hpp

#ifndef SCORE_INTERFACELIST_2018_10_22
#define SCORE_INTERFACELIST_2018_10_22
#pragma once
#include <score/plugins/Interface.hpp>
#include <score/tools/Debug.hpp>
#include <score/tools/std/IndirectContainer.hpp>
#include <score/tools/std/Pointer.hpp>
 
#include <ossia/detail/hash_map.hpp>
 
#include <nano_signal_slot.hpp>
#include <score_lib_base_export.h>
 
namespace score
{
class SCORE_LIB_BASE_EXPORT InterfaceListBase
{
public:
  static constexpr bool factory_list_tag = true;
  InterfaceListBase() noexcept = default;
  InterfaceListBase(const InterfaceListBase&) = delete;
  InterfaceListBase(InterfaceListBase&&) = delete;
  InterfaceListBase& operator=(const InterfaceListBase&) = delete;
  InterfaceListBase& operator=(InterfaceListBase&&) = delete;
  virtual ~InterfaceListBase();
 
  virtual score::InterfaceKey interfaceKey() const noexcept = 0;
 
  virtual void insert(std::unique_ptr<score::InterfaceBase>) = 0;
 
  virtual void optimize() noexcept = 0;
};
 
SCORE_LIB_BASE_EXPORT void
debug_types(const score::InterfaceBase* orig, const score::InterfaceBase* repl) noexcept;
 
class SCORE_LIB_BASE_EXPORT InterfaceListMain : public score::InterfaceListBase
{
public:
  InterfaceListMain();
  ~InterfaceListMain();
  void insert_base(std::unique_ptr<score::InterfaceBase> e, score::uuid_t k);
 
  mutable Nano::Signal<void(const score::InterfaceBase&)> added;
 
  auto reserve(std::size_t v) { return map.reserve(v); }
  auto size() const noexcept { return map.size(); }
  auto empty() const noexcept { return map.empty(); }
 
  void optimize() noexcept final override;
  ossia::hash_map<score::uuid_t, std::unique_ptr<score::InterfaceBase>> map;
};
 
template <typename FactoryType>
class InterfaceList : public score::InterfaceListMain
{
public:
  using factory_type = FactoryType;
  using key_type = typename FactoryType::ConcreteKey;
  using vector_type = IndirectContainer<FactoryType>;
  InterfaceList() = default;
  ~InterfaceList() = default;
 
  static const constexpr score::InterfaceKey static_interfaceKey() noexcept
  {
    return FactoryType::static_interfaceKey();
  }
 
  constexpr score::InterfaceKey interfaceKey() const noexcept final override
  {
    return FactoryType::static_interfaceKey();
  }
 
  void insert(std::unique_ptr<score::InterfaceBase> e) final override
  {
    if(auto result = dynamic_cast<factory_type*>(e.get()))
    {
      return insert_base(std::move(e), result->concreteKey().impl());
    }
    else
    {
      SCORE_SOFT_ASSERT("Invalid interface detected");
    }
  }
 
  FactoryType* get(const key_type& k) const noexcept
  {
    auto it = this->map.find(k.impl());
    return (it != this->map.end()) ? static_cast<FactoryType*>(it->second.get())
                                   : nullptr;
  }
 
  auto begin() noexcept
  {
    return make_indirect_cast_map_iterator<factory_type>(map.begin());
  }
  auto end() noexcept
  {
    return make_indirect_cast_map_iterator<factory_type>(map.end());
  }
  auto begin() const noexcept
  {
    return make_indirect_cast_map_iterator<factory_type>(map.begin());
  }
  auto end() const noexcept
  {
    return make_indirect_cast_map_iterator<factory_type>(map.end());
  }
 
  auto cbegin() const noexcept
  {
    return make_indirect_cast_map_iterator<factory_type>(map.cbegin());
  }
  auto cend() const noexcept
  {
    return make_indirect_cast_map_iterator<factory_type>(map.cend());
  }
 
private:
  InterfaceList(const InterfaceList&) = delete;
  InterfaceList(InterfaceList&&) = delete;
  InterfaceList& operator=(const InterfaceList&) = delete;
  InterfaceList& operator=(InterfaceList&&) = delete;
};
 
template <typename T>
class MatchingFactory : public score::InterfaceList<T>
{
public:
  template <typename Fun, typename... Args>
    requires std::is_invocable_v<
        Fun, typename score::InterfaceList<T>::factory_type&, Args...>
  auto make(Fun f, Args&&... args) const noexcept
  {
    using val_t = decltype(*this->begin());
    for(const val_t& elt : *this)
    {
      if(elt.matches(std::forward<Args>(args)...))
      {
        return (elt.*f)(std::forward<Args>(args)...);
      }
    }
    return decltype((std::declval<val_t>().*f)(std::forward<Args>(args)...)){};
  }
};
}
#endif