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: Parke
Namespace that wraps all Logic created by Tyler Parke
 *-----------------------------------------------------------------------------------------------**/
namespace NDEVR
{
 
    /**--------------------------------------------------------------------------------------------------
    Class: _ObjectAllocator
    
    \brief The default object allocator for Buffer.
    
    Author: Tyler Parke
    
    Date: 2017-11-19
     *-----------------------------------------------------------------------------------------------**/
    template<class t_index_type, bool is_primitive>
    class _ObjectAllocatorT;
 
    /**--------------------------------------------------------------------------------------------------
    Class: _ObjectAllocator
 
    \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)
        {}
 
        /**--------------------------------------------------------------------------------------------------
        Fn: template<bool t_primitive> static void _ObjectAllocator::_deallocate(t_buffer_type& buff,
        t_index_type start, t_index_type size);
 
        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)
        {}
 
        /**--------------------------------------------------------------------------------------------------
        Fn: static void _ObjectAllocator::_allocateElement<true>(t_buffer_type& buff, t_index_type start,
        t_index_type size, const t_type& object)
 
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: static void _ObjectAllocator::_allocateElement<true>(t_buffer_type& buff, t_index_type index,
        const t_type& object)
 
        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:
        /**--------------------------------------------------------------------------------------------------
        Fn: static void _ObjectAllocator::_allocate<false>(t_buffer_type& buff, t_index_type start, t_index_type size)
 
        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();
            }
        }
        /**--------------------------------------------------------------------------------------------------
        Fn: template<bool t_primitive> static void _ObjectAllocator::_deallocate(t_buffer_type& buff,
        t_index_type start, t_index_type size);
 
        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();
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: static void _ObjectAllocator::_allocateElement<false>(t_buffer_type& buff, t_index_type start,
        t_index_type size, const t_type& object)
 
        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);
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: static void _ObjectAllocator::_allocateElement<false>(t_buffer_type& buff, t_index_type index,
        const 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:
        
 
        /**--------------------------------------------------------------------------------------------------
        Fn: static void ObjectAllocator::allocate(t_buffer_type& buffer, t_index_type start, t_index_type size)
        
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: static void ObjectAllocator::deallocate(t_buffer_type& buffer, t_index_type start, t_index_type 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);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: static void ObjectAllocator::allocateElement(t_buffer_type& buffer, t_index_type start, t_index_type size,
        const t_type& object)
        
        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);
        }
        /**--------------------------------------------------------------------------------------------------
        Fn: static void ObjectAllocator::allocateElement(t_buffer_type& buffer, t_index_type index,
        const t_type& 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));
        }
        /**--------------------------------------------------------------------------------------------------
        Fn: static constexpr bool ObjectAllocator::isPrimitive()
        
        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;
        }
    };
 
    /**--------------------------------------------------------------------------------------------------
    Class: BufferAllocator
    
    A buffer allocator.
    
    Author: Tyler Parke
    
    Date: 2017-11-19
     *-----------------------------------------------------------------------------------------------**/
    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
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: BufferAllocator::~BufferAllocator()
        
        Destructor.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
         *-----------------------------------------------------------------------------------------------**/
 
        ~BufferAllocator()
        {
            if (capacity() != 0)
                free(m_buffer);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::createSpace(t_index_type size)
        
        Creates a space.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        size -  The size.
         *-----------------------------------------------------------------------------------------------**/
        template<bool t_managed>
        void createSpace(t_index_type size)
        {
            m_filled_size += size;
            allocationSizeCheck<t_managed>();
            nullTerminatorCheck<t_null_term>();
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::createSpace(t_index_type location, t_index_type size)
        
        Creates a space.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        location -  The location.
        size -      The size.
         *-----------------------------------------------------------------------------------------------**/
        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)));
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::addLast()
        
        Adds last.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
         *-----------------------------------------------------------------------------------------------**/
 
        void addLast()
        {
            createSpace<false>(1);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::removeLast()
        
        Removes the last.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
         *-----------------------------------------------------------------------------------------------**/
 
        void removeLast()
        {
            m_filled_size--;
            nullTerminatorCheck<t_null_term>();
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: t_index_type BufferAllocator::count(const t_type& value) const
        
        Counts the given value.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
        
        Parameters:
        value -  The value.
        
        Returns: An t_index_type.
         *-----------------------------------------------------------------------------------------------**/
 
        [[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;
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::addIndex()
        
        Adds index.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
         *-----------------------------------------------------------------------------------------------**/
 
        void addIndex()
        {
            createSpace<false>(1);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::addIndex(t_index_type location)
        
        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));
            
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::removeIndex(t_index_type location)
        
        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
        /**--------------------------------------------------------------------------------------------------
        Fn: sint04 BufferAllocator::compare(const BufferAllocator& allocator) const
        
        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)));
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: sint04 BufferAllocator::compare(const BufferAllocator& allocator, t_index_type start,
        t_index_type end) const
        
        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)));
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::swap(t_index_type index_a, t_index_type index_b)
        
        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]);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::clear()
        
        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>();
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::setSize(t_index_type size)
        
        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>();
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: t_type& BufferAllocator::get(t_index_type index)
        
        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];
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: const t_type& BufferAllocator::get(t_index_type index) const
        
        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);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: t_type* BufferAllocator::begin()
        
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: const t_type* BufferAllocator::begin() const
        
        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;
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: t_type* BufferAllocator::begin(t_index_type index) const
        
        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]);
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: t_index_type BufferAllocator::capacity() const
        
        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
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: t_type* BufferAllocator::end()
        
        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));
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: const t_type* BufferAllocator::end() const
        
        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));
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: t_type* BufferAllocator::end(t_index_type index)
        
        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));
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: inline void BufferAllocator::resizeSpace(t_index_type new_size)
        
        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
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::setAll(const t_type& object, t_index_type offset, t_index_type size)
        
        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;
                }
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: template<bool is_primitive> void BufferAllocator::setAll(const t_type* src, t_index_type offset,
        t_index_type size);
        
        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];
                }
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::setAll<true>(const t_type* src, t_index_type offset, t_index_type size)
        
        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));
        }*/
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::setAll<false>(const t_type* src, t_index_type offset, t_index_type size)
        
        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];
            }
        }*/
 
        /**--------------------------------------------------------------------------------------------------
        Fn: template<bool is_primitive> void BufferAllocator::setAll(const BufferAllocator& allocator,
        t_index_type offset, t_index_type other_offset, t_index_type size);
        
        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);
                }
            }
        }
        
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::setAllFromSource(const t_other_allocator& allocator, t_index_type offset,
        t_index_type other_offset, t_index_type size)
        
        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);
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: inline void BufferAllocator::allocationSizeCheck()
        
        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);
                }
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: void BufferAllocator::removeAllIndex(t_index_type start, t_index_type end)
        
        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>();
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: template<bool t_is_null> inline void BufferAllocator::nullTerminatorCheck();
        
        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>() {}*/
 
 
        /**--------------------------------------------------------------------------------------------------
        Fn: template<bool t_is_null> inline void BufferAllocator::nullTerminatorCheck();
 
        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;
            }
        }
 
        /**--------------------------------------------------------------------------------------------------
        Fn: t_index_type BufferAllocator::filledSize() const
        
        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:
 
        /**--------------------------------------------------------------------------------------------------
        Fn: inline BufferAllocator& BufferAllocator::operator=(BufferAllocator&& value)
        
        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
    };
}