include/dequeue.hpp - main - Ant010ff/ffpp

include/dequeue.hpp
93 строки3 KB
Ant010ff
Version 2.11.3.
08 авг 2026, 16:44
08 авг 2026, 16:44fd187d3
/*
This header is part of a Functional Flow Processing Primitives (FFPP) library, version 2.11.3.

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 FFPP_DEQUEUE_HPP
#define FFPP_DEQUEUE_HPP

namespace FFPP {

	////DequePolicy///////////////////////////////////////////////////////////////////////////////////////////////////////////////

	struct DequePolicy { 
		using ResourcePolicyT = DefaultResourcePolicy;
		using LockableT = Lockable<TicketMutex<>>;
	};

	////Deque/////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

	template<std::movable TValue, Concepts::QueuePolicy TPolicy = DequePolicy>
	class Deque : public TPolicy::LockableT {
	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 Type> 
		using AllocatorT = ResourcePolicyT::template AllocatorT<Type>;
		
		static size_t constexpr c_nInvalidLimit = ResourcePolicyT::template InvalidValue<size_t>();

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

		Deque(Deque const&) = delete;
		Deque(Deque&&) = delete;

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

		FFPP_ATTR_HOT_PATH
		bool Enqueue(ValueT&& vEnqueue, bool bObligate = false) {
			auto ul = this->GetUniqueLock();
			if(!bObligate && nLimit_.load(std::memory_order::acquire) <= dqEnqueued_.size()) return false;
			dqEnqueued_.emplace_back(std::move(vEnqueue));
			return true;
		}

		FFPP_ATTR_HOT_PATH
		bool Dequeue(ValueT& vDequeued) {
			auto ul = this->GetUniqueLock();
			if(dqEnqueued_.empty()) return false;
			vDequeued = std::move(dqEnqueued_.front());
			dqEnqueued_.pop_front();
			return true;
		}
		
		FFPP_ATTR_INLINE
		size_t Size() const { 
			auto sl = this->GetSharedLock();
			return dqEnqueued_.size(); 
		}

		FFPP_ATTR_INLINE
		bool Empty() const { 
			auto sl = this->GetSharedLock();
			return dqEnqueued_.empty(); 
		}

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

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

	private:        
		std::deque<ValueT, typename ResourcePolicyT::template AllocatorT<ValueT>>
			dqEnqueued_;
		std::atomic<size_t>
			nLimit_ = c_nInvalidLimit;
	};//Deque

}//FFPP

#endif//FFPP_DEQUEUE_HPP