InterfaceList.hpp

#ifndef SCORE_INTERFACELIST_2018_10_22
#define SCORE_INTERFACELIST_2018_10_22
#pragma once
#include <score/plugins/Interface.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;
template <typename FactoryType>
class InterfaceList
    : public score::InterfaceListBase
    , public IndirectContainer<FactoryType>
{
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()))
    {
      e.release();
      std::unique_ptr<factory_type> pf{result};
      vector_type::push_back(pf.get());
 
      auto k = pf->concreteKey();
      auto it = this->map.find(k);
      if(it == this->map.end())
      {
        this->map.emplace(std::make_pair(k, std::move(pf)));
      }
      else
      {
        score::debug_types(it->second.get(), result);
        it->second = std::move(pf);
      }
 
      added(vector_type::back());
    }
  }
 
  FactoryType* get(const key_type& k) const noexcept
  {
    auto it = this->map.find(k);
    return (it != this->map.end()) ? it->second.get() : nullptr;
  }
 
  mutable Nano::Signal<void(const factory_type&)> added;
 
protected:
  ossia::hash_map<typename FactoryType::ConcreteKey, std::unique_ptr<FactoryType>> map;
 
private:
  void optimize() noexcept final override
  {
    // score::optimize_hash_map(this->map);
    this->map.max_load_factor(0.1f);
    this->map.reserve(map.size());
  }
 
  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