terrama2::core::TerraMA2Init::TerraMA2Init(const std::string& serviceType, const int listeningPort) { curl_global_init(CURL_GLOBAL_ALL); terrama2::core::initializeTerralib(); terrama2::core::initializeLogger(serviceType+"_"+std::to_string(listeningPort)+"_terrama2.log"); auto& semanticsManager = terrama2::core::SemanticsManager::getInstance(); //read semantics from json file std::string semanticsPath = FindInTerraMA2Path("share/terrama2/semantics.json"); QFile semantcisFile(QString::fromStdString(semanticsPath)); semantcisFile.open(QFile::ReadOnly); QByteArray bytearray = semantcisFile.readAll(); QJsonDocument jsonDoc = QJsonDocument::fromJson(bytearray); auto array = jsonDoc.array(); for(const auto& json : array) { auto obj = json.toObject(); auto jsonProvidersTypes = obj["providers_type_list"].toArray(); std::vector<DataProviderType> providersTypes; for(const auto& providerType : jsonProvidersTypes) providersTypes.push_back(providerType.toString().toStdString()); auto jsonMetadata = obj["metadata"].toObject(); std::unordered_map<std::string, std::string> metadata; for(auto it = jsonMetadata.constBegin(); it != jsonMetadata.constEnd(); ++it) metadata.emplace(it.key().toStdString(), it.value().toString().toStdString()) ; semanticsManager.addSemantics(obj["code"].toString().toStdString(), obj["name"].toString().toStdString(), dataSeriesTypeFromString(obj["type"].toString().toStdString()), dataSeriesTemporalityFromString(obj["temporality"].toString().toStdString()), obj["format"].toString().toStdString(), providersTypes, metadata); } }
void AnnouncementApi::handleAnnounceResponse(QNetworkReply *reply) { QJsonParseError error; QByteArray body = reply->readAll(); QJsonDocument doc = QJsonDocument::fromJson(body, &error); if(error.error != QJsonParseError::NoError) throw ResponseError(QStringLiteral("Error parsing announcement response: %1").arg(error.errorString())); Announcement a; a.apiUrl = reply->property("API_URL").toUrl(); a.id = reply->property("SESSION_ID").toString(); a.updateKey = doc.object()["key"].toString(); a.listingId = doc.object()["id"].toInt(); logger::debug() << "Announced session. Got listing ID" << a.listingId; emit sessionAnnounced(a); QString welcome = doc.object()["message"].toString(); if(!welcome.isEmpty()) emit messageReceived(doc.object()["message"].toString()); }
void JsArchitecturalMetricsConfig::setMetricDefault() { QFile jsonFile(_jsArchitecturalMetricsDir+"/"+_jsonFileName); QString contentJsonFile; if (!jsonFile.open(QIODevice::ReadWrite | QIODevice::Text)) { qWarning("Couldn't open json file."); return; } contentJsonFile = jsonFile.readAll(); QJsonDocument jsonDocument = QJsonDocument::fromJson(contentJsonFile.toUtf8()); QJsonObject jsonObject = jsonDocument.object(); jsonObject["MetricDefault"] = _ui->metricDefaultComboBox->currentData().toString(); jsonDocument.setObject(jsonObject); jsonFile.resize(0); jsonFile.write(jsonDocument.toJson()); jsonFile.close(); }
bool DatabaseBackup::readContents(const QString &filename) { qDebug() << "Read contents from " + filename; QFile file(filename); QSqlQueryModel query; bool res = false; if (file.open(QIODevice::ReadOnly)) { QJsonDocument doc = QJsonDocument::fromJson(file.readAll()); if (doc.isObject()) { res = true; QJsonArray tables = doc.object().take("database").toObject().take("tables").toArray(); QJsonArray::const_iterator i = tables.constBegin(); while (i != tables.constEnd()) { QString tableName = (*i).toObject().take("name").toString(); qDebug() << tableName; QJsonArray records = (*i).toObject().take("records").toArray(); QJsonArray::const_iterator recordIterator = records.constBegin(); while (recordIterator != records.constEnd()) { QVariantMap record = (*recordIterator).toObject().toVariantMap(); QStringList fields = record.keys(); QStringList values; QStringList::const_iterator fieldIterator = fields.constBegin(); while (fieldIterator != fields.constEnd()) { values << record.take(*fieldIterator).toString(); ++fieldIterator; } qDebug() << "INSERT INTO " + tableName + " (" + fields.join(',') + ")" + " VALUES ('" + values.join("','") + "')"; query.setQuery( QSqlQuery("INSERT INTO " + tableName + " (" + fields.join(',') + ")" + " VALUES ('" + values.join("','") + "')") ); qDebug() << "Errors?" << query.lastError(); ++ recordIterator; } ++i; } } query.submit(); } file.close(); return res; }
QVariantMap DMenuPrivate::toVariantMap() const { QVariantList items; QVariantMap menuJsonContent; QVariantMap menuMap = menuVariant; for (DAction *action : menuActions) { QVariantMap map = action->d_func()->toVariantMap(); map["itemId"] = createActionId(action); items.push_back(map); } menuJsonContent["items"] = items; QJsonDocument menuJsonContentDoc = QJsonDocument::fromVariant(menuJsonContent); auto menuJsonContentStr = menuJsonContentDoc.toJson(); menuMap["menuJsonContent"] = menuJsonContentStr; return menuMap; }
QVariantList CBAttachmentsProvider::attributesForId(const QString &recId) { if (QDir(pathForId(recId)).exists()){ QString filename=attributePath(recId); QFile file(filename); if (!file.open(QIODevice::ReadOnly)){ qWarning("Cannot open attribute json"); } QString jsonData = file.readAll(); file.close(); QJsonDocument sd = QJsonDocument::fromJson(jsonData.toUtf8()); if (sd.isNull()){ qWarning("Wrong file attribute json format"); } return sd.array().toVariantList(); } else{ return QVariantList(); } }
void Helpers::importAddresses(QByteArray &data, const QDir& keystore) { QStringList existingList; const QStringList nameFilter("UTC*"); foreach ( const QString fileName, keystore.entryList(nameFilter) ) { QFile file(keystore.filePath(fileName)); file.open(QFile::ReadOnly); const QByteArray raw = file.readAll(); file.close(); const QJsonDocument doc = QJsonDocument::fromJson(raw); const QJsonObject contents = doc.object(); existingList.append(contents.value("address").toString("invalid")); } QDataStream stream(&data, QIODevice::ReadOnly); while ( !stream.atEnd() ) { quint32 size = 0; stream >> size; if ( size == 0 ) { throw QString("Invalid size in address datastream: " + QString::number(size, 10)); } QByteArray raw(size, '\0'); stream >> raw; const QJsonObject wrapper = QJsonDocument::fromBinaryData(raw).object(); // check for existing address NOTE: filename can differ! using address to address check const QString address = wrapper.value("address").toString(); if ( existingList.contains(address, Qt::CaseInsensitive) ) { continue; } const QJsonObject contents = wrapper.value("contents").toObject(); QFile file(keystore.filePath(wrapper.value("filename").toString("invalid"))); file.open(QFile::WriteOnly); file.write(QJsonDocument(contents).toJson(QJsonDocument::Compact)); file.close(); } }
BtsApiNotifier *BtsApi::setFolderHosts(const QString &secret, const QStringList &hosts) { QueryList ql; ql << QueryPair("secret", secret) << QueryPair("hosts", hosts.join(',')); QUrl apiUrl = getApiUrl(p, "set_folder_hosts", ql); QString queryString = apiUrl.query(QUrl::FullyEncoded); QNetworkReply *reply = p->nam->get(QNetworkRequest(apiUrl)); BtsApiNotifier *notifier = new BtsApiNotifier(this); connect(reply, &QNetworkReply::finished, [this, reply, notifier, secret]() { notifier->deleteLater(); if(checkForError(reply, notifier)) return; QJsonDocument doc = QJsonDocument::fromJson(reply->readAll()); if(checkForError(doc, notifier)) return; QJsonObject obj = doc.object(); QJsonArray arr = obj.value("hosts").toArray(); QStringList res; for(const QJsonValue &val: arr) res << val.toString(); emit setFolderHostsResult(res, secret); emit notifier->setFolderHostsResult(res, secret); }); return notifier; }
void CoapTests::jsonMessage() { CoapRequest request(QUrl("coap://coap.me:5683/5")); qDebug() << request.url().toString(); QSignalSpy spy(m_coap, SIGNAL(replyFinished(CoapReply*))); CoapReply *reply = m_coap->get(request); spy.wait(); QVERIFY2(spy.count() > 0, "Did not get a response."); QCOMPARE(reply->messageType(), CoapPdu::Acknowledgement); QCOMPARE(reply->statusCode(), CoapPdu::Content); QCOMPARE(reply->contentType(), CoapPdu::ApplicationJson); QCOMPARE(reply->error(), CoapReply::NoError); QJsonParseError error; QJsonDocument jsonDoc = QJsonDocument::fromJson(reply->payload(), &error); QCOMPARE(error.error, QJsonParseError::NoError); qDebug() << jsonDoc.toJson(); reply->deleteLater(); }
void JsonHandler::parseJson(QString path) { QFile file; file.setFileName(path); file.open(QIODevice::ReadOnly | QIODevice::Text); QJsonDocument document = QJsonDocument::fromJson(file.readAll()); file.close(); QJsonObject jsonObject = document.object(); QJsonArray jsonArray = jsonObject["circles"].toArray(); QJsonObject circle = jsonArray.at(0).toObject(); QJsonObject position = circle["position"].toObject(); int R = circle["R"].toInt(); int x = position["x"].toInt(); int y = position["y"].toInt(); params = new Params(x, y, R); QJsonObject panel = jsonObject["panel"].toObject(); QJsonObject jsonSize = panel["size"].toObject(); size.setHeight(jsonSize["y"].toInt()); size.setWidth(jsonSize["x"].toInt()); }
void AnimatorApplication::animate(){ printed = 0; QDir sourceDir(rootQML->property("sourceDirectory").toUrl().toLocalFile()); destinationDir = rootQML->property("destinationDirectory").toUrl().toLocalFile(); QString pathToSave(destinationDir); QDir saveDir(sourceDir); QStringList nameFilters; nameFilters << QString("*.json"); QStringList filelist = saveDir.entryList(nameFilters); //QMap сам сортирует по ключу вроде как QMap<int,GenAlgObject> map; QMap<int,double> fitnessMap; foreach(QString file, filelist){ int popNum = file.split("-")[0].toInt(); QFile jsonFile(sourceDir.absolutePath()+"\\" + file); jsonFile.open(QIODevice::ReadOnly); QByteArray data = jsonFile.readAll(); QJsonDocument doc = QJsonDocument::fromJson(data); map[popNum] = GenAlgObject(doc.object()); fitnessMap[popNum] = file.split("-")[1].toDouble(); }
void SDRdaemonSinkGui::networkManagerFinished(QNetworkReply *reply) { if (reply->error()) { ui->apiAddressLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }"); ui->statusText->setText(reply->errorString()); return; } QString answer = reply->readAll(); try { QByteArray jsonBytes(answer.toStdString().c_str()); QJsonParseError error; QJsonDocument doc = QJsonDocument::fromJson(jsonBytes, &error); if (error.error == QJsonParseError::NoError) { ui->apiAddressLabel->setStyleSheet("QLabel { background-color : green; }"); ui->statusText->setText(QString("API OK")); analyzeApiReply(doc.object()); } else { ui->apiAddressLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }"); QString errorMsg = QString("Reply JSON error: ") + error.errorString() + QString(" at offset ") + QString::number(error.offset); ui->statusText->setText(QString("JSON error. See log")); qInfo().noquote() << "SDRdaemonSinkGui::networkManagerFinished" << errorMsg; } } catch (const std::exception& ex) { ui->apiAddressLabel->setStyleSheet("QLabel { background:rgb(79,79,79); }"); QString errorMsg = QString("Error parsing request: ") + ex.what(); ui->statusText->setText("Error parsing request. See log for details"); qInfo().noquote() << "SDRdaemonSinkGui::networkManagerFinished" << errorMsg; } }
void CzmlReader::read(QString filename, QVector<SensorData>& data) { //file opening QFile czmlFile; QString czmlString; czmlFile.setFileName(filename); if(!czmlFile.open(QIODevice::ReadOnly | QIODevice::Text)){ return; } czmlString = czmlFile.readAll(); czmlFile.close(); //json QJsonDocument czmlDoc = QJsonDocument::fromJson(czmlString.toUtf8()); QJsonArray czmlArray = czmlDoc.array(); for(int i = 1; i < czmlArray.size(); i++){ QJsonObject czmlObject = czmlArray.at(i).toObject(); data.append(writeToSensorData(czmlObject)); } }
ContactPtr JSONToContact(const QByteArray& jsonData) { QJsonDocument document = QJsonDocument::fromJson(jsonData); const QVariantMap data = document.toVariant().toMap(); const QVariantMap entry = data.value(QStringLiteral("entry")).toMap(); const QVariantList categories = entry.value(QStringLiteral("category")).toList(); bool isContact = false; Q_FOREACH(const QVariant &c, categories) { const QVariantMap category = c.toMap(); if (category.value(QStringLiteral("term")).toString() == QLatin1String("http://schemas.google.com/contact/2008#contact")) { isContact = true; break; } } if (!isContact) { return ContactPtr(); } return Private::JSONToContact(entry).staticCast<Contact>(); }
void GetPocketApi::handleRemoveBookmarks(const QStringList& ids) { emit requestFinished(true); bool ok = false; QJsonDocument doc = PreparsingReply(sender(), ok); if (!ok) { qWarning() << Q_FUNC_INFO << "Failed preparsing reply phase"; return; } const auto& rootObject = doc.object(); if(rootObject ["status"].toInt() == 1) { emit bookmarksRemoved(ids); } else { emit error(tr("Unable to remove bookamark")); } }
void Storage::readDefaultLimits() { QString filename = QString(CLEPSYDRA_CONFIG_FOLDER).append(CLEPSYDRA_JSON_DEFAULTS_FILENAME); QFile file; QString data=NULL; file.setFileName(filename); if (file.open(QIODevice::ReadOnly | QIODevice::Text)==true) { data = file.readAll(); file.close(); } else { qDebug () << filename << "json file not found"; return; } QJsonDocument d = QJsonDocument::fromJson(data.toUtf8()); if (d.isEmpty()) { qDebug () << "Not valid document."; return; } QJsonObject obj = d.object(); QVariantMap tempData = obj.toVariantMap(); m_defaultLimits = tempData.take("default").toMap(); }
void GetPocketApi::handleTagsUpdated(const QString& id, const QString& tags) { emit requestFinished(true); bool ok = false; QJsonDocument doc = PreparsingReply(sender(), ok); if (!ok) { qWarning() << Q_FUNC_INFO << "Failed preparsing reply phase"; return; } const auto& rootObject = doc.object(); if(rootObject ["status"].toInt() == 1) { emit tagsUpdated(id, tags); } else { emit error(tr("Unable to update tags")); } }
void ThemeSelectorWidget::populateThemeList() { QDir dir; dir.cd("Themes"); QStringList dirList = dir.entryList(QDir::AllDirs); QString themeItem; foreach (themeItem, dirList) { if(themeItem == "." || themeItem == "..") continue; dir.cd(themeItem); QFile *file = new QFile(dir.absoluteFilePath("ThemeInfo.json")); file->open(QIODevice::ReadOnly); QTextStream stream(file); QString json = stream.readAll(); file->close(); QJsonDocument document = QJsonDocument::fromJson(json.toUtf8()); QJsonObject object = document.object(); QString themeName = object.take("Name").toString(); QString themeIcon = object.take("Icon").toString(); QString themeAuthor = object.take("Author").toString(); QString themeDesc = object.take("Desc").toString(); QString themeVer = object.take("Version").toString(); QString themeJS = object.take("ThemeScript").toString(); QString appBG = object.take("AppBackgroundColor").toString(); QString appTextColorScheme = object.take("AppTextColorScheme").toString(); QStringList itemData; itemData << dir.absoluteFilePath(themeJS); itemData << appBG; itemData << appTextColorScheme; itemDataList.append(itemData); QListWidgetItem *item = new QListWidgetItem(QIcon(dir.absoluteFilePath(themeIcon)),themeName); item->setToolTip(themeDesc + "\nAuthor: " + themeAuthor + "\nVersion: " +themeVer); ui->listWidget->addItem(new QListWidgetItem(QIcon(dir.absoluteFilePath(themeIcon)),themeName)); dir.cdUp(); } if(ui->listWidget->count() == 0) { ui->applyButton->setDisabled(true); } else { ui->applyButton->setDisabled(false); } }
void LoginManager::onGetUserRequestReady(QByteArray ba) { //qDebug() << "onGetUserRequestReady" << ba; disconnect(_oauthManager, SIGNAL(requestReady(QByteArray)), this, SLOT(onGetUserRequestReady(QByteArray))); if (_oauthManager->lastError() == KQOAuthManager::NoError) { QJsonDocument jsonResponse = QJsonDocument::fromJson(ba); QJsonObject user = jsonResponse.object(); if (user.value("name") != QJsonValue::Undefined) { _userName = user.value("name").toString(); _uid = user.value("id").toString().toInt(); emit getUserSuccess(); } else { emit getUserError(tr("Error while getting user info. Please try again")); } } else if (_oauthManager->lastError() != KQOAuthManager::NetworkError) { emit getUserError(tr("Error while getting user info: %1").arg(_oauthManager->lastError())); } }
QString CurrencyPane::SaveCurrencyRates() { QJsonDocument doc; QJsonArray array; for (int i = 0; i < ui->currencyTable->rowCount(); i++) { QTableWidgetItem* header = ui->currencyTable->verticalHeaderItem(i); QWidget* widget = ui->currencyTable->cellWidget(i, 1); QSpinBox* currencyBox = widget->findChild<QSpinBox*>("CurrencyCount"); QSpinBox* chaosBox = widget->findChild<QSpinBox*>("ChaosCount"); if (currencyBox && chaosBox) { QJsonObject obj; obj.insert("currency", header->text()); obj.insert("count", currencyBox->value()); obj.insert("chaos", chaosBox->value()); array.append(obj); } } doc.setArray(array); return doc.toJson(QJsonDocument::Compact); }
bool Parser::ParseCart(const QString &str, Cart &cart, const QHash<QString, Goods *> &pGoodsMap) { QJsonDocument doc = QJsonDocument::fromJson(str.toUtf8()); if (doc.isNull()) { return false; } // json array containing all items QJsonArray jCodeArray = doc.array(); if (jCodeArray.isEmpty()) { // no items or error json data return false; } // parse each item for (int i = 0; i < jCodeArray.size(); ++i) { QJsonValue jValue = jCodeArray.at(i); if (jValue.isString()) { QString strItem = jValue.toString(); QString strCode; int nCnt = 0; // parse barcode and count int pos = strItem.indexOf("-"); if (-1 == pos) { strCode = strItem; nCnt = 1; } else { strCode = strItem.left(pos); nCnt = strItem.mid(pos + 1).toInt(); nCnt = (nCnt > 0) ? nCnt : 1; } // add item cart.Insert(pGoodsMap.value(strCode), nCnt); } } return true; }
void Mod::ReadLiteModInfo(QByteArray contents) { QJsonParseError jsonError; QJsonDocument jsonDoc = QJsonDocument::fromJson(contents, &jsonError); auto object = jsonDoc.object(); if(object.contains("name")) { m_mod_id = m_name = object.value("name").toString(); } if(object.contains("version")) { m_version=object.value("version").toString(""); } else { m_version=object.value("revision").toString(""); } m_mcversion = object.value("mcversion").toString(); m_authors = object.value("author").toString(); m_description = object.value("description").toString(); m_homeurl = object.value("url").toString(); }
void DBTalker::parseResponseListFolders(const QByteArray& data) { QJsonParseError err; QJsonDocument doc = QJsonDocument::fromJson(data, &err); if (err.error != QJsonParseError::NoError) { emit signalBusy(false); emit signalListAlbumsFailed(i18n("Failed to list folders")); return; } QJsonObject jsonObject = doc.object(); QJsonArray jsonArray = jsonObject[QString::fromLatin1("contents")].toArray(); QList<QPair<QString, QString> > list; list.clear(); list.append(qMakePair(QString::fromLatin1("/"), QString::fromLatin1("root"))); foreach (const QJsonValue& value, jsonArray) { QString path(QString::fromLatin1("")); bool isDir; QJsonObject obj = value.toObject(); path = obj[QString::fromLatin1("path")].toString(); isDir = obj[QString::fromLatin1("is_dir")].toBool(); qCDebug(KIPIPLUGINS_LOG) << "Path is "<<path<<" Is Dir "<<isDir; if(isDir) { qCDebug(KIPIPLUGINS_LOG) << "Path is "<<path<<" Is Dir "<<isDir; QString name = path.section(QLatin1Char('/'), -2); qCDebug(KIPIPLUGINS_LOG) << "str " << name; list.append(qMakePair(path,name)); m_queue.enqueue(path); } }
void RunModel::loadded() { mDatas.clear(); beginResetModel(); qDebug()<<"received"; QNetworkReply * reply = qobject_cast<QNetworkReply*>(sender()); if (reply->error() != QNetworkReply::NoError) { emit error(reply->errorString()); return; } QJsonDocument document = QJsonDocument::fromJson(reply->readAll()); mTotalCount = document.object().value("meta").toObject().value("total_count").toInt(); mLimit = document.object().value("meta").toObject().value("limit").toInt(); mOffset = document.object().value("meta").toObject().value("offset").toInt(); qDebug()<<Q_FUNC_INFO<<"total "<<mTotalCount; QJsonArray array = document.object().value("objects").toArray(); foreach (QJsonValue value, array) { RunItem item; item.name = value.toObject().value("resultsName").toString(); item.date = QDateTime::fromString(value.toObject().value("timeStamp").toString(),Qt::ISODate); item.id = value.toObject().value("id").toInt(); item.reportLink = QUrl(value.toObject().value("reportLink").toString()); item.status = value.toObject().value("status").toString(); mDatas.append(item); }
bool HistoryModel::save(const QString &path) const { if (SessionsManager::isReadOnly()) { return false; } QSaveFile file(path); if (!file.open(QIODevice::WriteOnly)) { return false; } QJsonArray array; for (int i = 0; i < rowCount(); ++i) { QStandardItem *entry(item(i)); if (entry) { QJsonObject object; object.insert(QLatin1String("url"), entry->data(UrlRole).toUrl().toString()); object.insert(QLatin1String("title"), entry->data(TitleRole).toString()); object.insert(QLatin1String("time"), entry->data(TimeVisitedRole).toDateTime().toString(QLatin1String("yyyy-MM-dd hh:mm:ss"))); array.prepend(object); } } QJsonDocument document; document.setArray(array); file.write(document.toJson(QJsonDocument::Indented)); return file.commit(); }
bool SyncEngine::sync(const QJsonDocument &response_document) { bool changed = false; emit syncStarted(); QJsonObject root = { {"version", F_LEAKLOG_VERSION}, {"db_version", F_DB_VERSION}, {"source_uuid", sourceUUID()}, {"database_uuid", databaseUUID()}, {"database_name", databaseName()}, {"journal_version", JournalEntry::Version}, }; QJsonObject journal_state = journalState(); if (response_document.isObject()) { QJsonObject response = response_document.object(); QJsonObject local_journal_state = journalStateForVersion(journal_state, response.value("journal_version").toInt()); QJsonObject server_journal_state = journalStateForVersion(response.value("journal").toObject(), JournalEntry::Version); if (local_journal_state == server_journal_state) { return changed; } QJsonArray entries; QStringList local_journal_state_keys = local_journal_state.keys(); if (local_journal_state_keys.count()) { QStringList predicates; QVariantList values; foreach (const QJsonValue &source_uuid, local_journal_state_keys) { QStringList components = source_uuid.toString().split(':'); predicates << QString("(source_uuid = ? AND entry_id > ?)"); values << components.first(); values << server_journal_state.value(source_uuid.toString()).toInt(); }
void FbxAPI::requestAuthorizeStatusFinished() { QNetworkReply * reply = qobject_cast<QNetworkReply*>(sender()); QJsonDocument doc = QJsonDocument::fromJson(reply->readAll()); if(parseResult(doc)) { QString statusString = doc.object().value("result").toObject().value("status").toString(); AuthStatus status; if (statusString == "unknown") status = UnknownStatus; if (statusString == "pending") status = PendingStatus; if (statusString == "timeout") status = TimeOutStatus; if (statusString == "granted") status = GrantedStatus; if (statusString == "denied") status = DeniedStatus; qDebug()<<statusString<<status; emit authorizeStatusChanged(status); } reply->deleteLater(); }
bool Splitter::split(const QString &json) { // drapeau ok initialisé baissé bool ok = false; // récupération du calcul à fragmenter à partir du json QJsonParseError error; QJsonDocument doc = QJsonDocument::fromJson(json.toUtf8(), &error); QVariantMap params; if(!error.error && doc.isObject()) { if(doc.object().contains(CS_JSON_KEY_CALC_PARAMS) && doc.object().value(CS_JSON_KEY_CALC_PARAMS).isObject()) { params = doc.object().value(CS_JSON_KEY_CALC_PARAMS).toObject().toVariantMap(); } else { _error = QString("Missing '%1' field in calculation !") .arg(CS_JSON_KEY_CALC_PARAMS); } } else { _error = "Missing json object !"; } // vérification des paramètres if(params.contains(PARAM_MIN_LEN) && params.contains(PARAM_MAX_LEN)) { /* * La fragmentation stupide pour le bruteforce consiste a distribuer * en donnant une taille de mot de passe pour chaque fragment */ // -- récupération des valeurs de min et max len dans les champs des paramètres uint min_len = params.value(PARAM_MIN_LEN).toInt(); uint max_len = params.value(PARAM_MAX_LEN).toInt(); QJsonArray fragments; // -- pour chaque longueur entre min et max len, création d'un fragment for (uint l = min_len; l <= max_len; ++l) { // --- récupération de l'objet calcul de base QJsonObject frag = doc.object(); // --- identifiant du bloc de calcul frag.insert(CS_JSON_KEY_FRAG_ID, QString::number(l-min_len+1)); // --- récupération des paramètres du calcul de base QVariantMap frag_params = params; // --- modification des champs min et max len dans les paramètre frag_params.insert(PARAM_MIN_LEN, l); frag_params.insert(PARAM_MAX_LEN, l); // --- modification du champ paramètre frag.insert(CS_JSON_KEY_CALC_PARAMS, QJsonObject::fromVariantMap(frag_params)); // --- insertion du fragment dans la liste fragments.append(frag); } // -- insertion des fragment dans l'attribut résultat de l'objet splitter _result = QJsonDocument(fragments).toJson(QJsonDocument::Compact); // on lève le drapeau ok = true; } else { _error = QString("Missing fields '%1' and '%2' in field '%3' calculation !") .arg(PARAM_MAX_LEN, PARAM_MAX_LEN, CS_JSON_KEY_CALC_PARAMS); } return ok; }
bool loadConfig(const QString& filename, QMainWindow *mainWindow) { // Load Existing Configuration ///////////////////////////////////////////// QFile file(filename); if( !file.open(QFile::ReadOnly) ) { return false; } QJsonParseError error; const QJsonDocument cfgDoc = QJsonDocument::fromJson(file.readAll(), &error); file.close(); if( error.error != QJsonParseError::NoError ) { return false; } const QJsonObject cfgObj = cfgDoc.object(); if( cfgObj.isEmpty() ) { return false; } // WMainWindow ///////////////////////////////////////////////////////////// const QJsonObject mainObj = cfgObj[QStringLiteral("mainWindow")].toObject(); if( !mainObj.isEmpty() ) { loadGeometry(mainWindow, mainObj); } // WPlotWindow ///////////////////////////////////////////////////////////// WPlotWindow::loadConfig(cfgObj); // WValuesWindow /////////////////////////////////////////////////////////// WValuesWindow::loadConfig(cfgObj); return true; }
//-------------------------------------------------------------------------------------------- void Begin2DSceneMessage::build(const axtrace_time_s& traceTime, const axtrace_head_s& head, cyclone::RingBuf* ringBuf) { memcpy(&m_time, &traceTime, sizeof(axtrace_time_s)); m_processID = head.pid; m_threadID = head.tid; axtrace_2d_begin_scene_s value_head; size_t len = ringBuf->memcpy_out(&value_head, sizeof(value_head)); assert(len == sizeof(value_head)); m_sceneRect = QRectF(value_head.left, value_head.top, value_head.right-value_head.left, value_head.bottom-value_head.top); //copy name char tempBuf[AXTRACE_MAX_SCENE_DEFINE_LENGTH]; int name_length = value_head.name_len; //TODO: check name length len = ringBuf->memcpy_out(tempBuf, name_length); assert(len == name_length); tempBuf[name_length - 1] = 0; //make sure last char is '\0' m_sceneName = QString::fromUtf8(tempBuf); //copy define int define_length = value_head.define_len; len = ringBuf->memcpy_out(tempBuf, define_length); assert(len == define_length); tempBuf[define_length] = 0; //make json object if (define_length > 0) { QJsonParseError jerror; QJsonDocument jsonDocument = QJsonDocument::fromJson(tempBuf, &jerror); if (jerror.error == QJsonParseError::NoError) { m_sceneDefine = jsonDocument.object(); } } }