container.h

#pragma once
 
// Application headers
#include "include/database/database_version.h"
 
// Qt headers
#include <QDataStream>
#include <execution>
#include <type_traits>
 
namespace ehm_dal::container {
template<typename T_ItemCountType>
concept Number = std::is_integral<T_ItemCountType>::value;
template<typename T_DataType, Number T_ItemCountType = quint8>
class Container
{
public:
    Container(const quint32 size = 0, const bool is_sortable = true);
    Container(const Container &obj);
    virtual ~Container() {}
 
    // Add data
    void addRows(const qint32 count);
    inline void push_back(T_DataType &item) { data_.push_back(std::move(item)); }
    inline void push_back(T_DataType *item) { data_.push_back(std::move(*item)); }
 
    // Erase data
    void clear() { data_.clear(); }
    void erase(const qint32 first_index_to_delete, const qint32 last_index_to_delete);
 
    // File i/o
    virtual void read(QDataStream &in, ehm_dal::database::DatabaseVersion &version);
    void read(QDataStream &in,
              ehm_dal::database::DatabaseVersion &version,
              const T_ItemCountType count);
    void readInto(QDataStream &in, ehm_dal::database::DatabaseVersion &version);
    virtual void write(QDataStream &out, ehm_dal::database::DatabaseVersion &version);
    void write(QDataStream &out,
               ehm_dal::database::DatabaseVersion &version,
               const T_ItemCountType count);
 
    // Get data - attributes
    inline bool isSortable() const { return is_sortable_; }
    inline qint32 rowCount() const { return static_cast<qint32>(data_.size()); }
    inline T_ItemCountType size() const { return static_cast<T_ItemCountType>(data_.size()); }
 
    // Get data - values
    T_DataType *item(const T_ItemCountType pos);
    const T_DataType *itemConst(const T_ItemCountType pos) const;
 
    // Operator overloading
    Container &operator=(Container rhs);
 
protected:
    inline std::vector<T_DataType> *data() { return &data_; }
 
private:
    // Database
    std::vector<T_DataType> data_;
 
    // Sorting
    const bool is_sortable_;
};
 
/* ================== */
/*      Container     */
/* ================== */
 
// --- Default constructor --- //
template<typename T_DataType, Number T_ItemCountType>
Container<T_DataType, T_ItemCountType>::Container(const quint32 size, const bool is_sortable)
    : data_(size)
    , is_sortable_(is_sortable)
{}
 
// --- Copy constructor --- //
template<typename T_DataType, Number T_ItemCountType>
Container<T_DataType, T_ItemCountType>::Container(const Container &obj)
    : data_(std::move(obj.data_))
    , is_sortable_(obj.isSortable())
{
    // NOTE check std::move does not cause a crash - this probably shouldn't be move
    // (seeing as this is a copy constructor)
}
 
/* ================= */
/*      Add Data     */
/* ================= */
 
// --- Add blank items --- //
template<typename T_DataType, Number T_ItemCountType>
void Container<T_DataType, T_ItemCountType>::addRows(const qint32 count)
{
    for (auto i = 0; i < count; ++i) {
        T_DataType new_item;
        data_.push_back(std::move(new_item));
    }
}
 
/* =================== */
/*      Erase Data     */
/* =================== */
 
// --- Remove/delete rows --- //
template<typename T_DataType, Number T_ItemCountType>
void Container<T_DataType, T_ItemCountType>::erase(const qint32 first_index_to_delete,
                                                   const qint32 last_index_to_delete)
{
    data_.erase(data_.begin() + first_index_to_delete, data_.begin() + last_index_to_delete);
}
 
/* ================= */
/*      File I/O     */
/* ================= */
 
// --- Read all data --- //
template<typename T_DataType, Number T_ItemCountType>
void Container<T_DataType, T_ItemCountType>::read(QDataStream &in,
                                                  ehm_dal::database::DatabaseVersion &version)
{
    T_ItemCountType count{0};
    in.readRawData(reinterpret_cast<char *>(&count), sizeof(T_ItemCountType));
 
    read(in, version, count);
}
 
// --- Read the specified number of data items --- //
template<typename T_DataType, Number T_ItemCountType>
void Container<T_DataType, T_ItemCountType>::read(QDataStream &in,
                                                  ehm_dal::database::DatabaseVersion &version,
                                                  const T_ItemCountType count)
{
    for (T_ItemCountType i = 0; i < count; ++i) {
        T_DataType item;
        item.read(in, version);
        data_.emplace_back(item);
    }
 
    if (isSortable())
        std::sort(std::execution::par, this->data_.begin(), this->data_.end());
}
 
// --- Read the specified the data into the existing elements of the container --- //
template<typename T_DataType, Number T_ItemCountType>
void Container<T_DataType, T_ItemCountType>::readInto(QDataStream &in,
                                                      ehm_dal::database::DatabaseVersion &version)
{
    for (auto &itr : data_)
        itr.read(in, version);
 
    if (isSortable())
        std::sort(std::execution::par, this->data_.begin(), this->data_.end());
}
 
// --- Write all data --- //
template<typename T_DataType, Number T_ItemCountType>
void Container<T_DataType, T_ItemCountType>::write(QDataStream &out,
                                                   ehm_dal::database::DatabaseVersion &version)
{
    auto count{size()};
    out.writeRawData(reinterpret_cast<char *>(&count), sizeof(T_ItemCountType));
 
    write(out, version, count);
}
 
// --- Write the specified number of data items --- //
template<typename T_DataType, Number T_ItemCountType>
void Container<T_DataType, T_ItemCountType>::write(QDataStream &out,
                                                   ehm_dal::database::DatabaseVersion &version,
                                                   const T_ItemCountType count)
{
    if (isSortable())
        std::sort(std::execution::par, this->data_.begin(), this->data_.end());
 
    for (T_ItemCountType i = 0; i < count; ++i)
        this->data_[i].write(out, version);
}
 
/* ========================== */
/*      Get Data - Values     */
/* ========================== */
 
// --- Get item --- //
template<typename T_DataType, Number T_ItemCountType>
T_DataType *Container<T_DataType, T_ItemCountType>::item(const T_ItemCountType pos)
{
    if (pos < size() && pos >= 0)
        return &data_[pos];
 
    return nullptr;
}
 
// --- Get item --- //
template<typename T_DataType, Number T_ItemCountType>
const T_DataType *Container<T_DataType, T_ItemCountType>::itemConst(const T_ItemCountType pos) const
{
    if (pos < rowCount() && pos >= 0)
        return &data_[pos];
 
    return nullptr;
}
 
/* ============================= */
/*      Operator Overloading     */
/* ============================= */
 
// --- Assignment operator --- //
template<typename T_DataType, Number T_ItemCountType>
Container<T_DataType, T_ItemCountType> &Container<T_DataType, T_ItemCountType>::operator=(
    Container rhs)
{
    data_ = rhs.data_;
    return *this;
}
} // namespace ehm_dal::container