RecordQueue.hpp

Go to the documentation of this file.

//          Copyright Dominic Koepke 2021 - 2021.
// Distributed under the Boost Software License, Version 1.0.
//    (See accompanying file LICENSE_1_0.txt or copy at
//          https://www.boost.org/LICENSE_1_0.txt)
 
#ifndef SL_LOG_RECORD_QUEUE_HPP
#define SL_LOG_RECORD_QUEUE_HPP
 
#pragma once
 
#include "Record.hpp"
 
#include <chrono>
#include <condition_variable>
#include <mutex>
#include <optional>
#include <queue>
#include <type_traits>
 
namespace sl::log
{
    template <Record TRecord>
    class RecordQueue
    {
    public:
        using Record_t = std::remove_cvref_t<TRecord>;
 
        void push(Record_t record)
        {
            {
                std::scoped_lock lock{ m_RecordMx };
                m_QueuedRecords.emplace(std::move(record));
            }
            m_PushVar.notify_one();
        }
 
        [[nodiscard]]
        std::optional<Record_t> take(std::optional<std::chrono::milliseconds> waitingDuration = std::nullopt)
        {
            auto isQueueNotEmpty = [&records = m_QueuedRecords]() { return !std::empty(records); };
 
            std::unique_lock lock{ m_RecordMx };
            if (waitingDuration)
            {
                if (m_PushVar.wait_for(lock, *waitingDuration, isQueueNotEmpty))
                {
                    return takeNextAsOpt();
                }
                return std::nullopt;
            }
 
            m_PushVar.wait(lock, isQueueNotEmpty);
            return takeNextAsOpt();
        }
 
        [[nodiscard]]
        bool empty() const noexcept
        {
            std::scoped_lock lock{ m_RecordMx };
            return std::empty(m_QueuedRecords);
        }
 
        [[nodiscard]]
        std::size_t size() const noexcept
        {
            std::scoped_lock lock{ m_RecordMx };
            return std::size(m_QueuedRecords);
        }
 
    private:
        [[nodiscard]]
        std::optional<Record_t> takeNextAsOpt()
        {
            auto record = std::move(m_QueuedRecords.front());
            m_QueuedRecords.pop();
            return std::optional<Record_t>{ std::in_place, std::move(record) };
        }
 
        mutable std::mutex m_RecordMx;
        std::queue<Record_t> m_QueuedRecords;
        std::condition_variable m_PushVar;
    };
 
}
 
#endif