ServiceContext.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "corium/EventSink.hpp"
#include "corium/internal/VariantIndex.hpp"
 
namespace corium {
 
template <typename EventVariant = DefaultEvents>
class BasicServiceContext {
public:
    using GetServiceFn = void* (*)(void* registryPtr, internal::TypeIdPtr typeId);
 
    BasicServiceContext() = default;
 
    explicit BasicServiceContext(
        EventSinkT<EventVariant> sink,
        void* regPtr = nullptr,
        GetServiceFn fn = nullptr
    ) noexcept
        : _eventSink(sink), _registryPtr(regPtr), _getServiceFn(fn)
    {}
 
    [[nodiscard]] EventSinkT<EventVariant> mainSink() const noexcept
    {
        return _eventSink;
    }
 
    [[nodiscard]] EventSinkT<EventVariant> eventSink() const noexcept
    {
        return _eventSink;
    }
 
    void setRegistry(void* registryPtr, GetServiceFn fn) noexcept
    {
        _registryPtr = registryPtr;
        _getServiceFn = fn;
    }
 
    template <typename ServiceType>
    [[nodiscard]] ServiceType* getService() const noexcept
    {
        if (_registryPtr && _getServiceFn) {
            return static_cast<ServiceType*>(_getServiceFn(_registryPtr, internal::getTypeId<ServiceType>()));
        }
        return nullptr;
    }
 
    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>{};
    }
 
    template <typename TargetService, typename EventType>
    bool sendToService(EventType&& event, EventPriority priority = EventPriority::Normal) const
    {
        auto sinkHandle = getServiceSink<TargetService>();
        if (sinkHandle) {
            sinkHandle.post(std::forward<EventType>(event), priority);
            return true;
        }
        return false;
    }
 
private:
    EventSinkT<EventVariant> _eventSink;
    void* _registryPtr = nullptr;
    GetServiceFn _getServiceFn = nullptr;
};
 
using ServiceContext = BasicServiceContext<DefaultEvents>;
 
template <typename EventVariant = DefaultEvents>
using ServiceContextT = BasicServiceContext<EventVariant>;
 
} // namespace corium