Table.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: Table
Included in API: True
Author(s): Tyler Parke
 *-----------------------------------------------------------------------------------------**/
#pragma once
#include "DLLInfo.h"
#include <NDEVR/TableColumn.h>
#include <NDEVR/Dictionary.h>
#include <NDEVR/Pointer.h>
namespace NDEVR
{
    template<class t_type>
    class Set;

    struct BinaryFileTableInfo;

    class NDEVR_DATABASE_API Table
    {
    public:
        Table();

        explicit Table(const StringView& name);

        ~Table();

        bool validate() const;

        uint04 size() const;

        void fixIndexLinking(TableColumn* channel);

        template<class t_column_type>
        std::pair<uint04, TableColumn*> createColumn(const StringView& name)
        {
            auto iter = m_name_channels.find(name);
            if (iter != m_name_channels.end())
                return iter.value();
            t_column_type* channel = new t_column_type(name);
            m_generated_channels.add(channel);
            return { addChannel(channel), channel };
        }

        template<class t_column_type, class t_default_type>
        std::pair<uint04, TableColumn*> createColumn(const StringView& name, const t_default_type& default_value)
        {
            auto iter = m_name_channels.find(name);
            if (iter != m_name_channels.end())
                return iter.value();
            t_column_type* channel = new t_column_type(name);
            channel->setDefault(default_value);
            m_generated_channels.add(channel);
            return { addChannel(channel), channel };
        }

        std::pair<uint04, TableColumn*> createColumn(const StringView& name, const TypeInfo& type_info);
    public:
        void addIndexChannel(TableColumn* channel);

        void link(const Dictionary<UUID, Table*>& tables);

        uint04 addChannel(TableColumn* channel);

        uint04 rowSize() const;

        uint04 columnSize() const;

        void clear();

        void setSize(uint04 size);

        void addRow();

        void resetRow(uint04 row);

        void copyRow(uint04 source, uint04 destination);

        void copyRows(uint04 source, uint04 destination, uint04 size);

        void appendRows(uint04 size);

        void insertRow(uint04 index);

        void swapRows(uint04 a, uint04 b);

        void swapColumns(uint04 a, uint04 b);

        void swapColumns(TableColumn* a, TableColumn* b);

        void insertRows(uint04 index, uint04 size);

        void removeColumn(uint04 channel);

        void removeColumn(TableColumn* channel);

        void removeColumn(const StringView& channel);

        void removeRow(uint04 index);

        void removeRows(uint04 index, uint04 size);

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

        void removeRows(uint04 offset, const Buffer<bool>& remove_mask);

        bool hasColumn(const StringView& column_name) const;

        void renameColumn(uint04 column_index, const StringView& new_name);

        void renameColumn(TableColumn* column, const StringView& new_name);

        bool hasColumn(uint04 index) const;

        uint04 indexOf(const StringView& column_name) const;

        uint04 indexOf(TableColumn* column) const;

        inline TableColumn& get(uint04 channel_index)
        {
            lib_assert(channel_index < m_data_channels.size() && m_data_channels[channel_index] != nullptr, "Tried to access non-existent table");
            return *m_data_channels[channel_index];
        }

        inline const TableColumn& get(uint04 channel_index) const
        {
            lib_assert(channel_index < m_data_channels.size() && m_data_channels[channel_index] != nullptr, "Tried to access non-existent table");
            return *m_data_channels[channel_index];
        }

        inline TableColumn& get(const StringView& channel)
        {
            return *m_name_channels.get(channel).second;
        }

        inline const TableColumn& get(const StringView& channel) const
        {
            return *m_name_channels.get(channel).second;
        }

        inline const TableColumn& operator[](uint04 channel_index) const
        {
            return get(channel_index);
        }

        inline TableColumn& operator[](uint04 channel_index)
        {
            return get(channel_index);
        }

        template<class t_enum_type>
        inline const TableColumn& operator[](t_enum_type channel_index) const
        {
            return get(eint04<t_enum_type>(channel_index));
        }

        template<class t_enum_type>
        inline typename std::enable_if<ObjectInfo<t_enum_type>::Enum, TableColumn&>::type operator[](t_enum_type channel_index)
        {
            return get(eint04<t_enum_type>(channel_index));
        }

        template<class t_enum_type>
        inline typename std::enable_if<ObjectInfo<t_enum_type>::Enum, const TableColumn&>::type operator[](const StringView& channel) const
        {
            return get(channel);
        }

        inline TableColumn& operator[](const StringView& channel)
        {
            return get(channel);
        }

        bool hasMatchingColumns(const Table& table) const;

        auto begin()
        {
            return m_name_channels.begin();
        }

        auto end()
        {
            return m_name_channels.end();
        }

        bool operator==(const Table& table) const
        {
            return table.m_uuid == m_uuid;
        }

        UUID uuid() const
        {
            return m_uuid;
        }

        void fetchDataColumns(Buffer<TableColumn*>& columns, const Set<StringAllocatingView>& exclusion_list);

        const String& name() const;

        void mapToFile(BinaryFileTableInfo& file) const;

        static void SkipTable(BinaryFileTableInfo& file);

        void mapFromFile(BinaryFileTableInfo& file);

        void finishMapFromFile(BinaryFileTableInfo& file);

        Buffer<StringView> getColumnNames() const;

        void updateAll();

        void update(const TableChange& change);

        uint08 approximateMemorySize() const;

        void setAll(uint04 to_row, uint04 from_row, uint04 size, const Table& from_table);
    private:
        template<uint01 t_dims>
        std::pair<uint04, TableColumn*> createScalarChannel(const StringView& name, const TypeInfo& type_info);

        void writeColumnHeaders(BinaryFileTableInfo& file, const Buffer<uint08>& locations, uint08 start, uint08 end) const;

        std::pair<uint04, TableColumn*> createBufferChannel(const StringView& name, const TypeInfo& type_info, bool is_floating = false);
    protected:
        UUID m_uuid;                                                             
        Dictionary<StringView, std::pair<uint04, TableColumn*>> m_name_channels; 
        Buffer<TableColumn*> m_data_channels;                                    
        Buffer<TableColumn*> m_generated_channels;                               
        Buffer<TableColumn*> m_index_channels;                                   
        uint04 m_size;                                                           
        String m_name;                                                           
    };
}