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();
}
}
