multiton.hpp

浏览该文件的文档.

 
#pragma once
 
#include <concepts>
#include <initializer_list>
#include <stdexcept>
#include <string>
#include <unordered_map>
#include <memory>
#include <mutex>
#include <span>
#include <format>
#include <functional>
#include <unordered_set>
#include <utility>
#include <vector>
 
#include "utils/concepts.hpp"
#include "utils/singleton.hpp"
 
namespace roboctrl{
 
namespace multiton{
template <typename T>
concept descable = requires (const T& t) {
    { t.desc() } -> std::same_as<std::string>;
};
 
template<typename T>
concept multiton_info = requires(T info){
    typename T::key_type;
    typename T::owner_type;
    {info.key()} -> std::convertible_to<typename T::key_type>;
};
 
template<typename T>
concept info = multiton_info<T> or utils::singleton_info<T>;
 
template<typename T>
concept owner = requires(T owner){
    typename T::info_type;
    {T(std::declval<typename T::info_type>())};
};
 
template<multiton_info T>
using key_type_t = typename T::key_type;
 
 
template<multiton_info T>
using owner_type_t = typename T::owner_type;
 
namespace details{
 
template <typename owner_type>
struct multiton_impl final :
    public utils::immovable_base,
    public utils::not_copyable_base {
 
    using key_type = typename owner_type::info_type::key_type;
 
    static std::mutex mutex_;
    static std::unordered_map<key_type, std::unique_ptr<owner_type>> instances;
 
    using info_type = typename owner_type::info_type;
 
    static auto init(const info_type& info) -> owner_type& {
        std::lock_guard<std::mutex> lock{mutex_};
 
        const auto key = info.key();
        if (instances.contains(key)) {
            throw std::runtime_error(std::format("duplicate multiton key {}", key));
        }
 
        auto instance = std::make_unique<owner_type>(info);
        auto [it, inserted] = instances.emplace(key, std::move(instance));
        if (!inserted) {
            throw std::runtime_error(std::format("failed to register multiton key {}", key));
        }
        return *it->second;
    }
 
    static void init(std::initializer_list<info_type> infos) {
        init(std::span{infos.begin(), infos.size()});
    }
 
    static void init(std::span<const info_type> infos) {
        std::lock_guard<std::mutex> lock{mutex_};
 
        std::unordered_set<key_type> pending_keys;
        for (const auto& info : infos) {
            const auto key = info.key();
            if (instances.contains(key) || !pending_keys.emplace(key).second) {
                throw std::runtime_error(std::format("duplicate multiton key {}", key));
            }
        }
 
        std::vector<std::pair<key_type, std::unique_ptr<owner_type>>> pending;
        pending.reserve(infos.size());
        for (const auto& info : infos) {
            pending.emplace_back(info.key(), std::make_unique<owner_type>(info));
        }
 
        for (auto& [key, instance] : pending) {
            instances.emplace(std::move(key), std::move(instance));
        }
    }
 
    [[nodiscard]]
    static bool contains(const key_type& key){
        std::lock_guard<std::mutex> lock{mutex_};
        return instances.contains(key);
    }
 
    template<typename Fn>
    static void for_each(Fn&& fn) {
        std::lock_guard<std::mutex> lock{mutex_};
        for (auto& [key, instance] : instances) {
            std::invoke(fn, *instance);
        }
    }
 
    [[nodiscard]]
    static auto get(const key_type& key) -> owner_type& {
        std::lock_guard<std::mutex> lock { mutex_ };
        auto it = instances.find(key);
        if (it != instances.end()) {
            return *it->second;
        }
        
        throw std::runtime_error(std::format("uninitialized multiton {}",key)); //TODO:add detailed desc.
    };
};
 
template<multiton_info info_type>
using impl_t = multiton_impl<owner_type_t<info_type>>;
 
template <typename owner_type>
std::mutex multiton_impl<owner_type>::mutex_ {};
 
template <typename owner_type>
std::unordered_map<
    typename multiton_impl<owner_type>::key_type, 
    std::unique_ptr<owner_type>
> multiton_impl<owner_type>::instances {};
}
 
template<owner owner_type>
[[nodiscard]]
inline auto get(const typename details::multiton_impl<owner_type>::key_type& key) -> owner_type&{
    return details::multiton_impl<owner_type>::get(key);
}
 
template<typename T>
    requires(!owner<T> && utils::singleton<T>)
inline auto get() -> T&{
    return T::instance();
}
 
template<info info_type>
inline auto init(const info_type& info) -> bool{
    if constexpr (multiton_info<info_type>){
        details::impl_t<info_type>::init(info);
        return true;
    }
    else return get<typename info_type::owner_type>().init(info);
}
 
template<info info_type>
inline auto init(std::initializer_list<info_type> infos) -> bool{
    if constexpr (multiton_info<info_type>) {
        details::impl_t<info_type>::init(infos);
    } else {
        for (const auto& info : infos) {
            if (!init(info)) {
                return false;
            }
        }
    }
    return true;
}
 
template<multiton_info info_type>
inline auto init(std::span<const info_type> infos) -> bool{
    details::impl_t<info_type>::init(infos);
    return true;
}
 
template<info... info_types>
inline auto init(const info auto& info,const info_types&... infos) -> bool{
    if(init(info))
        return init(infos...);
    return false;
}
 
template<multiton_info info_type>
[[nodiscard]]
inline auto get(const info_type& info) -> owner_type_t<info_type>&{
    using owner_type = owner_type_t<info_type>;
    auto key = info.key();
    if(!details::multiton_impl<owner_type>::contains(key))
        details::multiton_impl<owner_type>::init(info);
 
    return details::multiton_impl<owner_type>::get(key);
}
 
[[nodiscard]]
inline auto desc(const descable auto& owner) -> std::string{
    return owner.desc();
}
 
template<owner owner_type, typename Fn>
void for_each_instance(Fn&& fn){
    details::multiton_impl<owner_type>::for_each(std::forward<Fn>(fn));
}
 
template<typename T>
concept startable = requires(T& instance) {
    { instance.start() } -> std::same_as<void>;
};
 
template<owner owner_type>
    requires startable<owner_type>
void start_all(){
    for_each_instance<owner_type>([](owner_type& instance) {
        instance.start();
    });
}
 
template<typename T>
concept connectable = requires(T& instance) {
    { instance.connect() } -> std::same_as<void>;
};
 
template<owner owner_type>
    requires connectable<owner_type>
void connect_all(){
    for_each_instance<owner_type>([](owner_type& instance) {
        instance.connect();
    });
}
 
}
 
 
 
template<typename T>
struct instance_ref{
    static_assert(multiton::owner<T>, "T must be a multiton owner.");
 
    using key_type = typename T::info_type::key_type;
 
    key_type key;
 
    explicit instance_ref(key_type key_) : key(std::move(key_)) {}
 
    T& operator *() const {
        return roboctrl::multiton::get<T>(key);
    }
 
    T* operator ->() const {
        return &roboctrl::multiton::get<T>(key);
    }
};
 
using namespace multiton;
}