bool SettingsManager::loadVariable(QIODevice* in, bool append) { if (!in || !in->isOpen() || !in->isReadable()) { qDebug() << "SettingsManager::loadVariableFromFile: Is not open or is not readable"; return false; } QDataStream stream(in); stream.setVersion(QDataStream::Qt_4_6); QVariant v; stream >> v; if (append) { QHash<QString, QVariant> hash = v.toHash(); QHash<QString, QVariant>::const_iterator i = hash.constBegin(); while (i != hash.constEnd()) { m_variables.insert(i.key(), i.value()); ++i; } } else { m_variables = v.toHash(); } return true; }
bool FBXMLHandler::endElement( const QString & /*namespaceURI*/, const QString & /*localName*/, const QString & /*qName*/ ) { flushCharacters(); QVariant c = iStack [iStack.count() - 1] ; QString name = topName(); iStack.removeLast(); iNameStack.removeLast(); if (!iStack.count()) { iRootObject = c; iRootName = name; } else { QVariant tC = iStack[iStack.count() - 1] ; if (tC.isNull()) { tC = QVariantHash(); iStack.replace(iStack.count() - 1, tC); } if (tC.type() == QVariant::List) { QVariantList list = tC.toList(); list.append( c.toHash() ); iStack.replace( iStack.count() - 1 , list); } else if (tC.type() == QVariant::Hash) { QVariantHash hash = tC.toHash(); if (c.isNull()) { c = QString(""); } hash.insert( name, c ); iStack.replace( iStack.count() - 1 , hash); } } return true; }
void TarryTown::breakpoint() { qDebug() << "Entering debugging mode"; QTextStream in(stdin); QTextStream out(stdout); QString to_eval; while (to_eval != "cont") { out << "> "; out.flush(); to_eval = in.readLine(); to_eval = to_eval.replace(QString("\n"),""); if (to_eval != "cont") { QScriptValue result = p_engine->evaluate(to_eval); if (p_engine->hasUncaughtException()) { QStringList backtrace = p_engine->uncaughtExceptionBacktrace(); fprintf (stderr, " %s\n\n", qPrintable(backtrace.join("\n"))); } else { QVariant value = result.toVariant(); if (value.type() == QMetaType::QVariantMap) { qDebug() << "=> " << value.toMap(); } else if (value.type() == QMetaType::QVariantList) { qDebug() << "=> " << value.toList(); } else if (value.type() == QMetaType::QVariantHash) { qDebug() << "=> " << value.toHash(); } else if (value.type() == QMetaType::QString) { qDebug() << "=> \n" << value.toString(); } else { qDebug() << "=> " << value; } } // if (p_engine->hasUncaughtException()) } } }
void setOptionsForQObject(const QVariant& opt, QObject *obj) { if (!opt.isValid()) return; qDebug() << QStringLiteral("set %1(%2) meta properties:").arg(QLatin1String(obj->metaObject()->className())).arg(obj->objectName()); if (opt.type() == QVariant::Hash) { QVariantHash options(opt.toHash()); if (options.isEmpty()) return; QHashIterator<QString, QVariant> i(options); while (i.hasNext()) { i.next(); if (i.value().type() == QVariant::Hash) // for example "vaapi": {...} continue; obj->setProperty(i.key().toUtf8().constData(), i.value()); qDebug("%s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); } } if (opt.type() != QVariant::Map) return; QVariantMap options(opt.toMap()); if (options.isEmpty()) return; QMapIterator<QString, QVariant> i(options); while (i.hasNext()) { i.next(); if (i.value().type() == QVariant::Map) // for example "vaapi": {...} continue; obj->setProperty(i.key().toUtf8().constData(), i.value()); qDebug("%s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); } }
QByteArray toJson( const QVariant &variant, bool* ok ) { #if QT_VERSION >= QT_VERSION_CHECK( 5, 0, 0 ) QVariant _variant = variant; if ( variant.type() == QVariant::Hash ) { // QJsonDocument cannot deal with QVariantHash, so convert. const QVariantHash hash = variant.toHash(); QVariantMap map; QHashIterator<QString, QVariant> it(hash); while ( it.hasNext() ) { it.next(); map.insert( it.key(), it.value() ); } _variant = map; } QJsonDocument doc = QJsonDocument::fromVariant( _variant ); if ( ok != NULL ) { *ok = !doc.isNull(); } return doc.toJson( QJsonDocument::Compact ); #else QJson::Serializer serializer; return serializer.serialize( variant, ok ); #endif }
/*! \~english Exports the all flash variants. \~japanese すべてのフラッシュオブジェクトをエクスポートする */ void TActionController::exportAllFlashVariants() { QVariant var = sessionStore.take(FLASH_VARS_SESSION_KEY); if (!var.isNull()) { exportVariants(var.toHash()); } }
void Keyboard::handleInfo(QVariant const& properties) { bool ok = false; QVariantHash items = properties.toHash(); QString newSize = items[QString::fromLatin1("size")].toString(); QVariantHash locale = items[QString::fromLatin1("locale")].toHash(); int intSize = newSize.toInt(&ok); if (!locale.isEmpty()) { QString languageId = locale[QString::fromLatin1("languageId")].toString(); QString countryId = locale[QString::fromLatin1("countryId")].toString(); if (!languageId.isEmpty()) mLanguageId = languageId; if (!countryId.isEmpty()) mCountryId = countryId; } if (ok && intSize != mKeyboardHeight) { mKeyboardHeight = intSize; emit notifyHeightChanged(mKeyboardHeight); } #ifdef PPS_KEYBOARD_DEBUG qDebug() << "Keyboard: height:" << mKeyboardHeight << " languageId:" << mLanguageId << " countryId:" << mCountryId; #endif }
void LuaEngine::luaPush(const QVariant& variant) { switch (variant.type()) { case QVariant::Bool: { luaPush(variant.toBool()); break; } case QVariant::String: { luaPush(variant.toString()); break; } case QVariant::Int: { luaPush(variant.toInt()); break; } case QVariant::Map: { luaPush(variant.toMap()); break; } case QVariant::Hash: { luaPush(variant.toHash()); break; } default: break; } }
FormGenAcceptResult FormGenRecordComposition::acceptsValueImpl(const QVariant &val) const { if( variantType(val) != QMetaType::QVariantHash ) return FormGenAcceptResult::reject({}, val); QVariantHash hash = val.toHash(); QStringList valueStringList; QSet<QString> processedTags; for( const auto &elm : mElements ) { auto elementAccepts = elm.element->acceptsValue(hash.value(elm.tag)); if( ! elementAccepts.acceptable ) { QString path = elm.tag; if( ! elementAccepts.path.isEmpty() ) path += QString("/%1").arg(elementAccepts.path); return FormGenAcceptResult::reject(path, elementAccepts.value); } valueStringList.append(FormGenElement::keyStringValuePair(elm.tag, elementAccepts.valueString)); processedTags.insert(elm.tag); } QSet<QString> remainingTags = hash.keys().toSet() - processedTags; if( ! remainingTags.isEmpty() ) return FormGenAcceptResult::reject(*remainingTags.cbegin(), hash.value(*remainingTags.cbegin())); return FormGenAcceptResult::accept(val, FormGenElement::objectString(valueStringList)); }
Command Command::fromQVariant(const QVariant &variant) { const QHash<QString, QVariant> hash = variant.toHash(); const QString namePref = QLatin1String("Name"); const QString executablePref = QLatin1String("Command"); const QString argumentsPref = QLatin1String("Arguments"); const QString workingDirectoryPref = QLatin1String("WorkingDirectory"); const QString enablePref = QLatin1String("Enabled"); const QString shortcutPref = QLatin1String("Shortcut"); const QString showOutputPref = QLatin1String("ShowOutput"); const QString saveBeforeExecutePref = QLatin1String("SaveBeforeExecute"); Command command; if (hash.contains(enablePref)) command.isEnabled = hash[enablePref].toBool(); if (hash.contains(namePref)) command.name = hash[namePref].toString(); if (hash.contains(executablePref)) command.executable = hash[executablePref].toString(); if (hash.contains(argumentsPref)) command.arguments = hash[argumentsPref].toString(); if (hash.contains(workingDirectoryPref)) command.workingDirectory = hash[workingDirectoryPref].toString(); if (hash.contains(shortcutPref)) command.shortcut = hash[shortcutPref].value<QKeySequence>(); if (hash.contains(showOutputPref)) command.showOutput = hash[showOutputPref].toBool(); if (hash.contains(saveBeforeExecutePref)) command.saveBeforeExecute = hash[saveBeforeExecutePref].toBool(); return command; }
void Session::persistSession(const QString &sessionId, const QVariant &data) const { const QString &sessionFile = SessionPrivate::filePath(sessionId); const QVariantHash &hash = data.toHash(); if (hash.isEmpty()) { qCDebug(C_SESSION) << "Clearing session values on" << sessionFile; bool ret = QFile::remove(sessionFile); if (!ret) { QSettings settings(sessionFile, QSettings::IniFormat); settings.clear(); } } else { qCDebug(C_SESSION) << "Persisting session values to" << sessionFile; QSettings settings(sessionFile, QSettings::IniFormat); settings.beginGroup(QLatin1String("Data")); QVariantHash::ConstIterator it = hash.constBegin(); while (it != hash.constEnd()) { if (it.value().isNull()) { settings.remove(it.key()); } else { settings.setValue(it.key(), it.value()); } ++it; } settings.endGroup(); } }
bool ZrpcResponsePacket::fromVariant(const QVariant &in) { if(in.type() != QVariant::Hash) return false; QVariantHash obj = in.toHash(); if(!obj.contains("id") || obj["id"].type() != QVariant::ByteArray) return false; id = obj["id"].toByteArray(); if(!obj.contains("success") || obj["success"].type() != QVariant::Bool) return false; success = obj["success"].toBool(); value.clear(); condition.clear(); if(success) { if(!obj.contains("value")) return false; value = obj["value"]; } else { if(!obj.contains("condition") || obj["condition"].type() != QVariant::ByteArray) return false; condition = obj["condition"].toByteArray(); } return true; }
QString EvaluateSubExpression(const QString& subexpr, const QVariant& v) { if (subexpr.size() == 0) { // limit the displayed decimal places if ((QMetaType::Type)v.type() == QMetaType::Double) { return QString::number(v.toDouble(), 'f', 2); } return v.toString(); } else if (subexpr.at(0) == '[') { int rightbracket = subexpr.indexOf(']'); if (rightbracket > 0) { bool ok = false; int index = subexpr.mid(1, rightbracket-1).toInt(&ok); if (ok && (QMetaType::Type)v.type() == QMetaType::QVariantList) { return EvaluateSubExpression(subexpr.mid(rightbracket + 1), v.toList().at(index)); } } } else { int dot = subexpr.indexOf('.'); QString key = subexpr.mid(0, dot); if ((QMetaType::Type)v.type() == QMetaType::QVariantHash) { QHash<QString, QVariant> h = v.toHash(); QHash<QString, QVariant>::const_iterator it = h.find(key); if (it != h.end()) return EvaluateSubExpression(subexpr.mid(key.length() + 1), *it); } else if ((QMetaType::Type)v.type() == QMetaType::QVariantMap) { QMap<QString, QVariant> h = v.toMap(); QMap<QString, QVariant>::const_iterator it = h.find(key); if (it != h.end()) return EvaluateSubExpression(subexpr.mid(key.length() + 1), *it); } } return ""; }
bool ConnectionManager2::applyConfig(QVariant const & config) { if (config.type() != QVariant::List) return false; QList<Connection *> newConns; struct cleanup { QList<Connection *> & conns; cleanup(QList<Connection *> & conns) : conns(conns) {} ~cleanup() { for (int i = 0; i < conns.size(); ++i) conns[i]->releaseAll(); } } cleanupGuard(newConns); QList<QVariant> const & connConfigs = config.toList(); for (int i = 0; i < connConfigs.size(); ++i) { if (connConfigs[i].type() != QVariant::Hash) return false; QHash<QString, QVariant> const & connConfig = connConfigs[i].toHash(); QVariant typev = connConfig.value("type"); if (typev.type() != QVariant::String) return false; QString const & type = typev.toString(); ConnectionPointer<Connection> conn; if (type == "serial_port") conn.reset(new SerialPort()); else if (type == "tcp_client") conn.reset(new TcpSocket()); else if (type == "udp_socket") conn.reset(new UdpSocket()); #ifdef HAVE_LIBYB else if (type == "usb_yb_acm") conn.reset(new UsbAcmConnection2(m_yb_runner)); #endif if (!conn) return false; QVariant settings = connConfig.value("settings"); if (settings.type() != QVariant::Hash || !conn->applyConfig(settings.toHash())) return false; newConns.push_back(conn.data()); conn.take(); } this->clearUserOwnedConns(); while (!newConns.empty()) { this->addUserOwnedConn(newConns.back()); newConns.pop_back(); } return true; }
QVariant variantMapValue(const QVariant& value, const QString& key) { if (value.userType() == QVariant::Map) { return value.toMap().value(key); } else { return value.toHash().value(key); } }
void CredentialsManager::keychainJobFinished( QKeychain::Job* j ) { tDebug() << Q_FUNC_INFO; if ( QKeychain::ReadPasswordJob* readJob = qobject_cast< QKeychain::ReadPasswordJob* >( j ) ) { if ( readJob->error() == QKeychain::NoError ) { tDebug() << "QtKeychain readJob for" << readJob->service() << "/" << readJob->key() << "finished without errors"; QVariant creds; QJson::Parser parser; bool ok; creds = parser.parse( readJob->textData().toLatin1(), &ok ); QVariantMap map = creds.toMap(); QVariantHash hash; for ( QVariantMap::const_iterator it = map.constBegin(); it != map.constEnd(); ++it ) { hash.insert( it.key(), it.value() ); } creds = QVariant( hash ); if ( !ok || creds.toHash().isEmpty() ) { creds = QVariant( readJob->textData() ); } m_credentials.insert( CredentialsStorageKey( readJob->service(), readJob->key() ), creds ); } else { tDebug() << "QtKeychain readJob for" << readJob->service() << "/" << readJob->key() << "finished with error:" << j->error() << j->errorString(); } m_readJobs[ readJob->service() ].removeOne( readJob ); if ( m_readJobs[ readJob->service() ].isEmpty() ) { emit serviceReady( readJob->service() ); } } else if ( QKeychain::WritePasswordJob* writeJob = qobject_cast< QKeychain::WritePasswordJob* >( j ) ) { tLog() << Q_FUNC_INFO << "QtKeychain writeJob for" << writeJob->service() << "/" << writeJob->key() << "finished" << ( ( j->error() == QKeychain::NoError ) ? "without error" : j->errorString() ); } else if ( QKeychain::DeletePasswordJob* deleteJob = qobject_cast< QKeychain::DeletePasswordJob* >( j ) ) { tLog() << Q_FUNC_INFO << "QtKeychain deleteJob for" << deleteJob->service() << "/" << deleteJob->key() << "finished" << ( ( j->error() == QKeychain::NoError ) ? "without error" : j->errorString() ); } j->deleteLater(); }
SerialPortEnumerator::SerialPortEnumerator() { connect(&m_refreshTimer, SIGNAL(timeout()), this, SLOT(refresh())); m_refreshTimer.start(1000); QVariant cfg = sConfig.get(CFG_VARIANT_SERIAL_CONNECTIONS); if(cfg.type() == QVariant::Hash) m_connCfg = cfg.toHash(); }
bool keyedObjectContains(const QVariant &in, const QString &name) { if(in.type() == QVariant::Hash) return in.toHash().contains(name); else if(in.type() == QVariant::Map) return in.toMap().contains(name); else return false; }
QVariant keyedObjectGetValue(const QVariant &in, const QString &name) { if(in.type() == QVariant::Hash) return in.toHash().value(name); else if(in.type() == QVariant::Map) return in.toMap().value(name); else return QVariant(); }
bool keyedObjectIsEmpty(const QVariant &in) { if(in.type() == QVariant::Hash) return in.toHash().isEmpty(); else if(in.type() == QVariant::Map) return in.toMap().isEmpty(); else return true; }
void lua::push_qvariant(lua_State* const state, const QVariant& value) { switch (value.userType()) { case QVariant::Invalid: lua::push(state, lua::value::nil); break; case QVariant::Bool: lua::push(state, value.toBool()); break; case QVariant::Char: lua::push(state, value.toChar()); break; case QVariant::Int: { lua::push(state, value.toInt()); break; } case QVariant::Double: case QVariant::UInt: lua::push(state, value.toDouble()); break; case QVariant::String: lua::push(state, value.toString()); break; case QVariant::Hash: { auto hash = value.toHash(); auto table = lua::push(state, lua::value::table); for (auto i = hash.begin(); i != hash.end(); ++i) { lua::table::set(table, i.key(), i.value()); } break; } case QVariant::StringList: { auto list = value.toStringList(); auto table = lua::push(state, lua::value::table); for (int i = 0; i < list.size(); ++i) { lua::table::set(table, i + 1, list[i]); } break; } default: { auto converter = qvariant_push_handler.find(value.userType()); if (converter != qvariant_push_handler.end()) { converter->second(state, value); } else { throw std::logic_error(std::string("No handler exists to push QVariant type: ") + value.typeName()); } } } }
//FIXME: why to lower case? void setOptionsToDict(const QVariant& opt, AVDictionary** dict) { if (!opt.isValid()) return; if (opt.type() == QVariant::Map) { QVariantMap options(opt.toMap()); if (options.isEmpty()) return; QMapIterator<QString, QVariant> i(options); while (i.hasNext()) { i.next(); const QVariant::Type vt = i.value().type(); if (vt == QVariant::Map) continue; const QByteArray key(i.key().toUtf8()); switch (vt) { case QVariant::Bool: { // QVariant.toByteArray(): "true" or "false", can not recognized by avcodec av_dict_set(dict, key.constData(), QByteArray::number(i.value().toInt()), 0); } break; default: // key and value are in lower case av_dict_set(dict, i.key().toUtf8().constData(), i.value().toByteArray().constData(), 0); break; } qDebug("dict: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); } return; } QVariantHash options(opt.toHash()); if (options.isEmpty()) return; QHashIterator<QString, QVariant> i(options); while (i.hasNext()) { i.next(); const QVariant::Type vt = i.value().type(); if (vt == QVariant::Hash) continue; const QByteArray key(i.key().toUtf8()); switch (vt) { case QVariant::Bool: { // QVariant.toByteArray(): "true" or "false", can not recognized by avcodec av_dict_set(dict, key.constData(), QByteArray::number(i.value().toInt()), 0); } break; default: // key and value are in lower case av_dict_set(dict, i.key().toUtf8().constData(), i.value().toByteArray().constData(), 0); break; } qDebug("dict: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); } }
QVariant Session::value(Cutelyst::Context *c, const QString &key, const QVariant &defaultValue) { QVariant session = c->property(SESSION_VALUES); if (session.isNull()) { session = SessionPrivate::loadSession(c); if (session.isNull()) { return defaultValue; } } return session.toHash().value(key, defaultValue); }
QVariant SessionPrivate::loadSession(Context *c) { QVariant ret; const QVariant property = c->property(SESSION_VALUES); if (!property.isNull()) { ret = property.toHash(); return ret; } static Session *session = c->plugin<Session*>(); if (!session) { qCCritical(C_SESSION) << "Session plugin not registered"; return ret; } const QString sid = Session::id(c); if (!loadSessionExpires(session, c, sid).isNull()) { if (SessionPrivate::validateSessionId(sid)) { const QVariantHash sessionData = session->d_ptr->store->getSessionData(c, sid, QStringLiteral("session")).toHash(); c->setProperty(SESSION_VALUES, sessionData); if (session->d_ptr->verifyAddress && sessionData.contains(QStringLiteral("__address")) && sessionData.value(QStringLiteral("__address")).toString() != c->request()->address().toString()) { qCWarning(C_SESSION) << "Deleting session" << sid << "due to address mismatch:" << sessionData.value(QStringLiteral("__address")).toString() << "!=" << c->request()->address().toString(); deleteSession(session, c, QStringLiteral("address mismatch")); return ret; } if (session->d_ptr->verifyUserAgent && sessionData.contains(QStringLiteral("__user_agent")) && sessionData.value(QStringLiteral("__user_agent")).toString() != c->request()->userAgent()) { qCWarning(C_SESSION) << "Deleting session" << sid << "due to user agent mismatch:" << sessionData.value(QStringLiteral("__user_agent")).toString() << "!=" << c->request()->userAgent(); deleteSession(session, c, QStringLiteral("user agent mismatch")); return ret; } qCDebug(C_SESSION) << "Restored session" << sid; ret = sessionData; } } return ret; }
void FormGenRecordComposition::setVaidatedValueImpl(const QVariant &val) { mUpdating = UpdatingState; const QVariantHash map = val.toHash(); for( auto it = map.cbegin(); it != map.cend(); ++it ) mElements.at(mTagIndexMap.value(it.key())).element->setValidatedValue(it.value()); if( mUpdating == UpdatingWithChangeState ) emit valueChanged(); mUpdating = NotUpdatingState; }
void XmlWriter::writeVariant( QXmlStreamWriter &stream, const QVariant &value ) { ASSERT_LIMITED_VARIANT( value ); if( value.isNull() || value.type() == QVariant::Invalid ) { stream.writeEmptyElement( "nil" ); } else if( value.type() == QVariant::Bool ) { stream.writeTextElement( "boolean", value.toBool() ? "true" : "false" ); } else if( value.type() == QVariant::ByteArray ) { stream.writeTextElement( "base64", value.toByteArray().toBase64() ); } else if( value.type() == QVariant::Color ) { writeColor( stream, value.value<QColor>() ); } else if( value.type() == QVariant::Date ) { stream.writeTextElement( "date", value.toDate().toString( Qt::ISODate ) ); } else if( value.type() == QVariant::DateTime ) { stream.writeTextElement( "datetime", value.toDateTime().toString( Qt::ISODate ) ); } else if( value.type() == QVariant::Double ) { stream.writeTextElement( "double", QString::number( value.toDouble() ) ); } else if( value.type() == QVariant::Hash ) { QHash<QString, QVariant> hash = value.toHash(); QHashIterator<QString, QVariant> it( hash ); stream.writeStartElement( "map" ); stream.writeAttribute( "type", "hash" ); while( it.hasNext() ) { it.next(); stream.writeStartElement( "item" ); stream.writeTextElement( "key", it.key() ); stream.writeStartElement( "value" ); writeVariant( stream, it.value() ); stream.writeEndElement(); // value stream.writeEndElement(); // item } stream.writeEndElement(); } else if( value.type() == QVariant::Image ) { QByteArray ba; QBuffer buffer( &ba ); buffer.open( QIODevice::WriteOnly ); value.value<QImage>().save( &buffer, "PNG" ); buffer.close(); stream.writeTextElement( "image", ba.toBase64() ); } else if( value.type() == QVariant::Int ) { stream.writeTextElement( "int", QString::number( value.toInt() ) ); } else if( value.type() == QVariant::List ) { stream.writeStartElement( "list" ); const QVariantList list = value.toList(); foreach( const QVariant & var, list ) { writeVariant( stream, var ); }
void setOptionsToFFmpegObj(const QVariant& opt, void* obj) { if (!opt.isValid()) return; AVClass *c = obj ? *(AVClass**)obj : 0; if (c) qDebug() << QStringLiteral("%1.%2 options:").arg(QLatin1String(c->class_name)).arg(QLatin1String(c->item_name(obj))); else qDebug() << "options:"; if (opt.type() == QVariant::Map) { QVariantMap options(opt.toMap()); if (options.isEmpty()) return; QMapIterator<QString, QVariant> i(options); while (i.hasNext()) { i.next(); const QVariant::Type vt = i.value().type(); if (vt == QVariant::Map) continue; const QByteArray key(i.key().toUtf8()); qDebug("%s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); if (vt == QVariant::Int || vt == QVariant::UInt || vt == QVariant::Bool) { // QVariant.toByteArray(): "true" or "false", can not recognized by avcodec av_opt_set_int(obj, key.constData(), i.value().toInt(), AV_OPT_SEARCH_CHILDREN); } else if (vt == QVariant::LongLong || vt == QVariant::ULongLong) { av_opt_set_int(obj, key.constData(), i.value().toLongLong(), AV_OPT_SEARCH_CHILDREN); } else if (vt == QVariant::Double) { av_opt_set_double(obj, key.constData(), i.value().toDouble(), AV_OPT_SEARCH_CHILDREN); } } return; } QVariantHash options(opt.toHash()); if (options.isEmpty()) return; QHashIterator<QString, QVariant> i(options); while (i.hasNext()) { i.next(); const QVariant::Type vt = i.value().type(); if (vt == QVariant::Hash) continue; const QByteArray key(i.key().toUtf8()); qDebug("%s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); if (vt == QVariant::Int || vt == QVariant::UInt || vt == QVariant::Bool) { av_opt_set_int(obj, key.constData(), i.value().toInt(), AV_OPT_SEARCH_CHILDREN); } else if (vt == QVariant::LongLong || vt == QVariant::ULongLong) { av_opt_set_int(obj, key.constData(), i.value().toLongLong(), AV_OPT_SEARCH_CHILDREN); } } }
QVariant getChild(const QVariant &in, const QString &parentName, const QString &childName, bool required, bool *ok, QString *errorMessage) { if(!isKeyedObject(in)) { QString pn = !parentName.isEmpty() ? parentName : QString("value"); setError(ok, errorMessage, QString("%1 is not an object").arg(pn)); return QVariant(); } QString pn = !parentName.isEmpty() ? parentName : QString("object"); QVariant v; if(in.type() == QVariant::Hash) { QVariantHash h = in.toHash(); if(!h.contains(childName)) { if(required) setError(ok, errorMessage, QString("%1 does not contain '%2'").arg(pn, childName)); else setSuccess(ok, errorMessage); return QVariant(); } v = h[childName]; } else // Map { QVariantMap m = in.toMap(); if(!m.contains(childName)) { if(required) setError(ok, errorMessage, QString("%1 does not contain '%2'").arg(pn, childName)); else setSuccess(ok, errorMessage); return QVariant(); } v = m[childName]; } setSuccess(ok, errorMessage); return v; }
bool QtVariantContext::isFalse(const QString& key) const { QVariant value = this->value(key); switch (value.userType()) { case QVariant::Bool: return !value.toBool(); case QVariant::List: return value.toList().isEmpty(); case QVariant::Hash: return value.toHash().isEmpty(); case QVariant::Map: return value.toMap().isEmpty(); default: return value.toString().isEmpty(); } }
void AVDecoder::setOptions(const QVariantHash &dict) { DPTR_D(AVDecoder); d.options = dict; // if dict is empty, can not return here, default options will be set for AVCodecContext // apply to AVCodecContext d.applyOptionsForContext(); /* set AVDecoder meta properties. * we do not check whether the property exists thus we can set dynamic properties. */ if (dict.isEmpty()) return; if (name() == "avcodec") return; QVariant opt; if (dict.contains(name())) opt = dict.value(name()); else if (dict.contains(name().toLower())) opt = dict.value(name().toLower()); else return; // TODO: set property if no name() key found? if (opt.type() == QVariant::Hash) { QVariantHash property_dict(opt.toHash()); if (property_dict.isEmpty()) return; QHashIterator<QString, QVariant> i(property_dict); while (i.hasNext()) { i.next(); if (i.value().type() == QVariant::Hash) // for example "vaapi": {...} continue; setProperty(i.key().toUtf8().constData(), i.value()); qDebug("decoder meta property: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); } } else if (opt.type() == QVariant::Map) { QVariantMap property_dict(opt.toMap()); if (property_dict.isEmpty()) return; QMapIterator<QString, QVariant> i(property_dict); while (i.hasNext()) { i.next(); if (i.value().type() == QVariant::Map) // for example "vaapi": {...} continue; setProperty(i.key().toUtf8().constData(), i.value()); qDebug("decoder meta property: %s=>%s", i.key().toUtf8().constData(), i.value().toByteArray().constData()); } } }