Fix address allocator's move constructors

Fletterio · Fletterio · commit dcbff651d0a3 · 2025-02-24T18:00:19.000-03:00
diff --git a/examples_tests b/examples_tests
@@ -1 +1 @@
-Subproject commit 903f0de86ab6833076c95e2e74aa54155cc9e659
+Subproject commit ff95b3bd8f58190aea2e1f961f414c7d195f6c4d
diff --git a/include/nbl/core/alloc/AddressAllocatorBase.h b/include/nbl/core/alloc/AddressAllocatorBase.h
@@ -14,9 +14,9 @@ namespace core
 {
 
     #define _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(SIZE_TYPE) \
-            typedef SIZE_TYPE                                   size_type;\
-            typedef typename std::make_signed<size_type>::type  difference_type;\
-            typedef uint8_t*                                    ubyte_pointer;\
+            using size_type =                                   SIZE_TYPE;\
+            using difference_type =                             typename std::make_signed<size_type>::type;\
+            using ubyte_pointer =                               uint8_t*;\
             static constexpr size_type                          invalid_address = nbl::core::address_type_traits<size_type>::invalid_address
 
     template<typename CRTP, typename _size_type>
@@ -72,9 +72,7 @@ namespace core
                     assert(core::isPoT(maxRequestableAlignment)); // this is not a proper alignment value
                 #endif // _NBL_DEBUG
             }
-            AddressAllocatorBase(CRTP&& other, void* newReservedSpc) :
-                    reservedSpace(nullptr), addressOffset(invalid_address), alignOffset(invalid_address),
-                    maxRequestableAlignment(invalid_address), combinedOffset(invalid_address)
+            AddressAllocatorBase(CRTP&& other, void* newReservedSpc)
             {
                 operator=(std::move(other));
                 reservedSpace = newReservedSpc;
@@ -123,14 +121,24 @@ namespace core
 
             AddressAllocatorBase& operator=(AddressAllocatorBase&& other)
             {
-                std::swap(reservedSpace,other.reservedSpace);
-                std::swap(addressOffset,other.addressOffset);
-                std::swap(alignOffset,other.alignOffset);
-                std::swap(maxRequestableAlignment,other.maxRequestableAlignment);
-                std::swap(combinedOffset,other.combinedOffset);
+                reservedSpace = other.reservedSpace;
+                addressOffset = other.addressOffset;
+                alignOffset = other.alignOffset;
+                maxRequestableAlignment = other.maxRequestableAlignment;
+                combinedOffset = other.combinedOffset;
+                other.invalidate();
                 return *this;
             }
 
+            void invalidate()
+            {
+                reservedSpace = nullptr;
+                addressOffset = invalid_address;
+                alignOffset = invalid_address;
+                maxRequestableAlignment = invalid_address;
+                combinedOffset = invalid_address;
+            }
+
             // pointer to allocator specific state-keeping data, please note that irrBaW address allocators were designed to allocate memory they can't actually access
             void*           reservedSpace;
             // automatic offset to be added to generated addresses
diff --git a/include/nbl/core/alloc/IteratablePoolAddressAllocator.h b/include/nbl/core/alloc/IteratablePoolAddressAllocator.h
@@ -21,36 +21,36 @@ namespace core
 template<typename _size_type>
 class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type>
 {
-        using Base = PoolAddressAllocator<_size_type>;
+        using base_t = PoolAddressAllocator<_size_type>;
     protected:
-        inline _size_type* begin() { return &Base::getFreeStack(Base::freeStackCtr); }
-        inline _size_type& getIteratorOffset(_size_type i) {return reinterpret_cast<_size_type*>(Base::reservedSpace)[Base::blockCount+i];}
-        inline const _size_type& getIteratorOffset(_size_type i) const {return reinterpret_cast<const _size_type*>(Base::reservedSpace)[Base::blockCount+i];}
+        inline _size_type* begin() { return &base_t::getFreeStack(base_t::freeStackCtr); }
+        inline _size_type& getIteratorOffset(_size_type i) {return reinterpret_cast<_size_type*>(base_t::reservedSpace)[base_t::blockCount+i];}
+        inline const _size_type& getIteratorOffset(_size_type i) const {return reinterpret_cast<const _size_type*>(base_t::reservedSpace)[base_t::blockCount+i];}
 
     private:
 
         void copySupplementaryState(const IteratablePoolAddressAllocator& other, _size_type newBuffSz)
         {
             std::copy(other.begin(),other.end(),begin());
-            for (auto i=0u; i<std::min(Base::blockCount,other.blockCount); i++)
+            for (auto i=0u; i<std::min(base_t::blockCount,other.blockCount); i++)
                 getIteratorOffset(i) = other.getIteratorOffset(i);
         }
         // use [freeStackCtr,blockCount) as the iteratable range
         // use [blockCount,blockCount*2u) to store backreferences to iterators
     public:
         _NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(_size_type);
 
-        IteratablePoolAddressAllocator() : Base() {}
+        IteratablePoolAddressAllocator() : base_t() {}
         virtual ~IteratablePoolAddressAllocator() {}
 
         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) {}
+			base_t(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, const IteratablePoolAddressAllocator& other, Args&&... args) noexcept :
-            Base(newBuffSz, other, std::forward<Args>(args)...)
+            base_t(newBuffSz, other, std::forward<Args>(args)...)
         {
             copySupplementaryState(other, newBuffSz);
         }
@@ -59,24 +59,23 @@ class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type
         IteratablePoolAddressAllocator(_size_type newBuffSz, IteratablePoolAddressAllocator&& other, Args&&... args) noexcept :
             IteratablePoolAddressAllocator(newBuffSz,other,std::forward<Args>(args)...)
         {
-            Base::operator=(std::move(other));
+            other.base_t::invalidate();
         }
 
         IteratablePoolAddressAllocator& operator=(IteratablePoolAddressAllocator&& other)
         {
-            Base::operator=(std::move(other));
+            base_t::operator=(std::move(other));
             return *this;
         }
 
-
         //! Functions that actually differ
         inline _size_type        alloc_addr(_size_type bytes, _size_type alignment, _size_type hint=0ull) noexcept
         {
-            const _size_type allocatedAddress = Base::alloc_addr(bytes,alignment,hint);
+            const _size_type allocatedAddress = base_t::alloc_addr(bytes,alignment,hint);
             if (allocatedAddress!=invalid_address)
             {
                 *begin() = allocatedAddress;
-                getIteratorOffset(addressToBlockID(allocatedAddress)) = Base::freeStackCtr;
+                getIteratorOffset(addressToBlockID(allocatedAddress)) = base_t::freeStackCtr;
             }
             return allocatedAddress;
         }
@@ -85,21 +84,21 @@ class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type
         {
             const _size_type iteratorOffset = getIteratorOffset(addressToBlockID(addr));
             #ifdef _NBL_DEBUG
-                assert(iteratorOffset>=Base::freeStackCtr);
+                assert(iteratorOffset>=base_t::freeStackCtr);
             #endif
             // swap the erased element with either end of the array in the contiguous array
             // not using a swap cause it doesn't matter where the erased element points
             const _size_type otherNodeOffset = *begin();
-            reinterpret_cast<_size_type*>(Base::reservedSpace)[iteratorOffset] = otherNodeOffset;
+            reinterpret_cast<_size_type*>(base_t::reservedSpace)[iteratorOffset] = otherNodeOffset;
             // but I need to patch up the back-link of the moved element
             getIteratorOffset(addressToBlockID(otherNodeOffset)) = iteratorOffset;
 
-            Base::free_addr(addr,bytes);
+            base_t::free_addr(addr,bytes);
         }
 
         // gets a range of all the allocated addresses
-        inline const _size_type* begin() const {return &Base::getFreeStack(Base::freeStackCtr);}
-        inline const _size_type* end() const {return &Base::getFreeStack(Base::blockCount);}
+        inline const _size_type* begin() const {return &base_t::getFreeStack(base_t::freeStackCtr);}
+        inline const _size_type* end() const {return &base_t::getFreeStack(base_t::blockCount);}
 
 
         inline _size_type        safe_shrink_size(_size_type sizeBound, _size_type newBuffAlignmentWeCanGuarantee=1u) noexcept
@@ -125,31 +124,31 @@ class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type
 
         inline void         reset()
         {
-            Base::reset();
+            base_t::reset();
         }
         inline _size_type    max_size() const noexcept
         {
-            return Base::max_size();
+            return base_t::max_size();
         }
         inline _size_type    min_size() const noexcept
         {
-            return Base::min_size();
+            return base_t::min_size();
         }
         inline _size_type    get_free_size() const noexcept
         {
-            return Base::get_free_size();
+            return base_t::get_free_size();
         }
         inline _size_type    get_allocated_size() const noexcept
         {
-            return Base::get_allocated_size();
+            return base_t::get_allocated_size();
         }
         inline _size_type    get_total_size() const noexcept
         {
-            return Base::get_total_size();
+            return base_t::get_total_size();
         }
         inline _size_type    addressToBlockID(_size_type addr) const noexcept
         {
-            return Base::addressToBlockID(addr);
+            return base_t::addressToBlockID(addr);
         }
 };
 
diff --git a/include/nbl/core/alloc/PoolAddressAllocator.h b/include/nbl/core/alloc/PoolAddressAllocator.h
@@ -20,32 +20,32 @@ template<typename _size_type>
 class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_size_type>,_size_type>
 {
     private:
-        typedef AddressAllocatorBase<PoolAddressAllocator<_size_type>,_size_type> Base;
+        using base_t = AddressAllocatorBase<PoolAddressAllocator<_size_type>,_size_type>;
 
         void copyState(const PoolAddressAllocator& other, _size_type newBuffSz)
         {
             if (blockCount>other.blockCount)
                 freeStackCtr = blockCount-other.blockCount;
 
             #ifdef _NBL_DEBUG
-                assert(Base::checkResize(newBuffSz,Base::alignOffset));
+                assert(base_t::checkResize(newBuffSz,base_t::alignOffset));
             #endif // _NBL_DEBUG
 
             for (_size_type i=0u; i<freeStackCtr; i++)
-                getFreeStack(i) = (blockCount-1u-i)*blockSize+Base::combinedOffset;
+                getFreeStack(i) = (blockCount-1u-i)*blockSize+base_t::combinedOffset;
 
             for (_size_type i=0; i<other.freeStackCtr; i++)
             {
-                _size_type freeEntry = other.getFreeStack(i)-other.Base::combinedOffset;
+                _size_type freeEntry = other.getFreeStack(i)-other.base_t::combinedOffset;
                 // check in case of shrink
                 if (freeEntry<blockCount*blockSize)
-                    getFreeStack(freeStackCtr++) = freeEntry+Base::combinedOffset;
+                    getFreeStack(freeStackCtr++) = freeEntry+base_t::combinedOffset;
             }
         }
 
         inline bool safe_shrink_size_common(_size_type& sizeBound, _size_type newBuffAlignmentWeCanGuarantee) noexcept
         {
-            _size_type capacity = get_total_size()-Base::alignOffset;
+            _size_type capacity = get_total_size()-base_t::alignOffset;
             if (sizeBound>=capacity)
                 return false;
 
@@ -71,7 +71,7 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         virtual ~PoolAddressAllocator() {}
 
         PoolAddressAllocator(void* reservedSpc, _size_type addressOffsetToApply, _size_type alignOffsetNeeded, _size_type maxAllocatableAlignment, size_type bufSz, size_type blockSz) noexcept :
-					Base(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment),
+					base_t(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment),
 						blockCount((bufSz-alignOffsetNeeded)/blockSz), blockSize(blockSz), freeStackCtr(0u)
         {
             reset();
@@ -80,32 +80,28 @@ 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(other,std::forward<Args>(args)...),
-						blockCount((newBuffSz-Base::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStackCtr(0u)
+					base_t(other,std::forward<Args>(args)...),
+						blockCount((newBuffSz-base_t::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStackCtr(0u)
         {
             copyState(other, newBuffSz);
 
-            Base::operator=(std::move(other));
-            std::swap(reservedSpace, other.reservedSpace);
-
-            other.blockCount = invalid_address;
-			other.blockSize = invalid_address;
-            other.freeStackCtr = invalid_address;
+            other.invalidate();
         }
         template<typename... Args>
         PoolAddressAllocator(_size_type newBuffSz, const PoolAddressAllocator& other, Args&&... args) noexcept :
-            Base(other, std::forward<Args>(args)...),
-            blockCount((newBuffSz-Base::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStackCtr(0u)
+            base_t(other, std::forward<Args>(args)...),
+            blockCount((newBuffSz-base_t::alignOffset)/other.blockSize), blockSize(other.blockSize), freeStackCtr(0u)
         {
             copyState(other, newBuffSz);
         }
 
         PoolAddressAllocator& operator=(PoolAddressAllocator&& other)
         {
-            Base::operator=(std::move(other));
-            std::swap(blockCount,other.blockCount);
-            std::swap(blockSize,other.blockSize);
-            std::swap(freeStackCtr,other.freeStackCtr);
+            base_t::operator=(std::move(other));
+            blockCount = other.blockCount;
+            blockSize = other.blockSize;
+            freeStackCtr = other.freeStackCtr;
+            other.invalidateLocal();
             return *this;
         }
 
@@ -121,15 +117,15 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         inline void             free_addr(size_type addr, size_type bytes) noexcept
         {
             #ifdef _NBL_DEBUG
-                assert(addr>=Base::combinedOffset && (addr-Base::combinedOffset)%blockSize==0 && freeStackCtr<blockCount);
+                assert(addr>=base_t::combinedOffset && (addr-base_t::combinedOffset)%blockSize==0 && freeStackCtr<blockCount);
             #endif // _NBL_DEBUG
 			getFreeStack(freeStackCtr++) = addr;
         }
 
         inline void             reset()
         {
             for (freeStackCtr=0u; freeStackCtr<blockCount; freeStackCtr++)
-                getFreeStack(freeStackCtr) = (blockCount-1u-freeStackCtr)*blockSize+Base::combinedOffset;
+                getFreeStack(freeStackCtr) = (blockCount-1u-freeStackCtr)*blockSize+base_t::combinedOffset;
         }
 
         //! conservative estimate, does not account for space lost to alignment
@@ -154,7 +150,7 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
                 for (size_type i=0; i<freeStackCtr; i++)
                 {
                     auto freeAddr = getFreeStack(i);
-                    if (freeAddr<sizeBound+Base::combinedOffset)
+                    if (freeAddr<sizeBound+base_t::combinedOffset)
                         continue;
 
                     tmpStackCopy[boundedCount++] = freeAddr;
@@ -165,7 +161,7 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
                     std::make_heap(tmpStackCopy,tmpStackCopy+boundedCount);
                     std::sort_heap(tmpStackCopy,tmpStackCopy+boundedCount);
                     // could do sophisticated modified version of std::adjacent_find with a binary search, but F'it
-                    size_type endAddr = (blockCount-1u)*blockSize+Base::combinedOffset;
+                    size_type endAddr = (blockCount-1u)*blockSize+base_t::combinedOffset;
                     size_type i=0u;
                     for (;i<boundedCount; i++,endAddr-=blockSize)
                     {
@@ -176,7 +172,7 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
                     sizeBound -= i*blockSize;
                 }
             }
-            return Base::safe_shrink_size(sizeBound,newBuffAlignmentWeCanGuarantee);
+            return base_t::safe_shrink_size(sizeBound,newBuffAlignmentWeCanGuarantee);
         }
 
 
@@ -200,16 +196,36 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         }
         inline size_type        get_total_size() const noexcept
         {
-            return blockCount*blockSize+Base::alignOffset;
+            return blockCount*blockSize+base_t::alignOffset;
         }
 
 
 
         inline size_type addressToBlockID(size_type addr) const noexcept
         {
-            return (addr-Base::combinedOffset)/blockSize;
+            return (addr-base_t::combinedOffset)/blockSize;
         }
     protected:
+
+        /**
+        * @brief Invalidates only fields from this class extension
+        */
+        void invalidateLocal()
+        {
+            blockCount = invalid_address;
+            blockSize = invalid_address;
+            freeStackCtr = invalid_address;
+        }
+
+        /**
+        * @brief Invalidates all fields
+        */
+        void invalidate()
+        {
+            base_t::invalidate();
+            invalidateLocal();
+        }
+
         size_type   blockCount;
         size_type   blockSize;
         // TODO: free address min-heap and allocated addresses max-heap, packed into the same memory (whatever is not allocated is free)
@@ -218,8 +234,8 @@ class PoolAddressAllocator : public AddressAllocatorBase<PoolAddressAllocator<_s
         // but then should probably have two pool allocators, because doing that changes insertion/removal from O(1) to O(log(N))
         size_type   freeStackCtr;
 
-        inline size_type& getFreeStack(size_type i) {return reinterpret_cast<size_type*>(Base::reservedSpace)[i];}
-        inline const size_type& getFreeStack(size_type i) const {return reinterpret_cast<const size_type*>(Base::reservedSpace)[i];}
+        inline size_type& getFreeStack(size_type i) {return reinterpret_cast<size_type*>(base_t::reservedSpace)[i];}
+        inline const size_type& getFreeStack(size_type i) const {return reinterpret_cast<const size_type*>(base_t::reservedSpace)[i];} 
 };
 
 

Original file line number	Diff line number	Diff line change
`@@ -21,36 +21,36 @@ namespace core`
`21`	`21`	`template<typename _size_type>`
`22`	`22`	`class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type>`
`23`	`23`	`{`
`24`		`- using Base = PoolAddressAllocator<_size_type>;`
	`24`	`+ using base_t = PoolAddressAllocator<_size_type>;`
`25`	`25`	`protected:`
`26`		`- inline _size_type* begin() { return &Base::getFreeStack(Base::freeStackCtr); }`
`27`		`- inline _size_type& getIteratorOffset(_size_type i) {return reinterpret_cast<_size_type*>(Base::reservedSpace)[Base::blockCount+i];}`
`28`		`- inline const _size_type& getIteratorOffset(_size_type i) const {return reinterpret_cast<const _size_type*>(Base::reservedSpace)[Base::blockCount+i];}`
	`26`	`+ inline _size_type* begin() { return &base_t::getFreeStack(base_t::freeStackCtr); }`
	`27`	`+ inline _size_type& getIteratorOffset(_size_type i) {return reinterpret_cast<_size_type*>(base_t::reservedSpace)[base_t::blockCount+i];}`
	`28`	`+ inline const _size_type& getIteratorOffset(_size_type i) const {return reinterpret_cast<const _size_type*>(base_t::reservedSpace)[base_t::blockCount+i];}`
`29`	`29`
`30`	`30`	`private:`
`31`	`31`
`32`	`32`	`void copySupplementaryState(const IteratablePoolAddressAllocator& other, _size_type newBuffSz)`
`33`	`33`	`{`
`34`	`34`	`std::copy(other.begin(),other.end(),begin());`
`35`		`- for (auto i=0u; i<std::min(Base::blockCount,other.blockCount); i++)`
	`35`	`+ for (auto i=0u; i<std::min(base_t::blockCount,other.blockCount); i++)`
`36`	`36`	`getIteratorOffset(i) = other.getIteratorOffset(i);`
`37`	`37`	`}`
`38`	`38`	`// use [freeStackCtr,blockCount) as the iteratable range`
`39`	`39`	`// use [blockCount,blockCount*2u) to store backreferences to iterators`
`40`	`40`	`public:`
`41`	`41`	`_NBL_DECLARE_ADDRESS_ALLOCATOR_TYPEDEFS(_size_type);`
`42`	`42`
`43`		`- IteratablePoolAddressAllocator() : Base() {}`
	`43`	`+ IteratablePoolAddressAllocator() : base_t() {}`
`44`	`44`	`virtual ~IteratablePoolAddressAllocator() {}`
`45`	`45`
`46`	`46`	`IteratablePoolAddressAllocator(void* reservedSpc, _size_type addressOffsetToApply, _size_type alignOffsetNeeded, _size_type maxAllocatableAlignment, _size_type bufSz, _size_type blockSz) noexcept :`
`47`		`- Base(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment,bufSz,blockSz) {}`
	`47`	`+ base_t(reservedSpc,addressOffsetToApply,alignOffsetNeeded,maxAllocatableAlignment,bufSz,blockSz) {}`
`48`	`48`
`49`	`49`
`50`	`50`	`//! When resizing we require that the copying of data buffer has already been handled by the user of the address allocator`
`51`	`51`	`template<typename... Args>`
`52`	`52`	`IteratablePoolAddressAllocator(_size_type newBuffSz, const IteratablePoolAddressAllocator& other, Args&&... args) noexcept :`
`53`		`- Base(newBuffSz, other, std::forward<Args>(args)...)`
	`53`	`+ base_t(newBuffSz, other, std::forward<Args>(args)...)`
`54`	`54`	`{`
`55`	`55`	`copySupplementaryState(other, newBuffSz);`
`56`	`56`	`}`
`@@ -59,24 +59,23 @@ class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type`
`59`	`59`	`IteratablePoolAddressAllocator(_size_type newBuffSz, IteratablePoolAddressAllocator&& other, Args&&... args) noexcept :`
`60`	`60`	`IteratablePoolAddressAllocator(newBuffSz,other,std::forward<Args>(args)...)`
`61`	`61`	`{`
`62`		`- Base::operator=(std::move(other));`
	`62`	`+ other.base_t::invalidate();`
`63`	`63`	`}`
`64`	`64`
`65`	`65`	`IteratablePoolAddressAllocator& operator=(IteratablePoolAddressAllocator&& other)`
`66`	`66`	`{`
`67`		`- Base::operator=(std::move(other));`
	`67`	`+ base_t::operator=(std::move(other));`
`68`	`68`	`return *this;`
`69`	`69`	`}`
`70`	`70`
`71`		`-`
`72`	`71`	`//! Functions that actually differ`
`73`	`72`	`inline _size_type alloc_addr(_size_type bytes, _size_type alignment, _size_type hint=0ull) noexcept`
`74`	`73`	`{`
`75`		`- const _size_type allocatedAddress = Base::alloc_addr(bytes,alignment,hint);`
	`74`	`+ const _size_type allocatedAddress = base_t::alloc_addr(bytes,alignment,hint);`
`76`	`75`	`if (allocatedAddress!=invalid_address)`
`77`	`76`	`{`
`78`	`77`	`*begin() = allocatedAddress;`
`79`		`- getIteratorOffset(addressToBlockID(allocatedAddress)) = Base::freeStackCtr;`
	`78`	`+ getIteratorOffset(addressToBlockID(allocatedAddress)) = base_t::freeStackCtr;`
`80`	`79`	`}`
`81`	`80`	`return allocatedAddress;`
`82`	`81`	`}`
`@@ -85,21 +84,21 @@ class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type`
`85`	`84`	`{`
`86`	`85`	`const _size_type iteratorOffset = getIteratorOffset(addressToBlockID(addr));`
`87`	`86`	`#ifdef _NBL_DEBUG`
`88`		`- assert(iteratorOffset>=Base::freeStackCtr);`
	`87`	`+ assert(iteratorOffset>=base_t::freeStackCtr);`
`89`	`88`	`#endif`
`90`	`89`	`// swap the erased element with either end of the array in the contiguous array`
`91`	`90`	`// not using a swap cause it doesn't matter where the erased element points`
`92`	`91`	`const _size_type otherNodeOffset = *begin();`
`93`		`- reinterpret_cast<_size_type*>(Base::reservedSpace)[iteratorOffset] = otherNodeOffset;`
	`92`	`+ reinterpret_cast<_size_type*>(base_t::reservedSpace)[iteratorOffset] = otherNodeOffset;`
`94`	`93`	`// but I need to patch up the back-link of the moved element`
`95`	`94`	`getIteratorOffset(addressToBlockID(otherNodeOffset)) = iteratorOffset;`
`96`	`95`
`97`		`- Base::free_addr(addr,bytes);`
	`96`	`+ base_t::free_addr(addr,bytes);`
`98`	`97`	`}`
`99`	`98`
`100`	`99`	`// gets a range of all the allocated addresses`
`101`		`- inline const _size_type* begin() const {return &Base::getFreeStack(Base::freeStackCtr);}`
`102`		`- inline const _size_type* end() const {return &Base::getFreeStack(Base::blockCount);}`
	`100`	`+ inline const _size_type* begin() const {return &base_t::getFreeStack(base_t::freeStackCtr);}`
	`101`	`+ inline const _size_type* end() const {return &base_t::getFreeStack(base_t::blockCount);}`
`103`	`102`
`104`	`103`
`105`	`104`	`inline _size_type safe_shrink_size(_size_type sizeBound, _size_type newBuffAlignmentWeCanGuarantee=1u) noexcept`
`@@ -125,31 +124,31 @@ class IteratablePoolAddressAllocator : protected PoolAddressAllocator<_size_type`
`125`	`124`
`126`	`125`	`inline void reset()`
`127`	`126`	`{`
`128`		`- Base::reset();`
	`127`	`+ base_t::reset();`
`129`	`128`	`}`
`130`	`129`	`inline _size_type max_size() const noexcept`
`131`	`130`	`{`
`132`		`- return Base::max_size();`
	`131`	`+ return base_t::max_size();`
`133`	`132`	`}`
`134`	`133`	`inline _size_type min_size() const noexcept`
`135`	`134`	`{`
`136`		`- return Base::min_size();`
	`135`	`+ return base_t::min_size();`
`137`	`136`	`}`
`138`	`137`	`inline _size_type get_free_size() const noexcept`
`139`	`138`	`{`
`140`		`- return Base::get_free_size();`
	`139`	`+ return base_t::get_free_size();`
`141`	`140`	`}`
`142`	`141`	`inline _size_type get_allocated_size() const noexcept`
`143`	`142`	`{`
`144`		`- return Base::get_allocated_size();`
	`143`	`+ return base_t::get_allocated_size();`
`145`	`144`	`}`
`146`	`145`	`inline _size_type get_total_size() const noexcept`
`147`	`146`	`{`
`148`		`- return Base::get_total_size();`
	`147`	`+ return base_t::get_total_size();`
`149`	`148`	`}`
`150`	`149`	`inline _size_type addressToBlockID(_size_type addr) const noexcept`
`151`	`150`	`{`
`152`		`- return Base::addressToBlockID(addr);`
	`151`	`+ return base_t::addressToBlockID(addr);`
`153`	`152`	`}`
`154`	`153`	`};`
`155`	`154`