ServiceRegistry.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <array>
#include <cstddef>
#include <stop_token>
 
#include "corium/ServiceContext.hpp"
 
namespace corium {
 
namespace internal {
 
template <typename T, typename Context>
concept HasSetContext = requires(T& t, Context ctx) {
    t.setContext(ctx);
};
 
template <typename T>
concept HasInitialize = requires(T& t) {
    t.initialize();
};
 
template <typename T>
concept HasRunToken = requires(T& t, std::stop_token st) {
    t.run(st);
};
 
template <typename T>
concept HasStart = requires(T& t) {
    t.start();
};
 
template <typename T>
concept HasStop = requires(T& t) {
    t.stop();
};
 
template <typename T>
concept HasJoin = requires(T& t) {
    t.join();
};
 
} // namespace internal
 
template <size_t MaxServices = 8, typename EventVariant = DefaultEvents>
class BasicServiceRegistry {
public:
    using ServiceContextType = ServiceContextT<EventVariant>;
 
    struct ServiceHandle {
        void* instance = nullptr;
        internal::TypeIdPtr typeId = nullptr;
        void (*initFn)(void* inst, ServiceContextType ctx) = nullptr;
        void (*startFn)(void* inst) = nullptr;
        void (*stopFn)(void* inst) noexcept = nullptr;
        void (*joinFn)(void* inst) noexcept = nullptr;
    };
 
    BasicServiceRegistry() = default;
 
    template <typename ServiceType>
    bool registerService(ServiceType& serviceInstance)
    {
        if (_count >= MaxServices) {
            return false;
        }
        _services[_count] = ServiceHandle{
            &serviceInstance,
            internal::getTypeId<ServiceType>(),
            [](void* ptr, ServiceContextType ctx) {
                auto* s = static_cast<ServiceType*>(ptr);
                if constexpr (internal::HasSetContext<ServiceType, ServiceContextType>) { s->setContext(ctx); }
                if constexpr (internal::HasInitialize<ServiceType>) { s->initialize(); }
            },
            [](void* ptr) {
                auto* s = static_cast<ServiceType*>(ptr);
                if constexpr (internal::HasRunToken<ServiceType>) {
                    s->startThread(s);
                } else if constexpr (internal::HasStart<ServiceType>) {
                    s->start();
                }
            },
            [](void* ptr) noexcept {
                auto* s = static_cast<ServiceType*>(ptr);
                if constexpr (internal::HasStop<ServiceType>) { s->stop(); }
            },
            [](void* ptr) noexcept {
                auto* s = static_cast<ServiceType*>(ptr);
                if constexpr (internal::HasJoin<ServiceType>) { s->join(); }
            }
        };
        _count++;
        return true;
    }
 
    [[nodiscard]] void* getServiceById(internal::TypeIdPtr typeId) const noexcept
    {
        for (size_t i = 0; i < _count; ++i) {
            if (_services[i].typeId == typeId) {
                return _services[i].instance;
            }
        }
        return nullptr;
    }
 
    template <typename ServiceType>
    [[nodiscard]] ServiceType* getService() const noexcept
    {
        return static_cast<ServiceType*>(getServiceById(internal::getTypeId<ServiceType>()));
    }
 
    template <typename ServiceType>
    [[nodiscard]] EventSinkT<EventVariant> getServiceSink() const noexcept
    {
        auto* service = getService<ServiceType>();
        if (service) {
            if constexpr (requires { service->sink(); }) {
                return service->sink();
            }
        }
        return EventSinkT<EventVariant>{};
    }
 
    void initialize(ServiceContextType ctx)
    {
        ctx.setRegistry(const_cast<BasicServiceRegistry*>(this), [](void* regPtr, internal::TypeIdPtr typeId) -> void* {
            return static_cast<BasicServiceRegistry*>(regPtr)->getServiceById(typeId);
        });
 
        for (size_t i = 0; i < _count; ++i) {
            if (_services[i].initFn) {
                _services[i].initFn(_services[i].instance, ctx);
            }
            if (_services[i].startFn) {
                _services[i].startFn(_services[i].instance);
            }
        }
    }
 
    void shutdown() noexcept
    {
        for (size_t i = 0; i < _count; ++i) {
            if (_services[i].stopFn) {
                _services[i].stopFn(_services[i].instance);
            }
        }
        for (size_t i = 0; i < _count; ++i) {
            if (_services[i].joinFn) {
                _services[i].joinFn(_services[i].instance);
            }
        }
        _count = 0;
    }
 
    [[nodiscard]] size_t size() const noexcept
    {
        return _count;
    }
 
private:
    std::array<ServiceHandle, MaxServices> _services{};
    size_t _count = 0;
};
 
using ServiceRegistry = BasicServiceRegistry<8, DefaultEvents>;
 
template <size_t MaxServices = 8, typename EventVariant = DefaultEvents>
using ServiceRegistryT = BasicServiceRegistry<MaxServices, EventVariant>;
 
} // namespace corium