TableColumnType.h

/*--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: Database
File: TableColumnType
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#if __clang__
    #pragma clang diagnostic push
    #pragma clang diagnostic ignored "-Woverloaded-virtual"
#endif
#include "DLLInfo.h"
#include <NDEVR/TableColumn.h>
#include <NDEVR/RGBColor.h>
#include <NDEVR/Matrix.h>
#include <NDEVR/Bounds.h>
#include <NDEVR/TypeInfo.h>
#include <NDEVR/BinaryFile.h>
#include <NDEVR/String.h>
#include <NDEVR/Compressor.h>
#include "BinaryFileTableInfo.h"
namespace NDEVR
{
    template<class t_type>
    struct DefaultSetter {
        void setDefaultValueFrom(TableColumn& a, const TableColumn& b)
        {
            a.setDefaultValue(b.getDefaultValue());
        }
    };

    template<class t_buffer_type>
    struct DefaultSetter<Buffer<t_buffer_type>> {
        void setDefaultValueFrom(TableColumn&, const TableColumn&)
        {
            lib_assert(false, "not yet implemented");
            //a.setDefaultValue(b.getDefaultValue<StringView>());
        }
    };

    template<>
    struct DefaultSetter<String> {
        void setDefaultValueFrom(TableColumn& a, const TableColumn& b)
        {
            a.setDefaultValue(b.getDefaultValue());
        }
    };

    template<class t_type>
    class TableColumnBuffer : public TableColumn
    {
    public:
        virtual TypeInfo type() const override
        {
            return GetTypeInfo<t_type>();
        }

        virtual void setDefaultValue(const StringAllocatingView& value) override
        {
            m_default_value = value.getAs<t_type>();
        }

        const StringAllocatingView getDefaultValue() const override
        {
            return StringAllocatingView::Allocate(m_default_value);
        }

        TableColumnBuffer(const StringView& label)
            : TableColumn(label)
            , m_default_value(Constant<t_type>::Invalid)
        {
        }

        TableColumnBuffer(const StringView& label, const t_type& default_value)
            : TableColumn(label)
            , m_default_value(default_value)
        {
        }

        TableColumnBuffer(const Buffer<t_type>& buffer, const StringView& label)
            : TableColumn(label)
            , m_default_value(Constant<t_type>::Invalid)
            , m_buffer(buffer)
        {}

        virtual void swap(uint04 a, uint04 b) override
        {
            m_buffer.swapIndices(a, b);
        }

        [[nodiscard]] inline decltype(auto) operator[](const uint04 index)
        {
            return m_buffer[index];
        }

        [[nodiscard]] inline decltype(auto) operator[](const uint04 index) const
        {
            return m_buffer[index];
        }

        void set(uint04 index, const t_type& value)
        {
            m_buffer[index] = value;
        }

        virtual void finishMapFromFile(BinaryFileTableInfo& file) override
        {
            if (!m_has_been_read)
                return;
            m_has_been_read = false;
            if (file.version_number < 1762047417)
            {
                if (file.version_number > 1539350691)
                    m_default_value = m_buffer[0];//default was front
                m_buffer.removeIndex(0);
            }
            else
            {
                m_default_value = m_buffer.last();
                m_buffer.removeLast();
            }
        }

        virtual void mapFromFile(BinaryFileTableInfo& file) override
        {
            if (file.version_number <= 1539350691)//versions <= 1539350691 had error in default value, so ignore
            {
                file.file.seek(file.file.position() + sizeof(t_type));
                file.file.readNow(m_buffer);
            }
            else if (file.version_number <= 1613942093)
            {
                Buffer<t_type> default_value_buffer;
                file.file.readNow(default_value_buffer);
                lib_assert(default_value_buffer.size() == 1, "Bad buffer read");
                file.file.readNow(m_buffer);
                m_default_value = default_value_buffer[0];
            }
            else
            {
                file.file.read(m_buffer);
                m_has_been_read = true;
            }
        }

        void setSize(uint04 size) override
        {
            uint04 old_size = m_buffer.size();
            if (old_size < size)
            {
                m_buffer.template addSpace<true>(1 + size - old_size);
                m_buffer.setAllToValue(defaultValue(), old_size, size - old_size);
                m_buffer.removeLast();//size confirmed
            }
            else
            {
                m_buffer.setSize(size);
            }
        }

        virtual void setDefaultValueFrom(const TableColumn& column) override
        {
            DefaultSetter<t_type>().setDefaultValueFrom(*this, column);
        }
    public:
        void insert(uint04 index) override
        {
            m_buffer.template addSpace<true>(index, 1U);
            m_buffer[index] = defaultValue();
        }

        virtual void resetRow(uint04 row) override
        {
            m_buffer[row] = m_default_value;
        }

        virtual void copyRow(uint04 source, uint04 destination) override
        {
            m_buffer[destination] = m_buffer[source];
        }

        virtual void copyRows(uint04 source, uint04 destination, uint04 size) override
        {
            if (destination < source)//prevent overlap
            {
                for (uint04 i = 0; i < size; i++)
                    m_buffer[destination + i] = m_buffer[source + i];
            }
            else
            {
                for (uint04 i = size - 1; IsValid(i); i--)
                    m_buffer[destination + i] = m_buffer[source + i];
            }
        }

        void removeRow(uint04 index) override
        {
            m_buffer.removeIndex(index);
        }

        virtual void removeRows(uint04 index, uint04 size) override
        {
            m_buffer.removeIndices(index, size);
        }

        virtual void removeRows(const Buffer<uint04>& sorted_remove_indices) override
        {
            if (sorted_remove_indices.size() == 0)
                return;
            uint04 current_position = 0;
            uint04 current_remove_index = 0;
            for (uint04 i = 0; i < m_buffer.size(); i++)
            {
                if (current_remove_index >= sorted_remove_indices.size() || i != sorted_remove_indices[current_remove_index])
                {
                    m_buffer[current_position++] = m_buffer[i];
                }
                else
                {
                    current_remove_index++;
                }
            }
            lib_assert(current_remove_index == sorted_remove_indices.size(), "Unexpected end remove value");
            m_buffer.setSize(current_position);
        }

        void removeRows(uint04 offset, const Buffer<bool>& indices) override
        {
            uint04 current_position = offset;
            for (uint04 i = 0; i < indices.size(); i++)
            {
                if (!indices[i])
                {
                    m_buffer[current_position] = m_buffer[offset + i];
                    current_position++;
                }
            }
            uint04 removed_size = current_position;
            for (uint04 i = offset + indices.size(); i < m_buffer.size(); i++)
            {
                m_buffer[current_position] = m_buffer[i];
                current_position++;
            }
            m_buffer.setSize(m_buffer.size() - (indices.size() - (removed_size - offset)));
        }

        virtual void compress(BinaryCompressionObject& object) override
        {
            if (m_compression_mode != CompressionMode::e_default_compression)
                object.compression_mode = m_compression_mode;
            m_buffer.add(defaultValue());
            Compressor::Compress(object, m_compressed_data, m_buffer);
            m_buffer.removeLast();
        }

        virtual void mapToFile(BinaryFileTableInfo& file, int compression) override
        {
            _mapToFile(file, cast<CompressionMode>(compression));
        }

        virtual void mapToFile(BinaryFileTableInfo& file, BinaryCompressionObject& object) override
        {
            _mapToFile(file, object);
        }
        
        void* begin() override { lib_assert(!ObjectInfo<t_type>::Boolean, "Begin not supported for boolean"); return m_buffer.ptr(); }
        void* end() override { return ((uint01*)m_buffer.ptr()) + m_buffer.memSize(); }

        const void* begin() const override { lib_assert(!ObjectInfo<t_type>::Boolean, "Begin not supported for boolean"); return m_buffer.ptr(); }
        const void* end() const override { return ((uint01*)m_buffer.ptr()) + m_buffer.memSize(); }

        virtual void addRow() override
        {
            t_type value = defaultValue();
            m_buffer.add(value);
        }

        virtual void insertRows(uint04 location, uint04 size) override
        {
            m_buffer.template addSpace<true>(location, size);
            m_buffer.setAllToValue(defaultValue(), location, size);
        }

        [[nodiscard]] bool isSame(uint04 index, const StringView& value) const override { return value.getAs<t_type>() == pullValue(index); }
        [[nodiscard]] bool contains(uint04 index, const StringView& value, bool ignore_case) const override { return String(pullValue(index)).hasSubString(value, ignore_case); }
        [[nodiscard]] bool beginsWith(uint04 index, const StringView& value, bool ignore_case) const override { return String(pullValue(index)).beginsWith(value, ignore_case); }
        uint04 size() const override { return m_buffer.size(); }
    private:
        void _mapToFile(BinaryFileTableInfo& file, CompressionMode compression)
        {
            m_buffer.add(defaultValue());//append default value to end
            file.file.write(m_buffer, compression);
            m_buffer.removeLast();
        }
        void _mapToFile(BinaryFileTableInfo& file, BinaryCompressionObject& object)
        {
            file.file.writeCompression(object);
        }
    protected:
        decltype(auto) pullValue(uint04 index)
        {
            return m_buffer[index];
        }

        decltype(auto) pullValue(uint04 index) const
        {
            return m_buffer[index];
        }

        decltype(auto) defaultValue()
        {
            return m_default_value;
        }

        decltype(auto) defaultValue() const
        {
            return m_default_value;
        }
        t_type m_default_value;            
        Buffer<t_type> m_buffer;           
        Buffer<uint01> m_compressed_data;  
        bool m_has_been_read = false;      
    };

    template<uint01 t_dims, class t_type>
    class TableVectorType : public TableColumnBuffer<Vector<t_dims, t_type>>
    {
    public:
        virtual TypeInfo type() const override
        {
            return GetTypeInfo<Vector<t_dims, t_type>>();
        }

        TableVectorType(const StringView& label)
            : TableColumnBuffer<Vector<t_dims, t_type>>(label)
        {}

        TableVectorType(const Buffer<Vector<t_dims, t_type>>& buffer, const StringView& label)
            : TableColumnBuffer<Vector<t_dims, t_type>>(buffer, label)
        {}
    public:
        virtual uint04 getRowSize(uint04) const override { return t_dims; };

        virtual void set(uint04 index, uint04 vector_pos, bool value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 vector_pos, uint01 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 vector_pos, uint02 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 vector_pos, uint04 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 vector_pos, uint08 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 vector_pos, sint01 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 vector_pos, sint02 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 vector_pos, sint04 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 vector_pos, sint08 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 vector_pos, fltp04 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 vector_pos, fltp08 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = cast<t_type>(value); };
 
        virtual void set(uint04 index, uint04 vector_pos, const StringView& value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)] = value.getAs<t_type>(); };

        virtual void set(uint04 index, bool value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, uint01 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, uint02 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, uint04 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, uint08 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, sint01 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, sint02 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, sint04 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, sint08 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, fltp04 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, fltp08 value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = cast<t_type>(value); };
        virtual void set(uint04 index, const StringView& value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = value.getAs<Vector<t_dims, t_type>>(); };
        virtual void set(uint04 index, RGBColor value) override { TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index) = value.as<t_dims, t_type>(); };
        
        virtual void get(uint04 index, uint04 vector_pos, bool& value) const override { value = cast<bool>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, uint01& value) const override { value = cast<uint01>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, uint02& value) const override { value = cast<uint02>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, uint04& value) const override { value = cast<uint04>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, uint08& value) const override { value = cast<uint08>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, sint01& value) const override { value = cast<sint01>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, sint02& value) const override { value = cast<sint02>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, sint04& value) const override { value = cast<sint04>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, sint08& value) const override { value = cast<sint08>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, fltp04& value) const override { value = cast<fltp04>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, fltp08& value) const override { value = cast<fltp08>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };
        virtual void get(uint04 index, uint04 vector_pos, StringAllocatingView& value) const override { value.allocate(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[cast<uint01>(vector_pos)]); };

        virtual void get(uint04 index, bool& value) const override { if constexpr (t_dims == 1) value = cast<bool>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]);   else value = cast<bool>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, uint01& value) const override { if constexpr (t_dims == 1) value = cast<uint01>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); else value = cast<uint01>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, uint02& value) const override { if constexpr (t_dims == 1) value = cast<uint02>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); else value = cast<uint02>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, uint04& value) const override { if constexpr (t_dims == 1) value = cast<uint04>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); else value = cast<uint04>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, uint08& value) const override { if constexpr (t_dims == 1) value = cast<uint08>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); else value = cast<uint08>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, sint01& value) const override { if constexpr (t_dims == 1) value = cast<sint01>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); else value = cast<sint01>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, sint02& value) const override { if constexpr (t_dims == 1) value = cast<sint02>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); else value = cast<sint02>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, sint04& value) const override { if constexpr (t_dims == 1) value = cast<sint04>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); else value = cast<sint04>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, sint08& value) const override { if constexpr (t_dims == 1) value = cast<sint08>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); else value = cast<sint08>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, fltp04& value) const override { if constexpr (t_dims == 1) value = cast<fltp04>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); else value = cast<fltp04>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, fltp08& value) const override { if constexpr (t_dims == 1) value = cast<fltp08>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); else value = cast<fltp08>(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)[0]); };
        virtual void get(uint04 index, StringAllocatingView& value) const override { value.allocate(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index)); };

        virtual void get(uint04, StringView&) const override { lib_assert(false, "Cannot get String view"); }
        virtual void get(uint04 index, RGBColor& value) const override { value = RGBColor(TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index).template as<4, t_type>()); };
        
        void getVector(uint04 index, Vector<3, fltp04>& vector) const override
        {
            vector = TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index).template as<3, fltp04>();
        }
 
        void getVector(uint04 index, Vector<3, fltp08>& vector) const override
        {
            vector = TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index).template as<3, fltp08>();
        }
 
        void getVector(uint04 index, Vector<3, uint04>& vector) const override
        {
            vector = TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index).template as<3, uint04>();
        }
 
        void getVector(uint04 index, Vector<2, uint04>& vector) const override
        {
            vector = TableColumnBuffer<Vector<t_dims, t_type>>::pullValue(index).template as<2, uint04>();
        }


        uint08 tableHash() const override
        {
            uint08 result = 2166136261U;
            std::hash<t_type> hash;
            for (const Vector<t_dims, t_type>& v : TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer)
            {
                for (uint01 i = 0; i < t_dims; i++)
                    result = (127 * result) + hash(v[i]);
            }
            return result;
        }

        TableVectorType<t_dims, t_type>* getSelected(const Buffer<bool>& selected_indices) const override
        {
            TableVectorType<t_dims, t_type>* new_vector_array = new TableVectorType<t_dims, t_type>(TableColumn::label());
            new_vector_array->setSize(selected_indices.count(true));
            uint04 current_index = 0;
            for (uint04 i = 0; i < selected_indices.size(); i++)
            {
                if (selected_indices[i])
                {
                    new_vector_array->m_buffer[current_index++] = TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i];
                }
            }
            return new_vector_array;
        }

        virtual void insertIndices(uint04 location, uint04 size) override
        {
            if (size == 0)
                return;
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer.size(); i++)
            {
                for (uint01 n = 0; n < t_dims; n++)
                {
                    if (IsValid(TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n])
                        && cast<uint04>(TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n]) >= location)
                    {
                        TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n] += cast<t_type>(size);
                        update_range.addToBounds(i);
                    }
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                TableColumnBuffer<Vector<t_dims, t_type>>::m_changes.add(
                    TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                TableColumnBuffer<Vector<t_dims, t_type>>::m_modified_time = Time::SystemTime();
            }
        }

        virtual void removeIndices(uint04 location, uint04 size) override
        {
            if (size == 0)
                return;
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer.size(); i++)
            {
                for (uint01 n = 0; n < t_dims; n++)
                {
                    if (IsValid(TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n])
                        && cast<uint04>(TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n]) >= location)
                    {
                        if (cast<uint04>(TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n]) < location + size)
                            TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n] = Constant<t_type>::Invalid;
                        else
                            TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n] -= cast<t_type>(size);
                        update_range.addToBounds(i);
                    }
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                TableColumnBuffer<Vector<t_dims, t_type>>::m_changes.add(
                    TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                TableColumnBuffer<Vector<t_dims, t_type>>::m_modified_time = Time::SystemTime();
            }
        }

        virtual void swapIndices(uint04 a, uint04 b) override
        {
            for (uint04 i = 0; i < TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer.size(); i++)
            {
                for (uint01 n = 0; n < t_dims; n++)
                {
                    if (!IsValid(TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n]))
                        continue;
                    uint04 val = cast<uint04>(TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n]);
                    if (val == a)
                        TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n] = cast<t_type>(b);
                    else if (val == b)
                        TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n] = cast<t_type>(a);
                }
            }
        }

        virtual void removeIndices(const Buffer<uint04>& offset_lookup_list) override
        {
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer.size(); i++)
            {
                for (uint01 n = 0; n < t_dims; n++)
                {
                    if (IsValid(TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n]))
                    {
                        uint04 new_index = offset_lookup_list[cast<uint04>(TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n])];
                        TableColumnBuffer<Vector<t_dims, t_type>>::m_buffer[i][n] = cast<t_type>(new_index);
                        update_range.addToBounds(i);
                    }
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                TableColumnBuffer<Vector<t_dims, t_type>>::m_changes.add(
                    TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                TableColumnBuffer<Vector<t_dims, t_type>>::m_modified_time = Time::SystemTime();
            }
        }

        virtual void get(uint04 index, Bounds<3, fltp08>& b) const override
        {
            lib_assert(t_dims == 6, "Bounds can only be accessed from 6 dimension vectors");
            if constexpr (std::is_same_v<fltp08, t_type>)
            {
                memcpy(&b, &TableVectorType<t_dims, t_type>::pullValue(index), sizeof(Bounds<3, t_type>));
            }
            else
            {
                Bounds<3, t_type> bounds;
                memcpy(&bounds, &TableVectorType<t_dims, t_type>::pullValue(index), sizeof(Bounds<3, t_type>));
                b = bounds.template as<3, fltp08>();
            }
        }
        virtual void get(uint04 index, Bounds<3, fltp04>& b) const override
        {
            lib_assert(t_dims == 6, "Bounds can only be accessed from 6 dimension vectors");
            if constexpr (std::is_same_v<fltp04, t_type>)
            {
                memcpy(&b, &TableVectorType<t_dims, t_type>::pullValue(index), sizeof(Bounds<3, t_type>));
            }
            else
            {
                Bounds<3, t_type> bounds;
                memcpy(&bounds, &TableVectorType<t_dims, t_type>::pullValue(index), sizeof(Bounds<3, t_type>));
                b = bounds.template as<3, fltp04>();
            }
        }

        virtual void set(uint04 index, const Bounds<3, fltp08>& b) override
        {
            lib_assert(t_dims == 6, "Bounds can only be accessed from 6 dimension vectors");
            if constexpr (std::is_same_v<fltp08, t_type>)
            {
                memcpy(&TableVectorType<t_dims, fltp08>::pullValue(index), &b, sizeof(Bounds<3, t_type>));
            }
            else
            {
                Bounds<3, t_type> bounds = b.as<3, t_type>();
                memcpy(&TableVectorType<t_dims, t_type>::pullValue(index), &bounds, sizeof(Bounds<3, t_type>));
            }
        }

        virtual void set(uint04 index, const Bounds<3, fltp04>& b) override
        {
            lib_assert(t_dims == 6, "Bounds can only be accessed from 6 dimension vectors");
            if constexpr (std::is_same_v<fltp04, t_type>)
            {
                memcpy(&TableVectorType<t_dims, fltp04>::pullValue(index), &b, sizeof(Bounds<3, t_type>));
            }
            else
            {
                Bounds<3, t_type> bounds = b.as<3, t_type>();
                memcpy(&TableVectorType<t_dims, t_type>::pullValue(index), &bounds, sizeof(Bounds<3, t_type>));
            }
        }

    };

    template<class t_type, uint01 t_cols, uint01 t_rows>
    class TableMatrixType : public TableVectorType<t_cols * t_rows, t_type>
    {
    public:
        using TableVectorType<t_cols* t_rows, t_type>::m_default_value;
        TableMatrixType(const StringView& label)
            : TableVectorType<t_cols* t_rows, t_type>(label)
        {}
    public:
        void set(uint04 index, const StringView& value) override
        {
            Matrix<t_type, t_cols, t_rows> mat = value.getAs<Matrix<t_type, t_cols, t_rows>>();
            memcpy(&TableVectorType<t_cols * t_rows, t_type>::m_buffer[index], &mat, sizeof(Matrix<t_type, t_cols, t_rows>));
        };

        void get(uint04 index, StringAllocatingView& value) const override
        {
            value.allocate(Matrix<t_type, t_cols, t_rows>(TableVectorType<t_cols * t_rows, t_type>::m_buffer[index]));
        };

        virtual void setDefaultValue(const StringAllocatingView& value) override
        {
            Matrix<t_type, t_cols, t_rows> mat = value.getAs<Matrix<t_type, t_cols, t_rows>>();
            memcpy(&m_default_value, &mat, sizeof(Matrix<t_type, t_cols, t_rows>));
        }

        void get(uint04 index, StringView& value) const override
        {
            UNUSED(index);
            UNUSED(value);
            lib_assert(false, "Cannot get as string view");
        };

        virtual void get(uint04 index, Matrix<fltp08>& transform) const override
        {
            if constexpr (t_cols == 4 && t_rows == 4 && std::is_same_v<fltp08, t_type>)
            {
                memcpy(&transform, &TableVectorType<t_cols * t_rows, t_type>::pullValue(index), sizeof(Matrix<t_type, t_cols, t_rows>));
            }
            else
            {
                Matrix<t_type, t_cols, t_rows> matrix;
                memcpy(&matrix, &TableVectorType<t_cols * t_rows, t_type>::pullValue(index), sizeof(Matrix<t_type, t_cols, t_rows>));
                transform = matrix.template as<fltp08, 4, 4>();
            }
        }
        virtual void get(uint04 index, Matrix<fltp04>& transform) const override
        {
            if constexpr (t_cols == 4 && t_rows == 4 && std::is_same_v<fltp04, t_type>)
            {
                memcpy(&transform, &TableVectorType<t_cols * t_rows, t_type>::pullValue(index), sizeof(Matrix<t_type, t_cols, t_rows>));
            }
            else
            {
                Matrix<t_type, t_cols, t_rows> matrix;
                memcpy(&matrix, &TableVectorType<t_cols * t_rows, t_type>::pullValue(index), sizeof(Matrix<t_type, t_cols, t_rows>));
                transform = matrix.template as<fltp04, 4, 4>();
            }
        }
        virtual void set(uint04 index, const Matrix<fltp08>& transform) override
        {
            if constexpr (t_cols == 4 && t_rows == 4 && std::is_same_v<fltp08, t_type>)
            {
                memcpy(&TableVectorType<t_cols * t_rows, t_type>::pullValue(index), &transform, sizeof(Matrix<t_type, t_cols, t_rows>));
            }
            else
            {
                Matrix<t_type, t_cols, t_rows> matrix = transform.as<t_type, t_cols, t_rows>();
                memcpy(&TableVectorType<t_cols * t_rows, t_type>::pullValue(index), &matrix, sizeof(Matrix<t_type, t_cols, t_rows>));
            }
        }
        virtual void set(uint04 index, const Matrix<fltp04>& transform) override
        {
            if constexpr (t_cols == 4 && t_rows == 4 && std::is_same_v<fltp04, t_type>)
            {
                memcpy(&TableVectorType<t_cols * t_rows, t_type>::pullValue(index), &transform, sizeof(Matrix<t_type, t_cols, t_rows>));
            }
            else
            {
                Matrix<t_type, t_cols, t_rows> matrix = transform.as<t_type, t_cols, t_rows>();
                memcpy(&TableVectorType<t_cols * t_rows, t_type>::pullValue(index), &matrix, sizeof(Matrix<t_type, t_cols, t_rows>));
            }
        }

    };
    
    template<class t_type>
    class TableVectorType<1, t_type> : public TableColumnBuffer<t_type>
    {
    public:
        virtual TypeInfo type() const override
        {
            return GetTypeInfo<t_type>();
        }

        TableVectorType(const StringView& label)
            : TableColumnBuffer<t_type>(label)
        {}

        TableVectorType(const Buffer<bool>& buffer, const StringView& label)
            : TableColumnBuffer<t_type>(buffer, label)
        {}
    public:
        virtual uint04 getRowSize(uint04) const override { return 1; };

        void set(uint04 index, uint04, bool value) override { TableColumnBuffer<t_type>::pullValue(index) = value; };
        void set(uint04 index, uint04, uint01 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint04, uint02 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint04, uint04 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint04, uint08 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint04, sint01 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint04, sint02 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint04, sint04 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint04, sint08 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint04, fltp04 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint04, fltp08 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
 
        void set(uint04 index, uint04, const StringView& value) override { TableColumnBuffer<t_type>::pullValue(index) = value.getAs<t_type>(); };

        void set(uint04 index, bool value) override { TableColumnBuffer<t_type>::pullValue(index) = value; };
        void set(uint04 index, uint01 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint02 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint04 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, uint08 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, sint01 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, sint02 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, sint04 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, sint08 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, fltp04 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, fltp08 value) override { TableColumnBuffer<t_type>::pullValue(index) = cast<t_type>(value); };
        void set(uint04 index, const StringView& value) override { TableColumnBuffer<t_type>::pullValue(index) = value.getAs<t_type>(); };
        void set(uint04, RGBColor) override {  /*TableColumnBuffer<t_type>::pullValue(index) = value.getAs<Vector<t_dims, t_type>>();*/ };

        void get(uint04 index, uint04, bool& value) const override { value = cast<bool>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, uint01& value) const override { value = cast<uint01>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, uint02& value) const override { value = cast<uint02>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, uint04& value) const override { value = cast<uint04>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, uint08& value) const override { value = cast<uint08>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, sint01& value) const override { value = cast<sint01>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, sint02& value) const override { value = cast<sint02>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, sint04& value) const override { value = cast<sint04>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, sint08& value) const override { value = cast<sint08>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, fltp04& value) const override { value = cast<fltp04>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, fltp08& value) const override { value = cast<fltp08>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04, StringAllocatingView& value) const override { value.allocate(TableColumnBuffer<t_type>::pullValue(index)); };

        void get(uint04 index, bool& value) const override { value = TableColumnBuffer<t_type>::pullValue(index); };
        void get(uint04 index, uint01& value) const override { value = cast<uint01>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint02& value) const override { value = cast<uint02>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint04& value) const override { value = cast<uint04>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, uint08& value) const override { value = cast<uint08>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, sint01& value) const override { value = cast<sint01>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, sint02& value) const override { value = cast<sint02>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, sint04& value) const override { value = cast<sint04>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, sint08& value) const override { value = cast<sint08>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, fltp04& value) const override { value = cast<fltp04>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, fltp08& value) const override { value = cast<fltp08>(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04 index, StringAllocatingView& value) const override { value.allocate(TableColumnBuffer<t_type>::pullValue(index)); };
        void get(uint04, StringView&) const override { lib_assert(false, "Cannot get as string view"); };
        void get(uint04, RGBColor&) const override { /*value = RGBColor(m_buffer[index].getAs<4, t_type>());*/ };

        TableVectorType<1, t_type>* getSelected(const Buffer<bool>& selected_indices) const override
        {
            TableVectorType<1, t_type>* new_vector_array = new TableVectorType<1, t_type>(TableColumn::label());
            new_vector_array->setSize(selected_indices.count(true));
            uint04 current_index = 0;
            for (uint04 i = 0; i < selected_indices.size(); i++)
            {
                if (selected_indices[i])
                {
                    new_vector_array->m_buffer[current_index++] = TableColumnBuffer<t_type>::m_buffer[i];
                }
            }
            return new_vector_array;
        }

        virtual void insertIndices(uint04 location, uint04 size) override
        {
            this->template _insertIndices<t_type>(location, size);
        }

        virtual void removeIndices(uint04 location, uint04 size) override
        {
            this->template _removeIndices<t_type>(location, size);
        }

        virtual void removeIndices(const Buffer<uint04>& offset_lookup_list) override
        {
            this->template _removeIndices<t_type>(offset_lookup_list);
        }

        virtual void swapIndices(uint04 a, uint04 b) override
        {
            this->template _swapIndices<t_type>(a, b);
        }
    private:
        template<class t_n_type>
        void _insertIndices(uint04 location, typename std::enable_if<ObjectInfo<t_n_type>::Number && ObjectInfo<t_n_type>::Dimensions < 16, uint04>::type size)
        {
            if (size == 0)
                return;
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < TableColumnBuffer<t_type>::m_buffer.size(); i++)
            {
                auto& it = TableColumnBuffer<t_type>::m_buffer[i];
                uint04 value = cast<uint04>(it);
                if (value >= location && IsValid(value))
                {
                    it += cast<t_type>(size);
                    update_range.addToBounds(i);
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                TableColumnBuffer<t_type>::m_changes.add(
                    TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                TableColumnBuffer<t_type>::m_modified_time = Time::SystemTime();
            }
        }
        template<class t_n_type>
        void _insertIndices(uint04 location, typename std::enable_if<!ObjectInfo<t_n_type>::Number || ObjectInfo<t_n_type>::Dimensions >= 16, uint04>::type size) {
            UNUSED(location);
            UNUSED(size);
        };

        template<class t_n_type>
        void _removeIndices(uint04 location, typename std::enable_if<ObjectInfo<t_n_type>::Number && ObjectInfo<t_n_type>::Dimensions < 16, uint04>::type size)
        {
            if (size == 0)
                return;
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < TableColumnBuffer<t_type>::m_buffer.size(); i++)
            {
                if (cast<uint04>(TableColumnBuffer<t_type>::m_buffer[i]) >= location && IsValid(TableColumnBuffer<t_type>::m_buffer[i]))
                {
                    if (cast<uint04>(TableColumnBuffer<t_type>::m_buffer[i]) < location + size)
                        TableColumnBuffer<t_type>::m_buffer[i] = Constant<t_type>::Invalid;
                    else
                        TableColumnBuffer<t_type>::m_buffer[i] -= cast<t_type>(size);
                    update_range.addToBounds(i);
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                TableColumnBuffer<t_type>::m_changes.add(
                    TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                TableColumnBuffer<t_type>::m_modified_time = Time::SystemTime();
            }
        }
        template<class t_n_type>
        void _removeIndices(uint04 location, typename std::enable_if<!ObjectInfo<t_n_type>::Number || ObjectInfo<t_n_type>::Dimensions >= 16, uint04>::type size) {UNUSED(location); UNUSED(size); }

        template<class t_n_type>
        void _removeIndices(typename std::enable_if<ObjectInfo<t_n_type>::Number, const Buffer<uint04>&>::type offset_lookup_list)
        {
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < TableColumnBuffer<t_type>::m_buffer.size(); i++)
            {
                if (IsValid(TableColumnBuffer<t_type>::m_buffer[i]))
                {
                    uint04 value = offset_lookup_list[cast<uint04>(TableColumnBuffer<t_type>::m_buffer[i])];
                    if (cast<t_type>(value) != TableColumnBuffer<t_type>::m_buffer[i])
                    {
                        TableColumnBuffer<t_type>::m_buffer[i] = cast<t_type>(value);
                        update_range.addToBounds(i);
                    }
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                TableColumnBuffer<t_type>::m_changes.add(
                    TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                TableColumnBuffer<t_type>::m_modified_time = Time::SystemTime();
            }
        }
        template<class t_n_type>
        void _swapIndices(typename std::enable_if<ObjectInfo<t_n_type>::Number, uint04>::type a, uint04 b)
        {
            for (uint04 i = 0; i < TableColumnBuffer<t_type>::m_buffer.size(); i++)
            {
                if (!IsValid(TableColumnBuffer<t_type>::m_buffer[i]))
                    continue;
                uint04 val = cast<uint04>(TableColumnBuffer<t_type>::m_buffer[i]);
                if (val == a)
                    TableColumnBuffer<t_type>::m_buffer[i] = cast<t_type>(b);
                else if (val == b)
                    TableColumnBuffer<t_type>::m_buffer[i] = cast<t_type>(a);
            }
        }
        template<class t_n_type>
        void _swapIndices(typename std::enable_if<!ObjectInfo<t_n_type>::Number, uint04>::type a, uint04 b) { UNUSED(a); UNUSED(b);}
        template<class t_n_type>
        void _removeIndices(typename std::enable_if<!ObjectInfo<t_n_type>::Number, const Buffer<uint04>&>::type offset_lookup_list) {UNUSED(offset_lookup_list);}
    };

    template<>
    class TableVectorType<1, UUID> : public TableVectorType<16, uint01>
    {
    public:
        TableVectorType(const StringView& label)
            : TableVectorType<16, uint01>(label)
        {}
    public:
        void get(uint04, bool& value) const override { value = false; };
        void set(uint04 index, bool value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, uint01 value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, uint02 value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, uint04 value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, uint08 value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, sint01 value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, sint02 value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, sint04 value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, sint08 value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, fltp04 value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, fltp08 value) override { TableVectorType<16, uint01>::pullValue(index) = UUID(0).appendUUID(value); };
        void set(uint04 index, RGBColor value) override {  UNUSED(index); UNUSED(value); lib_assert(false, "cannot get as color");/*TableColumnBuffer<t_type>::pullValue(index) = value.getAs<Vector<t_dims, t_type>>();*/ };
        void set(uint04 index, const StringView& value) override { TableVectorType<16, uint01>::pullValue(index) = value.getAs<UUID>(); };
        void get(uint04 index, StringAllocatingView& value) const override { value.allocate(UUID(TableVectorType<16, uint01>::pullValue(index))); };
        void get(uint04, StringView&) const override { lib_assert(false, "cannot get as string view"); };

        virtual void set(uint04 index, const UUID& value) final override
        {
            TableVectorType<16, uint01>::pullValue(index) = value;
        }

        virtual void get(uint04 index, UUID& id) const final override
        {
            id = UUID(TableVectorType<16, uint01>::pullValue(index));
        }

        decltype(auto) pullValue(uint04 index)
        {
            return m_buffer[index];
        }

        decltype(auto) pullValue(uint04 index) const
        {
            return m_buffer[index];
        }
    };

    template<class t_type>
    class TableColumnTypeBuffer : public TableColumnBuffer<Buffer<t_type>>
    {
    public:
        virtual TypeInfo type() const override
        {
            return GetTypeInfo<Buffer<t_type>>();
        }

        TableColumnTypeBuffer(const StringView& label)
            : TableColumnBuffer<Buffer<t_type>>(label)
        {}
    public:
        void set(uint04 index, uint04 vector_pos, bool value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, uint01 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, uint02 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, uint04 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, uint08 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, sint01 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, sint02 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, sint04 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, sint08 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, fltp04 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, fltp08 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = cast<t_type>(value); };
        void set(uint04 index, uint04 vector_pos, const StringView& value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos] = value.getAs<t_type>(); };

        void set(uint04 index, bool value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, uint01 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, uint02 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, uint04 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, uint08 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, sint01 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, sint02 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, sint04 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, sint08 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, fltp04 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, fltp08 value) override { TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(cast<t_type>(value)); };
        void set(uint04 index, const StringView& value) override { UNUSED(index); UNUSED(value);/*TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(value.getAs<Vector<t_dims, t_type>>());*/ };
        void set(uint04 index, RGBColor value) override { UNUSED(index); UNUSED(value);/*TableColumnBuffer<Buffer<t_type>>::pullValue(index).setAllToValue(value.getAs<t_dims, t_type>());*/ };

        void get(uint04 index, uint04 vector_pos, bool& value) const override { value = cast<bool>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, uint01& value) const override { value = cast<uint01>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, uint02& value) const override { value = cast<uint02>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, uint04& value) const override { value = cast<uint04>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, uint08& value) const override { value = cast<uint08>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, sint01& value) const override { value = cast<sint01>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, sint02& value) const override { value = cast<sint02>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, sint04& value) const override { value = cast<sint04>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, sint08& value) const override { value = cast<sint08>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, fltp04& value) const override { value = cast<fltp04>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, fltp08& value) const override { value = cast<fltp08>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos]); };
        void get(uint04 index, uint04 vector_pos, StringAllocatingView& value) const override { value.allocate(cast<fltp08>(TableColumnBuffer<Buffer<t_type>>::pullValue(index)[vector_pos])); };

        void get(uint04 index, bool& value) const override { value = cast<bool>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, uint01& value) const override { value = cast<uint01>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, uint02& value) const override { value = cast<uint02>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, uint04& value) const override { value = cast<uint04>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, uint08& value) const override { value = cast<uint08>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, sint01& value) const override { value = cast<sint01>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, sint02& value) const override { value = cast<sint02>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, sint04& value) const override { value = cast<sint04>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, sint08& value) const override { value = cast<sint08>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, fltp04& value) const override { value = cast<fltp04>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, fltp08& value) const override { value = cast<fltp08>(TableColumnBuffer<Buffer<t_type>>::pullValue(index).last()); };
        void get(uint04 index, StringAllocatingView& value) const override { lib_assert(false, "unimplemented"); UNUSED(index); UNUSED(value);/*value = String(TableColumnBuffer<Buffer<t_type>>::pullValue(index));*/ };
        void get(uint04 index, StringView& value) const override { lib_assert(false, "unimplemented"); UNUSED(index); UNUSED(value);/*value = String(TableColumnBuffer<Buffer<t_type>>::pullValue(index));*/ };
        void get(uint04 index, RGBColor& value) const override { lib_assert(false, "unimplemented"); UNUSED(index); UNUSED(value);/*value = RGBColor(m_buffer[index].last());*/ };

        virtual void insertIndices(uint04 location, uint04 size) override
        {
            this->template _insertIndices<t_type>(location, size);
        }

        virtual void removeIndices(uint04 location, uint04 size) override
        {
            this->template _removeIndices<t_type>(location, size);
        }

        virtual void removeIndices(const Buffer<uint04>& offset_lookup_list) override
        {
            this->template _removeIndices<t_type>(offset_lookup_list);
        }

        virtual void swapIndices(uint04 a, uint04 b) override
        {
            this->template _swapIndices<t_type>(a, b);
        }

        uint08 tableHash() const override
        {
            uint08 result = 2166136261U;
            std::hash<t_type> hash;
            for (const Buffer<t_type>& b : TableColumnBuffer<Buffer<t_type>>::m_buffer)
            {
                for(uint04 i = 0; i < b.size(); i++)
                    result = (127 * result) + hash(b[i]);
            }
            return result;
        }

        void setRowSize(uint04 index, uint04 size) override { TableColumnBuffer<Buffer<t_type>>::m_buffer[index].setSize(size); };
        uint04 getRowSize(uint04 index) const override { return TableColumnBuffer<Buffer<t_type>>::m_buffer[index].size(); };
        TableColumnTypeBuffer<t_type>* getSelected(const Buffer<bool>& selected_indices) const override { UNUSED(selected_indices); return nullptr; };
    private:
        template<class t_n_type>
        void _insertIndices(uint04 location, typename std::enable_if<ObjectInfo<t_n_type>::Number, uint04>::type size)
        {
            if (size == 0)
                return;
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < TableColumnBuffer<Buffer<t_type>>::m_buffer.size(); i++)
            {
                for (uint04 n = 0; n < TableColumnBuffer<Buffer<t_type>>::m_buffer[i].size(); n++)
                {
                    if (TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n] >= cast<t_type>(location)
                        && IsValid(TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n]))
                    {
                        TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n] += cast<t_type>(size);
                        update_range.addToBounds(i);
                    }
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                TableColumnBuffer<Buffer<t_type>>::m_changes.add(
                    TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                TableColumnBuffer<Buffer<t_type>>::m_modified_time = Time::SystemTime();
            }
        }
        template<class t_n_type>
        void _insertIndices(uint04 location, typename std::enable_if<!ObjectInfo<t_n_type>::Number, uint04>::type size) { UNUSED(location); UNUSED(size); }

        template<class t_n_type>
        void _removeIndices(uint04 location, typename std::enable_if<ObjectInfo<t_n_type>::Number, uint04>::type size)
        {
            if (size == 0)
                return;
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < TableColumnBuffer<Buffer<t_type>>::m_buffer.size(); i++)
            {
                for (uint04 n = TableColumnBuffer<Buffer<t_type>>::m_buffer[i].size() - 1; IsValid(n); --n)
                {
                    if (TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n] >= cast<t_type>(location) && IsValid(TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n]))
                    {
                        if (TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n] < cast<t_type>(location + size))
                            TableColumnBuffer<Buffer<t_type>>::m_buffer[i].removeIndex(n);
                        else
                            TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n] -= cast<t_type>(size);
                        update_range.addToBounds(i);
                    }
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                TableColumnBuffer<Buffer<t_type>>::m_changes.add(
                    TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                TableColumnBuffer<Buffer<t_type>>::m_modified_time = Time::SystemTime();
            }
        }
        template<class t_n_type>
        void _swapIndices(typename std::enable_if<ObjectInfo<t_n_type>::Number, uint04>::type a, uint04 b)
        {
            for (uint04 i = 0; i < TableColumnBuffer<Buffer<t_type>>::m_buffer.size(); i++)
            {
                for (uint04 n = TableColumnBuffer<Buffer<t_type>>::m_buffer[i].size() - 1; IsValid(n); --n)
                {
                    if (!IsValid(TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n]))
                        continue;
                    uint04 val = cast<uint04>(TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n]);
                    if (val == a)
                        TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n] = cast<t_type>(b);
                    else if (val == b)
                        TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n] = cast<t_type>(a);
                }
                
            }
        }
        template<class t_n_type>
        void _removeIndices(uint04 location, typename std::enable_if<!ObjectInfo<t_n_type>::Number, uint04>::type size)
        {
            UNUSED(location);
            UNUSED(size);
        }

        template<class t_n_type>
        void _removeIndices(typename std::enable_if<ObjectInfo<t_n_type>::Number, const Buffer<uint04>&>::type offset_lookup_list)
        {
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < TableColumnBuffer<Buffer<t_type>>::m_buffer.size(); i++)
            {
                for (uint04 n = TableColumnBuffer<Buffer<t_type>>::m_buffer[i].size() - 1; IsValid(n); --n)
                {
                    if (IsValid(TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n]))
                    {
                        uint04 value = offset_lookup_list[cast<uint04>(TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n])];
                        if (IsInvalid(value))
                        {
                            TableColumnBuffer<Buffer<t_type>>::m_buffer[i].removeIndex(n);
                            update_range.addToBounds(i);
                        }
                        else if(TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n] != cast<t_type>(value))
                        {
                            TableColumnBuffer<Buffer<t_type>>::m_buffer[i][n] = cast<t_type>(value);
                            update_range.addToBounds(i);
                        }
                    }
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                TableColumnBuffer<Buffer<t_type>>::m_changes.add(
                    TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                TableColumnBuffer<Buffer<t_type>>::m_modified_time = Time::SystemTime();
            }
        }
        template<class t_n_type>
        void _swapIndices(typename std::enable_if<!ObjectInfo<t_n_type>::Number, uint04>::type a, uint04 b)
        {
            UNUSED(a);
            UNUSED(b);
        }
        template<class t_n_type>
        void _removeIndices(typename std::enable_if<!ObjectInfo<t_n_type>::Number, const Buffer<uint04>&>::type offset_lookup_list)
        {
            UNUSED(offset_lookup_list);
        }
    };

    class NDEVR_DATABASE_API TableColumnString : public TableColumnBuffer<String>
    {
    public:
        virtual TypeInfo type() const override
        {
            return GetTypeInfo<String>();
        }

        TableColumnString(const StringView& label)
            : TableColumnBuffer<String>(label)
        {}
    public:
        void removeRows(uint04 offset, const Buffer<bool>& indices) override { UNUSED(offset); UNUSED(indices);};
        void set(uint04 index, uint04 vector_pos, bool value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04 index, uint04 vector_pos, uint01 value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04 index, uint04 vector_pos, uint02 value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04 index, uint04 vector_pos, uint04 value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04 index, uint04 vector_pos, uint08 value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04 index, uint04 vector_pos, sint01 value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04 index, uint04 vector_pos, sint02 value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04 index, uint04 vector_pos, sint04 value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04 index, uint04 vector_pos, sint08 value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04 index, uint04 vector_pos, fltp04 value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04 index, uint04 vector_pos, fltp08 value) override { TableColumnBuffer<String>::pullValue(index).insert(vector_pos, String(value)); };
        void set(uint04, uint04, const StringView&) override { lib_assert(false, "Not implemented"); };

        void set(uint04 index, bool value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, uint01 value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, uint02 value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, uint04 value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, uint08 value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, sint01 value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, sint02 value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, sint04 value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, sint08 value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, fltp04 value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, fltp08 value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };
        void set(uint04 index, const StringView& value) override { TableColumnBuffer<String>::pullValue(index) = value; };
        void set(uint04 index, RGBColor value) override { TableColumnBuffer<String>::pullValue(index).setFrom(value); };

        void get(uint04 index, uint04 vector_pos, bool& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<bool>(); };
        void get(uint04 index, uint04 vector_pos, uint01& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<uint01>(); };
        void get(uint04 index, uint04 vector_pos, uint02& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<uint02>(); };
        void get(uint04 index, uint04 vector_pos, uint04& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<uint04>(); };
        void get(uint04 index, uint04 vector_pos, uint08& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<uint08>(); };
        void get(uint04 index, uint04 vector_pos, sint01& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<sint01>(); };
        void get(uint04 index, uint04 vector_pos, sint02& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<sint02>(); };
        void get(uint04 index, uint04 vector_pos, sint04& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<sint04>(); };
        void get(uint04 index, uint04 vector_pos, sint08& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<sint08>(); };
        void get(uint04 index, uint04 vector_pos, fltp04& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<fltp04>(); };
        void get(uint04 index, uint04 vector_pos, fltp08& value) const override { value = String(&TableColumnBuffer<String>::pullValue(index)[vector_pos]).getAs<fltp08>(); };
        void get(uint04 index, uint04 vector_pos, StringAllocatingView& value) const override { value.allocate(String(&TableColumnBuffer<String>::pullValue(index)[vector_pos])); };

        void get(uint04 index, bool& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<bool>(); };
        void get(uint04 index, uint01& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<uint01>(); };
        void get(uint04 index, uint02& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<uint02>(); };
        void get(uint04 index, uint04& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<uint04>(); };
        void get(uint04 index, uint08& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<uint08>(); };
        void get(uint04 index, sint01& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<sint01>(); };
        void get(uint04 index, sint02& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<sint02>(); };
        void get(uint04 index, sint04& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<sint04>(); };
        void get(uint04 index, sint08& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<sint08>(); };
        void get(uint04 index, fltp04& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<fltp04>(); };
        void get(uint04 index, fltp08& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<fltp08>(); };
        void get(uint04 index, StringAllocatingView& value) const override { value.reference(TableColumnBuffer<String>::pullValue(index)); };
        void get(uint04 index, StringView& value) const override { value = TableColumnBuffer<String>::pullValue(index); };
        void get(uint04 index, RGBColor& value) const override { value = TableColumnBuffer<String>::pullValue(index).getAs<RGBColor>(); };

        TableColumnString* getSelected(const Buffer<bool>& selected_indices) const override { UNUSED(selected_indices); return nullptr; };
        virtual void insertIndices(uint04 location, uint04 size) override
        {
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < m_buffer.size(); i++)
            {
                uint04 value = m_buffer[i].getAs<uint04>();
                if (IsValid(value) && value >= location)
                {
                    m_buffer[i] = String(value + size);
                    update_range.addToBounds(i);
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                m_changes.add(TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                m_modified_time = Time::SystemTime();
            }
        }

        uint08 tableHash() const override
        {
            uint08 result = 2166136261U;
            for (const String& s : m_buffer)
                result = (127 * result) ^ s.hash();
            return result;
        }

        virtual void swapIndices(uint04, uint04) override
        {
            lib_assert(false, "Not implemented");
        }

        virtual void removeIndices(uint04 location, uint04 size) override
        {
            if (size == 0)
                return;
            Bounds<1, uint04> update_range = Constant<Bounds<1, uint04>>::Min;
            for (uint04 i = 0; i < m_buffer.size(); i++)
            {
                uint04 value = m_buffer[i].getAs<uint04>();
                if (IsValid(value) && value > location)
                {
                    if (value < location + size)
                        m_buffer[i] = "NaN";
                    else
                        m_buffer[i] = String(value -= size);
                    update_range.addToBounds(i);
                }
            }
            if (update_range != Constant<Bounds<1, uint04>>::Min)
            {
                m_changes.add(TableChange(TableChange::e_update, update_range[MIN], update_range.span()));
                m_modified_time = Time::SystemTime();
            }
        }

        virtual void removeIndices(const Buffer<uint04>& offset_lookup_list) override
        {
            UNUSED(offset_lookup_list);
            lib_assert(false, "Not yet implemented");
        }

        virtual void mapFromFile(BinaryFileTableInfo& file) override
        {
            if (file.version_number < 1614203273)
            {
                TableColumnBuffer<String>::mapFromFile(file);
            }
            else if (file.version_number < 1614739690)
            {
                bool allow_multithreading = false;
                file.file.readStringBuffer(m_buffer, allow_multithreading);
            }
            else
            {
                TableColumnBuffer<String>::mapFromFile(file);
            }
        }

        void setRowSize(uint04 index, uint04 size) override { m_buffer[index].setSize(size); }
        [[nodiscard]] uint04 getRowSize(uint04 index) const override { return m_buffer[index].size(); }
        [[nodiscard]] bool isSame(uint04 index, const StringView& value) const override { return value == m_buffer[index];}
        [[nodiscard]] bool contains(uint04 index, const StringView& value, bool ignore_case) const final override { return pullValue(index).hasSubString(value, ignore_case); }
        [[nodiscard]] bool beginsWith(uint04 index, const StringView& value, bool ignore_case) const final override { return pullValue(index).beginsWith(value, ignore_case); }
    };

    class TableColumnColorType : public TableColumnBuffer<RGBColor>
    {
    public:
        virtual TypeInfo type() const override
        {
            return GetTypeInfo<RGBColor>();
        }

        TableColumnColorType(const StringView& label)
            : TableColumnBuffer<RGBColor>(label)
        {}

        TableColumnColorType(const Buffer<RGBColor>& buffer, const String& label)
            : TableColumnBuffer<RGBColor>(buffer, label)
        {}

        virtual void setDefaultValue(const StringAllocatingView& value) override
        {
            TableColumnBuffer<RGBColor>::m_default_value = value.getAs<RGBColor>();
        }
    public:
        void set(uint04 index, uint04 vector_pos, bool value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = value ? 255 : 0; TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, uint01 value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = cast<uint01>(value); TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, uint02 value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = cast<uint01>(value); TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, uint04 value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = cast<uint01>(value); TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, uint08 value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = cast<uint01>(value); TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, sint01 value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = cast<uint01>(value); TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, sint02 value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = cast<uint01>(value); TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, sint04 value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = cast<uint01>(value); TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, sint08 value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = cast<uint01>(value); TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, fltp04 value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = cast<uint01>(value * 255); TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, fltp08 value) override { RGBColor color(TableColumnBuffer<RGBColor>::pullValue(index));  color[cast<uint01>(vector_pos)] = cast<uint01>(value * 255); TableColumnBuffer<RGBColor>::pullValue(index) = color; };
        void set(uint04 index, uint04 vector_pos, const StringView& value) override { set(index, vector_pos, value.getAs<uint01>()); };

        void set(uint04 index, bool value) override { TableColumnBuffer<RGBColor>::pullValue(index) = value ? RGBColor(255, 255, 255) : RGBColor(0, 0, 0); };
        void set(uint04 index, uint02 value) override { TableColumnBuffer<RGBColor>::pullValue(index) = RGBColor(value); };
        void set(uint04 index, uint01 value) override { TableColumnBuffer<RGBColor>::pullValue(index) = RGBColor(cast<uint04>(value)); };
        void set(uint04 index, sint02 value) override { TableColumnBuffer<RGBColor>::pullValue(index) = RGBColor(value); };
        void set(uint04 index, sint01 value) override { TableColumnBuffer<RGBColor>::pullValue(index) = RGBColor(cast<uint04>(value)); };
        void set(uint04 index, uint04 value) override { TableColumnBuffer<RGBColor>::pullValue(index) = RGBColor(value); };
        void set(uint04 index, uint08 value) override { TableColumnBuffer<RGBColor>::pullValue(index) = RGBColor(cast<uint04>(value)); };
        void set(uint04 index, sint04 value) override { TableColumnBuffer<RGBColor>::pullValue(index) = RGBColor(cast<uint04>(value)); };
        void set(uint04 index, sint08 value) override { TableColumnBuffer<RGBColor>::pullValue(index) = RGBColor(cast<uint04>(value)); };
        void set(uint04 index, fltp04 value) override { TableColumnBuffer<RGBColor>::pullValue(index) = RGBColor(value, value, value); };
        void set(uint04 index, fltp08 value) override { TableColumnBuffer<RGBColor>::pullValue(index) = RGBColor(value, value, value); };
        void set(uint04 index, const StringView& value) override { TableColumnBuffer<RGBColor>::pullValue(index) = value.getAs<RGBColor>(); };
        void set(uint04 index, RGBColor value) override { TableColumnBuffer<RGBColor>::pullValue(index) = value; };

        void get(uint04 index, uint04 vector_pos, bool& value) const override { value = cast<bool>(TableColumnBuffer<RGBColor>::pullValue(index)[cast<uint01>(vector_pos)]); };
        void get(uint04 index, uint04 vector_pos, uint01& value) const override { value = cast<uint01>(TableColumnBuffer<RGBColor>::pullValue(index)[cast<uint01>(vector_pos)]); };
        void get(uint04 index, uint04 vector_pos, uint02& value) const override { value = cast<uint02>(TableColumnBuffer<RGBColor>::pullValue(index)[cast<uint01>(vector_pos)]); };
        void get(uint04 index, uint04 vector_pos, uint04& value) const override { value = cast<uint04>(TableColumnBuffer<RGBColor>::pullValue(index)[cast<uint01>(vector_pos)]); };
        void get(uint04 index, uint04 vector_pos, uint08& value) const override { value = cast<uint08>(TableColumnBuffer<RGBColor>::pullValue(index)[cast<uint01>(vector_pos)]); };
        void get(uint04 index, uint04 vector_pos, sint01& value) const override { value = cast<sint01>(TableColumnBuffer<RGBColor>::pullValue(index)[cast<uint01>(vector_pos)]); };
        void get(uint04 index, uint04 vector_pos, sint02& value) const override { value = cast<sint02>(TableColumnBuffer<RGBColor>::pullValue(index)[cast<uint01>(vector_pos)]); };
        void get(uint04 index, uint04 vector_pos, sint04& value) const override { value = cast<sint04>(TableColumnBuffer<RGBColor>::pullValue(index)[cast<uint01>(vector_pos)]); };
        void get(uint04 index, uint04 vector_pos, sint08& value) const override { value = cast<sint08>(TableColumnBuffer<RGBColor>::pullValue(index)[cast<uint01>(vector_pos)]); };
        void get(uint04 index, uint04 vector_pos, fltp04& value) const override { value = TableColumnBuffer<RGBColor>::pullValue(index).getF(cast<uint01>(vector_pos)); };
        void get(uint04 index, uint04 vector_pos, fltp08& value) const override { value = TableColumnBuffer<RGBColor>::pullValue(index).getF(cast<uint01>(vector_pos)); };
        void get(uint04 index, uint04 vector_pos, StringAllocatingView& value) const override { value.allocate(TableColumnBuffer<RGBColor>::pullValue(index)[cast<uint01>(vector_pos)]); };

        void get(uint04 index, bool& value) const override { value = TableColumnBuffer<RGBColor>::pullValue(index).convertToRGBA32BitColor() == 0; };
        void get(uint04 index, sint01& value) const override { value = cast<sint01>(TableColumnBuffer<RGBColor>::pullValue(index).convertToRGBA32BitColor()); lib_assert(false, "unexpected conversion"); };
        void get(uint04 index, sint02& value) const override { value = cast<sint02>(TableColumnBuffer<RGBColor>::pullValue(index).convertToRGBA32BitColor()); lib_assert(false, "unexpected conversion"); };
        void get(uint04 index, uint01& value) const override { value = cast<uint01>(TableColumnBuffer<RGBColor>::pullValue(index).convertToRGBA32BitColor()); lib_assert(false, "unexpected conversion"); };
        void get(uint04 index, uint02& value) const override { value = cast<uint02>(TableColumnBuffer<RGBColor>::pullValue(index).convertToRGBA32BitColor()); lib_assert(false, "unexpected conversion"); };
        void get(uint04 index, uint04& value) const override { value = TableColumnBuffer<RGBColor>::pullValue(index).convertToRGBA32BitColor(); };
        void get(uint04 index, uint08& value) const override { value = TableColumnBuffer<RGBColor>::pullValue(index).convertToRGBA32BitColor(); };
        void get(uint04 index, sint04& value) const override { value = rcast<sint04>(TableColumnBuffer<RGBColor>::pullValue(index).convertToRGBA32BitColor()); };
        void get(uint04 index, sint08& value) const override { value = cast<sint08>(TableColumnBuffer<RGBColor>::pullValue(index).convertToRGBA32BitColor()); };
        void get(uint04 index, fltp04& value) const override { value = TableColumnBuffer<RGBColor>::pullValue(index).luminance(); };
        void get(uint04 index, fltp08& value) const override { value = TableColumnBuffer<RGBColor>::pullValue(index).luminance(); };
        void get(uint04 index, StringAllocatingView& value) const override { value.allocate(TableColumnBuffer<RGBColor>::pullValue(index)); };
        void get(uint04, StringView&) const override { lib_assert(false, "Not implemented"); };
        void get(uint04 index, RGBColor& value) const override { value = TableColumnBuffer<RGBColor>::pullValue(index); };

        void insertIndices(uint04, uint04) override { lib_assert(false, "Insert indices not implemented for color channel"); }
        void removeIndices(uint04, uint04) override { lib_assert(false, "Remove indices not implemented for color channel"); }
        void removeIndices(const Buffer<uint04>&) override { lib_assert(false, "Remove indices not implemented for color channel"); }
        virtual void swapIndices(uint04, uint04) override { lib_assert(false, "Not implemented for color channel"); }
        TableColumnColorType* getSelected(const Buffer<bool>& selected_indices) const override
        {
            TableColumnColorType* new_vector_array = new TableColumnColorType(TableColumn::label());
            new_vector_array->setSize(selected_indices.count(true));
            uint04 current_index = 0;
            for (uint04 i = 0; i < selected_indices.size(); i++)
            {
                if (selected_indices[i])
                {
                    new_vector_array->m_buffer[current_index++] = TableColumnBuffer<RGBColor>::m_buffer[i];
                }
            }
            return new_vector_array;
        }
    };
 
 
    template<class T> struct ColumnTBase { using type = TableVectorType<1, T>; };
 
    template<class T> struct ColumnTBase<Buffer<T>> { using type = TableColumnTypeBuffer<T>; };
    template<> struct ColumnTBase<Buffer<RGBColor>> { using type = TableColumnTypeBuffer<uint04>; };
 
    template<uint01 t_dims, class T> struct ColumnTBase<Vector<t_dims, T>> { using type = TableVectorType<t_dims, T>; };
 
    template<> struct ColumnTBase<String> { using type = TableColumnString; };
    template<> struct ColumnTBase<StringView> { using type = TableColumnString; };
    template<> struct ColumnTBase<TranslatedString> { using type = TableColumnString; };
 
    template<> struct ColumnTBase<RGBColor> { using type = TableColumnColorType; };
    template<> struct ColumnTBase<Time> { using type = TableVectorType<1, uint08>; };
 
    template<class T, uint01 t_cols, uint01 t_rows>
    struct ColumnTBase<Matrix<T, t_cols, t_rows>> { using type = TableMatrixType<T, t_cols, t_rows>; };
 
    template<uint01 t_dims, class T>
    struct ColumnTBase<Bounds<t_dims, T>> { using type = TableVectorType<2 * t_dims, T>; };
 
    template<> struct ColumnTBase<Vector<8, bool>> { using type = TableVectorType<1, uint01>; };
    template<> struct ColumnTBase<Vector<16, bool>> { using type = TableVectorType<1, uint02>; };
    template<> struct ColumnTBase<Vector<32, bool>> { using type = TableVectorType<1, uint04>; };
    template<> struct ColumnTBase<Vector<64, bool>> { using type = TableVectorType<1, uint08>; };
 
    template<class T>
    using ColumnT = typename ColumnTBase<T>::type;
}
#if __clang__
    #pragma clang diagnostic pop
#endif