EventQueue.hpp

Go to the documentation of this file.

 
#pragma once
 
#include <optional>
#include <utility>
 
#include "corium/Events.hpp"
#include "corium/policies/OverflowPolicies.hpp"
#include "corium/policies/QueuePolicies.hpp"
#include "corium/policies/SignalPolicies.hpp"
 
namespace corium {
namespace internal {
 
template <
    typename QueuePolicy = BoundedMpscQueuePolicy<DefaultEvents, 1024>,
    typename SignalPolicy = NoSignalPolicy,
    typename OverflowPolicy = DropNewestOverflowPolicy
>
class EventQueue {
public:
    using EventVariant = typename QueuePolicy::EventType;
 
    EventQueue() = default;
 
    bool pushEvent(EventVariant&& event, EventPriority priority = EventPriority::Normal)
    {
        auto res = _queuePolicy.tryPush(event, priority);
        if (!res.pushed) {
            return _overflowPolicy.handleOverflow(_queuePolicy, std::move(event), priority);
        }
 
        if (res.wasEmpty) {
            _signalPolicy.signal();
        }
 
        return true;
    }
 
    bool pushEvent(const EventVariant& event, EventPriority priority = EventPriority::Normal)
    {
        EventVariant copy = event;
        return pushEvent(std::move(copy), priority);
    }
 
    bool tryPopEvent(EventVariant& event)
    {
        return _queuePolicy.tryPop(event);
    }
 
    std::optional<EventVariant> tryPopEvent()
    {
        EventVariant event;
        if (_queuePolicy.tryPop(event)) {
            return event;
        }
        return std::nullopt;
    }
 
    [[nodiscard]] bool empty() const
    {
        return _queuePolicy.empty();
    }
 
    void setOnQueueNonEmpty(StaticCallback callback)
    {
        _signalPolicy.setOnQueueNonEmpty(callback);
    }
 
    [[nodiscard]] SignalPolicy& signalPolicy() noexcept
    {
        return _signalPolicy;
    }
 
    [[nodiscard]] const SignalPolicy& signalPolicy() const noexcept
    {
        return _signalPolicy;
    }
 
    [[nodiscard]] OverflowPolicy& overflowPolicy() noexcept
    {
        return _overflowPolicy;
    }
 
    [[nodiscard]] const OverflowPolicy& overflowPolicy() const noexcept
    {
        return _overflowPolicy;
    }
 
private:
    [[no_unique_address]] QueuePolicy _queuePolicy;
    [[no_unique_address]] SignalPolicy _signalPolicy;
    [[no_unique_address]] OverflowPolicy _overflowPolicy;
};
 
} // namespace internal
 
using internal::EventQueue;
 
} // namespace corium