void MixedTest::test_map()
{
QVariantMap map;
map.insert(QString("%1").QString::arg(0, 5), "v");
QByteArray arr = MsgPack::pack(map);
QVERIFY(arr.size() == map.size() * 8 + 1);
quint8 *p = (quint8 *)arr.data();
QVERIFY(p[0] == (0x80 | map.size()));
QVariantMap m2 = MsgPack::unpack(arr).toMap();
QVERIFY(m2 == map);
for (int i = 1; i < 16; ++i)
map.insert(QString("%1").QString::arg(i, 5), "v");
arr = MsgPack::pack(map);
QVERIFY(arr.size() == map.size() * 8 + 3);
p = (quint8 *)arr.data();
QVERIFY(p[0] == 0xde);
QVERIFY(p[1] == 0x00);
QVERIFY(p[2] == 0x10);
m2 = MsgPack::unpack(arr).toMap();
QVERIFY(m2 == map);
for (int i = 16; i < 65536; ++i)
map.insert(QString("%1").QString::arg(i, 5), "v");
arr = MsgPack::pack(map);
QVERIFY(arr.size() == map.size() * 8 + 5);
p = (quint8 *)arr.data();
QVERIFY(p[0] == 0xdf);
QVERIFY(p[1] == 0x00);
QVERIFY(p[2] == 0x01);
QVERIFY(p[3] == 0x00);
QVERIFY(p[4] == 0x00);
m2 = MsgPack::unpack(arr).toMap();
QVERIFY(m2 == map);
}
void DBTalker::parseResponseListFolders(const QByteArray& data)
{
//added root in list at constructor and call getfolderslist after calling list folders in dbwindow
QJson::Parser parser;
bool ok;
QVariant result = parser.parse(data,&ok);
if(!ok)
{
emit signalBusy(false);
emit signalListAlbumsFailed(i18n("Failed to list folders"));
return;
}
QList<QPair<QString, QString> > list;
list.clear();
list.append(qMakePair(QString("/"),QString("root")));
QVariantMap rmap = result.toMap();
QList<QString> a = rmap.uniqueKeys();
for(int i=0;i<rmap.size();i++)
{
if(a[i] == "contents")
{
QVariantList qwe = rmap[a[i]].toList();
foreach(QVariant abc, qwe)
{
QVariantMap qwer = abc.toMap();
QList<QString> b = qwer.uniqueKeys();
QString path("");
QString isDir("");
int temp = 0;
for(int i=0;i<qwer.size();i++)
{
if(b[i] == "is_dir")
isDir = qwer[b[i]].value<QString>();
if(b[i] == "path")
{
path = qwer[b[i]].value<QString>();
temp = i;
}
}
if(QString::compare(isDir, QString("true"), Qt::CaseInsensitive) == 0)
{
kDebug() << temp << " " << b[temp] << " : " << qwer[b[temp]] << " " << qwer[b[temp]].value<QString>() << endl;
QString name = qwer[b[temp]].value<QString>().section('/',-2);
kDebug() << "str " << name;
list.append(qMakePair(qwer[b[temp]].value<QString>(),name));
queue.enqueue(qwer[b[temp]].value<QString>());
}
}
}
std::map<QString, double> ScriptMatch::getFeatures(const ConstOsmMapPtr& map) const
{
Isolate* current = v8::Isolate::GetCurrent();
HandleScope handleScope(current);
Context::Scope context_scope(_script->getContext(current));
// removing these two lines causes a crash when checking for conflicts. WTF?
Handle<Object> global = _script->getContext(current)->Global();
global->Get(String::NewFromUtf8(current, "plugin"));
std::map<QString, double> result;
LOG_TRACE("Calling getMatchFeatureDetails...");
Handle<Value> v = _callGetMatchFeatureDetails(map);
if (v.IsEmpty() || v->IsObject() == false)
{
throw IllegalArgumentException(
"Expected getMatchFeatureDetails to return an associative array.");
}
QVariantMap vm = toCpp<QVariantMap>(v);
long valCtr = 0;
LOG_VART(vm.size());
for (QVariantMap::const_iterator it = vm.begin(); it != vm.end(); ++it)
{
if (it.value().isNull() == false)
{
double d = it.value().toDouble();
result[it.key()] = d;
if (::qIsNaN(result[it.key()]))
{
if (logWarnCount < Log::getWarnMessageLimit())
{
LOG_WARN("found NaN feature value for: " << it.key());
}
else if (logWarnCount == Log::getWarnMessageLimit())
{
LOG_WARN(className() << ": " << Log::LOG_WARN_LIMIT_REACHED_MESSAGE);
}
logWarnCount++;
}
}
valCtr++;
}
if (vm.size() > 0)
{
LOG_DEBUG("Processed " << vm.size() << " sample values.");
}
return result;
}
bool JsonRpcServer::convertArgs(const QMetaMethod& meta_method,
const QVariantMap& args,
QVariantList& converted_args)
{
QList<QByteArray> param_types = meta_method.parameterTypes();
if (args.size() != param_types.size()) {
logError(QString("wrong number of arguments to method %1 -- "
"expected %2 arguments, but got %3")
.arg(QString(meta_method.methodSignature()))
.arg(meta_method.parameterCount())
.arg(args.size()));
return false;
}
for (int i = 0; i < param_types.size(); i++) {
QByteArray param_name = meta_method.parameterNames().at(i);
if (args.find(param_name) == args.end()) {
// no arg with param name found
return false;
}
const QVariant& arg = args.value(param_name);
if (!arg.isValid()) {
logError(QString("argument %1 of %2 to method %3 is invalid")
.arg(i + 1)
.arg(param_types.size())
.arg(QString(meta_method.methodSignature())));
return false;
}
QByteArray arg_type_name = arg.typeName();
QByteArray param_type_name = param_types.at(i);
QVariant::Type param_type = QVariant::nameToType(param_type_name);
QVariant copy = QVariant(arg);
if (copy.type() != param_type) {
if (copy.canConvert(param_type)) {
if (!copy.convert(param_type)) {
// qDebug() << "cannot convert" << arg_type_name
// << "to" << param_type_name;
return false;
}
}
}
converted_args << copy;
}
return true;
}
QStringList WorkflowModel::addFlow(int vertexFrom, int vertexTo, const QVariantMap& flowpoints, int rectFrom, int rectTo)
{
QStringList* parameterEntrySet = new QStringList();
if ( vertexFrom >= 0 && vertexTo >= 0 && flowpoints.size() == 2) {
try {
const OVertex& fromOperationVertex = vertexFrom;
const OVertex& toOperationVertex = vertexTo;
int outParamIndex = flowpoints["fromParameterIndex"].toInt();
int inParamIndex = flowpoints["toParameterIndex"].toInt();
int parameterIndex = _workflow->getWorkflowParameterIndex(toOperationVertex, inParamIndex);
parameterEntrySet->push_back(QString::number(parameterIndex) + "|remove");
--_inputParameterCount;
EdgeProperties flowPoperties(
outParamIndex, inParamIndex,
rectFrom, rectTo
);
_workflow->addOperationFlow(fromOperationVertex,toOperationVertex,flowPoperties);
} catch (std::out_of_range e) {
qDebug() << "False operation";
}
}
return *parameterEntrySet;
}
void DBTalker::parseResponseAddPhoto(const QByteArray& data)
{
bool success = false;
QJson::Parser parser;
bool ok;
QVariant result = parser.parse(data, &ok);
QVariantMap rmap = result.toMap();
QList<QString> keys = rmap.uniqueKeys();
for(int i=0;i<rmap.size();i++)
{
if(keys[i] == "bytes")
{
success = true;
break;
}
}
emit signalBusy(false);
if(!success)
{
emit signalAddPhotoFailed(i18n("Failed to upload photo"));
}
else
{
emit signalAddPhotoSucceeded();
}
}
void DatabaseUtilities::prepareSetFieldsUpdateQuery(QSqlQuery& query, QString const& queryString, QVariantMap const& fieldsAndValues) {
if (fieldsAndValues.size() > 0) {
QString setString;
setString.reserve(512);
auto it = fieldsAndValues.constBegin();
auto const end = fieldsAndValues.constEnd();
int keyIndex = 1;
for (; it != end; ++it) {
if (!setString.isEmpty()) {
setString.append(QStringLiteral(", "));
}
setString.append(QStringLiteral("`%1` = :value%2").arg(it.key()).arg(keyIndex, 4, 10, QChar('0')));
++keyIndex;
}
query.prepare(queryString.arg(setString));
it = fieldsAndValues.constBegin();
keyIndex = 1;
for (; it != end; ++it) {
query.bindValue(QStringLiteral(":value%1").arg(keyIndex, 4, 10, QChar('0')), it.value());
++keyIndex;
}
} else {
throw openmittsu::exceptions::InternalErrorException() << "Can not build setFields update query part with empty field/value map, this should never happen!";
}
}
static Task::List parse(const QVariant &data)
{
const QVariantMap results = data.toMap();
Task::List tasks;
tasks.reserve(results.size());
for (auto iter = results.cbegin(), end = results.cend(); iter != end; ++iter) {
const QVariantMap d = iter.value().toMap();
Task task;
task.d_ptr->phid = iter.key().toLatin1();
task.d_ptr->id = d[QStringLiteral("id")].toUInt();
task.d_ptr->authorPHID = d[QStringLiteral("authorPHID")].toByteArray();
task.d_ptr->ownerPHID = d[QStringLiteral("ownerPHID")].toByteArray();
const QVariantList ccPHIDs = d[QStringLiteral("ccPHIDs")].toList();
task.d_ptr->ccPHIDs.reserve(ccPHIDs.size());
Q_FOREACH (const QVariant &ccPHID, ccPHIDs) {
task.d_ptr->ccPHIDs.push_back(ccPHID.toByteArray());
}
task.d_ptr->status = d[QStringLiteral("status")].toString();
task.d_ptr->statusName = d[QStringLiteral("statusName")].toString();
task.d_ptr->isClosed = d[QStringLiteral("isClosed")].toBool();
task.d_ptr->priority = d[QStringLiteral("priority")].toString();
task.d_ptr->priorityColor = d[QStringLiteral("priorityColor")].toString();
task.d_ptr->title = d[QStringLiteral("title")].toString();
task.d_ptr->description = d[QStringLiteral("description")].toString();
const QVariantList projectPHIDs = d[QStringLiteral("projectPHIDs")].toList();
task.d_ptr->projectPHIDs.reserve(projectPHIDs.size());
Q_FOREACH (const QVariant &projectPHID, projectPHIDs) {
task.d_ptr->projectPHIDs.push_back(projectPHID.toByteArray());
}
/*! \brief Returns parameters \a params as a string
*
* The string is formated like this: par1=var1&par2=var2
* \param params Parameters to convert
* \param skipOAuth Should parameters starting with oauth_ be omitted
* \return A string of sorted and encoded parameters
*/
QString Util::buildHTTPQuery(const QVariantMap ¶ms, bool skipOAuth)
{
if(params.size() == 0) {
return NULL;
}
QString out;
QMapIterator<QString, QVariant> it(params);
while(it.hasNext()) {
it.next();
QString key = Util::encode(it.key());
QString value = Util::encode(it.value().toString());
if(!(skipOAuth && key.contains("oauth_"))) {
out += QString("%1=%2&").arg(key).arg(value);
}
}
if(out.endsWith("&")) {
out.chop(1);
}
return out;
}
static jobject createHashMap(const QVariantMap &data) {
QAndroidJniEnvironment env;
jclass mapClass = env->FindClass("java/util/HashMap");
if (mapClass == NULL) {
qWarning() << "Failed to find class" << "java/util/HashMap";
return NULL;
}
jclass integerClass = env->FindClass("java/lang/Integer");
jmethodID integerConstructor = env->GetMethodID(integerClass, "<init>", "(I)V");
jclass booleanClass = env->FindClass("java/lang/Boolean");
jmethodID booleanConstructor = env->GetMethodID(booleanClass,"<init>","(Z)V");
jsize map_len = data.size();
jmethodID init = env->GetMethodID(mapClass, "<init>", "(I)V");
jobject hashMap = env->NewObject( mapClass, init, map_len);
jmethodID put = env->GetMethodID( mapClass, "put",
"(Ljava/lang/Object;Ljava/lang/Object;)Ljava/lang/Object;");
QMapIterator<QString, QVariant> iter(data);
while (iter.hasNext()) {
iter.next();
// qDebug() << iter.key() << iter.value();
QString key = iter.key();
jstring jkey = env->NewStringUTF(key.toLocal8Bit().data());
QVariant v = iter.value();
if (v.type() == QVariant::String) {
QString str = v.toString();
jstring vString = env->NewStringUTF(str.toLocal8Bit().data());
env->CallObjectMethod(hashMap,put,jkey,vString);
} else if (v.type() == QVariant::Int) {
jobject integer = env->NewObject(integerClass,integerConstructor,v.toInt());
env->CallObjectMethod(hashMap,put,jkey,integer);
} else if (v.type() == QVariant::Bool) {
jobject boolean = env->NewObject(booleanClass,booleanConstructor,v.toBool());
env->CallObjectMethod(hashMap,put,jkey,boolean);
} else {
qWarning() << "QASystemDispatcher: Non-supported data type - " << v.type();
}
}
if (env->ExceptionOccurred()) {
env->ExceptionDescribe();
env->ExceptionClear();
}
return hashMap;
}
void UtilTest::testJSONToVariantMap() {
QString json = "{ \"jid\": \"[email protected]\", \"message\": \"test \\\"test\\\"\\nhoe is't ermee?\\n/me ducks\\\\\", \"name\": \"messageReceived\" }";
QVariantMap variantMap = Util::jsonToVariantMap(json);
QCOMPARE(variantMap.size(), 3);
QCOMPARE(variantMap["name"].toString(), QString("messageReceived"));
QCOMPARE(variantMap["jid"].toString(), QString("*****@*****.**"));
QCOMPARE(variantMap["message"].toString(), QString("test \"test\"\nhoe is't ermee?\n/me ducks\\"));
}
void serializeData(QDataStream *stream, const QVariantMap &data)
{
*stream << static_cast<qint32>(-2);
const qint32 size = data.size();
*stream << size;
QByteArray bytes;
foreach (const QString &mime, data.keys()) {
bytes = data[mime].toByteArray();
bool compress = shouldCompress(bytes, mime);
*stream << compressMime(mime) << compress << ( compress ? qCompress(bytes) : bytes );
}
}
static bool compare(const QVariantMap& one, const QVariantMap& other)
{
if (one.size() != other.size())
return false;
QVariantMap::const_iterator it1 = one.begin();
QVariantMap::const_iterator it2 = other.begin();
while (it1 != one.end()) {
if (it1.value().userType() != it2.value().userType())
return false;
if (!(it1.value() == it2.value())) {
if (it1.value().userType() == qMetaTypeId<QDBusObjectPath>()) {
if (!(it1.value().value<QDBusObjectPath>() == it2.value().value<QDBusObjectPath>()))
return false;
}
}
if (qMapLessThanKey(it1.key(), it2.key()) || qMapLessThanKey(it2.key(), it1.key()))
return false;
++it2;
++it1;
}
return true;
}
bool QVariantMapValidator::validate(const QVariantMap &map) const
{
if (map.size() != m_infos.size())
return false;
for (auto I = map.constBegin(), E = map.constEnd(); I != E; ++I)
{
if (!m_infos.contains(I.key()))
return false;
if (m_infos.value(I.key()) != I.value().type())
return false;
}
return true;
}
void QSDiffRunnerAlgo::markItemAtToList(QSAlgoTypes::Type type, State& state)
{
if (insertStart >= 0 && type != QSAlgoTypes::Insert) {
/* Insert */
appendPatch(createInsertPatch(insertStart,
indexT - 1, to), false);
insertStart = -1;
}
if (type == QSAlgoTypes::Insert) {
if (insertStart < 0) {
insertStart = indexT;
}
}
if (type == QSAlgoTypes::Move) {
MoveOp change(state.posF,
indexT + state.posF - indexF,
indexT);
if (pendingMovePatch.isNull()) {
pendingMovePatch = change;
} else if (pendingMovePatch.canMerge(change)){
pendingMovePatch.merge(change);
} else {
appendMovePatch(pendingMovePatch);
pendingMovePatch = change;
}
state.isMoved = true;
hash[keyT] = state;
}
if (type != QSAlgoTypes::Move && !pendingMovePatch.isNull()) {
appendMovePatch(pendingMovePatch);
pendingMovePatch.clear();
}
if (indexT < to.size() && (type == QSAlgoTypes::Move || type == QSAlgoTypes::NoMove)) {
QVariantMap tmpItemF = from[state.posF].toMap();
QVariantMap diff = compareMap(tmpItemF, itemT);
if (diff.size()) {
updatePatches << QSPatch(QSPatch::Update, indexT, indexT, 1, diff);
}
}
}
void Decision::setOpinions(QVariantMap newOpinions)
{
canonicalizeOpinions(newOpinions);
if (newOpinions == opinions())
return;
// Now we actually allocate space for and set the opinions
auto opinionList = m_decision.initOpinions(newOpinions.size());
unsigned currentIndex = 0;
while (!newOpinions.empty()) {
auto builder = opinionList[currentIndex++];
auto key = newOpinions.firstKey();
builder.setContestant(key.toInt());
builder.setOpinion(newOpinions.take(key).toInt());
}
emit opinionsChanged();
}
static QVariantList createPositionalQueryAndList(QString& baseSql, const QVariantMap& bindValues) {
QVariantList values;
if (bindValues.size() > 0) {
//Note: the below algorithm is based on QSqlResultPrivate::namedToPositionalBinding
//in an attempt to keep this code in sync with QT's param parsing.
int length = baseSql.length();
bool inEscape = false;
for (int i = 0; i < length;) {
QChar ch = baseSql.at(i);
if (ch == QLatin1Char(':') && !inEscape && (i == 0 || baseSql.at(i - 1) != QLatin1Char(':'))
&& (i + 1 < length && (baseSql.at(i + 1)).isLetterOrNumber())) {
//fast forward to end of term
int end = i + 2;
for (; end < length && baseSql.at(end).isLetterOrNumber(); ++end)
;
//extract value for this term
QString oldKey = baseSql.mid(i, end - i);
//replace term with unique term
baseSql.replace(i, end - i, '?');
values.append(valueLookup(bindValues, oldKey));
//values.append(bindValues.value(oldKey));
//correct loop variables
length = baseSql.length();
i = end + (1 - oldKey.length());
} else {
if (ch == QLatin1Char('\'')) {
inEscape = !inEscape;
}
++i;
}
}
}
return values;
}
void DBTalker::parseResponseUserName(const QByteArray& data)
{
QJson::Parser parser;
bool ok;
QVariant result = parser.parse(data,&ok);
QVariantMap rmap = result.toMap();
QList<QString> keys = rmap.uniqueKeys();
QString temp;
for(int i=0;i<rmap.size();i++)
{
if(keys[i] == "display_name")
{
temp = rmap[keys[i]].value<QString>();
}
}
emit signalBusy(false);
emit signalSetUserName(temp);
}
int QSDiffRunnerAlgo::preprocess(const QVariantList &from, const QVariantList &to)
{
int index = 0;
int min = qMin(from.size(), to.size());
QVariantMap f;
QVariantMap t;
for (index = 0 ; index < min ;index++) {
f = from[index].toMap();
t = to[index].toMap();
if (f[m_keyField] != t[m_keyField]) {
break;
}
QVariantMap diff = compareMap(f,t);
if (diff.size()) {
//@TODO reserve in block size
updatePatches << QSPatch::createUpdate(index, diff);
}
}
if (from.size() == index && to.size() - index > 0) {
// Special case: append to end
skipped = to.size();
appendPatch(createInsertPatch(index,to.size() - 1,to));
return to.size();
}
if (to.size() == index && from.size() - index> 0) {
// Special case: removed from end
appendPatch(QSPatch::createRemove(index, from.size() - 1));
skipped = from.size();
return from.size();
}
skipped = index;
return index;
}
QList<QSPatch> QSDiffRunnerAlgo::compareWithoutKey(const QVariantList &from, const QVariantList &to)
{
QList<QSPatch> patches;
int max = qMax(from.size(), to.size());
for (int i = 0 ; i < max ; i++) {
if (i >= from.size()) {
patches << QSPatch(QSPatch::Insert, i, i, 1, to[i].toMap());
} else if (i >= to.size() ) {
patches << QSPatch(QSPatch::Remove, i, i, 1);
} else {
QVariantMap diff = compareMap(from[i].toMap(), to[i].toMap());
if (diff.size()) {
patches << QSPatch(QSPatch::Update, i, i, 1, diff);
}
}
}
return patches;
}
QMap<QString, DictionaryParams> Dictionary::parseAvailableDictionaries(const QString& json, QString& dixioToken)
{
qDebug() << Q_FUNC_INFO << json;
QMap<QString, DictionaryParams> dictionaryList;
bool parseOk;
QVariantMap result = Json::parse(json, parseOk).toMap();
if(!parseOk)
return dictionaryList;
dixioToken = result["tokenDixio"].toString();
QVariantMap dictionaries = result["dictionaries"].toMap();
if(!dictionaries.size())
return dictionaryList;
QMap<QString, QVariant>::iterator i;
for (i = dictionaries.begin(); i != dictionaries.end(); ++i)
{
QVariantMap dictionaryMap = i.value().toMap();
DictionaryParams dictionary;
dictionary.id = dictionaryMap["id"].toString();
dictionary.commercialName = dictionaryMap["commercialName"].toString();
dictionary.shortName = dictionaryMap["shortName"].toString();
dictionary.downloadUrl = dictionaryMap["url"].toString();
dictionary.dixFileSize = dictionaryMap["url_size"].toInt();
dictionary.downloadUrlComp = dictionaryMap["url_comp"].toString();
dictionary.compFileSize = dictionaryMap["url_comp_size"].toInt();
dictionary.downloadFileName = dictionaryMap["downloadFileName"].toString();
dictionary.downloadFileNameComp = dictionaryMap["downloadFileName_comp"].toString();
dictionary.activationState = true;
dictionaryList.insert(dictionary.commercialName, dictionary);
}
return dictionaryList;
}
void SettingsSection::setValues(const QVariant& values)
{
QVariantMap map = values.toMap();
QVariantMap updatedValues;
// values not included in the map are reset to default
foreach (const QString& key, m_values.keys())
{
if (!map.contains(key))
map[key] = m_values[key]->defaultValue();
}
foreach (const QString& key, map.keys())
{
if (key.isEmpty())
continue;
bool haveKey = m_values.contains(key);
if (haveKey && m_values[key]->value() == map[key])
continue;
if (haveKey)
{
m_values[key]->setValue(map[key]);
}
else
{
m_values[key] = new SettingsValue(key, QVariant(), PLATFORM_ANY, this);
m_values[key]->setValue(map[key]);
}
updatedValues.insert(key, map[key]);
}
if (updatedValues.size() > 0)
emit valuesUpdated(updatedValues);
}
void packDataValue(QVariant_ *var, DataValue *value)
{
QVariant *qvar = reinterpret_cast<QVariant *>(var);
// Some assumptions are made below regarding the size of types.
// There's apparently no better way to handle this since that's
// how the types with well defined sizes (qint64) are mapped to
// meta-types (QMetaType::LongLong).
switch ((int)qvar->type()) {
case QVariant::Invalid:
value->dataType = DTInvalid;
break;
case QMetaType::QUrl:
*qvar = qvar->value<QUrl>().toString();
// fallthrough
case QMetaType::QString:
{
value->dataType = DTString;
QByteArray ba = qvar->toByteArray();
*(char**)(value->data) = local_strdup(ba.constData());
value->len = ba.size();
break;
}
case QMetaType::Bool:
value->dataType = DTBool;
*(qint8*)(value->data) = (qint8)qvar->toInt();
break;
case QMetaType::LongLong:
// Some of these entries will have to be fixed when handling platforms
// where sizeof(long long) != 8 or sizeof(int) != 4.
value->dataType = DTInt64;
*(qint64*)(value->data) = qvar->toLongLong();
break;
case QMetaType::ULongLong:
value->dataType = DTUint64;
*(quint64*)(value->data) = qvar->toLongLong();
break;
case QMetaType::Int:
value->dataType = DTInt32;
*(qint32*)(value->data) = qvar->toInt();
break;
case QMetaType::UInt:
value->dataType = DTUint32;
*(quint32*)(value->data) = qvar->toUInt();
break;
case QMetaType::VoidStar:
value->dataType = DTUintptr;
*(uintptr_t*)(value->data) = (uintptr_t)qvar->value<void *>();
break;
case QMetaType::Double:
value->dataType = DTFloat64;
*(double*)(value->data) = qvar->toDouble();
break;
case QMetaType::Float:
value->dataType = DTFloat32;
*(float*)(value->data) = qvar->toFloat();
break;
case QMetaType::QColor:
value->dataType = DTColor;
*(unsigned int*)(value->data) = qvar->value<QColor>().rgba();
break;
case QMetaType::QVariantList:
{
QVariantList varlist = qvar->toList();
int len = varlist.size();
DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
for (int i = 0; i < len; i++) {
packDataValue((void*)&varlist.at(i), &dvlist[i]);
}
value->dataType = DTValueList;
value->len = len;
*(DataValue**)(value->data) = dvlist;
}
break;
case QMetaType::QVariantMap:
{
QVariantMap varmap = qvar->toMap();
int len = varmap.size() * 2;
DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
QMapIterator<QString, QVariant> it(varmap);
for (int i = 0; i < len; i += 2) {
if (!it.hasNext()) {
panicf("QVariantMap mutated during iteration");
}
it.next();
QVariant key = it.key();
QVariant val = it.value();
packDataValue((void*)&key, &dvlist[i]);
packDataValue((void*)&val, &dvlist[i+1]);
}
value->dataType = DTValueMap;
value->len = len;
*(DataValue**)(value->data) = dvlist;
}
break;
default:
if (qvar->type() == (int)QMetaType::QObjectStar || qvar->canConvert<QObject *>()) {
QObject *qobject = qvar->value<QObject *>();
GoValue *goValue = dynamic_cast<GoValue *>(qobject);
if (goValue) {
value->dataType = DTGoAddr;
*(void **)(value->data) = goValue->addr;
break;
}
GoPaintedValue *goPaintedValue = dynamic_cast<GoPaintedValue *>(qobject);
if (goPaintedValue) {
value->dataType = DTGoAddr;
*(void **)(value->data) = goPaintedValue->addr;
break;
}
value->dataType = DTObject;
*(void **)(value->data) = qobject;
break;
}
{
QQmlListReference ref = qvar->value<QQmlListReference>();
if (ref.isValid() && ref.canCount() && ref.canAt()) {
int len = ref.count();
DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
QVariant elem;
for (int i = 0; i < len; i++) {
elem.setValue(ref.at(i));
packDataValue(&elem, &dvlist[i]);
}
value->dataType = DTValueList;
value->len = len;
*(DataValue**)(value->data) = dvlist;
break;
}
}
if (qstrncmp(qvar->typeName(), "QQmlListProperty<", 17) == 0) {
QQmlListProperty<QObject> *list = reinterpret_cast<QQmlListProperty<QObject>*>(qvar->data());
if (list->count && list->at) {
int len = list->count(list);
DataValue *dvlist = (DataValue *) malloc(sizeof(DataValue) * len);
QVariant elem;
for (int i = 0; i < len; i++) {
elem.setValue(list->at(list, i));
packDataValue(&elem, &dvlist[i]);
}
value->dataType = DTValueList;
value->len = len;
*(DataValue**)(value->data) = dvlist;
break;
}
}
panicf("unsupported variant type: %d (%s)", qvar->type(), qvar->typeName());
break;
}
}
