Overriding QObject::setProperty - c++

Question

I would like override the QObject::setProperty(const char*, QVariant) because when I call this method with a QVariant which contains a QVariantList the method fail because it doesn't convert the QVariantList to QList<UnknownType>.
Any suggestions?
EDIT
I have the abstract class Node which contains
Context* _context;
QMap<QString, QString> _inputsPersisted;
QMap<QString, QString> _outputsPersisted;
The Node class has also a virtual void runImplementation() and the method void run() like this :
void Node::run()
{
//get inputs from Context
for(QMap<QString, QString>::iterator it = _inputsPersisted.begin() ; it != _inputsPersisted.end() ; ++it )
{
QVariant attribute = property(it.key().toStdString().c_str());
if(!attribute.isValid())
{
qWarning() << QObject::tr("%1:%2: Node::run:%3: the property %4 does not exist.").arg(__FILE__).arg(__LINE__).arg(_id.toString()).arg(it.key());
}
else
{
QVariant v = _context->getDataPersisted(it.value());
if(!v.isValid())
qWarning() << QObject::tr("%1:%2: Node::run:%3: %4 is not in the context.").arg(__FILE__).arg(__LINE__).arg(_id.toString()).arg(it.value());
else
if(v.type() != attribute.type())
qWarning() << QObject::tr("%1:%2: Node::run:%3: %4 and %5 have not the same type.").arg(__FILE__).arg(__LINE__).arg(_id.toString()).arg(it.key()).arg(it.value());
else
if(!setProperty(it.key().toStdString().c_str(), v))
qWarning() << QObject::tr("%1:%2: Node::run:%3: the property %4 have not been setted.").arg(__FILE__).arg(__LINE__).arg(_id.toString()).arg(it.key());
}
}
runImplementation();
//set outputs in the Context
for(QMap<QString, QString>::iterator it = _outputsPersisted.begin() ; it != _outputsPersisted.end() ; ++it )
{
QVariant attribute = property(it.key().toStdString().c_str());
if(!attribute.isValid())
{
qWarning() << QObject::tr("%1:%2: Node::run:%3: the property %4 does not exist.").arg(__FILE__).arg(__LINE__).arg(_id.toString()).arg(it.key());
}
else
{
_context->setDataPersisted(it.value(), attribute);
}
}
}
The Context class is like this :
class Context : public QObject
{
Q_OBJECT
public:
Context(Context* parent = NULL) : : _parent(parent){}
void setDataPersisted(QString name, QVariant value)
{
if(_parent != NULL && _parent->exist(name))
_parent->setDataPersisted(name, value);
else
{
if(_stack.contains(name))
_stack.insert(name, value);
else
_stack.insert(name, value);
}
}
QVariant getDataPersisted(QString name)
{
QVariant v;
QMap<QString, QVariant>::iterator it = _stack.find(name);
if(it != _stack.end())
v.setValue(it.value());
else
if(_parent != NULL)
v.setValue(_parent->getDataPersisted(name));
return v;
}
private:
bool exist(QString name)
{
bool contains = _stack.contains(name);
return contains || ((_parent != NULL) && (_parent->exist(name)));
}
private:
Context * _parent;
QMap<QString, QVariant> _stack;
};
With this a Node child class can put and get some variables in her Context, and this, only by declare her properties and initialize the _inputsPersisted and _outputsPersisted. All the logic is done by the Node class.
Now I would like add a mechanism. I would like manipulate list in a Context and do a append.
For this, I modify the Context::setDataPersisted method:
void setDataPersisted(QString name, QVariant value)
{
if(_parent != NULL && _parent->exist(name))
_parent->setDataPersisted(name, value);
else
{
if(_stack.contains(name) && _stack.find(name)->value().canConvert(QVariant::List))
{
QVariantList toChange = qvariant_cast<QVariantList>(_stack.find(name)->value());
toChange.append(value);
_stack.insert(name, toChange );
}
else
_stack.insert(name, value);
}
}
With this, after a setDataPersited, another setDataPersisted (to "append") and a getDataPersisted the data's list are corrupted.

Answer 1

Use Q_DECLARE_METATYPE macro to register QVariantList withing Qt metatype system. This will allow storing QVariantList as QVariant
Q_DECLARE_METATYPE(QVariantList);
...
QVariantList var;
QVariant v = QVariant::fromValue<QVariantList>( var );
QVariantList lst = v.value<QVariantList>();
To convert QList<SomeType> to QVariantList:
QList<SomeType> lst1;
...
QVariantList lst2;
for (const SomeType& st : lst1)
lst2.append( QVariant::fromValue<SomeType>( st ) );
To convert QVariantList to QList<SomeType> :
QVariantList lst2;
...
QList<SomeType> lst1;
for (const QVariant& st : lst2)
lst2.append( st.value<SomeType>() );
Edit 1:
auto it = _stack.find(name);
if (_stack.end() == it) {
it = _stack.insert( name, QVariant::fromValue<QVariantList>(QVariantList()) );
}
QVariantList toChange = it->value().value<QVariantList>();
toChange.append(value);
_stack.insert(name, QVariant::fromValue<QVariantList>(toChange) );