[include] Modify ConcurrentQueue to support emplace

(see cameron314/concurrentqueue#275)

Author: netborg-afps

include/lockfree/concurrentqueue/concurrentqueue.h

@@ -1008,6 +1008,18 @@ class ConcurrentQueue
 		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
 		else return inner_enqueue<CanAlloc>(std::move(item));
 	}
+
+  // Enqueues a single item (by constructing it in-place from arguments).
+	// Allocates memory if required. Only fails if memory allocation fails (or implicit
+	// production is disabled because Traits::INITIAL_IMPLICIT_PRODUCER_HASH_SIZE is 0,
+	// or Traits::MAX_SUBQUEUE_SIZE has been defined and would be surpassed).
+	// Thread-safe.
+	template<typename... Args>
+	inline bool enqueue_emplace(Args&&... args)
+	{
+		MOODYCAMEL_CONSTEXPR_IF (INITIAL_IMPLICIT_PRODUCER_HASH_SIZE == 0) return false;
+		else return inner_enqueue<CanAlloc>(std::forward<Args>(args)...);
+	}
 
 	// Enqueues a single item (by copying it) using an explicit producer token.
 	// Allocates memory if required. Only fails if memory allocation fails (or
@@ -1369,11 +1381,11 @@ class ConcurrentQueue
 		return static_cast<ExplicitProducer*>(token.producer)->ConcurrentQueue::ExplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
 	}
 
-	template<AllocationMode canAlloc, typename U>
-	inline bool inner_enqueue(U&& element)
+	template<AllocationMode canAlloc, typename... Args>
+	inline bool inner_enqueue(Args&& ... args)
 	{
 		auto producer = get_or_add_implicit_producer();
-		return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue<canAlloc>(std::forward<U>(element));
+		return producer == nullptr ? false : producer->ConcurrentQueue::ImplicitProducer::template enqueue<canAlloc>(std::forward<Args>(args)...);
 	}
 
 	template<AllocationMode canAlloc, typename It>
@@ -1845,8 +1857,8 @@ class ConcurrentQueue
 			}
 		}
 
-		template<AllocationMode allocMode, typename U>
-		inline bool enqueue(U&& element)
+		template<AllocationMode allocMode, typename... Args>
+		inline bool enqueue(Args&&... args)
 		{
 			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
 			index_t newTailIndex = 1 + currentTailIndex;
@@ -1912,11 +1924,11 @@ class ConcurrentQueue
 					++pr_blockIndexSlotsUsed;
 				}
 
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
+				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<Args>(args)...))) {
 					// The constructor may throw. We want the element not to appear in the queue in
 					// that case (without corrupting the queue):
 					MOODYCAMEL_TRY {
-						new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
+						new ((*this->tailBlock)[currentTailIndex]) T(std::forward<Args>(args)...);
 					}
 					MOODYCAMEL_CATCH (...) {
 						// Revert change to the current block, but leave the new block available
@@ -1938,14 +1950,14 @@ class ConcurrentQueue
 				blockIndex.load(std::memory_order_relaxed)->front.store(pr_blockIndexFront, std::memory_order_release);
 				pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);
 
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
+				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<Args>(args)...))) {
 					this->tailIndex.store(newTailIndex, std::memory_order_release);
 					return true;
 				}
 			}
 
 			// Enqueue
-			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
+			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<Args>(args)...);
 
 			this->tailIndex.store(newTailIndex, std::memory_order_release);
 			return true;
@@ -2483,8 +2495,8 @@ class ConcurrentQueue
 			}
 		}
 
-		template<AllocationMode allocMode, typename U>
-		inline bool enqueue(U&& element)
+		template<AllocationMode allocMode, typename... Args>
+		inline bool enqueue(Args&&... args)
 		{
 			index_t currentTailIndex = this->tailIndex.load(std::memory_order_relaxed);
 			index_t newTailIndex = 1 + currentTailIndex;
@@ -2516,10 +2528,10 @@ class ConcurrentQueue
 #endif
 				newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
 
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
+				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<Args>(args)...))) {
 					// May throw, try to insert now before we publish the fact that we have this new block
 					MOODYCAMEL_TRY {
-						new ((*newBlock)[currentTailIndex]) T(std::forward<U>(element));
+						new ((*newBlock)[currentTailIndex]) T(std::forward<Args>(args)...);
 					}
 					MOODYCAMEL_CATCH (...) {
 						rewind_block_index_tail();
@@ -2534,14 +2546,14 @@ class ConcurrentQueue
 
 				this->tailBlock = newBlock;
 
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
+				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<Args>(args)...))) {
 					this->tailIndex.store(newTailIndex, std::memory_order_release);
 					return true;
 				}
 			}
 
 			// Enqueue
-			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<U>(element));
+			new ((*this->tailBlock)[currentTailIndex]) T(std::forward<Args>(args)...);
 
 			this->tailIndex.store(newTailIndex, std::memory_order_release);
 			return true;