Function Function_Impl::factoryFromVariant(const QVariant& variant, const VersionString& version) { QVariantMap map = variant.toMap(); if (!map.contains("function_type")) { LOG_AND_THROW("Unable to find Function in expected location."); } std::string functionType = map["function_type"].toString().toStdString(); if (functionType == "LinearFunction") { return LinearFunction_Impl::fromVariant(variant,version); } LOG_AND_THROW("Unexpected function_type " << functionType << "."); }
//------------------------------------------------------------------------------ // Name: fromVariant //------------------------------------------------------------------------------ QJsonDocument QJsonDocument::fromVariant(const QVariant &variant) { QJsonDocument doc; if (variant.type() == QVariant::Map) { doc.setObject(QJsonObject::fromVariantMap(variant.toMap())); } else if (variant.type() == QVariant::List) { doc.setArray(QJsonArray::fromVariantList(variant.toList())); } else if (variant.type() == QVariant::StringList) { doc.setArray(QJsonArray::fromStringList(variant.toStringList())); } return doc; }
void YandexTranslationService::loadLanguages(const QString &file, bool withAutodetect) { if (withAutodetect) { m_sourceLanguages << Language("", tr("Autodetect")); m_langCodeToName.insert("", tr("Autodetect")); } QFile f(file); if (f.open(QFile::Text | QFile::ReadOnly)) { const QVariant data = parseJson(f.readAll()); f.close(); if (data.isValid()) { QVariantMapIterator langs(data.toMap().value("langs").toMap()); while (langs.hasNext()) { langs.next(); const QString code = langs.key(); const QString name = langs.value().toString(); m_langCodeToName.insert(code, name); } QSet<QString> duplicates; foreach (const QString &dirs, data.toMap().value("dirs").toStringList()) { const QStringList pair = dirs.split("-"); if (!duplicates.contains(pair.at(0))) { const QString code = pair.at(0); const QString name = m_langCodeToName.value(pair.at(0)); m_sourceLanguages << Language(code, name); m_targetLanguages[""] << Language(code, name); duplicates.insert(pair.at(0)); } m_targetLanguages[pair.at(0)] << Language(pair.at(1), m_langCodeToName.value(pair.at(1))); } } }
void Connector::processResponse(int id, QVariant responce) { QMap<int, QString>::Iterator it; Connector::Signal signal = 0; QString method = ""; requestListMutex.lock(); if(m_requests.size() < 1) { requestListMutex.unlock(); qDebug() << "network request has been deleted from queue before reply was received"; return; } it = m_requests.find(id); if(it != m_requests.end()) { method = it.value(); if(method == METHOD_USER_LOGIN) { QMap<QString , QVariant> elements(responce.toMap()); QString cookie = elements.value("session_name").toString(); cookie.append("="); cookie.append(elements.value("sessid").toString()); m_client.setCookie(cookie); m_isLogged = true; signal = &Connector::logInFinished; }else if(method == METHOD_TAXONOMY_GETTREE) { if(m_pointers.initFromRPC(&responce)) signal = &Connector::pointersLoaded; }else if(method == METHOD_FILE_UPLOAD) { signal = &Connector::fileUploadFinished; } m_requests.remove(id); } requestListMutex.unlock(); // Process send post requests if(!method.isEmpty() && signal) sendPostRequest(method); if(signal != 0) { emit (this->*signal)(); } }
Application::Application(int& argc, char* argv[]) : QApplication(argc, argv) { setApplicationName("Communi"); setOrganizationName("Communi"); setApplicationVersion(Irc::version()); setOrganizationDomain("communi.github.com"); *originalPalette() = palette(); QIcon icon; icon.addFile(":/resources/icons/16x16/communi.png"); icon.addFile(":/resources/icons/24x24/communi.png"); icon.addFile(":/resources/icons/32x32/communi.png"); icon.addFile(":/resources/icons/48x48/communi.png"); icon.addFile(":/resources/icons/64x64/communi.png"); icon.addFile(":/resources/icons/128x128/communi.png"); setWindowIcon(icon); qRegisterMetaTypeStreamOperators<ConnectionInfo>("ConnectionInfo"); qRegisterMetaTypeStreamOperators<ConnectionInfos>("ConnectionInfos"); QSettings settings; if (arguments().contains("-reset")) settings.clear(); if (arguments().contains("-reset-settings")) settings.remove("settings"); if (arguments().contains("-reset-connections")) settings.remove("connections"); if (arguments().contains("-reset-state")) { settings.remove("list"); settings.remove("tree"); settings.remove("splitter"); settings.remove("geometry"); } bool appliedSettings = false; if (settings.contains("settings")) { QVariant value = settings.value("settings"); if (value.canConvert<QVariantMap>()) { QVariantMap map = value.toMap(); // cleanup obsolete theme bloat foreach (const QString& key, map.keys()) { if (key.startsWith("ui.theme") || key.startsWith("themes.")) map.remove(key); } applySettings(map); appliedSettings = true; Application::settings()->setValues(map); }
void onStreamsRequestSuccess(QVariant response) { qDebug() << "Got stream info for video:" << _downloadData->videoId(); QVariantMap map = response.toMap(); Q_ASSERT(!map.isEmpty()); QSettings settings; QString quality = settings.value("Download/Quality", "360p").toString(); if (!map.contains(quality)) { if (map.contains("720p")) { quality = "720p"; } else if (map.contains("360p")) { quality = "360p"; } else if (map.contains("1080p")) { quality = "1080p"; } else { Q_ASSERT(false); onMetadataRequestError(response); return; } qDebug() << "User selected quality not available"; } qDebug() << "Selected video download quality:" << quality; if (_downloadData->hasPartialVideo()) { QString prevQuality = _downloadData->quality(); Q_ASSERT(!prevQuality.isEmpty()); // The user has changed video quality before unpausing the download if (prevQuality != quality) { if (map.contains(prevQuality)) quality = prevQuality; else _downloadData->removeVideoData(); } } QVariantMap urlMap; urlMap = map[quality].toMap(); _videoUrl = QUrl(urlMap["url"].toString(), QUrl::StrictMode); _downloadData->setQuality(quality); _streamRequest->deleteLater(); _streamRequest = NULL; beginDataDownloadsIfPossible(); }
bool SongListPrivate::parse( const QVariant& data ) { if(!data.toMap()[QLatin1String("result")].toMap().keys().contains("result") && !data.toMap()[QLatin1String("result")].toMap().keys().contains("Songs") ) { m_errorString = "received data is not valid"; return false; } bool isPlaylist = data.toMap()[QLatin1String("result")].toMap().keys().contains("Songs"); QVariantList varList; if(isPlaylist) varList = data.toMap()[QLatin1String("result")].toMap()[QLatin1String("Songs")].toList(); else varList = data.toMap()[QLatin1String("result")].toMap()[QLatin1String("result")].toList(); QVariantList songList; foreach( QVariant var, varList ) { QVariant v; v.setValue<GrooveShark::SongPtr>( SongPtr( new Song( var, isPlaylist ) ) ); songList.append( v ); }
void TestDevices::getPlugins() { QVariant response = injectAndWait("Devices.GetPlugins"); QVariantList plugins = response.toMap().value("params").toMap().value("plugins").toList(); QCOMPARE(plugins.count() > 0, true); bool found = false; foreach (const QVariant &listEntry, plugins) { if (PluginId(listEntry.toMap().value("id").toString()) == mockPluginId) { found = true; } } QCOMPARE(found, true); }
BrainOutMotor::BrainOutMotor(QVariant data, btRotationalLimitMotor* motor) : motor(motor){ QVariantMap outMap = data.toMap(); // new version if(outMap.contains("contractionOutput")) { boMaxMotorForce = new BrainOut(outMap["contractionOutput"]); boTargetVelocity = new BrainOut(outMap["expansionOutput"]); } // old version else { QVariantList dataL = outMap["brainOuts"].toList(); boMaxMotorForce = new BrainOut(dataL[0]); boTargetVelocity = new BrainOut(dataL[1]); } }
IntegerMutation::IntegerMutation(QVariant variant) { QVariantMap map = variant.toMap(); if(map["type"].toInt() == IntegerMutationType) { probability = map["probability"].toDouble(); minIncr = map["minIncr"].toDouble(); maxIncr = map["maxIncr"].toDouble(); minValue = map["minValue"].toDouble(); maxValue = map["maxValue"].toDouble(); enable = map["enable"].toBool(); } else qDebug() << Q_FUNC_INFO << "Wrong mutation type" << map["Type"].toInt(); }
void TestEvents::getEventType() { QFETCH(EventTypeId, eventTypeId); QFETCH(DeviceManager::DeviceError, error); QVariantMap params; params.insert("eventTypeId", eventTypeId.toString()); QVariant response = injectAndWait("Events.GetEventType", params); verifyDeviceError(response, error); if (error == DeviceManager::DeviceErrorNoError) { QVERIFY2(EventTypeId(response.toMap().value("params").toMap().value("eventType").toMap().value("id").toString()) == eventTypeId, "Didnt get reply for same actionTypeId as requested."); } }
optional<Error> eachMember(const QVariant& value, Fn&& fn) { auto map = value.toMap(); auto iter = map.constBegin(); while (iter != map.constEnd()) { optional<Error> result = fn(iter.key().toStdString(), iter.value()); if (result) { return result; } ++iter; } return {}; }
void QTweetAccountRateLimitStatus::parsingJsonFinished(const QVariant &json, bool ok, const QString &errorMsg) { if (ok) { QVariantMap respMap = json.toMap(); int remainingHits = respMap["remaining_hits"].toInt(); int resetTime = respMap["reset_time_in_seconds"].toInt(); int hourlyLimit = respMap["hourly_limit"].toInt(); emit rateLimitInfo(remainingHits, resetTime, hourlyLimit); } else { qDebug() << "QTweetAccountRateLimitStatus parser error: " << errorMsg; emit error(QTweetJsonError(errorMsg, json.toByteArray())); } }
void MainWindow::recvModelsList(const QVariantList &list) { ui->lwModelsList->clear(); QVariant var; QString str; for (int i=0; i < list.size(); i++) { var = list.at(i); str = var.toMap()["id"].toString(); ui->lwModelsList->insertItem(0, new QListWidgetItem(str)); } ui->lwModelDescription->clear(); ui->lineEditTextToPredict->clear(); }
ParameterStudyAlgorithm ParameterStudyAlgorithm_Impl::fromVariant(const QVariant& variant, const VersionString& version) { QVariantMap map = variant.toMap(); ParameterStudyAlgorithmOptions options = ParameterStudyAlgorithmOptions_Impl::fromVariant(map["options"],version); return ParameterStudyAlgorithm(toUUID(map["uuid"].toString().toStdString()), toUUID(map["version_uuid"].toString().toStdString()), map.contains("display_name") ? map["display_name"].toString().toStdString() : std::string(), map.contains("description") ? map["description"].toString().toStdString() : std::string(), map["complete"].toBool(), map["failed"].toBool(), map["iter"].toInt(), options, map.contains("restart_file_reference") ? openstudio::detail::toFileReference(map["restart_file_reference"],version) : OptionalFileReference(), map.contains("out_file_reference") ? openstudio::detail::toFileReference(map["out_file_reference"],version) : OptionalFileReference(), map.contains("job") ? runmanager::detail::JSON::toJob(variant,version, true) : boost::optional<runmanager::Job>()); }
// To create from serialization data SmellSensor::SmellSensor(QVariant data, RigidBodyOrigin::RigidBodyType smellType, Fixation * fixation) : Sensor(data, fixation) { QVariantMap map = data.toMap(); this->smellType = smellType; intensityInput = new BrainIn(map["intensityInput"]); // the max value equals radius of smell ! radiusOfSmell = map["radiusOfSmell"].toFloat(); //intensityInput->setMax(radiusOfSmell); brainInputs.append(intensityInput); createRigidBody(radiusOfSmell); }
void TestLogging::removeDevice() { // enable notifications QCOMPARE(enableNotifications(), true); // get this logentry with filter QVariantMap params; params.insert("deviceIds", QVariantList() << m_mockDeviceId); QVariant response = injectAndWait("Logging.GetLogEntries", params); verifyLoggingError(response); QVariantList logEntries = response.toMap().value("params").toMap().value("logEntries").toList(); QVERIFY(logEntries.count() > 0); QSignalSpy clientSpy(m_mockTcpServer, SIGNAL(outgoingData(QUuid,QByteArray))); // Remove the device params.clear(); params.insert("deviceId", m_mockDeviceId); response = injectAndWait("Devices.RemoveConfiguredDevice", params); verifyDeviceError(response); clientSpy.wait(200); QVariant notification = checkNotification(clientSpy, "Logging.LogDatabaseUpdated"); QVERIFY(!notification.isNull()); // verify that the logs from this device where removed from the db params.clear(); params.insert("deviceIds", QVariantList() << m_mockDeviceId); response = injectAndWait("Logging.GetLogEntries", params); verifyLoggingError(response); logEntries = response.toMap().value("params").toMap().value("logEntries").toList(); QCOMPARE(logEntries.count(), 0); // disable notifications QCOMPARE(disableNotifications(), true); }
void MaiaObject::parseResponse(QString response) { QDomDocument doc; QVariant arg; if(!doc.setContent(response)) { emit fault(-32700, tr("parse error: response not well formed.")); delete this; return; } if(doc.documentElement().firstChild().toElement().tagName().toLower() == "params") { QDomNode paramNode = doc.documentElement().firstChild().firstChild(); if(!paramNode.isNull()) { arg = fromXml( paramNode.firstChild().toElement() ); } emit aresponse(arg); } else if(doc.documentElement().firstChild().toElement().tagName().toLower() == "fault") { const QVariant errorVariant = fromXml(doc.documentElement().firstChild().firstChild().toElement()); emit fault(errorVariant.toMap() [ "faultCode" ].toInt(), errorVariant.toMap() [ "faultString" ].toString()); } else { emit fault(-32600, tr("parse error: invalid xml-rpc. not conforming to spec.")); } delete this; return; }
QVariant decode(const QByteArray &token, const QByteArray &key) { if(!QCA::isSupported("hmac(sha256)")) return QVariant(); int at = token.indexOf('.'); if(at == -1) return QVariant(); QByteArray headerPart = token.mid(0, at); ++at; int start = at; at = token.indexOf('.', start); if(at == -1) return QVariant(); QByteArray claimPart = token.mid(start, at - start); QByteArray sig = token.mid(at + 1); bool ok; QJson::Parser parser; QByteArray headerJson = unbase64url(headerPart); if(headerJson.isEmpty()) return QVariant(); QVariant headerObj = parser.parse(headerJson, &ok); if(!ok || headerObj.type() != QVariant::Map) return QVariant(); QVariantMap header = headerObj.toMap(); if(header.value("typ").toString() != "JWT" || header.value("alg").toString() != "HS256") return QVariant(); QByteArray claimJson = unbase64url(claimPart); if(claimJson.isEmpty()) return QVariant(); QVariant claim = parser.parse(claimJson, &ok); if(!ok) return QVariant(); if(jws_sign(headerPart, claimPart, key) != sig) return QVariant(); return claim; }
bool DecaptchaPluginConfig::load(const QString &filePath) { m_filePath = filePath; QFile file(filePath); if ((!file.exists()) || (!file.open(QFile::ReadOnly))) { Logger::log("DecaptchaPluginConfig::load(): Unable to open config file: " + filePath); return false; } bool ok; const QVariant v = QtJson::Json::parse(QString::fromUtf8(file.readAll()), ok); file.close(); if (!ok) { Logger::log("DecaptchaPluginConfig::load(): Error parsing config file: " + filePath); return false; } const QVariantMap config = v.toMap(); if (!config.contains("name")) { Logger::log("DecaptchaPluginConfig::load(): 'name' parameter is missing"); return false; } Logger::log("DecaptchaPluginConfig::load(): Config file loaded: " + filePath, Logger::MediumVerbosity); const int slash = filePath.lastIndexOf("/"); const QString fileName = filePath.mid(slash + 1); const int dot = fileName.lastIndexOf("."); m_displayName = config.value("name").toString(); m_iconFilePath = config.contains("icon") ? QString("%1/icons/%2").arg(filePath.section("/", 0, -3)) .arg(config.value("icon").toString()) : DEFAULT_ICON; m_id = fileName.left(dot); m_pluginType = config.value("type").toString(); m_settings = config.value("settings").toList(); m_version = qMax(1, config.value("version").toInt()); if (m_pluginType == "js") { m_pluginFilePath = filePath.left(slash + 1) + m_id + ".js"; } else { m_pluginFilePath = filePath.left(slash + 1) + LIB_PREFIX + m_id + LIB_SUFFIX; } emit changed(); return true; }
void DataFetcher::processReply() { if(sender() != m_reply) return; m_reply->deleteLater(); bool replyIsValid = true; if(m_reply->error() != QNetworkReply::NoError) { replyIsValid = false; m_lastError = m_reply->errorString(); // If we couldn't pass authentication... if(m_reply->error() == QNetworkReply::AuthenticationRequiredError) { m_login.clear(); m_password.clear(); } } else if(!m_reply->header(QNetworkRequest::ContentTypeHeader).toString().contains("application/json")) { replyIsValid = false; m_lastError = "Invalid response received from Jira. User login and password might be incorrect."; } else { const QByteArray& bytes = m_reply->readAll(); QJson::Parser parser; QVariant map = parser.parse(bytes, &replyIsValid); m_workLog = QSharedPointer<WorkLog>(new WorkLog(map.toMap())); if(!replyIsValid) { m_lastError = "Invalid JSON received."; qWarning() << "JSON:" << bytes; } } Q_ASSERT(replyIsValid || !m_lastError.isNull()); if(!replyIsValid && m_lastError.isNull()) m_lastError = "Unknown error"; m_reply = NULL; emit finished(replyIsValid); }
void CommandSetFileProperties::queryFinished() { Q_D(CommandSetFileProperties); tryAutoDelete(); QNetworkReply *reply = qobject_cast<QNetworkReply*>(sender()); if (!reply) { //TODO throw an error message qDebug() << "There is no reply::"+reply->errorString(); return; } reply->deleteLater(); if (checkInvalidReplyAndRefreshToken(reply)) { qDebug() << "There is invalid reply and refresh token::"+reply->errorString(); return; } QString reason = reply->attribute( QNetworkRequest::HttpReasonPhraseAttribute ).toString(); if (reason!="OK") { qDebug() <<"Set File properties response returned error "+reason; emitError(UnknownError, tr("Set File properties response returned error")); return; } QNetworkRequest req=reply->request(); qDebug()<< req.url(); bool ok; QVariant res = QJson::Parser().parse(reply, &ok); QMap<QString,QVariant> responseMap=res.toMap(); if (!ok) { emitError(UnknownError, tr("Set File properties response parse error")); return; } if (!(responseMap.contains(KEY_STRING)&&responseMap[KEY_STRING].toString()==currentKey && responseMap[VALUE_STRING]==d->fields[currentKey])) { qDebug() << "Failed to create property "+currentKey+"="+d->fields[currentKey]; emitError(UnknownError, tr("Set File properties response has error.No property created")); return; } emitSuccess(); }
glm::vec3 EntityActionInterface::extractVec3Argument(QString objectName, QVariantMap arguments, QString argumentName, bool& ok, bool required) { if (!arguments.contains(argumentName)) { if (required) { qDebug() << objectName << "requires argument:" << argumentName; } ok = false; return glm::vec3(0.0f); } QVariant resultV = arguments[argumentName]; if (resultV.type() != (QVariant::Type) QMetaType::QVariantMap) { qDebug() << objectName << "argument" << argumentName << "must be a map"; ok = false; return glm::vec3(0.0f); } QVariantMap resultVM = resultV.toMap(); if (!resultVM.contains("x") || !resultVM.contains("y") || !resultVM.contains("z")) { qDebug() << objectName << "argument" << argumentName << "must be a map with keys: x, y, z"; ok = false; return glm::vec3(0.0f); } QVariant xV = resultVM["x"]; QVariant yV = resultVM["y"]; QVariant zV = resultVM["z"]; bool xOk = true; bool yOk = true; bool zOk = true; float x = xV.toFloat(&xOk); float y = yV.toFloat(&yOk); float z = zV.toFloat(&zOk); if (!xOk || !yOk || !zOk) { qDebug() << objectName << "argument" << argumentName << "must be a map with keys: x, y, and z of type float."; ok = false; return glm::vec3(0.0f); } if (x != x || y != y || z != z) { // at least one of the values is NaN ok = false; return glm::vec3(0.0f); } return glm::vec3(x, y, z); }
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; }
QVariant ConversionUtil::fromVariant(QVariant::Type type, int userType, const QVariant &variant) { switch (type) { case QVariant::Bool: case QVariant::Int: case QVariant::Double: case QVariant::String: return variant; case QVariant::StringList: return variant.toStringList(); case QVariant::DateTime: return QDateTime::fromMSecsSinceEpoch(variant.toLongLong()); case QVariant::Map: { QVariantMap variantMap; QVariantMap map = variant.toMap(); for (const QString &key : map.keys()) { QVariantList valueList = map[key].toList(); if (valueList.length() == 3) { QVariant::Type valueType = (QVariant::Type) valueList[0].toInt(); int valueUserType = valueList[1].toInt(); QVariant value = valueList[2]; variantMap[key] = fromVariant(valueType, valueUserType, value); } else { LogUtil::logError("Invalid map format in key: %1", key); } } return variantMap; } case QVariant::UserType: { MetaTypeRegistry::JsonConverters converters = MetaTypeRegistry::jsonConverters(QMetaType::typeName(userType)); if (converters.jsonVariantToTypeConverter) { return converters.jsonVariantToTypeConverter(variant); } else { const char *typeName = QMetaType::typeName(userType); if (typeName) { LogUtil::logError("User type not serializable: %1", typeName); } else { LogUtil::logError("Unknown user type: %1", QString::number(userType)); } return QVariant(); } } default: LogUtil::logError("Unknown type: %1", QVariant::typeToName(type)); return QVariant(); } }
void parse(const QVariant &data) { foreach (const QVariant &resultVariant, data.toMap()[QLatin1String("results")].toList()) { QVariantMap result(resultVariant.toMap()); if (result[QLatin1String("kind")].toString() != QLatin1String("podcast")) { continue; } addPodcast(result[QLatin1String("trackName")].toString(), result[QLatin1String("feedUrl")].toUrl(), result[QLatin1String("artworkUrl100")].toUrl(), QString(), result[QLatin1String("collectionViewUrl")].toString(), 0); } }
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(); } }
QRect qRectFromVariant(const QVariant& objectVar, bool& valid) { QVariantMap object = objectVar.toMap(); QRect rect; valid = false; rect.setX(object["x"].toInt(&valid)); if (valid) { rect.setY(object["y"].toInt(&valid)); } if (valid) { rect.setWidth(object["width"].toInt(&valid)); } if (valid) { rect.setHeight(object["height"].toInt(&valid)); } return rect; }
void FriendJobPrivate::handleLocation(UserInfo *userInfo, const QVariant &data) { if (data.isValid()) { const QVariant nameVariant = data.toMap()["name"]; const QString name = nameVariant.toString(); if (!name.isEmpty()) { if (name.contains(',') && name.count(',') == 1) { QStringList parts = name.split(','); userInfo->setCity(parts[0].simplified()); userInfo->setCountry(parts[1].simplified()); } else { userInfo->setCity(name); } } } }
glm::mat4 qMapToGlmMat4(const QVariant& q) { QVariantMap qMap = q.toMap(); if (qMap.contains("r0c0") && qMap.contains("r1c0") && qMap.contains("r2c0") && qMap.contains("r3c0") && qMap.contains("r0c1") && qMap.contains("r1c1") && qMap.contains("r2c1") && qMap.contains("r3c1") && qMap.contains("r0c2") && qMap.contains("r1c2") && qMap.contains("r2c2") && qMap.contains("r3c2") && qMap.contains("r0c3") && qMap.contains("r1c3") && qMap.contains("r2c3") && qMap.contains("r3c3")) { return glm::mat4( qMap["r0c0"].toFloat(), qMap["r1c0"].toFloat(), qMap["r2c0"].toFloat(), qMap["r3c0"].toFloat(), qMap["r0c1"].toFloat(), qMap["r1c1"].toFloat(), qMap["r2c1"].toFloat(), qMap["r3c1"].toFloat(), qMap["r0c2"].toFloat(), qMap["r1c2"].toFloat(), qMap["r2c2"].toFloat(), qMap["r3c2"].toFloat(), qMap["r0c3"].toFloat(), qMap["r1c3"].toFloat(), qMap["r2c3"].toFloat(), qMap["r3c3"].toFloat() ); } else { return glm::mat4(); } }