Don't require std::atomic to be trivial. Fixes C++20 compile errors. R…

…esolves #66.

include/atomic_queue/atomic_queue.h

@@ -125,11 +125,10 @@ constexpr T nil() noexcept {
     return {};
 }
 
-template<class T, class U>
-inline void trivial_uninitialized_fill_n(std::atomic<T>* p, unsigned n, U value) noexcept {
-    static_assert(std::is_trivial<std::atomic<T>>::value, "std::atomic<T> must be a trivial type, its constructor and destructor aren't invoked.");
-    for(auto q = p + n; p < q; ++p)
-        p->store(value, X);
+template<class T>
+inline void destroy_n(T* p, unsigned n) noexcept {
+    for(auto q = p + n; p != q;)
+        (p++)->~T();
 }
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////
@@ -379,7 +378,8 @@ class AtomicQueue : public AtomicQueueCommon<AtomicQueue<T, SIZE, NIL, MINIMIZE_
 
     AtomicQueue() noexcept {
         assert(std::atomic<T>{NIL}.is_lock_free()); // Queue element type T is not atomic. Use AtomicQueue2/AtomicQueueB2 for such element types.
-        details::trivial_uninitialized_fill_n(elements_, size_, NIL);
+        for(auto p = elements_, q = elements_ + size_; p != q; ++p)
+            p->store(NIL, X);
     }
 
     AtomicQueue(AtomicQueue const&) = delete;
@@ -467,7 +467,7 @@ class AtomicQueueB : private std::allocator_traits<A>::template rebind_alloc<std
         , size_(std::max(details::round_up_to_power_of_2(size), 1u << (SHUFFLE_BITS * 2)))
         , elements_(AllocatorElements::allocate(size_)) {
         assert(std::atomic<T>{NIL}.is_lock_free()); // Queue element type T is not atomic. Use AtomicQueue2/AtomicQueueB2 for such element types.
-        details::trivial_uninitialized_fill_n(elements_, size_, NIL);
+        std::uninitialized_fill_n(elements_, size_, NIL);
         assert(get_allocator() == allocator); // The standard requires the original and rebound allocators to manage the same state.
     }
 
@@ -484,8 +484,10 @@ class AtomicQueueB : private std::allocator_traits<A>::template rebind_alloc<std
     }
 
     ~AtomicQueueB() noexcept {
-        if(elements_)
+        if(elements_) {
+            details::destroy_n(elements_, size_);
             AllocatorElements::deallocate(elements_, size_); // TODO: This must be noexcept, static_assert that.
+        }
     }
 
     A get_allocator() const noexcept {
@@ -566,7 +568,7 @@ class AtomicQueueB2 : private std::allocator_traits<A>::template rebind_alloc<un
         , size_(std::max(details::round_up_to_power_of_2(size), 1u << (SHUFFLE_BITS * 2)))
         , states_(allocate_<AtomicState>())
         , elements_(allocate_<T>()) {
-        details::trivial_uninitialized_fill_n(states_, size_, Base::EMPTY);
+        std::uninitialized_fill_n(states_, size_, Base::EMPTY);
         A a = get_allocator();
         assert(a == allocator); // The standard requires the original and rebound allocators to manage the same state.
         for(auto p = elements_, q = elements_ + size_; p < q; ++p)
@@ -592,6 +594,7 @@ class AtomicQueueB2 : private std::allocator_traits<A>::template rebind_alloc<un
             for(auto p = elements_, q = elements_ + size_; p < q; ++p)
                 std::allocator_traits<A>::destroy(a, p);
             deallocate_(elements_);
+            details::destroy_n(states_, size_);
             deallocate_(states_);
         }
     }