test/common/atomic_queue/adaptor.hpp - main - Ant010ff/ffpp

test/common/atomic_queue/adaptor.hpp
75 строк2 KB
Ant010ff
Demo code update, 2026.
08 фев 2026, 14:26
08 фев 2026, 14:261a5a363
/*
atomic_queue (https://github.com/max0x7ba/atomic_queue) adaptor for FFPP library.

Official repository: https://gitlab.com/ant010ff/ffpp

Licensed under the MIT License <http://opensource.org/licenses/MIT>.
SPDX-License-Identifier: MIT
Copyright (c) 2021 - 2026 Anton Nasonov <ant010fff @ gmail . com>.
*/

#ifndef ATOMIC_QUEUE_ADAPTOR_HPP
#define ATOMIC_QUEUE_ADAPTOR_HPP

#include "atomic_queue/atomic_queue.h"

////AtomicQueuePolicy/////////////////////////////////////////////////////////////////////////////////////////////////////////////

struct AtomicQueuePolicy { 
	using ResourcePolicyT = ffpp::DefaultResourcePolicy;
	using LockableT = ffpp::Lockable<ffpp::TicketMutex<>>;
};

////AtomicQueueAdaptor////////////////////////////////////////////////////////////////////////////////////////////////////////////

template<std::movable TValue, ffpp::Concepts::QueuePolicy TPolicy = AtomicQueuePolicy>
class AtomicQueueAdaptor {
public:
	using ValueT = TValue;
	using PolicyT = TPolicy;
	using ResourcePolicyT = typename PolicyT::ResourcePolicyT;        
	template<typename T> using AllocatorT = typename ResourcePolicyT::template AllocatorT<T>;
	
	static size_t constexpr c_nInvalidLimit = ResourcePolicyT::template InvalidValue<size_t>();

	AtomicQueueAdaptor(size_t nLimit = c_nInvalidLimit) 
	: nLimit_(nLimit)
	, qEnqueued_(c_nQueueSize)
	{ }

	AtomicQueueAdaptor(AtomicQueueAdaptor const&) = delete;
	AtomicQueueAdaptor(AtomicQueueAdaptor&&) = delete;

	AtomicQueueAdaptor& operator = (AtomicQueueAdaptor const&) = delete;
	AtomicQueueAdaptor& operator = (AtomicQueueAdaptor&&) = delete;

	bool Enqueue(ValueT&& vEnqueue, bool bObligate) {
		if(!bObligate && Limit() <= Size()) return false;
		qEnqueued_.push(std::move(vEnqueue));
		return true;
	}

	bool Dequeue(ValueT& vDequeued) {
		return qEnqueued_.try_pop(vDequeued);
	}
	
	inline size_t Size() const { return qEnqueued_.was_size(); }

	inline bool Empty() const { return qEnqueued_.was_empty(); }

	inline size_t Limit(size_t nLimit) { return nLimit_.exchange(nLimit, std::memory_order::acq_rel); }

	inline size_t Limit() { return nLimit_.load(std::memory_order::acquire); }

private:   
	static constexpr uint32_t c_nQueueSize = 1 << 8;
	
	using QueueT = atomic_queue::AtomicQueueB2<ValueT, AllocatorT<ValueT>>;
	
	QueueT        
		qEnqueued_;
	std::atomic<size_t>
		nLimit_ = c_nInvalidLimit;
};//AtomicQueueAdaptor

#endif//ATOMIC_QUEUE_ADAPTOR_HPP