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

test/common/concurrentqueue/adaptor.hpp
75 строк3 KB
Ant010ff
Demo code update, 2026.
08 фев 2026, 14:26
08 фев 2026, 14:261a5a363
/*
moodycamel::ConcurrentQueue (https://github.com/cameron314/concurrentqueue) 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 MOODYCAMEL_QUEUE_ADAPTOR_HPP
#define MOODYCAMEL_QUEUE_ADAPTOR_HPP

#include "concurrentqueue/concurrentqueue.h"

////McqueuePolicy/////////////////////////////////////////////////////////////////////////////////////////////////////////////////

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

////ConcurrentQueueAdaptor////////////////////////////////////////////////////////////////////////////////////////////////////////

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

	ConcurrentQueueAdaptor(size_t nLimit = c_nInvalidLimit) 
	: nLimit_(nLimit)
	{ }

	ConcurrentQueueAdaptor(ConcurrentQueueAdaptor const&) = delete;
	ConcurrentQueueAdaptor(ConcurrentQueueAdaptor&&) = delete;

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

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

	bool Dequeue(ValueT& vDequeued) {
		return qEnqueued_.try_dequeue(vDequeued);
	}
	
	size_t Size() const { return qEnqueued_.size_approx(); }

	bool Empty() const { return qEnqueued_.size_approx() == 0; }

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

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

private:   
	struct ConcurrentQueueTraits : moodycamel::ConcurrentQueueDefaultTraits { };
	using QueueT = moodycamel::ConcurrentQueue<ValueT, ConcurrentQueueTraits>;

	QueueT
		qEnqueued_;
	std::atomic<size_t>
		nLimit_ = c_nInvalidLimit;
};//ConcurrentQueueAdaptor

#endif//MOODYCAMEL_QUEUE_ADAPTOR_HPP