ETLHelpers.hpp

Go to the documentation of this file.

#pragma once
 
#include <xrpl/basics/base_uint.h>
 
#include <condition_variable>
#include <cstddef>
#include <cstdint>
#include <memory>
#include <mutex>
#include <optional>
#include <queue>
#include <vector>
 
namespace etl {
 
// TODO: does the note make sense? lockfree queues provide the same blocking behaviour just without
// mutex, don't they?
template <typename T>
class ThreadSafeQueue {
    std::queue<T> queue_;
 
    mutable std::mutex m_;
    std::condition_variable cv_;
    uint32_t maxSize_;
 
public:
    ThreadSafeQueue(uint32_t maxSize) : maxSize_(maxSize)
    {
    }

    void
    push(T const& elt)
    {
        std::unique_lock lck(m_);
        cv_.wait(lck, [this] { return queue_.size() <= maxSize_; });
        queue_.push(elt);
        cv_.notify_all();
    }

    void
    push(T&& elt)
    {
        std::unique_lock lck(m_);
        cv_.wait(lck, [this] { return queue_.size() <= maxSize_; });
        queue_.push(std::move(elt));
        cv_.notify_all();
    }

    T
    pop()
    {
        std::unique_lock lck(m_);
        cv_.wait(lck, [this] { return !queue_.empty(); });
 
        T ret = std::move(queue_.front());
        queue_.pop();
 
        cv_.notify_all();
        return ret;
    }

    std::optional<T>
    tryPop()
    {
        std::scoped_lock const lck(m_);
        if (queue_.empty())
            return {};
 
        T ret = std::move(queue_.front());
        queue_.pop();
 
        cv_.notify_all();
        return ret;
    }

    std::size_t
    size() const
    {
        return queue_.size();
    }
};

std::vector<xrpl::uint256>
getMarkers(size_t numMarkers);
 
}  // namespace etl