TableColumn.h

Go to the documentation of this file.

/**--------------------------------------------------------------------------------------------
Copyright (c) 2019, NDEVR LLC
tyler.parke@ndevr.org
  __    __   ____     _____ __     __  _______
 |  \  |  | |  __ \  |  ___|\ \   / / |   __  \
 |   \ |  | | |  \ \ | |___  \ \ / /  |  |__)  |
 |  . \|  | | |__/ / | |___   \ V /   |   _   /
 |  |\    |_|_____/__|_____|___\_/____|  | \  \
 |__| \__________________________________|  \__\
 
Subject to the terms of the Enterprise+ Agreement, NDEVR hereby grants 
Licensee a limited, non-exclusive, non-transferable, royalty-free license 
(without the right to sublicense) to use the API solely for the purpose of 
Licensee's internal development efforts to develop applications for which 
the API was provided.
 
The above copyright notice and this permission notice shall be included in all 
copies or substantial portions of the Software.
 
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED,
INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE
FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
 
Library: 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 BinaryFile;
    struct NDEVR_DATABASE_API TableChange
    {
        enum TableChangeType
        {
              e_update
            , e_insertion
            , e_deletion
        };
        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 String& label);
        TableColumn(const String& label, const TypeInfo type);
        virtual ~TableColumn();
        const String& label() const;
        void setLabel(const String& 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 { return m_type; }
        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;
        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 String& 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 String& value) = 0;
        virtual void set(uint04 index, const Matrix<fltp08>& transform);
        virtual void set(uint04 index, const Matrix<fltp04>& transform);
        virtual void compress(BinaryCompressionObject& object) = 0;
        virtual void compressIfNeeded(BinaryCompressionObject& object)
        {
            /*if (m_compression_valid)
            {
                uint08 hash = tableHash();
                if (m_compression_hash != hash)
                {
                    m_compression_hash = hash;
                    m_compression_valid = false;
                }
            }
            else
            {
                m_compression_hash = tableHash();
            }
            if (!m_compression_valid)
            {*/
                compress(object);
            /*}
            else
            {
                object = m_compression_object;
            }*/     
        }
        void updateCompressionInfo(BinaryCompressionObject& object)
        {
            m_compression_valid = true;
            m_compression_object = object;
            m_compression_hash = tableHash();
        }
        virtual void mapToFile(BinaryFile& file, int compression) = 0;
        virtual void mapToFile(BinaryFile& file, BinaryCompressionObject& object) = 0;
        virtual void mapFromFile(BinaryFile& file, uint08 version_number) = 0;
        virtual void set(uint04 index, const UUID& value);
        void set(uint04 index, const Time& time);
        void set(uint04 index, const Vector<32, bool>& 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 String& value) const = 0;
        virtual bool isSame(uint04 index, const char* value) const = 0;
        virtual bool contains(uint04 index, const String& value, bool ignore_case) const = 0;
        virtual bool contains(uint04 index, const char* value, bool ignore_case) const = 0;
        virtual bool beginsWith(uint04 index, const String& value, bool ignore_case) const = 0;
        virtual bool beginsWith(uint04 index, const char* 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<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>::NaN;
        }
        void setCompressionMode(CompressionMode compression_mode) 
        { 
            if (m_compression_mode != compression_mode)
            {
                m_compression_mode = compression_mode;
                m_compression_valid = false;
            }
        }
        
        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, String& 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, String& 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 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
        {
            String 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, TranslatedString& string) const
        {
            String 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 < 3 * 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<String>(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<String>(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 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 modifiedTime() 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>
        void setDefaultValue(const t_type& value)
        {
            set(Constant<uint04>::NaN, value);
        }
        template<class t_type>
        t_type getDefaultValue() const
        {
            return get<t_type>(Constant<uint04>::NaN);
        }
        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;
        BinaryCompressionObject& compressionObject() { return m_compression_object; }
        bool compressionValid() const { return m_compression_valid; }
    protected:
        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:
        BinaryCompressionObject m_compression_object;
        Time m_modified_time;
        String m_label;
        TypeInfo m_type;
        uint08 m_compression_hash;
        Buffer<TableChange> m_changes;
        CompressionMode m_compression_mode = CompressionMode::e_default_compression;
        bool m_compression_valid;
    };
}