Changes to allocators talked over with Matt

Author: Fletterio

include/nbl/core/alloc/IteratablePoolAddressAllocator.h

@@ -46,19 +46,20 @@ class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type
         IteratablePoolAddressAllocator(void* reservedSpc, _size_type addressOffsetToApply, _size_type alignOffsetNeeded, _size_type maxAllocatableAlignment, _size_type bufSz, _size_type blockSz) noexcept :
 			Base(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment,bufSz,blockSz) {}
 
+
         //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator
         template<typename... Args>
-        IteratablePoolAddressAllocator(_size_type newBuffSz, IteratablePoolAddressAllocator&& other, Args&&... args) noexcept :
-			Base(newBuffSz,std::move(other),std::forward<Args>(args)...)
+        IteratablePoolAddressAllocator(_size_type newBuffSz, const IteratablePoolAddressAllocator& other, Args&&... args) noexcept :
+            Base(newBuffSz, other, std::forward<Args>(args)...)
         {
-            copyState(other, newBuffSz);
+            copySupplementaryState(other, newBuffSz);
         }
-
+        
         template<typename... Args>
-        IteratablePoolAddressAllocator(_size_type newBuffSz, const IteratablePoolAddressAllocator& other, Args&&... args) noexcept :
-			Base(newBuffSz,other,std::forward<Args>(args)...)
+        IteratablePoolAddressAllocator(_size_type newBuffSz, IteratablePoolAddressAllocator&& other, Args&&... args) noexcept :
+            IteratablePoolAddressAllocator(newBuffSz,other,std::forward<Args>(args)...)
         {
-            copyState(other, newBuffSz);
+            Base::operator=(std::move(other));
         }
 
         IteratablePoolAddressAllocator& operator=(IteratablePoolAddressAllocator&& other)

include/nbl/core/alloc/PoolAddressAllocator.h

@@ -43,27 +43,6 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
             }
         }
 
-        void copyStateMove(_size_type otherBlockCount, _size_type otherFreeStackCtr, _size_type newBuffSz)
-        {
-            if (blockCount > otherBlockCount)
-                freeStackCtr = blockCount - otherBlockCount;
-
-            #ifdef _NBL_DEBUG
-            assert(Base::checkResize(newBuffSz, Base::alignOffset));
-            #endif // _NBL_DEBUG
-
-            for (_size_type i = 0u; i < freeStackCtr; i++)
-                getFreeStack(i) = (blockCount - 1u - i) * blockSize + Base::combinedOffset;
-
-            for (_size_type i = 0; i < otherFreeStackCtr; i++)
-            {
-                _size_type freeEntry = getFreeStack(i) - Base::combinedOffset;
-                // check in case of shrink
-                if (freeEntry < blockCount * blockSize)
-                    getFreeStack(freeStackCtr++) = freeEntry + Base::combinedOffset;
-            }
-        }
-
         inline bool safe_shrink_size_common(_size_type& sizeBound, _size_type newBuffAlignmentWeCanGuarantee) noexcept
         {
             _size_type capacity = get_total_size()-Base::alignOffset;
@@ -101,10 +80,13 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         //! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator
         template<typename... Args>
         PoolAddressAllocator(_size_type newBuffSz, PoolAddressAllocator&& other, Args&&... args) noexcept :
-					Base(std::move(other),std::forward<Args>(args)...),
+					Base(other,std::forward<Args>(args)...),
 						blockCount((newBuffSz-Base::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStackCtr(0u)
         {
-            copyStateMove(other.blockCount, other.freeStackCtr, newBuffSz);
+            copyState(other, newBuffSz);
+
+            Base::operator=(std::move(other));
+            std::swap(reservedSpace, other.reservedSpace);
 
             other.blockCount = invalid_address;
 			other.blockSize = invalid_address;

include/nbl/core/containers/DoublyLinkedList.h

@@ -198,7 +198,7 @@ class DoublyLinkedList
 		// Copy memory over to new buffer
 		memcpy(newArray, m_array, m_cap * sizeof(node_t));
 		// Create new address allocator from old one
-		m_addressAllocator = std::unique_ptr<address_allocator_t>(new address_allocator_t(newCapacity, std::move(*(m_addressAllocator)), newReservedSpace));
+		m_addressAllocator = std::make_unique<address_allocator_t>(newCapacity, std::move(*(m_addressAllocator)), newReservedSpace);
 		// After address allocator creation we can free the old buffer
 		_NBL_ALIGNED_FREE(m_reservedSpace);
 		m_cap = newCapacity;
@@ -216,7 +216,7 @@ class DoublyLinkedList
 		m_reservedSpace = _NBL_ALIGNED_MALLOC(firstPart + capacity * sizeof(node_t), alignof(node_t));
 		m_array = reinterpret_cast<node_t*>(reinterpret_cast<uint8_t*>(m_reservedSpace) + firstPart);
 
-		m_addressAllocator = std::unique_ptr<address_allocator_t>(new address_allocator_t(m_reservedSpace, 0u, 0u, 1u, capacity, 1u));
+		m_addressAllocator = std::make_unique<address_allocator_t>(m_reservedSpace, 0u, 0u, 1u, capacity, 1u);
 		m_cap = capacity;
 		m_back = invalid_iterator;
 		m_begin = invalid_iterator;