data_type.h

#pragma once
 
// Application headers
#include "include/database/database_version.h"
 
// Qt headers
#include <QDataStream>
#include <QLocale>
#include <QVariant>
#include <type_traits>
 
namespace ehm_dal::data_types {
template<class T>
concept Number = std::is_integral<T>::value || std::is_floating_point<T>::value;
 
template<Number T>
class DataType
{
public:
    DataType(const T value = 0);
    // NOTE making DataType virtual in any manner results in vtable corruption
    //virtual ~DataType() = default;
 
    template<Number T_CustomType>
    void readCustomType(QDataStream &in);
    template<Number T_CustomType>
    void writeCustomType(QDataStream &out);
 
    // File i/o (for compatibility with container classes)
    bool read(QDataStream &in, ehm_dal::database::DatabaseVersion &version);
    bool write(QDataStream &out, ehm_dal::database::DatabaseVersion &version);
 
    // Get data
    QVariant data(const qint32 role = Qt::DisplayRole) const;
    inline T value() const { return value_; }
 
    // Get data - decimals
    // TODO <float> results in inaccurate decimal values (see e.g. Continent::RegionalStrength)
    QVariant accurateDecimal(const qint32 role = Qt::DisplayRole) const;
    QVariant roundedDecimal(const qint32 role = Qt::DisplayRole) const;
    double toDouble() const;
    float toFloat() const;
 
    // Operator overloading: Comparators
    inline auto operator<=>(const DataType &rhs) const { return value() <=> rhs.value(); }
    inline bool operator==(const DataType &rhs) const { return value() == rhs.value(); }
    inline auto operator<=>(const qint32 &rhs) const { return value() <=> rhs; }
    inline bool operator==(const qint32 &rhs) const { return value() == rhs; }
    inline bool operator==(const bool &rhs) const { return static_cast<bool>(value()) == rhs; }
 
    // Set data
    Q_DECL_DEPRECATED void set(const QVariant &value, const qint32 role = Qt::EditRole);
    // BUG making setData() a virtual function appears to corrupt the vtable
    void setData(const QVariant &value, const qint32 role = Qt::EditRole);
    inline void setValue(const T value) { value_ = value; }
 
private:
    T value_;
 
    // File i/o
    friend QDataStream &operator>>(QDataStream &in, DataType<T> &data)
    {
        in.readRawData(reinterpret_cast<char *>(&data.value_), sizeof(T));
        return in;
    }
    friend QDataStream &operator<<(QDataStream &out, const DataType<T> &data)
    {
        out.writeRawData(reinterpret_cast<const char *>(&data.value_), sizeof(T));
        return out;
    }
};
 
/* ================== */
/*      Data Type     */
/* ================== */
 
template<Number T>
DataType<T>::DataType(const T value)
    : value_(value)
{}
 
/* ================== */
/*      File I/O      */
/* ================== */
 
// --- Read data (for compatibility with container classes which require this method) --- //
template<Number T>
inline bool DataType<T>::read(QDataStream &in, database::DatabaseVersion &version)
{
    Q_UNUSED(version);
    in >> *this;
    return true;
}
 
// --- Write data (for compatibility with container classes which require this method) --- //
template<Number T>
inline bool DataType<T>::write(QDataStream &out, database::DatabaseVersion &version)
{
    Q_UNUSED(version);
    out << *this;
    return true;
}
 
// --- Read data from a data stream using a custom source type --- //
template<Number T>
template<Number T_CustomType>
inline void DataType<T>::readCustomType(QDataStream &in)
{
    T_CustomType buffer;
    in.readRawData(reinterpret_cast<char *>(&buffer), sizeof(T_CustomType));
    value_ = static_cast<T>(buffer);
}
 
// --- Write data to a data stream using a custom source type --- //
template<Number T>
template<Number T_CustomType>
inline void DataType<T>::writeCustomType(QDataStream &out)
{
    T_CustomType buffer{static_cast<T_CustomType>(value_)};
    out.writeRawData(reinterpret_cast<const char *>(&buffer), sizeof(T_CustomType));
}
 
/* ================= */
/*      Get Data     */
/* ================= */
 
template<Number T>
QVariant DataType<T>::data(const qint32 role) const
{
    switch (role) {
    case Qt::DisplayRole:
    case Qt::EditRole:
        return value_;
    default:
        return QVariant();
    }
}
 
/* ============================ */
/*      Get Data - Decimals     */
/* ============================ */
 
template<Number T>
QVariant DataType<T>::accurateDecimal(const qint32 role) const
{
    if (role == Qt::DisplayRole || role == Qt::EditRole)
        return QLocale().toString(value_);
 
    return QVariant();
}
 
template<Number T>
QVariant DataType<T>::roundedDecimal(const qint32 role) const
{
    if (role != Qt::DisplayRole && role != Qt::EditRole)
        return QVariant();
 
    if constexpr (std::is_floating_point_v<T>)
        return QLocale().toString(value_, 'g', 8);
 
    return QString::number(0.0);
}
 
template<Number T>
double DataType<T>::toDouble() const
{
    return static_cast<double>(value_);
}
 
template<Number T>
float DataType<T>::toFloat() const
{
    return static_cast<float>(value_);
}
 
/* ================= */
/*      Set Data     */
/* ================= */
 
// TODO deprecate this function in favour of setData()
template<Number T>
void DataType<T>::set(const QVariant &value, const qint32 role)
{
    setData(value, role);
}
 
template<Number T>
void DataType<T>::setData(const QVariant &value, const qint32 role)
{
    if (role != Qt::EditRole)
        return;
 
    if constexpr (std::is_floating_point_v<T>)
        setValue(static_cast<T>(value.toDouble()));
    else if constexpr (std::is_unsigned_v<T>)
        setValue(static_cast<T>(value.toUInt()));
    else
        setValue(static_cast<T>(value.toInt()));
}
 
} // namespace ehm_dal::data_types