Table.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: 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
{
    class BinaryFile;
    class NDEVR_DATABASE_API Table
    {
    public:
        Table();
        explicit Table(const String& name);
        virtual ~Table();
        bool validate() const;
        virtual uint04 size() const;
        void setAll(uint04 to_location, uint04 from_location, uint04 size, ConstPointer<Table> from_table);
        void fixIndexLinking(const DynamicPointer<TableColumn>& channel);
        virtual uint04 createChannel(const String& name, const TypeInfo& type_info, bool is_floating = false) = 0;
    public:
        virtual void addIndexChannel(const DynamicPointer<TableColumn>& channel);
        virtual uint04 addChannel(const DynamicPointer<TableColumn>& channel, bool is_floating = false);
 
        template<class t_type>
        void set(uint04 channel_index, uint04 value_index, const t_type& value)
        {
            lib_assert(!m_data_channels[channel_index].isNull(), "Invalid Channel Selected");
            m_data_channels[channel_index]->set(value_index, value);
        }
        template<uint01 t_dims, class t_type>
        void set(uint04 channel_index, uint04 value_index, const Vector<t_dims, t_type>& value)
        {
            lib_assert(!m_data_channels[channel_index].isNull(), "Invalid Channel Selected");
            m_data_channels[channel_index]->set(value_index, value);
        }
        virtual uint04 rowSize() const;
        virtual uint04 columnSize() const;
        void clear();
        void setSize(uint04 size);
        void addRow();
        void copyRow(uint04 source, uint04 destination);
        void copyRows(uint04 source, uint04 destination, uint04 size);
        void appendRows(uint04 size);
        void insertRow(uint04 index);
        void insertRows(uint04 index, uint04 size);
        void removeColumn(uint04 channel);
        void removeColumn(const String& channel);
        void removeRow(uint04 index);
        void removeRows(uint04 index, uint04 size);
        void removeRows(const Buffer<uint04>& sorted_romove_indices);
        void removeRows(uint04 offset, const Buffer<bool>& remove_mask);
        bool hasColumn(const String& column_name) const;
        void renameColumn(uint04 column_index, const String& new_name);
        bool hasColumn(uint04 index) const;
        uint04 indexOf(const String& column_name) const;
 
        const TableColumn& operator[](uint04 channel_index) const
        {
            return get(channel_index);
        }
        TableColumn& operator[](uint04 channel_index)
        {
            return get(channel_index);
        }
 
        const TableColumn& operator[](const String& channel) const
        {
            return get(channel);
        }
        TableColumn& operator[](const String& channel)
        {
            return get(channel);
        }
 
        TableColumn& get(uint04 channel_index);
        const TableColumn& get(uint04 channel_index) const;
        const DynamicPointer<TableColumn>& getPtr(uint04 channel_index)
        {
            return m_data_channels[channel_index];
        }
        TableColumn& get(const String& channel)
        {
            return m_name_channels[channel].get();
        }
        const TableColumn& get(const String& channel) const
        {
            return m_name_channels[channel].get();
        }
        const DynamicPointer<TableColumn>& getPtr(const String& channel)
        {
            return m_name_channels[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;
        }
        virtual UUID GUID() const
        {
            return m_uuid;
        }
        void fetchDataColumns(Buffer<DynamicPointer<TableColumn>>& columns, const Buffer<String>& exclusion_list);
        const String& name() const;
        void mapToFile(BinaryFile& file, const Buffer<String>& exclusion_list = {}) const;
        void mapFromFile(BinaryFile& file, uint08 version_number);
        Buffer<String> getColumnNames() const;
        void updateAll(bool update_floating);
        void update(const TableChange& change, bool update_floating);
    protected:
        UUID m_uuid;
        Dictionary<String, DynamicPointer<TableColumn>> m_name_channels;
        Buffer<bool> m_is_floating;
        Buffer<DynamicPointer<TableColumn>> m_data_channels;
        Buffer<DynamicPointer<TableColumn>> m_index_channels;
        uint04 m_size;
        String m_name;
    };
}