marvin_FIFO.h

Go to the documentation of this file.

// ========================================================================================================
//  _______ _______ ______ ___ ___ _______ _______
// |   |   |   _   |   __ \   |   |_     _|    |  |
// |       |       |      <   |   |_|   |_|       |
// |__|_|__|___|___|___|__|\_____/|_______|__|____|
//
// This file is part of the Marvin open source library and is licensed under the terms of the MIT License.
//
// ========================================================================================================
 
#ifndef MARVIN_FIFO_H
#define MARVIN_FIFO_H
#include <readerwriterqueue.h>
#include <concurrentqueue.h>
#include <optional>
#include <type_traits>
namespace marvin::containers::fifos {
    enum class Type {
        SPSC,
        MPMC
    };

    template<Type QueueType, typename T>
    requires std::is_copy_constructible_v<T> &&
             std::is_move_constructible_v<T> &&
             std::is_default_constructible_v<T>
    class FIFO final {
    public:
        explicit FIFO(size_t maxSize) : m_queue(maxSize) {
 
        }

        [[nodiscard]] std::optional<T> tryPop() noexcept {
            T temp{};
            const auto res = m_queue.try_dequeue(temp);
            if (!res) return {};
            return temp;
        }

        void tryPush(T&& x) noexcept {
            [[maybe_unused]] const auto res = m_queue.try_enqueue(std::move(x));
        }

        void emptyQueue() noexcept {
            auto res{ false };
            do {
                [[maybe_unused]] T curr;
                res = m_queue.try_dequeue(curr);
            } while (res);
        }
 
    private:
        using queue_t = std::conditional_t<QueueType == Type::SPSC, moodycamel::ReaderWriterQueue<T>, moodycamel::ConcurrentQueue<T>>;
        queue_t m_queue;
    };
 
    template<typename T>
    using SPSC = FIFO<Type::SPSC, T>;
 
    template<typename T>
    using MPMC = FIFO<Type::MPMC, T>;
} // namespace marvin::containers::fifos
#endif