Service.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "corium/EventBus.hpp"
#include "corium/EventSink.hpp"
#include "corium/ServiceContext.hpp"
#include "corium/policies/QueuePolicies.hpp"
#include "corium/policies/SignalPolicies.hpp"
#include "corium/policies/StoragePolicies.hpp"
 
#include <cstddef>
#include <utility>
 
namespace corium {
 
template <
    typename EventVariantType = DefaultEvents,
    typename QueuePolicy = BoundedMpscQueuePolicy<EventVariantType, 1024>,
    typename SignalPolicy = CallbackSignalPolicy,
    typename StoragePolicy = DefaultStoragePolicy,
    typename OverflowPolicy = DropNewestOverflowPolicy
>
class Service {
public:
    using EventVariant = EventVariantType;
    using IncomingBus = BasicEventBus<EventVariant, QueuePolicy, SignalPolicy, StoragePolicy, OverflowPolicy>;
 
    Service() = default;
 
    explicit Service(ServiceContextT<EventVariant> context)
        : _context(context)
    {}
 
    ~Service() = default;
 
    Service(const Service&) = delete;
    Service& operator=(const Service&) = delete;
 
    Service(Service&&) noexcept = default;
    Service& operator=(Service&&) noexcept = default;
 
    void setContext(ServiceContextT<EventVariant> context) noexcept
    {
        _context = context;
    }
 
    [[nodiscard]] EventSinkT<EventVariant> sink() noexcept
    {
        return _incomingBus.sink();
    }
 
    [[nodiscard]] EventSinkT<EventVariant> mainSink() const noexcept
    {
        return _context.mainSink();
    }
 
    template <typename EventType, typename Handler>
    bool registerHandler(Handler&& handler)
    {
        return _incomingBus.template registerHandler<EventType>(std::forward<Handler>(handler));
    }
 
    template <typename Handler>
    bool on(Handler&& handler)
    {
        return _incomingBus.registerHandler(std::forward<Handler>(handler));
    }
 
    bool processOne()
    {
        return _incomingBus.processOne();
    }
 
    std::size_t pump()
    {
        std::size_t processed = 0;
        while (_incomingBus.processOne()) {
            processed++;
        }
        return processed;
    }
 
    std::size_t pump(std::size_t maxEvents)
    {
        std::size_t processed = 0;
        while (processed < maxEvents && _incomingBus.processOne()) {
            processed++;
        }
        return processed;
    }
 
protected:
    [[nodiscard]] ServiceContextT<EventVariant>& context() noexcept { return _context; }
    [[nodiscard]] const ServiceContextT<EventVariant>& context() const noexcept { return _context; }
 
    template <typename EventType>
    void post(EventType&& event, EventPriority priority = EventPriority::Normal) const
    {
        _context.mainSink().post(std::forward<EventType>(event), priority);
    }
 
    template <typename EventType>
    void postHighPriority(EventType&& event) const
    {
        _context.mainSink().postHighPriority(std::forward<EventType>(event));
    }
 
    template <typename TargetService, typename EventType>
    bool sendToService(EventType&& event, EventPriority priority = EventPriority::Normal) const
    {
        return _context.template sendToService<TargetService>(std::forward<EventType>(event), priority);
    }
 
    [[nodiscard]] IncomingBus& incomingBus() noexcept { return _incomingBus; }
    [[nodiscard]] const IncomingBus& incomingBus() const noexcept { return _incomingBus; }
 
private:
    ServiceContextT<EventVariant> _context;
    [[no_unique_address]] IncomingBus _incomingBus;
};
 
template <typename EventVariant = DefaultEvents>
using ProducerService = Service<
    EventVariant,
    NoQueuePolicy<EventVariant>,
    NoSignalPolicy,
    ZeroStoragePolicy
>;
 
template <typename EventVariant = DefaultEvents, std::size_t Capacity = 64>
using ConsumerService = Service<
    EventVariant,
    BoundedMpscQueuePolicy<EventVariant, Capacity>,
    CallbackSignalPolicy,
    DefaultStoragePolicy
>;
 
} // namespace corium