phonebook.hpp

#pragma once
 
#include <cassert>
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <typeindex>
#include <unordered_map>
 
#ifndef NDEBUG
    #include <iostream>
    #include <spdlog/spdlog.h>
    #include <stdexcept>
#endif
 
namespace ILLIXR {
 
class phonebook {
    /*
      Proof of thread-safety:
      - Since all instance members are private, acquiring a lock in each method implies the class is datarace-free.
      - Since there is only one lock and this does not call any code containing locks, this is deadlock-free.
      - Both of these methods are only used during initialization, so the locks are not contended in steady-state.
 
      However, to write a correct program, one must also check the thread-safety of the elements
      inserted into this class by the caller.
    */
 
public:
    class service {
    public:
        virtual ~service() = default;
    };
 
    template<typename specific_service>
    void register_impl(std::shared_ptr<specific_service> impl) {
        const std::unique_lock<std::shared_mutex> lock{_m_mutex};
 
        const std::type_index type_index = std::type_index(typeid(specific_service));
#ifndef NDEBUG
        spdlog::get("illixr")->debug("[phonebook] Register {}", type_index.name());
#endif
        assert(_m_registry.count(type_index) == 0);
        _m_registry.try_emplace(type_index, impl);
    }
 
    template<typename specific_service>
    std::shared_ptr<specific_service> lookup_impl() const {
        const std::shared_lock<std::shared_mutex> lock{_m_mutex};
 
        const std::type_index type_index = std::type_index(typeid(specific_service));
 
#ifndef NDEBUG
        // if this assert fails, and there are no duplicate base classes, ensure the hash_code's are unique.
        if (_m_registry.count(type_index) != 1) {
            throw std::runtime_error{"Attempted to lookup an unregistered implementation " + std::string{type_index.name()}};
        }
#endif
 
        std::shared_ptr<service> this_service = _m_registry.at(type_index);
        assert(this_service);
 
        std::shared_ptr<specific_service> this_specific_service = std::dynamic_pointer_cast<specific_service>(this_service);
        assert(this_specific_service);
 
        return this_specific_service;
    }
 
private:
    std::unordered_map<std::type_index, const std::shared_ptr<service>> _m_registry;
    mutable std::shared_mutex                                           _m_mutex;
};
} // namespace ILLIXR