Buffer.hpp

/*--------------------------------------------------------------------------------------------
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/BufferBase.h>
#include <initializer_list>
#include <utility>
#include <functional>
namespace NDEVR
{
    template<class t_type, class t_memory_manager = BufferAllocator<t_type, AlignmentDeterminator<t_type>::Size(), ObjectInfo<t_type>::Primitive, uint04, false>>
    class Buffer : BufferBase
    {
    public:
        using t_index_type = typename t_memory_manager::index_type;
        using t_allocator = typename t_memory_manager::allocator;
        constexpr Buffer() noexcept
            : m_memory_interface()
        {}

        constexpr Buffer(const Buffer& buffer)
            : m_memory_interface()
        {
            addAll(buffer);
        }

        constexpr Buffer(Buffer&& buffer) noexcept
            : m_memory_interface(std::move(buffer.m_memory_interface))
        {}
        
        explicit Buffer(t_index_type size)
            : m_memory_interface()
        {
            m_memory_interface.resizeSpace(size);
        }

        constexpr explicit Buffer(const t_type* buffer, t_index_type size)
            : m_memory_interface()
        {
            if (size != 0)
                addAll(buffer, size);
        }

        constexpr Buffer(t_index_type size, const t_type& fill_object)
            : m_memory_interface()
        {
            m_memory_interface.template createSpace<false>(size);
            t_allocator::AllocateElement(m_memory_interface, 0, size, fill_object);
        }

        Buffer(std::initializer_list<t_type> l)
            : m_memory_interface()
        {
            addAll(l.begin(), cast<t_index_type>(l.size()));
        }

        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;
            }
        }

 
        ~Buffer()
        {
            t_allocator::Deallocate(m_memory_interface, 0, size());
        }

        [[nodiscard]] operator decltype(auto) () const
        {
            return begin();
        }

        [[nodiscard]] operator decltype(auto) ()
        {
            return begin();
        }

        template<class t_other_type, class t_other_memory_manager = t_memory_manager>
        [[nodiscard]] Buffer<t_other_type, t_other_memory_manager> getAs() const
        {
            Buffer<t_other_type, t_other_memory_manager> other(size());
            for (t_index_type i = 0; i < size(); i++)
            {
                other.add(t_other_type(get(i)));
            }
            return other;
        }

        void add(t_type&& object)
        {
            m_memory_interface.addIndex();
            t_memory_manager::allocator::AllocateElement(m_memory_interface, size() - 1, std::move(object));
        }

        void add(const t_type& object)
        {
            m_memory_interface.addIndex();
            t_memory_manager::allocator::AllocateElement(m_memory_interface, size() - 1, object);
        }

        void add(t_index_type location, const t_type& object)
        {
            lib_assert(begin() > &object || end() <= &object, "cannot add to buffer from same buffer");
            m_memory_interface.addIndex(location);
            t_memory_manager::allocator::AllocateElement(m_memory_interface, location, object);
        }

        void add(t_index_type location, t_type&& object)
        {
            lib_assert(begin() > &object || end() <= &object, "cannot add to buffer from same buffer");
            m_memory_interface.addIndex(location);
            t_memory_manager::allocator::AllocateElement(m_memory_interface, location, std::move(object));
        }

        void insert(t_index_type location, const t_type& object)
        {
            lib_assert(begin() > &object || end() <= &object, "cannot add to buffer from same buffer");
            m_memory_interface.addIndex(location);
            t_memory_manager::allocator::AllocateElement(m_memory_interface, location, object);
        }

        void insert(t_index_type location, t_type&& object)
        {
            lib_assert(begin() > &object || end() <= &object, "cannot add to buffer from same buffer");
            m_memory_interface.addIndex(location);
            t_memory_manager::allocator::AllocateElement(m_memory_interface, location, std::move(object));
        }
        template<class t_other_memory_manager>
        constexpr void addAll(const Buffer<t_type, t_other_memory_manager>& buffer)
        {
            lib_assert(buffer.begin() != begin() || size() == 0, "cannot add to buffer from same buffer");
            t_index_type offset = size();
            m_memory_interface.template createSpace<false>(cast<t_index_type>(buffer.size()));
            if constexpr (t_memory_manager::allocator::isPrimitive())
            {
                m_memory_interface.template setAll<true>(buffer.memoryInterface(), offset, 0, cast<t_index_type>(buffer.size()));
            }
            else
            {
                for (t_index_type i = 0; i < buffer.size(); i++)
                    t_memory_manager::allocator::AllocateElement(m_memory_interface, i + offset, buffer[i]);
            }
        }
        constexpr void addAll(const t_type* buffer, t_index_type buffer_size)
        {
            lib_assert(begin() > buffer || end() <= buffer || size() == 0, "cannot add to buffer from same buffer");
            t_index_type offset = size();
            m_memory_interface.template createSpace<false>(buffer_size);
            if constexpr (t_memory_manager::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_manager::allocator::AllocateElement(m_memory_interface, i + offset, buffer[i]);
            }
        }
        template<class t_iterator>
        constexpr void addAll(t_iterator buffer, t_index_type buffer_size)
        {
            if (buffer_size == 0U)
                return;
            t_index_type offset = size();
            m_memory_interface.template createSpace<false>(buffer_size);
            if constexpr (t_memory_manager::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_manager::allocator::AllocateElement(m_memory_interface, i + offset, buffer[i]);
            }
        }
        void addAll(const t_type* buffer)
        {
            lib_assert(begin() > buffer || end() < buffer, "cannot add to buffer from same 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)
        {
            lib_assert(buffer.begin() != begin() || size() == 0, "cannot add to buffer from same buffer");
            m_memory_interface.template createSpace<false>(offset, buffer.size());
            if constexpr (t_memory_manager::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_manager::allocator::AllocateElement(m_memory_interface, i + offset, buffer[i]);
            }
        }
        template<class t_replace_buffer_type>
        void replaceIndexRange(t_index_type offset, t_index_type replace_size, const t_replace_buffer_type& buffer)
        {
            replaceIndexRange(offset, replace_size, buffer.begin(), buffer.size());
        }
        void replaceIndexRange(t_index_type offset, t_index_type replace_size, const t_type* buffer, t_index_type buffer_size)
        {
            lib_assert(buffer < begin() || buffer >= end(), "cannot replace buffer from same 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_manager::allocator::isPrimitive())
                {
                    for (t_index_type i = 0; i < size_dff; i++)
                        t_memory_manager::allocator::AllocateElement(m_memory_interface, i + offset, buffer[i]);
                }
            }
            else if (replace_size > buffer_size)
            {
                removeIndices(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
        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_manager::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_manager::allocator::AllocateElement(m_memory_interface, i + offset, buffer[i]);
            }
        }
#ifdef __clang__
    #pragma clang diagnostic pop
#endif
        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);
        }

        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_allocator::Allocate(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_allocator::AllocateElement(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_allocator::Allocate(m_memory_interface, location, size);
        }
        [[nodiscard]] constexpr decltype(auto) ptr()
        {
            return m_memory_interface.ptr();
        }
 
        [[nodiscard]] constexpr decltype(auto) ptr() const
        {
            return m_memory_interface.ptr();
        }
 
        [[nodiscard]] auto memSize() const
        {
            return m_memory_interface.memSize();
        }
 
        [[nodiscard]] constexpr decltype(auto) begin()
        {
            return m_memory_interface.begin();
        }
 
        [[nodiscard]] constexpr decltype(auto) begin() const
        {
            return m_memory_interface.begin();
        }
 
        [[nodiscard]] constexpr decltype(auto) begin(t_index_type index) const
        {
            return m_memory_interface.begin(index);
        }
        [[nodiscard]] constexpr decltype(auto) begin(t_index_type index)
        {
            return m_memory_interface.begin(index);
        }
        [[nodiscard]] t_index_type capacity() const
        {
            return m_memory_interface.capacity();
        }
 
        constexpr void clear()
        {
            t_allocator::Deallocate(m_memory_interface, 0U, size());
            m_memory_interface.clear();
        }
        void clear(t_index_type new_capacity)
        {
            t_allocator::Deallocate(m_memory_interface, 0, size());
            m_memory_interface.clear();
            ensureCapacity(new_capacity, true, true);
        }

        [[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;
        }
        template<class t_comparable_type>
        [[nodiscard]] bool contains(const t_comparable_type& element) const
        {
            return m_memory_interface.contains(element, 0, size());
        }
        [[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");
            return m_memory_interface.contains(element, start, size() - start);
        }
        [[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");
            return m_memory_interface.contains(element, start, search_size);
        }
        [[nodiscard]] t_index_type count(const t_type& element) const
        {
            return m_memory_interface.count(element);
        }
        [[nodiscard]] decltype(auto) end()
        {
            return m_memory_interface.end();
        }
        [[nodiscard]] decltype(auto) end() const
        {
            return m_memory_interface.end();
        }
        [[nodiscard]] 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_manager::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_allocator::Deallocate(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
        }
        template<class t_comparable_type>
        bool removeElement(const t_comparable_type& element)
        {
            for (t_index_type i = size() - 1; IsValid(i); --i)//start at last element as less expensive to removeRows
            {
                if (get(i) == element)
                {
                    removeIndex(i);
                    return true;
                }
            }
            return false;
        }
        template<class t_comparable_type>
        bool removeElement(const t_comparable_type& element, uint04 first)
        {
            first--;
            for (t_index_type i = size() - 1; i != first; --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_allocator::Deallocate(m_memory_interface, size() - 1, 1);
            m_memory_interface.removeLast();
        }

        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;
                }
            }
            setSize(end);
        }

        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);
                }
            }
            setSize(end);
        }

        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);
        }

        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 removeIndices(t_index_type start, t_index_type size)
        {
            if (size == 0U)
                return;
            t_allocator::Deallocate(m_memory_interface, start, size);
            m_memory_interface.removeAllIndex(start, start + size);
        }
        template<class t_range_buffer>
        void removeIndices(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_allocator::Deallocate(m_memory_interface, start, end - start);
            }
            m_memory_interface.removeIndices(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_manager::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_manager::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_manager::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_manager::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_manager::allocator::AllocateElement(m_memory_interface, offset + size_a, fill_size - size_a, value);
            }
        }
        void setSize(t_index_type new_size)
        {
            if (new_size == size())
                return;
            resize(new_size);
        }
        void resize(t_index_type new_size)
        {
            if (new_size < size())
                t_allocator::Deallocate(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_allocator::Allocate(m_memory_interface, old_size, size() - old_size);
        }
        void setSize(const t_index_type new_size, const t_type& fill_element)
        {
            if (new_size == size())
                return;
            if (new_size < size())
            {
                t_allocator::Deallocate(m_memory_interface, new_size, size() - new_size);
                m_memory_interface.setSize(new_size);
            }
            else
            {
                const t_index_type old_size = size();
                m_memory_interface.setSize(new_size);
                t_allocator::AllocateElement(m_memory_interface, old_size, size() - old_size, fill_element);
            }
        }
        [[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 (IsValid(index_2))
                    {
                        swapIndices(index_1, index_2);
                        return;
                    }
                }
                else if (get(i) == element2)
                {
                    index_2 = i;
                    if (IsValid(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_manager::allocator::isPrimitive())
                primitiveSort();
            else
                sort();
            setSize(cast<t_index_type>(std::unique(begin(), end()) - begin()));
        }
        void setUniquePresorted()
        {
            setSize(cast<t_index_type>(std::unique(begin(), end()) - begin()));
        }
        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_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_manager>
    struct Constant<Buffer<t_type, t_memory_manager>>
    {
        inline const static Buffer<t_type, t_memory_manager> Invalid{};
    };
    template <class t_type, class t_memory_manager = BufferAllocator<t_type, DetermineAlignment<sizeof(t_type)>(), ObjectInfo<t_type>::Primitive, uint08, false>>
    using HighCapacityBuffer = Buffer<t_type, t_memory_manager>;
    template <class t_type, class t_memory_manager = BufferAllocator<t_type, DetermineAlignment<sizeof(t_type)>(), true, uint04, false>>
    using PrimitiveBuffer = Buffer<t_type, t_memory_manager>;
    template <class t_type, size_t t_alignment, class t_memory_manager = BufferAllocator<t_type, DetermineAlignment<t_alignment>(), ObjectInfo<t_type>::Primitive, uint04, false>>
    using AlignedBuffer = Buffer<t_type, t_memory_manager>;
    template <class t_type, size_t t_alignment, class t_memory_manager = BufferAllocator<t_type, DetermineAlignment<t_alignment>(), true, uint04, false>>
    using PrimitiveAlignedBuffer = Buffer<t_type, t_memory_manager>;
    template <class t_type, size_t t_alignment, class t_memory_manager = BufferAllocator<t_type, DetermineAlignment<t_alignment>(), false, uint04, false>>
    using AlocatingAlignedBuffer = Buffer<t_type, t_memory_manager>;
}
#include "BoolBuffer.hpp"