abstract_table.h

#pragma once
 
// Application headers
#include "include/schema/abstract_id_table_item.h"
#include "include/tables/private/abstract_base_model.h"
#include "include/tables/table_attributes.h"
#include "include/tables/table_index.h"
#include "include/tables/table_type.h"
 
// Application headers
namespace ehm_dal::data_types {
class Pointer;
}
 
// Qt headers
#include <QAbstractTableModel>
#include <QString>
#include <memory>
#include <vector>
 
namespace ehm_dal::tables {
 
// --- Table base class --- //
class AbstractTable : public AbstractBaseModel
{
    // NOTE: Insert rows, delete rows and move rows functions are entirely untested
public:
    AbstractTable(
        const QString &table_name,
        const ehm_dal::tables::TableIndex table_id,
        const ehm_dal::tables::TableType table_type,
        ehm_dal::column_data::ColumnData *column_data = new ehm_dal::column_data::ColumnData(),
        const qint16 minimum_supported_database_version = TableAttributes::NO_DATABASE_VERSION);
 
    // Child data
    void addChildItem(const qint32 parent_row_id,
                      std::shared_ptr<ehm_dal::schema::AbstractIdTableItem> item,
                      const ehm_dal::tables::TableIndex child_table);
    QVariant childData(const QModelIndex &index,
                       qint32 role,
                       ehm_dal::column_data::ColumnData *column_data,
                       const ehm_dal::tables::TableIndex child_table);
    qint32 childItemId(const qint32 parent_row_id,
                       const ehm_dal::tables::TableIndex child_table) const;
    virtual qint32 childRowCount(const qint32 parent_row_id,
                                 const ehm_dal::tables::TableIndex child_table) const;
    bool setChildData(const QModelIndex &index,
                      const QVariant &value,
                      const qint32 role,
                      std::vector<qint32> &modified_columns,
                      ehm_dal::column_data::ColumnData *column_data,
                      const ehm_dal::tables::TableIndex child_table);
 
    // File i/o
    bool read(QDataStream &in);
    bool readData(QByteArray *data);
 
    // Find data
    ehm_dal::data_types::Pointer find(const qint32 value, const quint16 column);
    ehm_dal::data_types::Pointer find(const QString &text,
                                      const quint16 column,
                                      const Qt::CaseSensitivity cs = Qt::CaseInsensitive);
    ehm_dal::data_types::Pointer findContains(const QString &text,
                                              const quint16 column,
                                              const Qt::CaseSensitivity cs = Qt::CaseInsensitive);
    std::vector<ehm_dal::data_types::Pointer> findAll(const qint32 value, const quint16 column);
    std::vector<ehm_dal::data_types::Pointer> findAll(
        const QString &text,
        const quint16 column,
        const Qt::CaseSensitivity cs = Qt::CaseInsensitive);
    std::vector<ehm_dal::data_types::Pointer> findAllContains(
        const QString &text,
        const quint16 column,
        const Qt::CaseSensitivity cs = Qt::CaseInsensitive);
 
    // Get data
    QVariant data(const QModelIndex &index, qint32 role = Qt::DisplayRole) const override;
    bool isValidRow(const qint32 row_id) const;
    QString text(const qint32 row) const;
 
    // Get data - counts
    qint32 rowCount(const QModelIndex &parent = QModelIndex()) const override;
 
    // Get data - pointers
    std::shared_ptr<ehm_dal::schema::AbstractIdTableItem> pointer(const qint32 row);
 
    // Get data - table attributes
    const TableAttributes *attributes() const { return &table_attributes_; }
 
    // Initialisation
    bool init();
 
    // Move data
    //bool moveRow(const QModelIndex &sourceParent, qint32 source_row, const QModelIndex &destination_parent, qint32 destination_child) override;
    bool moveRows(const QModelIndex &source_parent,
                  qint32 source_row,
                  qint32 count,
                  const QModelIndex &destination_parent,
                  qint32 destination_child) override;
 
    // Parent table
    enum class ParentTableRelationshipType : qint8 {
        TableDoesNotHaveAnyParent,
        ParentTableHasChildIdField,
        ChildTableHasParentIdField
    };
    qint32 parentRowId(const QModelIndex &index) const;
    inline virtual std::shared_ptr<ehm_dal::tables::AbstractTable> parentTable() const
    {
        return nullptr;
    }
    inline virtual ParentTableRelationshipType parentTableRelationship() const
    {
        return ParentTableRelationshipType::TableDoesNotHaveAnyParent;
    }
    inline virtual void setParentTable(
        const std::shared_ptr<ehm_dal::tables::AbstractTable> parent_table,
        const ParentTableRelationshipType relationship)
    {
        Q_UNUSED(parent_table)
        Q_UNUSED(relationship)
        return;
    }
 
    // Remove data
    bool clearAll();
    bool removeRows(qint32 row, qint32 count, const QModelIndex &parent = QModelIndex()) override;
 
    // Set data
    bool setData(const QModelIndex &index,
                 const QVariant &value,
                 qint32 role = Qt::EditRole) override;
 
protected:
    // Table data
    TableAttributes table_attributes_;
    std::vector<std::shared_ptr<ehm_dal::schema::AbstractIdTableItem>> data_;
 
private:
    bool is_initialised_{false};
 
    virtual bool readStream(QDataStream &in) = 0;
};
 
} // namespace ehm_dal::tables