MemoryManager.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants
Licensee a limited, non-exclusive, non-transferable, royalty-free license
(without the right to sublicense) to use the API solely for the purpose of
Licensee's internal development efforts to develop applications for which
the API was provided.
 
The above copyright notice and this permission notice shall be included in all
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Base
File: MemoryManager
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/BaseValues.h>
#include <NDEVR/LibAssert.h>
#include <algorithm>
#include <cstring>
#ifdef __clang__
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wdynamic-class-memaccess"
#endif
#ifdef _WIN32
    #define NDEVR_HAS_ALIGNED_ALLOC 1
    #include <memory.h>
    #include <cstddef>
    inline void* ndevr_aligned_realloc(void* old_ptr,
        size_t new_size,
        size_t old_size,
        size_t alignment)
    {
        UNUSED(old_size);
        return _aligned_realloc(old_ptr, new_size, alignment);
    }
    inline auto ndevr_aligned_malloc(
        size_t new_size,
        size_t alignment)
    {
        return _aligned_malloc(new_size, alignment);
    }
    inline auto ndevr_aligned_free(void* ptr)
    {
        return _aligned_free(ptr);
    }
#elif defined(ANDROID)
    #define NDEVR_HAS_ALIGNED_ALLOC 0
#elif defined(__GNUC__) || defined(__clang__)
    #define NDEVR_HAS_ALIGNED_ALLOC 1
    #include <cstdlib>
    #include <stdlib.h>
    #define ndevr_aligned_free ::free
    inline void* ndevr_aligned_malloc(
        size_t new_size,
        size_t alignment)
    {
        // aligned_alloc requires size to be a multiple of alignment (C11 spec)
        size_t fixed_size = (new_size + alignment - 1) / alignment * alignment;
        return ::aligned_alloc(alignment, fixed_size);
    }
    inline void* ndevr_aligned_realloc(void* old_ptr,
                          size_t new_size,
                          size_t old_size,
                          size_t alignment)
    {
        // std::aligned_alloc requires size to be a multiple of alignment
        size_t fixed_new_size = (new_size + alignment - 1) / alignment * alignment;
 
        void* new_ptr = ::aligned_alloc(alignment, fixed_new_size);
        if (old_ptr)
        {
            memcpy(new_ptr, old_ptr, getMin(old_size, new_size));
            free(old_ptr);
        }
 
        return new_ptr;
    }
#else
    #define NDEVR_HAS_ALIGNED_ALLOC 0
#endif
namespace NDEVR
{
#if NDEVR_HAS_ALIGNED_ALLOC
#if defined(__cpp_lib_assume_aligned) && __cpp_lib_assume_aligned
    #define NDEVR_ASSUME_ALIGNED(ALIGN, PTR) \
            (__builtin_assume_aligned(PTR, ALIGN))
    #elif defined(_MSC_VER)
    #define NDEVR_ASSUME_ALIGNED(ALIGN, PTR) \
            ((__assume((reinterpret_cast<std::uintptr_t>(PTR) & ((ALIGN) - 1)) == 0), (PTR)))
    #elif defined(__GNUC__) || defined(__clang__)
    #define NDEVR_ASSUME_ALIGNED(ALIGN, PTR) \
            (__builtin_assume_aligned(PTR, ALIGN))
    #else
    #define NDEVR_ASSUME_ALIGNED(ALIGN, PTR) \
            (PTR)
    #endif
#else
    #define NDEVR_ASSUME_ALIGNED(ALIGN, PTR) \
            (PTR)
#endif
    template<size_t t_size>
    static constexpr size_t DetermineAlignment() noexcept
    {
    #if NDEVR_HAS_ALIGNED_ALLOC
        if constexpr (t_size >= 64)
            return 64;
        else if constexpr (t_size >= 32)
            return 32;
        else if constexpr (t_size >= 16)
            return 16;
        else if constexpr (t_size >= 8)
            return 8;
        else
    #endif
            return 0;
    }

    template<class t_type>
    struct AlignmentDeterminator
    {
        static constexpr size_t Size() noexcept
        {
            return DetermineAlignment<sizeof(t_type)>();
        }
    };

    template<class t_index_type, bool is_primitive>
    class ObjectAllocatorT;
    template<class t_index_type>
    class ObjectAllocatorT<t_index_type, true>
    {
    public:
        template<class t_buffer_type, class t_type>
        static void Allocate(t_buffer_type&, t_index_type, t_index_type) noexcept
        {}

        template<class t_buffer_type, class t_type>
        static constexpr void Deallocate(t_buffer_type&, t_index_type, t_index_type) noexcept
        {}

        template<class t_buffer_type, class t_type>
        static void AllocateElement(t_buffer_type& buff, t_index_type start, t_index_type size, const t_type& object) noexcept
        {
            buff.setAll(object, start, size);
        }

        template<class t_buffer_type, class t_type>
        static void AllocateElement(t_buffer_type& buff, t_index_type index, const t_type& object) noexcept
        {
            buff.get(index) = object;
        }

        template<class t_buffer_type, class t_type>
        static void AllocateElement(t_buffer_type& buff, t_index_type index, t_type&& object) noexcept
        {
            buff.get(index) = std::forward<t_type>(object);
        }
    };

    template<class t_index_type>
    class ObjectAllocatorT<t_index_type, false>
    {
    public:
        template<class t_buffer_type, class t_type>
        static constexpr void Allocate(t_buffer_type& buff, t_index_type start, t_index_type size) noexcept
        {
            if constexpr (!std::is_trivially_default_constructible_v<t_type>)
            {
                for (t_index_type i = 0; i < size; i++)
                    new (&buff.get(i + start)) t_type();
            }
        }

        template<class t_buffer_type, class t_type>
        static constexpr void Deallocate(t_buffer_type& buff, t_index_type start, t_index_type size) noexcept
        {
            if constexpr (!std::is_trivially_destructible<t_type>::value)
            {
                t_index_type end = start + size;
                for (t_index_type i = start; i < end; i++)
                    (&buff.get(i))->~t_type();
            }
        }

        template<class t_buffer_type, class t_type>
        static constexpr void AllocateElement(t_buffer_type& buff, t_index_type start, t_index_type size, const t_type& object) noexcept
        {
            t_index_type end = start + size;
            for (t_index_type i = start; i < end; i++)
                new (&buff.get(i)) t_type(object);
        }

        template<class t_buffer_type, class t_type>
        static constexpr void AllocateElement(t_buffer_type& buff, t_index_type index, const t_type& object) noexcept
        {
            new (&buff.get(index)) t_type(object);
        }

        template<class t_buffer_type, class t_type>
        static constexpr void AllocateElement(t_buffer_type& buff, t_index_type index, t_type&& object) noexcept
        {
            new (&buff.get(index)) t_type(std::move(object));
        }
    };

    template<class t_type, bool t_is_primitive, class t_index_type>
    class ObjectAllocator
    {
    public:
        template<class t_buffer_type>
        static constexpr void Allocate(t_buffer_type& buffer, t_index_type start, t_index_type size) noexcept
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template Allocate<t_buffer_type, t_type>(buffer, start, size);
        }

        template<class t_buffer_type>
        static constexpr void Deallocate(t_buffer_type& buffer, t_index_type start, t_index_type size) noexcept
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template Deallocate<t_buffer_type, t_type>(buffer, start, size);
        }

        template<class t_buffer_type>
        static constexpr void AllocateElement(t_buffer_type& buffer, t_index_type start, t_index_type size, const t_type& object) noexcept
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template AllocateElement<t_buffer_type, t_type>(buffer, start, size, object);
        }

        template<class t_buffer_type>
        static constexpr void AllocateElement(t_buffer_type& buffer, t_index_type start, t_index_type size, t_type& object) noexcept
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template AllocateElement<t_buffer_type, t_type>(buffer, start, size, object);
        }

        template<class t_buffer_type>
        static constexpr void AllocateElement(t_buffer_type& buffer, t_index_type index, const t_type& object) noexcept
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template AllocateElement<t_buffer_type, t_type>(buffer, index, object);
        }

        template<class t_buffer_type>
        static constexpr void AllocateElement(t_buffer_type& buffer, t_index_type index, t_type&& object) noexcept
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template AllocateElement<t_buffer_type, t_type>(buffer, index, std::forward<t_type>(object));
        }

        static constexpr bool isPrimitive() noexcept
        {
            return t_is_primitive;
        }
    };
    // Memory Allocation tuned per platform
    #if defined(_MSC_VER) && !defined(__clang__)
        #define NDEVR_HAS_UMUL128 1
    #else
        #define NDEVR_HAS_UMUL128 0
    #endif
    #if defined(__EMSCRIPTEN__)
        #define NDEVR_ALIGN_TINY    64ULL//64
        #define NDEVR_ALIGN_MED     65536ULL//64KB
        #define NDEVR_ALIGN_LARGE   1048576ULL//1MB
    #elif defined(_WIN32)
        #define NDEVR_ALIGN_TINY    64ULL//64
        #define NDEVR_ALIGN_MED     4096ULL//4KB
        #define NDEVR_ALIGN_LARGE   65536ull//64KB
        #define NDEVR_ALIGN_HUGE    2097152ull//2MB
    #elif defined(__ANDROID__)
        #define NDEVR_ALIGN_TINY    64ULL//64
        #define NDEVR_ALIGN_MED     4096ULL//4KB
        #define NDEVR_ALIGN_LARGE   1048576ULL//1MB
    #else
        #define NDEVR_ALIGN_TINY    64ULL//64
        #define NDEVR_ALIGN_MED     4096ULL//4KB
        #define NDEVR_ALIGN_LARGE   1048576ULL//1MB
    #endif
#if __cpp_lib_bitops <= 201907L
    template<size_t t_value>
    struct ShiftCount { static constexpr int value = ((t_value & 1) != 0) ? 0 : (1 + ShiftCount<(t_value >> 1)>::value); };
    template<> struct ShiftCount<0> { static constexpr int value = 0; };
#endif
    template<uint08 D>
    struct MagicDiv
    {
    #if NDEVR_HAS_UMUL128
        static constexpr uint08 m = (uint08(~uint08(0)) / D) + 1; 
    #else
        static constexpr unsigned __int128 high_bit = (unsigned __int128)1 << 64; 
        static constexpr uint08 m = uint08((high_bit + (D - 1)) / D); 
    #endif
    };

    template<class t_index_type, size_t t_elem_size>
    static inline t_index_type NextCapacityBytes(t_index_type cap_elems, t_index_type need_elems) noexcept
    {
        constexpr size_t min_step = size_t(8) * t_elem_size;
 
        size_t old_b = size_t(cap_elems) * t_elem_size;
        size_t need_b = size_t(need_elems) * t_elem_size;
 
        size_t base = (old_b < size_t(256)) ? (old_b << 1) : (old_b + (old_b >> 1));
        size_t grow_b = (base > old_b + min_step) ? base : (old_b + min_step);
        if (grow_b < need_b)
            grow_b = need_b;
 
        size_t align_b;
    #ifdef NDEVR_ALIGN_HUGE
        if (grow_b >= NDEVR_ALIGN_HUGE || t_elem_size >= NDEVR_ALIGN_HUGE)
            align_b = NDEVR_ALIGN_HUGE;
        else
    #endif
        if (grow_b >= NDEVR_ALIGN_LARGE || t_elem_size >= NDEVR_ALIGN_LARGE)
            align_b = NDEVR_ALIGN_LARGE;
        else if (grow_b >= NDEVR_ALIGN_MED || t_elem_size >= NDEVR_ALIGN_MED)
            align_b = NDEVR_ALIGN_MED;
        else
            align_b = NDEVR_ALIGN_TINY;
        if constexpr ((t_elem_size & (t_elem_size - size_t(1))) == 0)
        {
        #if __cpp_lib_bitops > 201907L
            constexpr int shift = std::countr_zero((size_t)t_elem_size);
        #else
            constexpr int shift = ShiftCount<t_elem_size>::value;
        #endif
            size_t rounded = (grow_b + (align_b - size_t(1))) & ~(align_b - size_t(1));
            size_t elems = rounded >> shift;
            return cast<t_index_type>(elems);
        }
        else
        {
            size_t rounded = (grow_b + (align_b - size_t(1))) & ~(align_b - size_t(1));
        #if NDEVR_HAS_UMUL128
            size_t hi;
            (void)_umul128(rounded, MagicDiv<t_elem_size>::m, &hi);
            return cast<t_index_type>(hi);
        #else
            unsigned __int128 prod = (unsigned __int128)(rounded) * (unsigned __int128)MagicDiv<t_elem_size>::m;
            size_t elems = size_t(prod >> 64);
            return cast<t_index_type>(elems);
        #endif
        }
    }

    template<class t_type, size_t t_aligned_size, bool t_is_primitive, class t_index_type = uint04, bool t_null_term = false, bool t_allow_reference = false>
    class BufferAllocator
    {
    public:
        using index_type = t_index_type; 
        typedef ObjectAllocator<t_type, t_is_primitive, t_index_type> allocator; 

        [[nodiscard]] static constexpr bool IsNullTerm() noexcept { return t_null_term; }

        constexpr explicit BufferAllocator() noexcept
            : m_buffer{ emptyPtr<t_null_term>() }
            , m_filled_size(0)
            , m_allocated_size(0)
        {}

        constexpr BufferAllocator(BufferAllocator&& allocator) noexcept
            : m_buffer{ emptyPtr<t_null_term>() }
            , m_filled_size(0)
            , m_allocated_size(0)
        {
            std::swap(allocator.m_buffer, m_buffer);
            std::swap(allocator.m_filled_size, m_filled_size);
            std::swap(allocator.m_allocated_size, m_allocated_size);
        }

        ~BufferAllocator() noexcept
        {
            if (capacity() != 0)
            {
            #if NDEVR_HAS_ALIGNED_ALLOC
                if constexpr (t_aligned_size > 0)
                    ndevr_aligned_free(ptr());
                else
            #endif
                    free(ptr());
            }
        }

        template<bool t_managed>
        constexpr void createSpace(t_index_type size) noexcept
        {
            t_index_type new_size = m_filled_size + size;
            allocationSizeCheck<t_managed>(new_size);
            m_filled_size = new_size;
            nullTerminatorCheck<t_null_term>();
        }

        template<bool t_managed>
        constexpr void createSpace(t_index_type location, t_index_type size) noexcept
        {
            createSpace<t_managed>(size);
            memmove(begin() + location + size, begin() + location, sizeof(t_type) * (m_filled_size - (size + location)));
        }

        void addLast() noexcept
        {
            createSpace<false>(1);
        }

        void removeLast() noexcept
        {
            m_filled_size--;
            nullTerminatorCheck<t_null_term>();
        }

        void removeLast(t_index_type count) noexcept
        {
            m_filled_size -= count;
            nullTerminatorCheck<t_null_term>();
        }

        [[nodiscard]] constexpr t_index_type count(const t_type& value) const noexcept
        {
            t_index_type count = 0;
            for (t_index_type i = 0; i < m_filled_size; i++)
            {
                if (ptr()[i] == value)
                    ++count;
            }
            return count;
        }

        template<class t_comparable_type>
        [[nodiscard]] constexpr bool contains(const t_comparable_type& value, t_index_type start, t_index_type size) const noexcept
        {
            for (t_index_type i = start; i < start + size; ++i)
            {
                if (ptr()[i] == value)
                    return true;
            }
            return false;
        }

        constexpr void addIndex() noexcept
        {
            createSpace<false>(1);
        }

        constexpr void addIndex(t_index_type location) noexcept
        {
            lib_assert(location <= m_filled_size, "Out of bounds add");
            createSpace<false>(1);
            memmove(ptr() + location + 1, ptr() + location, sizeof(t_type) * (m_filled_size - location - 1));
 
        }

        void removeIndex(t_index_type location) noexcept
        {
            lib_assert(location <= m_filled_size, "Out of bounds remove");
            memmove(ptr() + location, ptr() + location + 1, (m_filled_size - location - 1) * sizeof(t_type));
            m_filled_size--;
            nullTerminatorCheck<t_null_term>();
        }

        [[nodiscard]] sint04 compare(const BufferAllocator& allocator) const noexcept
        {
            return cast<sint04>(memcmp(ptr(), allocator.ptr(), sizeof(t_type) * getMin(allocator.filledSize(), m_filled_size)));
        }

        [[nodiscard]] sint04 compare(const BufferAllocator& allocator, t_index_type start, t_index_type end) const noexcept
        {
            return cast<sint04>(memcmp(&(ptr()[start]), &(allocator.ptr()[start]), sizeof(t_type) * getMin(allocator.filledSize(), m_filled_size, end)));
        }

        void swap(t_index_type index_a, t_index_type index_b) noexcept
        {
            std::swap(ptr()[index_a], ptr()[index_b]);
        }

        void clear() noexcept
        {
            m_filled_size = 0;
            nullTerminatorCheck<t_null_term>();
        }

        void setSize(t_index_type size) noexcept
        {
            allocationSizeCheck<false>(size);
            m_filled_size = size;
            nullTerminatorCheck<t_null_term>();
        }

        [[nodiscard]] t_type& get(t_index_type index) noexcept
        {
            return ptr()[index];
        }

        [[nodiscard]] const t_type& get(t_index_type index) const noexcept
        {
            return ptr()[index];
        }

        [[nodiscard]] constexpr decltype(auto) ptr() noexcept
        {
            if constexpr (t_aligned_size > 0)
                return  (t_type*)NDEVR_ASSUME_ALIGNED(t_aligned_size, m_buffer);
            else
                return m_buffer;
        }

        [[nodiscard]] constexpr decltype(auto) ptr() const noexcept
        {
            if constexpr (t_aligned_size > 0)
                return (const t_type*)NDEVR_ASSUME_ALIGNED(t_aligned_size, m_buffer);
            else
                return m_buffer;
        }

        [[nodiscard]] constexpr decltype(auto) begin() noexcept
        {
            return ptr();
        }

        [[nodiscard]] constexpr decltype(auto) begin() const noexcept
        {
            return ptr();
        }

        [[nodiscard]] constexpr decltype(auto) begin(t_index_type index) const noexcept
        {
            return &(ptr()[index]);
        }

        [[nodiscard]] constexpr decltype(auto) begin(t_index_type index) noexcept
        {
            return &(ptr()[index]);
        }

        [[nodiscard]] constexpr decltype(auto) end() noexcept
        {
            return ptr() ? &(ptr()[m_filled_size]) : ptr();
        }

        [[nodiscard]] constexpr decltype(auto) end() const noexcept
        {
            return ptr() ? &(ptr()[m_filled_size]) : ptr();
        }

        [[nodiscard]] constexpr decltype(auto) end(t_index_type index) noexcept
        {
            return &(get(m_filled_size - index));
        }

        [[nodiscard]] constexpr t_index_type capacity() const noexcept
        {
            return m_allocated_size;
        }

        [[nodiscard]] constexpr t_index_type filledSize() const noexcept
        {
            return m_filled_size;
        }

        [[nodiscard]] constexpr bool ownsMemory() const
        {
            return m_allocated_size != 0;
        }

        [[nodiscard]] constexpr size_t memSize() const noexcept
        {
            return m_filled_size * sizeof(t_type);
        }

        inline void resizeSpace(t_index_type new_size) noexcept
        {
            if (new_size == 0)
            {
                if (capacity() != 0)
                {
                #if NDEVR_HAS_ALIGNED_ALLOC
                    if constexpr(t_aligned_size > 0)
                        ndevr_aligned_free(ptr());
                    else
                #endif
                        free(ptr());
                }
                m_buffer = emptyPtr<t_null_term>();//this will provide the needed null termination without a malloc
            }
            else
            {
                if (capacity() == 0)
                {
                    if constexpr (t_allow_reference)
                    {
                        if (m_filled_size > 0)//we are referencing another memory location, so be sure to move value
                        {
                            auto referenced_data = ptr();
                        #if NDEVR_HAS_ALIGNED_ALLOC
                            if constexpr (t_aligned_size > 0)
                                m_buffer = (t_type*)ndevr_aligned_malloc(sizeof(t_type) * (t_null_term ? new_size + 1 : new_size), t_aligned_size);
                            else
                        #endif
                                m_buffer = (t_type*)malloc(sizeof(t_type) * (t_null_term ? new_size + 1 : new_size));
                            setAll<t_is_primitive>(referenced_data, 0, m_filled_size);
                        }
                        else
                        {
                        #if NDEVR_HAS_ALIGNED_ALLOC
                            if constexpr (t_aligned_size > 0)
                                m_buffer = (t_type*)ndevr_aligned_malloc(sizeof(t_type) * (t_null_term ? new_size + 1 : new_size), t_aligned_size);
                            else
                        #endif
                                m_buffer = (t_type*)malloc(sizeof(t_type) * (t_null_term ? new_size + 1 : new_size));
                        }
                    }
                    else
                    {
                    #if NDEVR_HAS_ALIGNED_ALLOC
                        if constexpr (t_aligned_size > 0)
                            m_buffer = (t_type*)ndevr_aligned_malloc(sizeof(t_type) * (t_null_term ? new_size + 1 : new_size), t_aligned_size);
                        else
                    #endif
                            m_buffer = (t_type*)malloc(sizeof(t_type) * (t_null_term ? new_size + 1 : new_size));
                        }
                }
                else
                {
                #if NDEVR_HAS_ALIGNED_ALLOC
                    if constexpr (t_aligned_size > 0)
                        m_buffer = (t_type*)ndevr_aligned_realloc(ptr()
                            , sizeof(t_type) * (t_null_term ? new_size + 1 : new_size)
                            , sizeof(t_type) * (t_null_term ? m_filled_size + 1 : m_filled_size), t_aligned_size);
                    else
                #endif
                        m_buffer = (t_type*)realloc(ptr(), sizeof(t_type) * (t_null_term ? new_size + 1 : new_size));
                }
                if (ptr() == nullptr)
                {
                    m_buffer = emptyPtr<t_null_term>();
                    lib_assert(false, "Unable to allocate buffer: Perhaps out of system memory!");
                }
            }
            m_allocated_size = new_size;
        }

        void setAll(const t_type& object, t_index_type offset, t_index_type size) noexcept
        {
            for (t_index_type i = offset; i < offset + size; i++)
                ptr()[i] = object;
        }

        template<bool is_primitive>
        void setAll(const t_type* src, t_index_type offset, t_index_type size) noexcept
        {
            if constexpr (is_primitive)
            {
                memmove(&ptr()[offset], src, size * sizeof(t_type));
            }
            else
            {
                for (t_index_type i = 0; i < size; i++)
                {
                    ptr()[i + offset] = src[i];
                }
            }
        }

        template<bool t_is_other_primitive, class t_other_index_type, bool t_other_null_term>
        void setAll(const BufferAllocator<t_type, t_aligned_size, t_is_other_primitive, t_other_index_type, t_other_null_term>& allocator, t_index_type offset, t_index_type other_offset, t_index_type size) noexcept
        {
            if constexpr (t_is_other_primitive)
            {
                memmove(&ptr()[offset], &(allocator.ptr()[other_offset]), size * sizeof(t_type));
            }
            else
            {
                for (t_index_type i = 0; i < size; i++)
                    ptr()[i + offset] = allocator.get(i + other_offset);
            }
        }

        template<class t_other_allocator>
        void setAllFromSource(const t_other_allocator& allocator, t_index_type offset, t_index_type other_offset, t_index_type size) noexcept
        {
            for (t_index_type i = 0; i < size; i++)
            {
                ptr()[i + offset] = allocator.get(i + other_offset);
            }
        }

        inline void autoSetCapacity(t_index_type size) noexcept
        {
            const t_index_type nc = NextCapacityBytes<t_index_type, sizeof(t_type)>(m_allocated_size, size);
            lib_assert(nc >= size, "Bad allocation prediciton");
            lib_assert(nc < Constant<uint04>::Max, "Bad allocation prediciton");
            resizeSpace(nc);
        }

        constexpr void reference(t_type* reference, t_index_type new_size)
        {
            resizeSpace(0);
            m_buffer = reference;
            m_filled_size = new_size;
        }

        template<bool t_auto_set_capacity>
        constexpr inline void allocationSizeCheck(t_index_type new_size) noexcept
        {
            if constexpr (t_auto_set_capacity)//We only 1, assume more to come shortly and allocate more space than required
            {
                if(new_size >= m_allocated_size)
                {
                    autoSetCapacity(new_size);
                }
            }
            else //We added more than 1, increase buffer only once for compaction
            {
                if (new_size == m_allocated_size + 1)
                {
                    autoSetCapacity(new_size);
                }
                else if (new_size > m_allocated_size)
                {
                    resizeSpace(new_size);
                }
            }
        }

        void removeAllIndex(t_index_type start, t_index_type end) noexcept
        {
            lib_assert(end <= m_filled_size, "Bad remove index");
            if (end == m_filled_size)
            {
                m_filled_size = start;
            }
            else
            {
                memmove(&ptr()[start], &ptr()[end], (m_filled_size - end) * sizeof(t_type));
                m_filled_size -= (end - start);
            }
            nullTerminatorCheck<t_null_term>();
        }

        template<class t_range_buffer>
        void removeAllIndices(const t_range_buffer& ranges) noexcept
        {
            t_index_type offset = 0;
            for (t_index_type i = 0; i < ranges.size(); i++)
            {
                auto range = ranges[i];
                t_index_type start = range.first;
                t_index_type end = range.second;
                t_index_type next = i == ranges.size() - 1 ? m_filled_size : ranges[i + 1].start;
                memmove(&ptr()[start], &ptr()[end], (next - (end + offset)) * sizeof(t_type));
                offset += (end - start);
            }
            m_filled_size -= offset;
            nullTerminatorCheck<t_null_term>();
        }

        template<bool t_is_null>
        inline void nullTerminatorCheck() noexcept
        {
            if constexpr (t_is_null)
            {
                if (capacity() != 0)
                    memset(&(ptr()[m_filled_size]), 0, sizeof(t_type));//Ensure null termination
            }
        }

        template<bool t_is_null>
        [[nodiscard]] decltype(auto) emptyPtr() const noexcept
        {
            if constexpr(t_is_null)
            {
            #if NDEVR_HAS_ALIGNED_ALLOC
                if constexpr (t_aligned_size > 0)
                {
                    alignas(t_aligned_size) static constexpr t_type null_object = {};
                    return const_cast<t_type*>(&null_object);
                }
                else
            #endif
                {
                    static constexpr t_type null_object = {};
                    return const_cast<t_type*>(&null_object);
                }
            }
            else
            {
                return nullptr;
            }
        }
    public:
        inline BufferAllocator& operator=(BufferAllocator&& value) noexcept
        {
            std::swap(value.m_buffer, m_buffer);
            std::swap(value.m_filled_size, m_filled_size);
            std::swap(value.m_allocated_size, m_allocated_size);
            return *this;
        }
    public:
        t_type* m_buffer;
        t_index_type m_filled_size; 
        t_index_type m_allocated_size; 
    };
}
#ifdef __clang__
    #pragma clang diagnostic pop
#endif