Buffer.hpp

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: Buffer
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include <NDEVR/BaseValues.h>
#include <NDEVR/LibAssert.h>
#include <NDEVR/ObjectAllocator.h>
#include <NDEVR/BufferAllocator.h>
#include <NDEVR/ObjectInfo.h>
#include <initializer_list>
#include <utility>
#include <functional>
namespace NDEVR
{
    /**--------------------------------------------------------------------------------------------------
    \brief The equivelent of std::vector but with a bit more control. The basic array unit of the library.
 
    t_type = what the buffer holds
    t_index_type = the index reference (default uint04 but can be made uint08 for large buffer support)
    t_memory_allocator = The object in charge of object allocation when creating space
    t_memory_manager = The thing that actually stores the memory
    Author: Tyler Parke
 
    Date: 2017-11-19
    */
    template<class t_type, class t_index_type = uint04, class t_memory_allocator = ObjectAllocator<ObjectInfo<t_type>::Primitive, t_index_type>, class t_memory_manager = BufferAllocator<t_type, t_index_type, false>>
    class Buffer : BufferBase
    {
    public:
        /**
        Creates an empty buffer
         **/
        constexpr Buffer()
            : m_memory_interface()
        {}
 
        /**
        Optimized copy consturctor
         **/
        constexpr Buffer(const Buffer& buffer)
            : m_memory_interface()
        {
            addAll(buffer);
        }
 
        /**
        Optimized move constructor
         **/
        constexpr Buffer(Buffer&& buffer) noexcept
            : m_memory_interface(std::move(buffer.m_memory_interface))
        {}
        
        /**
        Constuctor that reserves space. Note that the buffer will still be empty, but allocation
            will be more efficient using add or inserts.
         **/
        explicit Buffer(t_index_type size)
            : m_memory_interface()
        {
            m_memory_interface.resizeSpace(size);
        }
 
        /**
        Constuctor that allows for an a start pointer, and size, and adds all elements to the buffer
         **/
        explicit Buffer(const t_type* buffer, t_index_type size)
            : m_memory_interface()
        {
            if (size != 0)
                addAll(buffer, size);
        }
 
        /**
        Constuctor that allows for a set size, and then fills the buffer with the specified object
         **/
        Buffer(t_index_type size, const t_type& fill_object)
            : m_memory_interface()
        {
            m_memory_interface.template createSpace<false>(size);
            t_memory_allocator::template AllocateElement<t_type>(m_memory_interface, 0, size, fill_object);
        }
 
        /**
        Constuctor that allows for an initializer list, allowing { and } to be used
         **/
        Buffer(std::initializer_list<t_type> l)
            : m_memory_interface()
        {
            addAll(l.begin(), cast<t_index_type>(l.size()));
        }
 
        /**
        Constuctor that allows for an iterator begin and end.
         **/
        template<class t_iterator>
        Buffer(const t_iterator& begin, const t_iterator& end)
            : m_memory_interface()
        {
            setSize(cast<t_index_type>(std::distance(begin, end)));
            uint04 index = 0;
            for (auto iter = begin; iter != end; iter++)
            {
                get(index++) = *iter;
            }
        }
 
        /**
                Destructor.
        
        Author: Tyler Parke
        
        Date: 2017-11-19
         **/
 
        ~Buffer()
        {
            t_memory_allocator::template Deallocate<t_type>(m_memory_interface, 0, size());
        }
 
        /**
        \brief Gets the first location of type* in the array.
        \return A const pointer to the beginning of the array.
         **/
        operator const t_type* () const
        {
            return begin();
        }
 
        /**
        \brief Gets the first location of type* in the array.
        \return A const pointer to the beginning of the array.
         **/
        operator t_type* ()
        {
            return begin();
        }
 
        /**
        \brief Gets a copy of this buffer, with filled objects t_other_type, where all objects are created using 
            the contents of this buffer.
        \return a copy of the buffer.
         **/
        template<class t_other_type, class t_other_index_type = uint04, class t_other_memory_allocator = ObjectAllocator<ObjectInfo<t_other_type>::Primitive>, class t_other_memory_manager = BufferAllocator<t_other_type, t_index_type, false>>
        [[nodiscard]] Buffer<t_other_type, t_other_index_type, t_other_memory_allocator, t_other_memory_manager> getAs() const
        {
            Buffer<t_other_type, t_other_memory_allocator, t_other_memory_manager> other(size());
            for (t_index_type i = 0; i < size(); i++)
            {
                other.add(t_other_type(get(i)));
            }
            return other;
        }
 
        /**
        \brief Adds object to the end of the buffer.
        \param[in] object The object to add to the end.
         **/
        void add(t_type&& object)
        {
            m_memory_interface.addIndex();
            t_memory_allocator::template AllocateElement(m_memory_interface, size() - 1, std::move(object));
        }
        /**
        \brief Adds object to the end of the buffer.
        \param[in] object The object to add to the end.
         **/
        void add(const t_type& object)
        {
            m_memory_interface.addIndex();
            t_memory_allocator::template AllocateElement(m_memory_interface, size() - 1, object);
        }
 
        /**
        \brief Adds and object to a specific location. Equivelent to insert
        \param[in] location The index where the object should be inserted.
        \param[in] object The object to add to the buffer at the specified location.
         **/
        void add(t_index_type location, const t_type& object)
        {
            m_memory_interface.addIndex(location);
            t_memory_allocator::template AllocateElement(m_memory_interface, location, object);
        }
        /**
        \brief Adds an object to a specific location. Equivelent to insert.
        \param[in] location The index where the object should be inserted.
        \param[in] object The object to add to the buffer at the specified location.
         **/
        void add(t_index_type location, t_type&& object)
        {
            m_memory_interface.addIndex(location);
            t_memory_allocator::template AllocateElement(m_memory_interface, location, std::move(object));
        }
 
        /**
        \brief Adds an object to a specific location.
        \param[in] location The index where the object should be inserted.
        \param[in] object The object to add to the buffer at the specified location.
         **/
        void insert(t_index_type location, const t_type& object)
        {
            m_memory_interface.addIndex(location);
            t_memory_allocator::template AllocateElement(m_memory_interface, location, object);
        }
        /**
        \brief Adds an object to a specific location.
        \param[in] location The index where the object should be inserted.
        \param[in] object The object to add to the buffer at the specified location.
         **/
        void insert(t_index_type location, t_type&& object)
        {
            m_memory_interface.addIndex(location);
            t_memory_allocator::template AllocateElement(m_memory_interface, location, std::move(object));
        }
        template<class t_other_memory_allocator, class t_other_index_type, class t_other_memory_manager>
        void addAll(const Buffer<t_type, t_other_index_type, t_other_memory_allocator, t_other_memory_manager>& buffer)
        {
            t_index_type offset = size();
            m_memory_interface.template createSpace<false>(buffer.size());
            if constexpr (t_memory_allocator::isPrimitive())
            {
                m_memory_interface.template setAll<true>(buffer.memoryInterface(), offset, 0, buffer.size());
            }
            else
            {
                for (t_index_type i = 0; i < buffer.size(); i++)
                    t_memory_allocator::template AllocateElement(m_memory_interface, i + offset, buffer[i]);
            }
        }
        void addAll(const t_type* buffer, t_index_type buffer_size)
        {
            t_index_type offset = size();
            m_memory_interface.template createSpace<false>(buffer_size);
            if constexpr (t_memory_allocator::isPrimitive())
            {
                m_memory_interface.template setAll<true>(buffer, offset, buffer_size);
            }
            else
            {
                for (t_index_type i = 0; i < buffer_size; i++)
                    t_memory_allocator::AllocateElement(m_memory_interface, i + offset, buffer[i]);
            }
        }
        void addAll(const t_type* buffer)
        {
            t_index_type size = 0;
            int loc = 0;
            for (;;)
            {
                if (memcmp(&buffer[size], &loc, sizeof(t_type)) == 0)
                    break;
                ++size;
            }
            addAll(buffer, size);
        }
        void insert(t_index_type offset, const Buffer& buffer)
        {
            m_memory_interface.template createSpace<false>(offset, buffer.size());
            if constexpr (t_memory_allocator::isPrimitive())
            {
                m_memory_interface.template setAll<true>(buffer.m_memory_interface, offset, 0, buffer.size());
            }
            else
            {
                for (t_index_type i = 0; i < buffer.size(); i++)
                    t_memory_allocator::AllocateElement(m_memory_interface, i + offset, buffer[i]);
            }
        }
        void replaceIndexRange(t_index_type offset, t_index_type replace_size, const Buffer& buffer)
        {
            lib_assert(offset + replace_size <= size(), "end > size in buffer replace");
            if (replace_size < buffer.size())
            {
                t_index_type size_dff = buffer.size() - replace_size;
                m_memory_interface.template createSpace<false>(offset, size_dff);
                if constexpr (!t_memory_allocator::isPrimitive())
                {
                    for (t_index_type i = 0; i < size_dff; i++)
                        t_memory_allocator::AllocateElement(m_memory_interface, i + offset, buffer[i]);
                }
            }
            else if (replace_size > buffer.size())
            {
                removeAllIndex(offset, offset + (replace_size - buffer.size()));
            }
            setAll(buffer, offset, buffer.size());
        }
 
        
#ifdef __clang__
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Wunused-value"//Weird error in clang thinks expression result not used
#endif
        /**
        \brief Inserts data into the buffer.
        \param[in] offset The offset where the data should be inserted.
        \param[in] buffer The buffer of objects to insert.
        \param[in] buffer_size number of elements of the data to insert.
         **/
        void insert(t_index_type offset, const t_type* const buffer, t_index_type buffer_size)
        {
            m_memory_interface.template createSpace<false>(offset, buffer_size);
            if constexpr (t_memory_allocator::isPrimitive())
            {
                m_memory_interface.template setAll<true>(buffer, offset, buffer_size);
            }
            else
            {
                for (t_index_type i = 0; i < buffer_size; i++)
                    t_memory_allocator::AllocateElement(m_memory_interface, i + offset, buffer[i]);
            }
        }
#ifdef __clang__
    #pragma clang diagnostic pop
#endif
        /**
        \brief Inserts data into the buffer, assumed to be null terminated.
        \param[in] location The offset where the data should be inserted.
        \param[in] buffer The buffer.
         **/
        void insert(const t_index_type location, const t_type* buffer)
        {
            t_index_type size = 0;
            int loc = 0;
            for (;;)
            {
                if (memcmp(&buffer[size], &loc, sizeof(t_type)) == 0)
                    break;
                ++size;
            }
            insert(location, buffer, size);
        }
 
        /**
        \brief Adds a space to the end of the buffer.
        \param[in] space_to_add The number of elements to add.
         **/
        template<bool t_managed>
        void addSpace(t_index_type space_to_add)
        {
            const t_index_type offset = size();
            m_memory_interface.template createSpace<t_managed>(space_to_add);
            t_memory_allocator::template  Allocate<t_type>(m_memory_interface, offset, size() - offset);
        }
        template<bool t_managed = false>
        void addAndFillSpace(t_index_type space_to_add, const t_type& fill_object)
        {
            const t_index_type offset = size();
            m_memory_interface.template createSpace<t_managed>(space_to_add);
            t_memory_allocator::template AllocateElement<t_type>(m_memory_interface, offset, size() - offset, fill_object);
        }
        template<bool t_managed>
        void addSpace(t_index_type location, t_index_type size)
        {
            lib_assert(location <= this->size(), "Tried to insert into a bad location");
            m_memory_interface.template createSpace<t_managed>(location, size);
 
            t_memory_allocator::template Allocate<t_type>(m_memory_interface, location, size);
        }
        [[nodiscard]] decltype(auto) ptr()
        {
            return m_memory_interface.ptr();
        }
 
        [[nodiscard]] decltype(auto) ptr() const
        {
            return m_memory_interface.ptr();
        }
 
        [[nodiscard]] t_index_type memSize() const
        {
            return m_memory_interface.memSize();
        }
 
        [[nodiscard]] decltype(auto) begin()
        {
            return m_memory_interface.begin();
        }
 
        [[nodiscard]] decltype(auto) begin() const
        {
            return m_memory_interface.begin();
        }
 
        [[nodiscard]] decltype(auto) begin(t_index_type index) const
        {
            return m_memory_interface.begin(index);
        }
 
        [[nodiscard]] t_index_type capacity() const
        {
            return m_memory_interface.capacity();
        }
 
        void clear()
        {
            t_memory_allocator::template Deallocate<t_type>(m_memory_interface, 0U, size());
            m_memory_interface.clear();
        }
        void clear(t_index_type new_capacity)
        {
            t_memory_allocator::template Deallocate<t_type>(m_memory_interface, 0, size());
            m_memory_interface.clear();
            ensureCapacity(new_capacity, true, true);
        }
 
        /**
        \brief Compares this Buffer to another to determine their relative ordering.
        \param[in] value The Buffer to compare to this object.
        \returns Negative if 'value' is less than '', 0 if they are equal, or positive if it is greater.
         **/
        [[nodiscard]] sint04 compare(const Buffer& value) const
        {
            sint04 cmp_value = m_memory_interface.compare(value.m_memory_interface);
            if (cmp_value != 0)
                return cmp_value;
            else if (value.size() > size())
                return -1;
            else if (value.size() < size())
                return  1;
            else
                return  0;
        }
        [[nodiscard]] sint04 compare(const Buffer& value, t_index_type start, t_index_type end) const
        {
            sint04 cmp_value = m_memory_interface.compare(value.m_memory_interface, start, end);
            if (cmp_value != 0)
                return cmp_value;
            else if (value.size() == size())
                return  0;
            else if (end > size())
                return -1;
            else if (end > value.size())
                return  1;
            else
                return  0;
        }
        [[nodiscard]] bool contains(const t_type& element) const
        {
            for (t_index_type i = 0; i < size(); ++i)
            {
                if (get(i) == element)
                    return true;
            }
            return false;
        }
        [[nodiscard]] bool contains(const t_type& element, const std::function<bool(const t_type&, const t_type&)>& equal_function) const
        {
            for (uint04 i = 0; i < size(); ++i)
            {
                if (equal_function(get(i), element))
                    return true;
            }
            return false;
        }
        [[nodiscard]] bool contains(const t_type& element, t_index_type start) const
        {
            lib_assert(start < size(), "buffer contains using bad start value");
            for (t_index_type i = start; i < size(); ++i)
            {
                if (get(i) == element)
                    return true;
            }
            return false;
        }
        [[nodiscard]] bool contains(const t_type& element, t_index_type start, t_index_type search_size) const
        {
            lib_assert(search_size + start <= size(), "buffer contains using bad start value");
            for (t_index_type i = start; i < start + search_size; ++i)
            {
                if (get(i) == element)
                    return true;
            }
            return false;
        }
        [[nodiscard]] t_index_type count(const t_type& element) const
        {
            return m_memory_interface.count(element);
        }
        decltype(auto) end()
        {
            return m_memory_interface.end();
        }
        [[nodiscard]] decltype(auto) end() const
        {
            return m_memory_interface.end();
        }
        decltype(auto) end(t_index_type index)
        {
            return m_memory_interface.end(index);
        }
        void ensureCapacity(t_index_type new_capacity, bool ensure_not_greater = false, bool ensure_not_less = true)
        {
            if (new_capacity == capacity())
                return;
            if (new_capacity > capacity())
            {
                if (ensure_not_less)
                    m_memory_interface.resizeSpace(new_capacity);
            }
            else if (ensure_not_greater)
            {
                lib_assert(new_capacity >= size(), "Array can't have capacity less than size");
                m_memory_interface.resizeSpace(new_capacity);
            }
        }
        [[nodiscard]] bool equals(const Buffer& buffer) const
        {
            if (size() == buffer.size())
                return _equals<t_memory_allocator::isPrimitive()>(buffer);
            else
                return false;
        }
        [[nodiscard]] decltype(auto) get(t_index_type index)
        {
            lib_assert(index < size(), "Buffer out of bounds");
            return m_memory_interface.get(index);
        }
        [[nodiscard]] decltype(auto) get(t_index_type index) const
        {
            lib_assert(index < size(), "Buffer out of bounds");
            return m_memory_interface.get(index);
        }
 
 
        [[nodiscard]] Buffer getAll(t_index_type start, t_index_type size)
        {
            Buffer buff(size);
            buff.addAll(begin(start), size);
            return buff;
        }
        [[nodiscard]] t_index_type indexOf(const t_type& element) const
        {
            for (t_index_type i = 0; i < size(); ++i)
            {
                if (get(i) == element) return i;
            }
            return Constant<t_index_type>::Invalid;
        }
        [[nodiscard]] t_index_type indexOf(const t_type& element, t_index_type start_pos) const
        {
            for (t_index_type i = start_pos; i < size(); ++i)
            {
                if (get(i) == element) return i;
            }
            return Constant<t_index_type>::Invalid;
        }
        [[nodiscard]] t_index_type indexOf(const t_type& element, t_index_type start_pos, t_index_type search_size) const
        {
            lib_assert(search_size + start_pos <= size(), "bad index of in equation");
            for (t_index_type i = start_pos; i < start_pos + search_size; ++i)
            {
                if (get(i) == element) return i;
            }
            return Constant<t_index_type>::Invalid;
        }
        [[nodiscard]] bool isEmpty() const
        {
            return size() == 0;
        }
        [[nodiscard]] decltype(auto) last()
        {
            lib_assert(size() != 0, "Cannot get last: out of bounds");
            return get(size() - 1);
        }
        [[nodiscard]] decltype(auto) last() const
        {
            lib_assert(size() != 0, "Cannot get last: out of bounds");
            return get(size() - 1);
        }
        [[nodiscard]] t_index_type lastIndexOf(const t_type& element) const
        {
            for (t_index_type i = size() - 1; i < size(); --i)
            {
                if (get(i) == element) return i;
            }
            return Constant<t_index_type>::Invalid;
        }
        void removeIndex(t_index_type location)
        {
            lib_assert(location < size(), "Out of bounds remove");
            t_memory_allocator::template Deallocate<t_type>(m_memory_interface, location, 1);
            m_memory_interface.removeIndex(location);
        }
        void removeIndexBackSwap(t_index_type location)
        {
            swapIndices(location, size() - 1);//swap with back
            removeLast();//remove back
        }
        bool removeElement(const t_type& element)
        {
            for (t_index_type i = size() - 1; !IsInvalid(i); --i)//start at last element as less expensive to removeRows
            {
                if (get(i) == element)
                {
                    removeIndex(i);
                    return true;
                }
            }
            return false;
        }
        void removeLast()
        {
            lib_assert(size() > 0, "Cannot remove last from empty buffer");
            t_memory_allocator::template Deallocate<t_type>(m_memory_interface, size() - 1, 1);
            m_memory_interface.removeLast();
        }
 
        /**
        \brief Removes all unordered described by object. This function does not preserve the order of the buffer.
        \warning This function does not preserve the order of the buffer.
        \param[in] object The object to remove.
         **/
        void removeAllUnordered(const t_type& object)
        {
            t_index_type end = size();
            for (t_index_type i = 0; i < end; i++)
            {
                if (get(i) == object)
                {
                    swapIndices(i, --end);
                    --i;
                }
            }
            if (end != size())
                removeAllIndex(end, size());
        }
 
        /**
        \brief Removes all items based on the functor. The functor should return true if the
            item is deleted or false if the item should stay in the array. Faster function then removeAllOrdered but
            order is not preserved.
        \warning This function does not preserve the order of the buffer.
        \param[in] functor A functor that takes a value and returns true if value is to be removed, or false otherwise.
         **/
        template<class t_functor>
        void removeAllUnordered(const t_functor& functor)
        {
            t_index_type end = size();
            for (t_index_type i = 0; i < end; i++)
            {
                if (functor(get(i)))
                {
                    swapIndices(i--, --end);
                }
            }
            if (end != size())
                removeAllIndex(end, size());
        }
 
        /**
        \brief Removes all instances of the object. Function is slower than removeAllUnordered but
            order is preserved.
        \param[in] object The object.
         **/
        void removeAllOrdered(const t_type& object)
        {
            t_index_type start = 0;
            uint04 end = size();
            for (t_index_type i = 0; i < end; i++)
            {
                get(start) = get(i);
                if (get(i) != object)
                    ++start;
            }
            if (start != end)
                m_memory_interface.removeAllIndex(start, end);
        }
        /**
        \brief Removes all items based on the functor. The functor should return true if the
            item is deleted or false if the item should stay in the array. Function is slower than removeAllUnordered but
            order is preserved.
        \param[in] functor A functor that takes a value and returns true if value is to be removed, or false otherwise.
         **/
        template<class t_functor>
        void removeAllOrderedFn(const t_functor& functor)
        {
            t_index_type start = 0;
            t_index_type end = size();
            for (t_index_type i = 0; i < end; i++)
            {
                get(start) = get(i);
                if (!functor(get(i)))
                    ++start;
            }
            if (start != size())
                m_memory_interface.removeAllIndex(start, size());
        }
        void removeAllIndex(t_index_type start, t_index_type end)
        {
            if (start == end)
                return;
            lib_assert(start <= end, "remove all start > end");
            t_memory_allocator::template Deallocate<t_type>(m_memory_interface, start, end - start);
            m_memory_interface.removeAllIndex(start, end);
        }
        template<class t_range_buffer>
        void removeAllIndices(const t_range_buffer& ranges)
        {
#ifdef _DEBUG
            uint04 last_delete_index = 0;
#endif
            for (const auto& range : ranges)
            {
                t_index_type start = range.first;
                t_index_type end = range.second;
#ifdef _DEBUG
                lib_assert(last_delete_index <= start, "ranges must be ordered");
                lib_assert(start <= end, "remove all start > end");
                last_delete_index = end;
#endif
                t_memory_allocator::template Deallocate<t_type>(m_memory_interface, start, end - start);
            }
            m_memory_interface.removeAllIndices(ranges);
        }
        void replaceAll(const t_type& var, const t_type& replacement)
        {
            for (t_index_type i = 0; i < size(); i++)
            {
                if (get(i) == var)
                    get(i) = replacement;
            }
        }
        void reverse()
        {
            for (t_index_type i = 0; i < size() / 2; i++)
            {
                m_memory_interface.swap(i, size() - i - 1);
            }
        }
        void reverse(const t_index_type start, const t_index_type end)
        {
            const t_index_type size = end - start;
            for (t_index_type i = 0; i < size / 2; i++)
            {
                m_memory_interface.swap(start + i, (start + size) - i - 1);
            }
        }
        template<class t_o_type>
        void setAll(const t_o_type* src, t_index_type offset, t_index_type size)
        {
            m_memory_interface.template setAll<t_memory_allocator::isPrimitive()>(src, offset, size);
        }
        void setAll(const Buffer& buffer, t_index_type offset, t_index_type size)
        {
            lib_assert(buffer.size() >= size, "too small of buffer being used in set all");
            m_memory_interface.template setAll<t_memory_allocator::isPrimitive()>(buffer.m_memory_interface, offset, 0, size);
        }
        void setAll(const Buffer& buffer, t_index_type offset, t_index_type other_offset, t_index_type size)
        {
            lib_assert(buffer.size() >= size, "too small of buffer being used in set all");
            m_memory_interface.template setAll<t_memory_allocator::isPrimitive()>(buffer.m_memory_interface, offset, other_offset, size);
        }
        template<class t_o_type>
        void setAllToValue(const t_o_type& fill_element, const t_index_type offset = 0, t_index_type fill_size = Constant<t_index_type>::Invalid)
        {
            const t_index_type old_size = size();
            if (IsInvalid(fill_size))
                fill_size = old_size - offset;
            else if(offset + fill_size > old_size)
            {
                m_memory_interface.setSize(offset + fill_size);
            }
            const t_type value(fill_element);
            if (t_memory_allocator::isPrimitive() || size() == old_size)
            {
                m_memory_interface.setAll(value, offset, fill_size);
            }
            else
            {
                t_index_type size_a = old_size - offset;
                m_memory_interface.setAll(value, offset, size_a);
                t_memory_allocator::AllocateElement(m_memory_interface, offset + size_a, fill_size - size_a, value);
            }
        }
        void setSize(t_index_type new_size)
        {
            if(new_size < size())
                t_memory_allocator::template Deallocate<t_type>(m_memory_interface, new_size, size() - new_size);
            const t_index_type old_size = size();
            m_memory_interface.setSize(new_size);
            if (old_size < size())
                t_memory_allocator::template Allocate<t_type>(m_memory_interface, old_size, size() - old_size);
        }
        void resize(t_index_type new_size)
        {
            setSize(new_size);
        }
        void setSize(const t_index_type new_size, const t_type& fill_element)
        {
            const t_index_type old_size = size();
            setSize(new_size);
            if(old_size < new_size)
                setAllToValue(fill_element, old_size);
        }
        [[nodiscard]] constexpr t_index_type size() const
        {
            return m_memory_interface.filledSize();
        }
        void swapElements(const t_type& element1, const t_type& element2)
        {
            if (element1 == element2)
                return;
            t_index_type index_1 = Constant<t_index_type>::Invalid;
            t_index_type index_2 = Constant<t_index_type>::Invalid;
            for (t_index_type i = 0; i < size(); i++)
            {
                if (get(i) == element1)
                {
                    index_1 = i;
                    if (!IsInvalid(index_2))
                    {
                        swapIndices(index_1, index_2);
                        return;
                    }
                }
                else if (get(i) == element2)
                {
                    index_2 = i;
                    if (!IsInvalid(index_1))
                    {
                        swapIndices(index_1, index_2);
                        return;
                    }
                }
            }
        }
        void swapAllElements(const t_type& element1, const t_type& element2)
        {
            if (element1 == element2)
                return;
            for (t_index_type ii = 0; ii < size(); ++ii)
            {
                if (get(ii) == element1)
                    get(ii) = element2;
                else if (get(ii) == element2)
                    get(ii) = element1;
            }
        }
        void swapIndices(t_index_type index_1, t_index_type index_2)
        {
            std::swap(get(index_1), get(index_2));
        }
        void move(t_index_type from, t_index_type to)
        {
            if (to == from)
                return;
            t_type object = get(from);
            removeIndex(from);
            if (to > from)
                to--;
            add(to, object);
        }
        void primitiveSort()
        {
            struct primitiveUniqueDataComparison
            {
                bool operator()(const t_type& lhs, const t_type& rhs)
                {
                    return memcmp(&lhs, &rhs, sizeof(t_type)) > 0;
                }
            };
            std::sort(begin(), end(), primitiveUniqueDataComparison());
        }
        void sort()
        {
            std::sort(begin(), end());
        }
        void sortRange(t_index_type start, t_index_type end)
        {
            std::sort(begin() + start, begin() + end);
        }
        void setUnique()
        {
            if constexpr (t_memory_allocator::isPrimitive())
                primitiveSort();
            else
                sort();
            removeAllIndex(cast<t_index_type>(std::unique(begin(), end()) - begin()), size());
        }
        void setUniquePresorted()
        {
            removeAllIndex(cast<t_index_type>(std::unique(begin(), end()) - begin()), size());
        }
        t_index_type sortAboutValue(t_index_type value_index)
        {
            return sortAboutValue(value_index, 0, size());
        }
        t_index_type sortAboutValue(t_index_type value_index, t_index_type start, t_index_type end)
        {
            const t_type value = get(value_index);
            std::swap(get(value_index), get(--end));
            t_index_type store = start;
            for (t_index_type idx = start; idx < end; ++idx)
            {
                if (get(idx) <= value)
                {
                    std::swap(get(idx), get(store));
                    store++;
                }
            }
            std::swap(get(end), get(store));
            return store;
        }
        inline Buffer& operator=(const Buffer& buffer)
        {
            if (&(buffer) == this)
                return *this;//check to ensure not setting equal to ourselves
            clear();
            addAll(buffer);
            return *this;
        }
        inline Buffer& operator=(Buffer&& buffer) noexcept
        {
            std::swap(m_memory_interface, buffer.m_memory_interface);
            return *this;
        }
        [[nodiscard]] inline bool operator==(const Buffer& buffer) const
        {
            return equals(buffer);
        }
        [[nodiscard]] inline bool operator>(const Buffer& buffer) const
        {
            return compare(buffer) > 0;
        }
        [[nodiscard]] inline bool operator<(const Buffer& buffer) const
        {
            return compare(buffer) < 0;
        }
        [[nodiscard]] inline bool operator>=(const Buffer& buffer) const
        {
            return compare(buffer) >= 0;
        }
        [[nodiscard]] inline bool operator<=(const Buffer& buffer) const
        {
            return compare(buffer) <= 0;
        }
        [[nodiscard]] inline bool operator!=(const Buffer& buffer) const
        {
            return !equals(buffer);
        }
        [[nodiscard]] decltype(auto) operator[](const t_index_type index)
        {
            return get(index);
        }
        [[nodiscard]] decltype(auto) operator[](const int index)
        {
            return get(cast<t_index_type>(index));
        }
        [[nodiscard]] decltype(auto) operator[](const t_index_type value) const
        {
            return get(value);
        }
        [[nodiscard]] decltype(auto) operator[](const int index) const
        {
            return get(cast<t_index_type>(index));
        }
        [[nodiscard]] Buffer operator+(const t_type& element) const
        {
            Buffer<t_type, t_memory_allocator, t_memory_manager> buffer(1 + size());
            buffer.addAll(*this);
            buffer.add(element);
            return buffer;
        }
        const Buffer& operator+=(const t_type& element)
        {
            add(element);
            return *this;
        }
        inline Buffer& operator+=(const Buffer& value)
        {
            addAll(value);
            return (*this);
        }
        [[nodiscard]] inline Buffer operator+(const Buffer& value) const
        {
            Buffer buffer(size() + value.size());
            buffer.addAll(*this);
            buffer.addAll(value);
            return buffer;
        }
        [[nodiscard]] bool isSorted() const
        {
            if (size() <= 1)
                return true;
            for (t_index_type i = 0; i < size() - 1; i++)
            {
                if (get(i) >= get(i + 1))
                    return false;
            }
            return true;
        }
        [[nodiscard]] bool isSortedSet() const
        {
            for (t_index_type i = 0; i < size() - 1; i++)
            {
                if (get(i) > get(i + 1))
                    return false;
            }
            return true;
        }
        [[nodiscard]] constexpr static t_type Type() { t_type* ptr = nullptr;  return *ptr; }
 
        [[nodiscard]] constexpr t_memory_manager& memoryInterface()
        {
            return m_memory_interface;
        }
        [[nodiscard]] constexpr const t_memory_manager& memoryInterface() const
        {
            return m_memory_interface;
        }
    private:
        template<bool t_is_primitive>
        [[nodiscard]] bool _equals(const Buffer& buffer) const
        {
            if (t_is_primitive)
            {
                return compare(buffer) == 0;
            }
            else
            {
                for (t_index_type i = 0; i < size(); i++)
                {
                    if (get(i) != buffer.get(i))
                        return false;
                }
                return true;
            }
        }
    private:
        t_memory_manager m_memory_interface;
    };
    template<class t_type, class t_memory_allocator, class t_memory_manager>
    struct Constant<Buffer<t_type, t_memory_allocator, t_memory_manager>>
    {
        /** The Invalid value. This is the value that means the vector is 'not valid' or has an unset dimension. */
        inline const static Buffer<t_type, t_memory_allocator, t_memory_manager> Invalid{};
    };
}
#include "BoolBuffer.hpp"