Saving a class into qsettings

Question

I have a class which is a QObject and it has a member which is a Unit *.

The saving is complaining that it can not save a Unit *

[26.04 12:53:21 W] QVariant::save: unable to save type 'Unit*' (type id: 1362).

I tried to register it with qRegisterMetaTypeStreamOperators<Unit*>("Unit*"); but I get the following error

/usr/include/qt/QtCore/qvariant.h:465: error: 'QVariant::QVariant(void*)' is private
     inline QVariant(void *) Q_DECL_EQ_DELETE;
            ^

Here is my loading and saving mechanism

void Profile::save(QSettings& settings) const {
    for(int i=0; i<metaObject()->propertyCount(); ++i) {
        const auto& p = metaObject()->property(i);
        if(p.isStored(this)) {
            settings.setValue(p.name(), property(p.name()));
        }
    }
}

void Profile::load(QSettings& settings) {
    for(int i=0; i<metaObject()->propertyCount(); ++i) {
        const auto& p = metaObject()->property(i);
        if(p.isStored(this)) {
            setProperty(p.name(), settings.value(p.name()));
        }
    }
}

here is my unit class

Unit::Unit(int unit, QObject *parent)
    : EraObject(parent),
      m_value(0.0),
      m_unit(unit)
{
    connect(eApp->systemController()->unitManager(),&UnitManager::onUnitChanged,this,&Unit::changeUnit);
}

Unit::Unit(const Unit &other)
{
    m_value = other.m_value;
    m_unit = other.m_unit;
    qRegisterMetaTypeStreamOperators<Unit*>("Unit*");
}

Unit &Unit::operator=(const qreal value)
{
    if (m_value == value)
        return *this;

    m_value = value;
    emit userValueChanged();

    return *this;
}


void Unit::loadFrom(Settings &set, bool ownGroup)
{
    Q_UNUSED(ownGroup)
    if(set.contains(objectName())) {
        m_value = set.value(objectName(),0.0).toDouble();
        emit userValueChanged();
    }
}

void Unit::saveTo(Settings &set, bool ownGroup, bool force)
{
    Q_UNUSED(ownGroup)
    Q_UNUSED(force)
    set.setValue(objectName(),m_value);
}

Unit::operator qreal() const
{
    return m_value;
}

qreal Unit::userValue() const
{
    return isDefault() ?  m_value : UnitManager::convertTo(m_value,m_unit);
}

QString Unit::symbol() const
{
    return UnitManager::symbolName(m_unit);
}

void Unit::setUserValue(const qreal userValue)
{
    qDebug() << "setUserValue" <<  this->userValue() << userValue << QString::number(m_unit,2);
    if (this->userValue() == userValue)
        return;

    if(isDefault())
        m_value = userValue;
    else
        m_value = UnitManager::convertFrom(userValue,m_unit);

    qDebug() << "Value" <<  m_value;

    emit userValueChanged();
    setDirty(RamDirty);
}

void Unit::setup(quint32 unit, const QString name, QObject *parent)
{
    if(!m_unit)
        m_unit = (unit << 16);
    setObjectName(name);
    setParent(parent);
    connectDirtyWithParent(parent);
}

void Unit::changeUnit(const quint32 &unit)
{
    if(m_unit == unit || category() != (unit >> 16))
        return;
    m_unit = unit;
    emit userValueChanged();
    emit symbolChanged();
}

UPDATE:

now I tried to write

QDataStream& operator<<(QDataStream& out, const Unit& v) {
    out << v.userValue();
    return out;
}

QDataStream& operator>>(QDataStream& in, Unit& v) {
    in >> v.userValue();
    return in;
}

and I get

/home/ahmed/server/elec/software_t/backup17/checko5/eracommon5/src/cpp/system/unit/unit.cpp:21: error: ambiguous overload for 'operator<<' (operand types are 'QDataStream' and 'qreal {aka double}')
     out << v.userValue();
         ^

UPDATE2 :

QDataStream &Unit::operator <<(QDataStream &out,  Unit &val)
{
    out << val.userValue();
    return out;
}

QDataStream &Unit::operator >>(QDataStream &out,  Unit &val)
{
    in >> val.userValue();
    return in;
}

Update 3:

Unit::Unit(int unit, QObject *parent)
    : EraObject(parent),
      m_value(0.0),
      m_unit(unit)
{
    connect(eApp->systemController()->unitManager(),&UnitManager::onUnitChanged,this,&Unit::changeUnit);
    qRegisterMetaTypeStreamOperators<Unit>("Unit");

}

Unit::Unit(const Unit &other)
{
    m_value = other.m_value;
    m_unit = other.m_unit;
}


QDataStream &operator<<(QDataStream &out, const Unit &unit)
{
    out << unit.value();
    return out;
}
QDataStream &operator>>(QDataStream &in, Unit &unit)
{
    in >> unit.value();
    return in;
}

Answer 1

Here's the documentation for qRegisterMetaTypeStreamOperators(). Start there to fix your streaming operators, i.e. it should look like this:

QDataStream &operator<<(QDataStream &out, const Unit &unit);
QDataStream &operator>>(QDataStream &out, Unit &unit);

Otherwise, that portion of your code is correct.

The second fix is that you cannot register a pointer with QMetaType. You need to register the type itself:

qRegisterMetaTypeStreamOperators<Unit>("Unit");

Lastly, qRegisterMetaType() and qRegisterMetaTypeStreamOperators() should be called only once (you have called qRegisterMetaType() as well, right?). If you note the documentation for QMetaType::load(), these functions should only be called once (e.g. in int main() or some other initialization code.