row_deque.hpp

Go to the documentation of this file.

 
#pragma once
 
#include "common.hpp"
 
#include <vector>
 
#if CSV_ENABLE_THREADS
#include "thread_safe_deque.hpp"
#else
#include "single_thread_deque.hpp"
#endif
 
#include <cstddef>
#include <type_traits>
#include <utility>
 
#ifdef CSV_HAS_CXX20
#include <concepts>
#endif
 
namespace csv {
    namespace internals {
#if !CSV_ENABLE_THREADS
    template<typename T>
    using ThreadSafeDeque = SingleThreadDeque<T>;
#endif
 
#ifdef CSV_HAS_CXX20
        // This concept is intentionally limited to parser queue semantics.
        // Diagnostics such as ThreadSafeDeque::inspect() stay out of the
        // contract so single-threaded and threaded queues can use different
        // storage without inventing a generic inspection-view abstraction.
        template<typename Q, typename T>
        concept RowDequeLike = requires(Q q, const Q cq, T item, size_t n, std::vector<T> batch) {
            { Q(100) };
            { q.push_back(std::move(item)) } -> std::same_as<void>;
            { q.append_rows(std::move(batch)) } -> std::same_as<void>;
            { q.pop_front() } -> std::same_as<T>;
            { q.drain_front(batch, n) } -> std::same_as<size_t>;
            { cq.empty() } -> std::same_as<bool>;
            { cq.is_waitable() } -> std::same_as<bool>;
            { q.wait() } -> std::same_as<void>;
            { q.notify_all() } -> std::same_as<void>;
            { q.kill_all() } -> std::same_as<void>;
            { cq.size() } -> std::same_as<size_t>;
        };
 
#if CSV_ENABLE_THREADS
            static_assert(RowDequeLike<ThreadSafeDeque<int>, int>, "ThreadSafeDeque must satisfy RowDequeLike contract");
#else
            static_assert(RowDequeLike<SingleThreadDeque<int>, int>, "SingleThreadDeque must satisfy RowDequeLike contract");
            static_assert(RowDequeLike<ThreadSafeDeque<int>, int>, "Selected ThreadSafeDeque alias must satisfy RowDequeLike contract");
#endif
#endif
    }
}