TableColumn.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: TableColumn
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/String.h>
#include <NDEVR/Time.h>
#include <NDEVR/File.h>
#include <NDEVR/UUID.h>
#include <NDEVR/Vector.h>
#include <NDEVR/TranslatedString.h>
#include <NDEVR/TypeInfo.h>
#include <NDEVR/RGBColor.h>
#include <NDEVR/BitFlag.h>
#include <NDEVR/Compressor.h>
namespace NDEVR
{
    class RGBColor;
    class Table;
    struct BinaryFileTableInfo;
    struct NDEVR_DATABASE_API TableChange
    {
        enum TableChangeType
        {
              e_update          
            , e_insertion       
            , e_deletion        
            , e_full_update     
        };

        TableChange(TableChangeType type, uint04 start, uint04 size, Time time = Time::SystemTime())
            : time(time)
            , start(start)
            , size(size)
            , type(type)
        {}
        Time time;              
        uint04 start;           
        uint04 size;            
        TableChangeType type;   
    };

    class NDEVR_DATABASE_API TableColumn
    {
    public:
        TableColumn(const StringView& label);

        virtual ~TableColumn();

        const String& label() const;

        void setLabel(const StringView& label);

        virtual void setSize(uint04 size) = 0;

        virtual void setRowSize(uint04, uint04) { lib_assert(false, "Must be of array type to use"); };

        virtual uint04 getRowSize(uint04) const { lib_assert(false, "Must be of array type to use"); return 0; };

        virtual TypeInfo type() const = 0;

        virtual void removeRow(uint04 index) = 0;

        virtual void removeRows(uint04 index, uint04 size) = 0;

        virtual void removeRows(const Buffer<uint04>& sorted_remove_indices) = 0;

        virtual void insert(uint04 index) = 0;

        template<class t_class>
        typename std::enable_if<!ObjectInfo<t_class>::Enum>::type set(uint04 index, const t_class& value);

        template<std::size_t N>
        void set(uint04 index, const char(&string)[N])
        {
            set(index, StringView(string));
        }

        void set(uint04 index, const char* string)
        {
            set(index, StringView(string));
        }

        void set(uint04 index, const StringAllocatingView& string)
        {
            set(index, StringView(string));
        }

        void set(uint04 index, const BitReference& val)
        {
            bool bval = val;
            set(index, bval);
        }

        template<class t_pointer_type>
        void set(uint04 index, t_pointer_type* pointer)
        {
            set(index, (uint08)(pointer));
        }

        template<class t_pointer_type>
        void set(uint04 index, const t_pointer_type* pointer)
        {
            set(index, (uint08)(pointer));
        }

        void set(uint04 index, const std::nullptr_t&)
        {
            set(index, 0U);
        }

        virtual void swap(uint04 a, uint04 b) = 0;

        virtual void set(uint04 index, bool value) = 0;

        virtual void set(uint04 index, uint01 value) = 0;

        virtual void set(uint04 index, uint02 value) = 0;

        virtual void set(uint04 index, uint04 value) = 0;

        virtual void set(uint04 index, uint08 value) = 0;

        virtual void set(uint04 index, sint01 value) = 0;

        virtual void set(uint04 index, sint02 value) = 0;

        virtual void set(uint04 index, sint04 value) = 0;

        virtual void set(uint04 index, sint08 value) = 0;

        virtual void set(uint04 index, fltp04 value) = 0;

        virtual void set(uint04 index, fltp08 value) = 0;

        virtual void set(uint04 index, const StringView& value) = 0;

        virtual void set(uint04 index, RGBColor value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, bool value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, uint01 value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, uint02 value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, uint04 value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, uint08 value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, sint01 value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, sint02 value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, sint04 value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, sint08 value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, fltp04 value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, fltp08 value) = 0;

        virtual void set(uint04 index, uint04 vector_pos, const StringView& value) = 0;

        virtual void set(uint04 index, const Matrix<fltp08>& transform);

        virtual void set(uint04 index, const Matrix<fltp04>& transform);

        virtual void set(uint04 index, const Bounds<3, fltp08>& bounds);

        virtual void set(uint04 index, const Bounds<3, fltp04>& bounds);

        virtual void compress(BinaryCompressionObject& object) = 0;

        virtual void resetRow(uint04) {}

        virtual void mapToFile(BinaryFileTableInfo&, int) {};

        virtual void mapToFile(BinaryFileTableInfo&, BinaryCompressionObject&) {};

        virtual void mapFromFile(BinaryFileTableInfo&) {};

        virtual void finishMapFromFile(BinaryFileTableInfo&) {};

        virtual void set(uint04 index, const UUID& value);

        void set(uint04 index, const Time& time);

        void set(uint04 index, const Vector<32, bool>& value);

        void set(uint04 index, const TranslatedString& value);

        void set(uint04 index, const File& value);

        void set(uint04 index, const String& value);

        template<uint01 t_dims, class t_type>
        void set(uint04 index, const Triangle<t_dims, t_type>& value)
        {
            lib_assert(type().vector_size == t_dims * 3, "Unexpected vector size write to column");
            for (uint01 i = 0; i < 3; i++)
                for (uint01 n = 0; n < t_dims; n++)
                    set(index, 3 * i + n, value[i][n]);
        }
 

        template<uint01 t_dims, class t_type>
        void set(uint04 index, const Bounds<t_dims, t_type>& value)
        {
            lib_assert(type().vector_size == t_dims * 2, "Unexpected vector size write to column");
            for (uint01 i = 0; i < 2; i++)
                for (uint01 n = 0; n < t_dims; n++)
                    set(index, t_dims * i + n, value[i][n]);
        }

        template<class t_type, uint01 t_col, uint01 t_row>
        void set(uint04 index, const Matrix<t_type, t_col, t_row>& matrix)
        {
            lib_assert(type().vector_size == t_col * t_row, "Unexpected vector size write to column");
            for (uint01 col = 0; col < t_col; col++)
                for (uint01 row = 0; row < t_row; row++)
                    set(index, col * t_row + row, matrix[col][row]);
        }

        template<class t_class>
        typename std::enable_if<IsVec<t_class>::value>::type set(uint04 index, const t_class& value)
        {
            if (t_class::NumberOfDimensions() == 1)
                set(index, value[0]);
            else
                setVector(index, value);
        }

        template<class t_class>
        typename std::enable_if<ObjectInfo<t_class>::Enum>::type set(uint04 index, const t_class& value)
        {
            lib_assert(type().vector_size == 0, "Unexpected vector size write to column");
            set(index, cast<uint04>(value));
        }

        inline void set(uint04 index, const BitFlag& bitflag)
        {
            set(index, bitflag.bits());
        }
        /*template<class t_class>
        typename std::enable_if<!ObjectInfo<t_class>::Enum && !IsVec<t_class>::value>::type set(uint04 index, const t_class& value)
        {
            lib_assert(type().vector_size == 0, "Unexpected vector size write to column");
            set(index, String(value));
        }*/

        template<class t_type>
        void set(t_type* values, uint04 start_index, uint04 size)
        {
            if (GetTypeInfo<t_type>() == type())
            {
                memcpy(((t_type*)begin()) + start_index, values, size * sizeof(t_type));
            }
            else for (uint04 i = 0; i < size; i++)
            {
                set(i + start_index, values[i]);
            }
        }

        template<uint01 t_dims, class t_type>
        void setVector(uint04 index, const Vector<t_dims, t_type>& value)
        {
            const uint01 dim_size = getMin(cast<uint01>(type().vector_size), t_dims);
            for (uint01 i = 0; i < dim_size; i++)
                set(index, i, value[i]);
        }

        virtual bool isSame(uint04 index, const StringView& value) const = 0;

        virtual bool contains(uint04 index, const StringView& value, bool ignore_case) const = 0;

        virtual bool beginsWith(uint04 index, const StringView& value, bool ignore_case) const = 0;

        template<class t_class>
        void get(uint04 index, Vector<1, t_class>& vector) const
        {
            get(index, vector[0]);
        }

        void get(uint04 index, BitFlag& bitflag) const
        {
            uint01 value;
            get(index, value);
            bitflag = BitFlag(value);
        }

        template<class t_class>
        typename std::enable_if<std::is_pointer<t_class>::value>::type get(uint04 index, t_class& vector) const
        {
            uint08 value;
            get(index, value);
            vector = (t_class)value;
        }

        template<class t_class>
        typename std::enable_if<IsVec<t_class>::value && t_class::NumberOfDimensions() != 1>::type get(uint04 index, t_class& vector) const
        {
            getVector(index, vector);
        }

        template<class t_class>
        typename std::enable_if<ObjectInfo<t_class>::Enum>::type get(uint04 index, t_class& enum_value) const
        {
            uint04 value;
            get(index, value);
            enum_value = cast<t_class>(value);
        }
 

        template<class t_type>
        inline uint04 getIndexOf(const t_type& object) const
        {
            for (uint04 i = 0; i < size(); i++)
            {
                if (object == get<t_type>(i))
                    return i;
            }
            return Constant<uint04>::Invalid;
        }

        void setCompressionMode(CompressionMode compression_mode)
        {
            if (m_compression_mode != compression_mode)
                m_compression_mode = compression_mode;
        }

        virtual void get(uint04 index, uint04 vector_pos, bool& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, uint01& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, uint02& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, uint04& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, uint08& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, sint01& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, sint02& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, sint04& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, sint08& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, fltp04& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, fltp08& value) const = 0;

        virtual void get(uint04 index, uint04 vector_pos, StringAllocatingView& value) const = 0;

        virtual void get(uint04 index, bool& value) const = 0;

        virtual void get(uint04 index, uint01& value) const = 0;

        virtual void get(uint04 index, uint02& value) const = 0;

        virtual void get(uint04 index, uint04& value) const = 0;

        virtual void get(uint04 index, uint08& value) const = 0;

        virtual void get(uint04 index, sint01& value) const = 0;

        virtual void get(uint04 index, sint02& value) const = 0;

        virtual void get(uint04 index, sint04& value) const = 0;

        virtual void get(uint04 index, sint08& value) const = 0;

        virtual void get(uint04 index, fltp04& value) const = 0;

        virtual void get(uint04 index, fltp08& value) const = 0;

        virtual void get(uint04 index, StringAllocatingView& value) const = 0;

        virtual void get(uint04 index, StringView& value) const = 0;

        virtual void get(uint04 index, RGBColor& value) const = 0;

        virtual void get(uint04 index, Matrix<fltp08>& transform) const;

        virtual void get(uint04 index, Matrix<fltp04>& transform) const;

        virtual void get(uint04 index, Bounds<3, fltp08>& bounds) const;

        virtual void get(uint04 index, Bounds<3, fltp04>& bounds) const;

        virtual void getVector(uint04 index, Vector<3, fltp04>& vector) const;

        virtual void getVector(uint04 index, Vector<3, fltp08>& vector) const;

        virtual void getVector(uint04 index, Vector<3, uint04>& vector) const;

        virtual void getVector(uint04 index, Vector<2, uint04>& vector) const;

        virtual void getVector(uint04 index, Vector<1, uint04>& vector) const;

        template<class t_type, uint01 t_col, uint01 t_row>
        void get(uint04 index, Matrix<t_type, t_col, t_row>& matrix) const
        {
            for (uint01 col = 0; col < t_col; col++)
                for (uint01 row = 0; row < t_row; row++)
                    get(index, col * t_row + row, matrix[col][row]);
        }

        void get(uint04 index, File& file) const
        {
            StringAllocatingView value;
            get(index, value);
            file = value;
        }

        virtual void get(uint04 index, UUID& vector) const
        {
            for (uint01 i = 0; i < 16; i++)
                get(index, i, vector[i]);
        }

        void get(uint04 index, Time& time) const
        {
            uint08 value;
            get(index, value);
            time = Time(value);
        }

        void get(uint04 index, const String& value) const = delete;

        void get(uint04 index, TranslatedString& string) const
        {
            StringAllocatingView value;
            get(index, value);
            string = TranslatedString(value);
        }

        void get(uint04 index, Vector<32, bool>& value) const
        {
            uint04 int_value;
            get(index, int_value);
            value = rcast<Vector<32, bool>>(int_value);
            //memcpy(&value, &int_value, sizeof(int_value));
        }

        template<uint01 t_dims, class t_type>
        void get(uint04 index, Bounds<t_dims, t_type>& bounds) const
        {
            for (uint01 i = 0; i < 2; i++)
                for (uint01 n = 0; n < t_dims; n++)
                    get(index, t_dims * i + n, bounds[i][n]);
        }

        template<uint01 t_dims, class t_type>
        void get(uint04 index, Triangle<t_dims, t_type>& tri) const
        {
            for (uint01 i = 0; i < 3; i++)
                for (uint01 n = 0; n < t_dims; n++)
                    get(index, 3 * i + n, tri[i][n]);
        }

        template<class t_class>
        t_class get(uint04 index) const
        {
            t_class value;
            get(index, value);
            return value;
        }

        template<class t_class>
        t_class get(uint04 index, uint04 sub_index) const
        {
            t_class value;
            get(index, sub_index, value);
            return value;
        }

        template<uint01 t_dims, class t_type>
        void getVector(uint04 index, Vector<t_dims, t_type>& value) const
        {
            for (uint01 i = 0; i < t_dims; i++)
                get(index, i, value[i]);
        }

        template<class t_type>
        void insert(uint04 index, const t_type& value)
        {
            insert(index);
            set(index, value);
        }

        virtual void setAll(uint04 to_location, uint04 from_location, uint04 size, const TableColumn& from_column)
        {
            switch (type().vector_size)
            {
            case 0:
            case 1:
            {
                if (type().is_string)
                    setAll<StringView>(to_location, from_location, size, from_column);
                else
                    _setAll<1>(to_location, from_location, size, from_column);
            } break;
 
            case 2: _setAll<2>(to_location, from_location, size, from_column); break;
            case 3: _setAll<3>(to_location, from_location, size, from_column); break;
            case 4: _setAll<4>(to_location, from_location, size, from_column); break;
            case 16: _setAll<16>(to_location, from_location, size, from_column); break;
            default: setAll<StringView>(to_location, from_location, size, from_column); break;
            }
        };

        template<class t_type>
        void setAll(uint04 to_location, uint04 from_location, uint04 size, const TableColumn& from_column)
        {
            bool can_copy = ObjectInfo<t_type>::Primitive;
            can_copy &= !ObjectInfo<t_type>::Boolean;
            can_copy &= type() == GetTypeInfo<t_type>();
            can_copy &= from_column.type() == type();
            can_copy &= begin() != nullptr;
            can_copy &= from_column.begin() != nullptr;
            if(can_copy)
            {
                memmove(
                      (uint01*)(begin()) + to_location * sizeof(t_type)
                    , (uint01*)(from_column.begin()) + from_location * sizeof(t_type)
                    , size * sizeof(t_type));
            }
            else
            {
                for (uint04 i = 0; i < size; i++)
                {
                    set(to_location + i, from_column.get<t_type>(from_location + i));
                }
            }
        }

        virtual TableColumn* getSelected(const Buffer<bool>& selected_indices) const = 0;

        virtual void insertRows(uint04 location, uint04 size) = 0;

        virtual void addRow() { insertRows(size(), 1); }

        virtual void swapIndices(uint04 a, uint04 b) = 0;

        virtual void insertIndices(uint04 location, uint04 size) = 0;

        virtual void removeIndices(uint04 location, uint04 size) = 0;

        virtual void removeIndices(const Buffer<uint04>& offset_lookup_list) = 0;

        virtual void removeRows(uint04 offset, const Buffer<bool>& indices) = 0;

        Time getModifiedTime() const
        {
            return m_modified_time;
        }

        void clearUpdates()
        {
            m_modified_time = Time(0);
            m_changes.clear();
        }

        void updateAll()
        {
            update(TableChange(TableChange::e_update, 0, size()));
        }

        virtual void updateFrom(const TableColumn& column);

        void update(const TableChange& change);

        virtual void copyRow(uint04 source, uint04 destination) = 0;

        virtual void copyRows(uint04 source, uint04 destination, uint04 size) = 0;

        template<class t_type>
        typename std::enable_if<std::is_enum<t_type>::value>::type setDefault(const t_type& value)
        {
            setDefaultValue(StringAllocatingView(cast<uint04>(value)));
        }

        template<class t_type>
        typename std::enable_if<!std::is_enum<t_type>::value>::type setDefault(const t_type& value)
        {
            setDefaultValue(StringAllocatingView(value));
        }

        virtual void setDefaultValue(const StringAllocatingView& value) = 0;

        virtual void setDefaultValueFrom(const TableColumn& column) = 0;

        virtual const StringAllocatingView getDefaultValue() const = 0;

        const Buffer<TableChange>& changes() const
        {
            return m_changes;
        }

        template<class t_type>
        Buffer<t_type> getAll(uint04 start, uint04 size) const
        {
            Buffer<t_type> values(size);
            values.setSize(size);
            if (GetTypeInfo<t_type>() == type())
            {
                memcpy(values.begin(), ((const t_type*)begin()) + start, size * sizeof(t_type));
            }
            else
            {
                for (uint04 i = 0; i < size; ++i)
                    get(i + start, values[i]);
            }
            return values;
        }

        Buffer<TableChange> changesSince(const Time& time) const;

        Buffer<TableChange> changesSince(const Time& time, const Bounds<1, uint04>& range) const;

        bool hasChangesSince(const Time& time, const Bounds<1, uint04>& range) const;

        virtual uint04 size() const = 0;

        virtual void* begin() = 0;

        virtual void* end() = 0;

        virtual const void* begin() const = 0;

        virtual const void* end() const = 0;

        UUID referenceTable() const
        {
            return m_reference_table;
        }

        void setReferenceTable(const UUID table)
        {
            m_reference_table = table;
        }
    private:
        template<uint01 t_dims>
        void _setAll(uint04 to_location, uint04 from_location, uint04 size, const TableColumn& from_column)
        {
            if constexpr (t_dims == 1)
            {
                if (type().is_number)
                {
                    if (type().is_float)
                    {
                        if (type().byte_size == 4)
                            setAll<fltp04>(to_location, from_location, size, from_column);
                        if (type().byte_size == 8)
                            setAll<fltp08>(to_location, from_location, size, from_column);
                    }
                    else if (type().is_unsigned)
                    {
                        if (type().byte_size == 1)
                            setAll<uint01>(to_location, from_location, size, from_column);
                        if (type().byte_size == 2)
                            setAll<uint02>(to_location, from_location, size, from_column);
                        if (type().byte_size == 4)
                            setAll<uint04>(to_location, from_location, size, from_column);
                        if (type().byte_size == 8)
                            setAll<uint08>(to_location, from_location, size, from_column);
                    }
                    else
                    {
                        if (type().byte_size == 1)
                            setAll<sint01>(to_location, from_location, size, from_column);
                        if (type().byte_size == 2)
                            setAll<sint02>(to_location, from_location, size, from_column);
                        if (type().byte_size == 4)
                            setAll<sint04>(to_location, from_location, size, from_column);
                        if (type().byte_size == 8)
                            setAll<sint08>(to_location, from_location, size, from_column);
                    }
                }
                else
                {
                    lib_assert(false, "Table copy type not supported");
                }
            }
            else
            {
                if (type().is_number)
                {
                    if (type().is_float)
                    {
                        if (type().byte_size == 4)
                            setAll<Vector<t_dims, fltp04>>(to_location, from_location, size, from_column);
                        if (type().byte_size == 8)
                            setAll<Vector<t_dims, fltp08>>(to_location, from_location, size, from_column);
                    }
                    else if (type().is_unsigned)
                    {
                        if (type().byte_size == 1)
                            setAll<Vector<t_dims, uint01>>(to_location, from_location, size, from_column);
                        if (type().byte_size == 2)
                            setAll<Vector<t_dims, uint02>>(to_location, from_location, size, from_column);
                        if (type().byte_size == 4)
                            setAll<Vector<t_dims, uint04>>(to_location, from_location, size, from_column);
                        if (type().byte_size == 8)
                            setAll<Vector<t_dims, uint08>>(to_location, from_location, size, from_column);
                    }
                    else
                    {
                        if (type().byte_size == 1)
                            setAll<Vector<t_dims, sint01>>(to_location, from_location, size, from_column);
                        if (type().byte_size == 2)
                            setAll<Vector<t_dims, sint02>>(to_location, from_location, size, from_column);
                        if (type().byte_size == 4)
                            setAll<Vector<t_dims, sint04>>(to_location, from_location, size, from_column);
                        if (type().byte_size == 8)
                            setAll<Vector<t_dims, sint08>>(to_location, from_location, size, from_column);
                    }
                }
                else if (type().is_color)
                {
                    setAll<RGBColor>(to_location, from_location, size, from_column);
                }
                else
                {
                    lib_assert(false, "Table copy type not supported");
                }
            }
        };

        virtual uint08 tableHash() const
        {
            uint08 result = 2166136261U;
            uint01* start = (uint01*)begin();
            uint01* stop = (uint01*)end();
            for (uint01* c = start; c < stop; c++)
                result = (127 * result) ^ *c;
            return result;
        }
 
    protected:
        Buffer<TableChange> m_changes;          
        String m_label;                         
        UUID m_reference_table = Constant<UUID>::Invalid;   
        Time m_modified_time;                   
        CompressionMode m_compression_mode = CompressionMode::e_default_compression;    
    };
}