MemoryManager.h

Go to the documentation of this file.

/*--------------------------------------------------------------------------------------------
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 <typeinfo> 
#include <cstring>
#ifdef _WIN32
//#define NDEVR_LIB_SIZE_FUNCTION _msize
#endif
namespace NDEVR
{
 
    /**--------------------------------------------------------------------------------------------------
    \brief The default object allocator for Buffer.
    
    Author: Tyler Parke
    
    Date: 2017-11-19
    **/
    template<class t_index_type, bool is_primitive>
    class ObjectAllocatorT;
 
    /**--------------------------------------------------------------------------------------------------
    \brief The default object allocator for Buffers of primitive types such as doubles or ints
 
    Author: Tyler Parke
 
    Date: 2017-11-19
    **/
    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)
        {}
 
        /**--------------------------------------------------------------------------------------------------
        
        Deallocates.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Typeparams:
        t_primitive -  Type of the primitive.
        Parameters:
        buff -      [in,out] The buffer.
        start -     The start.
        size -      The size.
        **/
        template<class t_buffer_type, class t_type>
        static void Deallocate(t_buffer_type&, t_index_type, t_index_type)
        {}
 
        /**--------------------------------------------------------------------------------------------------
        
        Allocate element.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Typeparams:
        true -  Type of the true.
        Parameters:
        buff -      [in,out] The buffer.
        start -     The start.
        size -      The size.
        object -    The object.
        **/
        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)
        {
            buff.setAll(object, start, size);
        }
 
        /**--------------------------------------------------------------------------------------------------
        
        Allocate element.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Typeparams:
        true -  Type of the true.
        Parameters:
        buff -      [in,out] The buffer.
        index -     Zero-based index of the.
        object -    The object.
        **/
        template<class t_buffer_type, class t_type>
        static void AllocateElement(t_buffer_type& buff, t_index_type index, const t_type& object)
        {
            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)
        {
            buff.get(index) = std::forward<t_type>(object);
        }
    };
    
    /**--------------------------------------------------------------------------------------------------
    Class: ObjectAllocator
 
    \brief The default object allocator for Buffers of non-primitive types that have destructors or memory
    on the heap.
 
    Author: Tyler Parke
 
    Date: 2017-11-19
    **/
    template<class t_index_type>
    class ObjectAllocatorT<t_index_type, false>
    {
    public:
        /**--------------------------------------------------------------------------------------------------
                Allocates.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Typeparams:
        false -  Type of the false.
        Parameters:
        buff -      [in,out] The buffer.
        start -     The start.
        size -      The size.
        **/
        template<class t_buffer_type, class t_type>
        static void Allocate(t_buffer_type& buff, t_index_type start, t_index_type size)
        {
            for (t_index_type i = 0; i < size; i++)
            {
                new (&buff.get(i + start)) t_type();
            }
        }
        /**--------------------------------------------------------------------------------------------------
        
        Deallocates.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Typeparams:
        t_primitive -  Type of the primitive.
        Parameters:
        buff -      [in,out] The buffer.
        start -     The start.
        size -      The size.
        **/
        template<class t_buffer_type, class t_type>
        static void Deallocate(t_buffer_type& buff, t_index_type start, t_index_type size)
        {
            for (t_index_type i = 0; i < size; i++)
            {
                (&buff.get(i + start))->~t_type();
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
        
        Allocate element.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Typeparams:
        false -  Type of the false.
        Parameters:
        buff -      [in,out] The buffer.
        start -     The start.
        size -      The size.
        object -    The object.
        **/
        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)
        {
            for (t_index_type i = 0; i < size; i++)
            {
                new (&buff.get(i + start)) t_type(object);
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
        
        Allocate element.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Typeparams:
        false -  Type of the false.
        Parameters:
        buff -      [in,out] The buffer.
        index -     Zero-based index of the.
        object -    The object.
        **/
        template<class t_buffer_type, class t_type>
        static void AllocateElement(t_buffer_type& buff, t_index_type index, const t_type& object)
        {
            new (&buff.get(index)) t_type(object);
        }
        template<class t_buffer_type, class t_type>
        static void AllocateElement(t_buffer_type& buff, t_index_type index, t_type&& object)
        {
            new (&buff.get(index)) t_type(std::move(object));
        }
    };
 
    /**--------------------------------------------------------------------------------------------------
    Class: ObjectAllocator
    
    An object allocator.
    
    Author: Tyler Parke
    
    Date: 2017-11-19
    **/
    template<bool t_is_primitive, class t_index_type = uint04>
    class ObjectAllocator
    {
    public:
        
 
        /**--------------------------------------------------------------------------------------------------
                Allocates.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        buffer -    [in,out] The buffer.
        start -     The start.
        size -      The size.
        **/
        template<class t_type, class t_buffer_type>
        static void Allocate(t_buffer_type& buffer, t_index_type start, t_index_type size)
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template Allocate<t_buffer_type, t_type>(buffer, start, size);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Deallocates.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        buffer -    [in,out] The buffer.
        start -     The start.
        size -      The size.
        **/
        template<class t_type, class t_buffer_type>
        static void Deallocate(t_buffer_type& buffer, t_index_type start, t_index_type size)
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template Deallocate<t_buffer_type, t_type>(buffer, start, size);
        }
 
        /**--------------------------------------------------------------------------------------------------
                
        Allocate element.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        buffer -    [in,out] The buffer.
        start -     The start.
        size -      The size.
        object -    The object.
        **/
        template<class t_type, class t_buffer_type>
        static void AllocateElement(t_buffer_type& buffer, t_index_type start, t_index_type size, const t_type& object)
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template AllocateElement<t_buffer_type, t_type>(buffer, start, size, object);
        }
        template<class t_type, class t_buffer_type>
        static void AllocateElement(t_buffer_type& buffer, t_index_type start, t_index_type size, t_type& object)
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template AllocateElement<t_buffer_type, t_type>(buffer, start, size, object);
        }
        /**--------------------------------------------------------------------------------------------------
                
        Allocate element.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        buffer -    [in,out] The buffer.
        index -     Zero-based index of the.
        object -    The object.
        **/
        template<class t_type, class t_buffer_type>
        static void AllocateElement(t_buffer_type& buffer, t_index_type index, const t_type& object)
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template AllocateElement<t_buffer_type, t_type>(buffer, index, object);
        }
        template<class t_type, class t_buffer_type>
        static void AllocateElement(t_buffer_type& buffer, t_index_type index, t_type&& object)
        {
            ObjectAllocatorT<t_index_type, t_is_primitive>::template AllocateElement<t_buffer_type, t_type>(buffer, index, std::forward<t_type>(object));
        }
        /**--------------------------------------------------------------------------------------------------
                Query if this object is primitive.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        \returns True if primitive, false if not.
        **/
 
        static constexpr bool isPrimitive()
        {
            return t_is_primitive;
        }
    };
 
    /**--------------------------------------------------------------------------------------------------
    \brief Specific logic for reserving memory for a Buffer. When managed, and more memory is needed 
        memory is reserved using the ([Current Capacity] * 3) / 2) + 1
    **/
    template<class t_type, class t_index_type, bool t_null_term = false>
    class BufferAllocator
    {
    public:
        [[nodiscard]] static constexpr bool IsNullTerm() { return t_null_term; }
 
        constexpr explicit BufferAllocator()
            : m_buffer(emptyPtr<t_null_term>())
            , m_filled_size(0)
#ifndef NDEVR_LIB_SIZE_FUNCTION
            , m_allocated_size(0)
#endif
        {}
        constexpr BufferAllocator(BufferAllocator&& allocator) noexcept
            : m_buffer(emptyPtr<t_null_term>())
            , m_filled_size(0)
#ifndef NDEVR_LIB_SIZE_FUNCTION
            , m_allocated_size(0)
#endif
        {
            std::swap(allocator.m_buffer, m_buffer);
            std::swap(allocator.m_filled_size, m_filled_size);
#ifndef NDEVR_LIB_SIZE_FUNCTION
            std::swap(allocator.m_allocated_size, m_allocated_size);
#endif
        }
        ~BufferAllocator()
        {
            if (capacity() != 0)
                free(m_buffer);
        }
        template<bool t_managed>
        void createSpace(t_index_type size)
        {
            m_filled_size += size;
            allocationSizeCheck<t_managed>();
            nullTerminatorCheck<t_null_term>();
        }
        template<bool t_managed>
        void createSpace(t_index_type location, t_index_type size)
        {
            createSpace<t_managed>(size);
            memmove(begin() + location + size, begin() + location, sizeof(t_type) * (m_filled_size - (size + location)));
        }
        void addLast()
        {
            createSpace<false>(1);
        }
        void removeLast()
        {
            m_filled_size--;
            nullTerminatorCheck<t_null_term>();
        }
 
        [[nodiscard]] t_index_type count(const t_type& value) const
        {
            t_index_type count = 0;
            for (t_index_type i = 0; i < m_filled_size; i++)
            {
                if (m_buffer[i] == value)
                    ++count;
            }
            return count;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Adds index.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        **/
 
        void addIndex()
        {
            createSpace<false>(1);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Adds an index.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        location -  The location.
        **/
 
        void addIndex(t_index_type location)
        {
            lib_assert(location <= m_filled_size, "Out of bounds add");
            createSpace<false>(1);
            memmove(m_buffer + location + 1, m_buffer + location, sizeof(t_type) * (m_filled_size - location - 1));
            
        }
 
        /**--------------------------------------------------------------------------------------------------
                Removes the index described by location.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        location -  The location.
        **/
#ifdef __clang__
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wdynamic-class-memaccess"
#endif
        void removeIndex(t_index_type location)
        {
            lib_assert(location <= m_filled_size, "Out of bounds remove");
            memmove(m_buffer + location, m_buffer + location + 1, (m_filled_size - location - 1) * sizeof(t_type));
            m_filled_size--;
            nullTerminatorCheck<t_null_term>();
        }
#ifdef __clang__
    #pragma clang diagnostic pop
#endif
        /**--------------------------------------------------------------------------------------------------
                Compares this const BufferAllocator&amp; object to another to determine their relative
        ordering.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        allocator -  The constant buffer allocator&amp; to compare to this object.
        
        \returns Negative if 'allocator' is less than '', 0 if they are equal, or positive if it is
        greater.
        **/
 
        [[nodiscard]] sint04 compare(const BufferAllocator& allocator) const
        {
            return cast<sint04>(memcmp(m_buffer, allocator.m_buffer, sizeof(t_type) * getMin(allocator.filledSize(), m_filled_size)));
        }
 
        /**--------------------------------------------------------------------------------------------------
                
        Compares objects.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        allocator -  Constant buffer allocator&amp; to be compared.
        start -      Uint 04 to be compared.
        end -        Uint 04 to be compared.
        
        \returns Negative if 'allocator' is less than 'start', 0 if they are equal, or positive if it is
        greater.
        **/
 
        [[nodiscard]] sint04 compare(const BufferAllocator& allocator, t_index_type start, t_index_type end) const
        {
            return cast<sint04>(memcmp(&(m_buffer[start]), &(allocator.m_buffer[start]), sizeof(t_type) * getMin(allocator.filledSize(), m_filled_size, end)));
        }
 
        /**--------------------------------------------------------------------------------------------------
                Swaps.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        index_a -   The index a.
        index_b -   The index b.
        **/
 
        void swap(t_index_type index_a, t_index_type index_b)
        {
            std::swap(m_buffer[index_a], m_buffer[index_b]);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Clears this object to its blank/initial state.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        **/
 
        void clear()
        {
            m_filled_size = 0;
            nullTerminatorCheck<t_null_term>();
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets a size.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        size -  The size.
        **/
 
        void setSize(t_index_type size)
        {
            m_filled_size = size;
            allocationSizeCheck<false>();
            nullTerminatorCheck<t_null_term>();
        }
 
        /**--------------------------------------------------------------------------------------------------
                Gets a t type&amp; using the given index.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        index -  The index to get.
        
        \returns A reference to a t_type.
        **/
 
        t_type& get(t_index_type index)
        {
            return m_buffer[index];
        }
 
        /**--------------------------------------------------------------------------------------------------
                Gets a constant type&amp; using the given index.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        index -  The index to get.
        
        \returns A reference to a const t_type.
        **/
 
        [[nodiscard]] const t_type& get(t_index_type index) const
        {
            return m_buffer[index];
        }
 
        t_type* ptr()
        {
            return m_buffer;
        }
 
        [[nodiscard]] const t_type* ptr() const
        {
            return m_buffer;
        }
 
        [[nodiscard]] t_index_type memSize() const
        {
            return m_filled_size * sizeof(t_type);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Gets the begin.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        \returns Null if it fails, else a pointer to a t_type.
        **/
 
        [[nodiscard]] t_type* begin()
        {
            return m_buffer;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Gets the begin.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        \returns Null if it fails, else a pointer to a const t_type.
        **/
 
        [[nodiscard]] const t_type* begin() const
        {
            return m_buffer;
        }
 
        /**--------------------------------------------------------------------------------------------------
                Begins the given index.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        index -  Zero-based index of the.
        
        \returns Null if it fails, else a pointer to a t_type.
        **/
 
        [[nodiscard]] t_type* begin(t_index_type index) const
        {
            return &(m_buffer[index]);
        }
 
        /**--------------------------------------------------------------------------------------------------
                Gets the capacity of the buffer or total space allocated to it.
        
        Author: Tyler Parke
        
        Date: 2017-04-15
        
        \returns The capacity of the current allocated buffer.
        **/
        [[nodiscard]] t_index_type capacity() const
        {
#ifdef NDEVR_LIB_SIZE_FUNCTION
            if (m_buffer != emptyPtr<t_null_term>())
                if(t_null_term)
                    return cast<t_index_type>(NDEVR_LIB_SIZE_FUNCTION(m_buffer) / sizeof(t_type)) - 1;
                else
                    return cast<t_index_type>(NDEVR_LIB_SIZE_FUNCTION(m_buffer) / sizeof(t_type));
            else
                return 0;
#else
            return m_allocated_size;
#endif
        }
 
        /**--------------------------------------------------------------------------------------------------
                Gets the end.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        \returns Null if it fails, else a pointer to a t_type.
        **/
 
        [[nodiscard]] t_type* end()
        {
            if (capacity() == 0)
                return m_buffer;
            return &(get(m_filled_size));
        }
 
        /**--------------------------------------------------------------------------------------------------
                Gets the end.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        \returns Null if it fails, else a pointer to a const t_type.
        **/
 
        [[nodiscard]] const t_type* end() const
        {
            if (capacity() == 0)
                return m_buffer;
            return &(get(m_filled_size));
        }
 
        /**--------------------------------------------------------------------------------------------------
                Ends the given index.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        index -  Zero-based index of the.
        
        \returns Null if it fails, else a pointer to a t_type.
        **/
 
        t_type* end(t_index_type index)
        {
            return &(get(m_filled_size - index));
        }
 
        /**--------------------------------------------------------------------------------------------------
                Resize space.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        new_size -  Size of the new.
        **/
 
        inline void resizeSpace(t_index_type new_size)
        {
            if (new_size == 0)
            {
                if (capacity() != 0)
                    free(m_buffer);
                m_buffer = emptyPtr<t_null_term>();//this will provide the needed null termination without a malloc
            }
            else
            {
                if (capacity() == 0)
                    m_buffer = (t_type*)malloc(sizeof(t_type) * (t_null_term ? new_size + 1 : new_size));
                else
                    m_buffer = (t_type*)realloc(m_buffer, sizeof(t_type) * (t_null_term ? new_size + 1 : new_size));
                if (m_buffer == nullptr)
                {
                    m_buffer = emptyPtr<t_null_term>();
                    lib_assert(false, "Unable to allocate buffer: Perhaps out of system memory!");
                }
            }
#ifndef NDEVR_LIB_SIZE_FUNCTION
            m_allocated_size = new_size;
#endif
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets all.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        object -    The object.
        offset -    The offset.
        size -      The size.
        **/
 
        void setAll(const t_type& object, t_index_type offset, t_index_type size)
        {
            //if (sizeof(int) == sizeof(t_type))
            {
                //memset(&m_buffer[offset], *((int*)(&object)), size);
            }
            //else
            {
                for (t_index_type i = offset; i < offset + size; i++)
                {
                    m_buffer[i] = object;
                }
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
                
        Sets all.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Typeparams:
        is_primitive -  Type of the is primitive.
        Parameters:
        src -       Source for the.
        offset -    The offset.
        size -      The size.
        **/
 
        template<bool is_primitive>
        void setAll(const t_type* src, t_index_type offset, t_index_type size)
        {
            if constexpr (is_primitive)
            {
                memmove(&m_buffer[offset], src, size * sizeof(t_type));
            }
            else
            {
                for (t_index_type i = 0; i < size; i++)
                {
                    m_buffer[i + offset] = src[i];
                }
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
                Sets all.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Typeparams:
        true -  Type of the true.
        Parameters:
        src -       Source for the.
        offset -    The offset.
        size -      The size.
        **/
        /*template<>
        void setAll<true>(const t_type* src, t_index_type offset, t_index_type size)
        {
            memmove(&m_buffer[offset], src, size * sizeof(t_type));
        }*/
 
        /**--------------------------------------------------------------------------------------------------
                Sets all.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Typeparams:
        false -  Type of the false.
        Parameters:
        src -       Source for the.
        offset -    The offset.
        size -      The size.
        **/
        /*template<>
        void setAll<false>(const t_type* src, t_index_type offset, t_index_type size)
        {
            for (t_index_type i = 0; i < size; i++)
            {
                m_buffer[i + offset] = src[i];
            }
        }*/
 
        /**--------------------------------------------------------------------------------------------------
                
        Sets all.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Typeparams:
        is_primitive -  Type of the is primitive.
        Parameters:
        allocator -     The allocator.
        offset -        The offset.
        other_offset -  The other offset.
        size -          The size.
        **/
 
        template<bool is_primitive, class t_other_index_type, bool t_other_null_term>
        void setAll(const BufferAllocator<t_type, t_other_index_type, t_other_null_term>& allocator, t_index_type offset, t_index_type other_offset, t_index_type size)
        {
            if constexpr (is_primitive)
            {
                memmove(&m_buffer[offset], &(allocator.m_buffer[other_offset]), size * sizeof(t_type));
            }
            else
            {
                for (t_index_type i = 0; i < size; i++)
                {
                    m_buffer[i + offset] = allocator.get(i + other_offset);
                }
            }
        }
        
        /**--------------------------------------------------------------------------------------------------
                
        Sets all from source.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        allocator -     The allocator.
        offset -        The offset.
        other_offset -  The other offset.
        size -          The size.
        **/
        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)
        {
            for (t_index_type i = 0; i < size; i++)
            {
                m_buffer[i + offset] = allocator.get(i + other_offset);
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
                Allocation size check.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        **/
        template<bool t_managed>
        inline void allocationSizeCheck()
        {
            if constexpr (t_managed)//We only 1, assume more to come shortly and allocate more space than required
            {
                if(m_filled_size >= capacity())
                {
                    lib_assert((cast<uint08>(m_filled_size) * 3U) / 2 < cast<uint08>(Constant<t_index_type>::Max), "Buffer overflow");
                    resizeSpace(cast<t_index_type>((cast<uint08>(m_filled_size) * 3) / 2) + 1);
                }
            }
            else //We added more than 1, increase buffer only once for compaction
            {
                if (m_filled_size == capacity() + 1)
                {
                    lib_assert(cast<uint08>(m_filled_size) < cast<uint08>(Constant<t_index_type>::Max), "Buffer overflow");
                    resizeSpace(cast<t_index_type>((cast<uint08>(capacity()) * 3) / 2) + 1);
                }
                else if (m_filled_size > capacity())
                {
                    resizeSpace(m_filled_size);
                }
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
                Removes all index.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        start -     The start.
        end -       The end.
        **/
 
        void removeAllIndex(t_index_type start, t_index_type end)
        {
            if (end == m_filled_size)
            {
                m_filled_size = start;
            }
            else
            {
                memmove(&m_buffer[start], &m_buffer[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)
        {
            uint04 offset = 0;
            for (uint04 i = 0; i < ranges.size(); i++)
            {
                auto range = ranges[i];
                t_index_type start = range.first;
                t_index_type end = range.second;
                uint04 next = i == ranges.size() - 1 ? m_filled_size : ranges[i + 1].start;
                memmove(&m_buffer[start], &m_buffer[end], (next - (end + offset)) * sizeof(t_type));
                offset += (end - start);
            }
            m_filled_size -= offset;
            nullTerminatorCheck<t_null_term>();
        }
 
        /**--------------------------------------------------------------------------------------------------
                Null terminator check.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Typeparams:
        t_is_null -  Type of the is null.
        **/
 
        template<bool t_is_null>
        inline void nullTerminatorCheck()
        {
            if constexpr (t_is_null)
            {
                if (capacity() != 0)
                    memset(&(m_buffer[m_filled_size]), 0, sizeof(t_type));//Ensure null termination
            }
        }
 
        /*template<>
        inline void nullTerminatorCheck<true>()
        {
            if (capacity() != 0)
                memset(&(m_buffer[m_filled_size]), 0, sizeof(t_type));//Ensure null termination
        }
        template<>
 
        inline void nullTerminatorCheck<false>() {}*/
 
 
        /**--------------------------------------------------------------------------------------------------
                Null terminator check.
 
        Author: Tyler Parke
 
        Date: 2017-11-19
 
        Typeparams:
        t_is_null -  Type of the is null.
        **/
 
        template<bool t_is_null>
        [[nodiscard]] t_type* emptyPtr() const
        {
            if constexpr(t_is_null)
            {
                static constexpr t_type null_object = {};
                return const_cast<t_type*>(&null_object);
            }
            else
            {
                return nullptr;
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
                Filled size.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        \returns An t_index_type.
        **/
 
        [[nodiscard]] constexpr t_index_type filledSize() const
        {
            return m_filled_size;
        }
    public:
 
        /**--------------------------------------------------------------------------------------------------
                Move assignment operator.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        value -  [in,out] The value.
        
        \returns A shallow copy of this object.
        **/
 
        inline BufferAllocator& operator=(BufferAllocator&& value) noexcept
        {
            std::swap(value.m_buffer, m_buffer);
            std::swap(value.m_filled_size, m_filled_size);
#ifndef NDEVR_LIB_SIZE_FUNCTION
            std::swap(value.m_allocated_size, m_allocated_size);
#endif
            return *this;
        }
    public:
        /** The buffer that stores the actual data. */
        t_type* m_buffer;
        t_index_type  m_filled_size;
#ifndef NDEVR_LIB_SIZE_FUNCTION
        t_index_type  m_allocated_size;
#endif
    };
}