Merge pull request #223 from slumber/slumber/clang-warnings

cameron314 · web-flow · commit 6f57c62fed35 · 2020-09-25T20:42:49.000-04:00
Fixed clang warnings.
diff --git a/concurrentqueue.h b/concurrentqueue.h
@@ -1688,7 +1688,7 @@ class ConcurrentQueue
 		{
 		}
 		
-		virtual ~ProducerBase() { };
+		virtual ~ProducerBase() { }
 		
 		template<typename U>
 		inline bool dequeue(U& element)
@@ -1897,7 +1897,7 @@ class ConcurrentQueue
 					++pr_blockIndexSlotsUsed;
 				}
 
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
+				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
 					// The constructor may throw. We want the element not to appear in the queue in
 					// that case (without corrupting the queue):
 					MOODYCAMEL_TRY {
@@ -1923,7 +1923,7 @@ 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 ((T*)nullptr) T(std::forward<U>(element)))) {
+				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
 					this->tailIndex.store(newTailIndex, std::memory_order_release);
 					return true;
 				}
@@ -2139,7 +2139,7 @@ class ConcurrentQueue
 					block = block->next;
 				}
 				
-				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))) {
+				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
 					blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
 				}
 			}
@@ -2158,7 +2158,7 @@ class ConcurrentQueue
 				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
 					stopIndex = newTailIndex;
 				}
-				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))) {
+				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
 					while (currentTailIndex != stopIndex) {
 						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
 					}
@@ -2173,7 +2173,7 @@ class ConcurrentQueue
 							// may only define a (noexcept) move constructor, and so calls to the
 							// cctor will not compile, even if they are in an if branch that will never
 							// be executed
-							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<(bool)!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
+							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
 							++currentTailIndex;
 							++itemFirst;
 						}
@@ -2220,7 +2220,7 @@ class ConcurrentQueue
 				this->tailBlock = this->tailBlock->next;
 			}
 			
-			MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))) {
+			MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
 				if (firstAllocatedBlock != nullptr)
 					blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);
 			}
@@ -2239,7 +2239,7 @@ class ConcurrentQueue
 				desiredCount = desiredCount < max ? desiredCount : max;
 				std::atomic_thread_fence(std::memory_order_acquire);
 				
-				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);;
+				auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);
 				
 				tail = this->tailIndex.load(std::memory_order_acquire);
 				auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));
@@ -2501,7 +2501,7 @@ class ConcurrentQueue
 #endif
 				newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();
 
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
+				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
 					// 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));
@@ -2519,7 +2519,7 @@ class ConcurrentQueue
 				
 				this->tailBlock = newBlock;
 				
-				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {
+				MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {
 					this->tailIndex.store(newTailIndex, std::memory_order_release);
 					return true;
 				}
@@ -2697,15 +2697,15 @@ class ConcurrentQueue
 				if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {
 					stopIndex = newTailIndex;
 				}
-				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))) {
+				MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))) {
 					while (currentTailIndex != stopIndex) {
 						new ((*this->tailBlock)[currentTailIndex++]) T(*itemFirst++);
 					}
 				}
 				else {
 					MOODYCAMEL_TRY {
 						while (currentTailIndex != stopIndex) {
-							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<(bool)!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new ((T*)nullptr) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
+							new ((*this->tailBlock)[currentTailIndex]) T(details::nomove_if<!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(*itemFirst), new (static_cast<T*>(nullptr)) T(details::deref_noexcept(itemFirst)))>::eval(*itemFirst));
 							++currentTailIndex;
 							++itemFirst;
 						}
@@ -3459,7 +3459,7 @@ class ConcurrentQueue
 					}
 					
 					auto newHash = new (raw) ImplicitProducerHash;
-					newHash->capacity = (size_t)newCapacity;
+					newHash->capacity = static_cast<size_t>(newCapacity);
 					newHash->entries = reinterpret_cast<ImplicitProducerKVP*>(details::align_for<ImplicitProducerKVP>(raw + sizeof(ImplicitProducerHash)));
 					for (size_t i = 0; i != newCapacity; ++i) {
 						new (newHash->entries + i) ImplicitProducerKVP;
@@ -3698,15 +3698,15 @@ ConsumerToken::ConsumerToken(ConcurrentQueue<T, Traits>& queue)
 	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
 {
 	initialOffset = queue.nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
-	lastKnownGlobalOffset = (std::uint32_t)-1;
+	lastKnownGlobalOffset = static_cast<std::uint32_t>(-1);
 }
 
 template<typename T, typename Traits>
 ConsumerToken::ConsumerToken(BlockingConcurrentQueue<T, Traits>& queue)
 	: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)
 {
 	initialOffset = reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->nextExplicitConsumerId.fetch_add(1, std::memory_order_release);
-	lastKnownGlobalOffset = (std::uint32_t)-1;
+	lastKnownGlobalOffset = static_cast<std::uint32_t>(-1);
 }
 
 template<typename T, typename Traits>

Original file line number	Diff line number	Diff line change
`@@ -1688,7 +1688,7 @@ class ConcurrentQueue`
`1688`	`1688`	`{`
`1689`	`1689`	`}`
`1690`	`1690`
`1691`		`- virtual ~ProducerBase() { };`
	`1691`	`+ virtual ~ProducerBase() { }`
`1692`	`1692`
`1693`	`1693`	`template<typename U>`
`1694`	`1694`	`inline bool dequeue(U& element)`
`@@ -1897,7 +1897,7 @@ class ConcurrentQueue`
`1897`	`1897`	`++pr_blockIndexSlotsUsed;`
`1898`	`1898`	`}`
`1899`	`1899`
`1900`		`- MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {`
	`1900`	`+ MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {`
`1901`	`1901`	`// The constructor may throw. We want the element not to appear in the queue in`
`1902`	`1902`	`// that case (without corrupting the queue):`
`1903`	`1903`	`MOODYCAMEL_TRY {`
`@@ -1923,7 +1923,7 @@ class ConcurrentQueue`
`1923`	`1923`	`blockIndex.load(std::memory_order_relaxed)->front.store(pr_blockIndexFront, std::memory_order_release);`
`1924`	`1924`	`pr_blockIndexFront = (pr_blockIndexFront + 1) & (pr_blockIndexSize - 1);`
`1925`	`1925`
`1926`		`- MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {`
	`1926`	`+ MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {`
`1927`	`1927`	`this->tailIndex.store(newTailIndex, std::memory_order_release);`
`1928`	`1928`	`return true;`
`1929`	`1929`	`}`
`@@ -2139,7 +2139,7 @@ class ConcurrentQueue`
`2139`	`2139`	`block = block->next;`
`2140`	`2140`	`}`
`2141`	`2141`
`2142`		`- MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new ((T)nullptr) T(details::deref_noexcept(itemFirst)))) {`
	`2142`	`+ MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new (static_cast<T>(nullptr)) T(details::deref_noexcept(itemFirst)))) {`
`2143`	`2143`	`blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);`
`2144`	`2144`	`}`
`2145`	`2145`	`}`
`@@ -2158,7 +2158,7 @@ class ConcurrentQueue`
`2158`	`2158`	`if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {`
`2159`	`2159`	`stopIndex = newTailIndex;`
`2160`	`2160`	`}`
`2161`		`- MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new ((T)nullptr) T(details::deref_noexcept(itemFirst)))) {`
	`2161`	`+ MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new (static_cast<T>(nullptr)) T(details::deref_noexcept(itemFirst)))) {`
`2162`	`2162`	`while (currentTailIndex != stopIndex) {`
`2163`	`2163`	`new ((this->tailBlock)[currentTailIndex++]) T(itemFirst++);`
`2164`	`2164`	`}`
`@@ -2173,7 +2173,7 @@ class ConcurrentQueue`
`2173`	`2173`	`// may only define a (noexcept) move constructor, and so calls to the`
`2174`	`2174`	`// cctor will not compile, even if they are in an if branch that will never`
`2175`	`2175`	`// be executed`
`2176`		`- new ((this->tailBlock)[currentTailIndex]) T(details::nomove_if<(bool)!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new ((T)nullptr) T(details::deref_noexcept(itemFirst)))>::eval(itemFirst));`
	`2176`	`+ new ((this->tailBlock)[currentTailIndex]) T(details::nomove_if<!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new (static_cast<T>(nullptr)) T(details::deref_noexcept(itemFirst)))>::eval(itemFirst));`
`2177`	`2177`	`++currentTailIndex;`
`2178`	`2178`	`++itemFirst;`
`2179`	`2179`	`}`
`@@ -2220,7 +2220,7 @@ class ConcurrentQueue`
`2220`	`2220`	`this->tailBlock = this->tailBlock->next;`
`2221`	`2221`	`}`
`2222`	`2222`
`2223`		`- MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new ((T)nullptr) T(details::deref_noexcept(itemFirst)))) {`
	`2223`	`+ MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new (static_cast<T>(nullptr)) T(details::deref_noexcept(itemFirst)))) {`
`2224`	`2224`	`if (firstAllocatedBlock != nullptr)`
`2225`	`2225`	`blockIndex.load(std::memory_order_relaxed)->front.store((pr_blockIndexFront - 1) & (pr_blockIndexSize - 1), std::memory_order_release);`
`2226`	`2226`	`}`
`@@ -2239,7 +2239,7 @@ class ConcurrentQueue`
`2239`	`2239`	`desiredCount = desiredCount < max ? desiredCount : max;`
`2240`	`2240`	`std::atomic_thread_fence(std::memory_order_acquire);`
`2241`	`2241`
`2242`		`- auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);;`
	`2242`	`+ auto myDequeueCount = this->dequeueOptimisticCount.fetch_add(desiredCount, std::memory_order_relaxed);`
`2243`	`2243`
`2244`	`2244`	`tail = this->tailIndex.load(std::memory_order_acquire);`
`2245`	`2245`	`auto actualCount = static_cast<size_t>(tail - (myDequeueCount - overcommit));`
`@@ -2501,7 +2501,7 @@ class ConcurrentQueue`
`2501`	`2501`	`#endif`
`2502`	`2502`	`newBlock->ConcurrentQueue::Block::template reset_empty<implicit_context>();`
`2503`	`2503`
`2504`		`- MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {`
	`2504`	`+ MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {`
`2505`	`2505`	`// May throw, try to insert now before we publish the fact that we have this new block`
`2506`	`2506`	`MOODYCAMEL_TRY {`
`2507`	`2507`	`new ((*newBlock)[currentTailIndex]) T(std::forward<U>(element));`
`@@ -2519,7 +2519,7 @@ class ConcurrentQueue`
`2519`	`2519`
`2520`	`2520`	`this->tailBlock = newBlock;`
`2521`	`2521`
`2522`		`- MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new ((T*)nullptr) T(std::forward<U>(element)))) {`
	`2522`	`+ MOODYCAMEL_CONSTEXPR_IF (!MOODYCAMEL_NOEXCEPT_CTOR(T, U, new (static_cast<T*>(nullptr)) T(std::forward<U>(element)))) {`
`2523`	`2523`	`this->tailIndex.store(newTailIndex, std::memory_order_release);`
`2524`	`2524`	`return true;`
`2525`	`2525`	`}`
`@@ -2697,15 +2697,15 @@ class ConcurrentQueue`
`2697`	`2697`	`if (details::circular_less_than<index_t>(newTailIndex, stopIndex)) {`
`2698`	`2698`	`stopIndex = newTailIndex;`
`2699`	`2699`	`}`
`2700`		`- MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new ((T)nullptr) T(details::deref_noexcept(itemFirst)))) {`
	`2700`	`+ MOODYCAMEL_CONSTEXPR_IF (MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new (static_cast<T>(nullptr)) T(details::deref_noexcept(itemFirst)))) {`
`2701`	`2701`	`while (currentTailIndex != stopIndex) {`
`2702`	`2702`	`new ((this->tailBlock)[currentTailIndex++]) T(itemFirst++);`
`2703`	`2703`	`}`
`2704`	`2704`	`}`
`2705`	`2705`	`else {`
`2706`	`2706`	`MOODYCAMEL_TRY {`
`2707`	`2707`	`while (currentTailIndex != stopIndex) {`
`2708`		`- new ((this->tailBlock)[currentTailIndex]) T(details::nomove_if<(bool)!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new ((T)nullptr) T(details::deref_noexcept(itemFirst)))>::eval(itemFirst));`
	`2708`	`+ new ((this->tailBlock)[currentTailIndex]) T(details::nomove_if<!MOODYCAMEL_NOEXCEPT_CTOR(T, decltype(itemFirst), new (static_cast<T>(nullptr)) T(details::deref_noexcept(itemFirst)))>::eval(itemFirst));`
`2709`	`2709`	`++currentTailIndex;`
`2710`	`2710`	`++itemFirst;`
`2711`	`2711`	`}`
`@@ -3459,7 +3459,7 @@ class ConcurrentQueue`
`3459`	`3459`	`}`
`3460`	`3460`
`3461`	`3461`	`auto newHash = new (raw) ImplicitProducerHash;`
`3462`		`- newHash->capacity = (size_t)newCapacity;`
	`3462`	`+ newHash->capacity = static_cast<size_t>(newCapacity);`
`3463`	`3463`	`newHash->entries = reinterpret_cast<ImplicitProducerKVP*>(details::align_for<ImplicitProducerKVP>(raw + sizeof(ImplicitProducerHash)));`
`3464`	`3464`	`for (size_t i = 0; i != newCapacity; ++i) {`
`3465`	`3465`	`new (newHash->entries + i) ImplicitProducerKVP;`
`@@ -3698,15 +3698,15 @@ ConsumerToken::ConsumerToken(ConcurrentQueue<T, Traits>& queue)`
`3698`	`3698`	`: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)`
`3699`	`3699`	`{`
`3700`	`3700`	`initialOffset = queue.nextExplicitConsumerId.fetch_add(1, std::memory_order_release);`
`3701`		`- lastKnownGlobalOffset = (std::uint32_t)-1;`
	`3701`	`+ lastKnownGlobalOffset = static_cast<std::uint32_t>(-1);`
`3702`	`3702`	`}`
`3703`	`3703`
`3704`	`3704`	`template<typename T, typename Traits>`
`3705`	`3705`	`ConsumerToken::ConsumerToken(BlockingConcurrentQueue<T, Traits>& queue)`
`3706`	`3706`	`: itemsConsumedFromCurrent(0), currentProducer(nullptr), desiredProducer(nullptr)`
`3707`	`3707`	`{`
`3708`	`3708`	`initialOffset = reinterpret_cast<ConcurrentQueue<T, Traits>*>(&queue)->nextExplicitConsumerId.fetch_add(1, std::memory_order_release);`
`3709`		`- lastKnownGlobalOffset = (std::uint32_t)-1;`
	`3709`	`+ lastKnownGlobalOffset = static_cast<std::uint32_t>(-1);`
`3710`	`3710`	`}`
`3711`	`3711`
`3712`	`3712`	`template<typename T, typename Traits>`