void ValgrindRunner::traceActivity(Activity activity, const QString &buildDirCallgrind, const QString &buildDirMassif) { QString activityString; QString qbsCommand; bool dryRun; switch (activity) { case ActivityResolving: activityString = "resolving"; qbsCommand = "resolve"; dryRun = false; break; case ActivityRuleExecution: activityString = "rule-execution"; qbsCommand = "build"; dryRun = true; break; case ActivityNullBuild: activityString = "null-build"; qbsCommand = "build"; dryRun = false; break; } const QString outFileCallgrind = m_baseOutputDir + "/outfile." + activityString + ".callgrind"; const QString outFileMassif = m_baseOutputDir + "/outfile." + activityString + ".massif"; QFuture<qint64> callGrindFuture = QtConcurrent::run(this, &ValgrindRunner::runCallgrind, qbsCommand, buildDirCallgrind, dryRun, outFileCallgrind); QFuture<qint64> massifFuture = QtConcurrent::run(this, &ValgrindRunner::runMassif, qbsCommand, buildDirMassif, dryRun, outFileMassif); callGrindFuture.waitForFinished(); massifFuture.waitForFinished(); addToResults(ValgrindResult(activity, callGrindFuture.result(), massifFuture.result())); }
void tst_QtConcurrentRun::functor() { //this test functor without result_type, decltype need to be supported by the compiler #ifndef Q_COMPILER_DECLTYPE QSKIP("Compiler do not suport decltype", SkipAll); #else Functor f; { QFuture<int> fut = QtConcurrent::run(f); QCOMPARE(fut.result(), 42); } { QFuture<double> fut = QtConcurrent::run(f, 8.5, 1.8); QCOMPARE(fut.result(), (8.5/1.8)); } { QFuture<int> fut = QtConcurrent::run(f, 19, 3); QCOMPARE(fut.result(), int(19/3)); } { QtConcurrent::run(f, 1).waitForFinished(); QtConcurrent::run(f, 1,2).waitForFinished(); QtConcurrent::run(f, 1,2,3).waitForFinished(); QtConcurrent::run(f, 1,2,3,4).waitForFinished(); QtConcurrent::run(f, 1,2,3,4,5).waitForFinished(); } #endif }
// This tests functor without result_type; decltype need to be supported by the compiler. void tst_QtConcurrentRun::functor() { #ifndef Q_COMPILER_DECLTYPE QSKIP("Compiler does not support decltype"); #else Functor f; { QFuture<int> fut = QtConcurrent::run(f); QCOMPARE(fut.result(), 42); } { QFuture<double> fut = QtConcurrent::run(f, 8.5, 1.8); QCOMPARE(fut.result(), (8.5/1.8)); } { QFuture<int> fut = QtConcurrent::run(f, 19, 3); QCOMPARE(fut.result(), int(19/3)); } { QtConcurrent::run(f, 1).waitForFinished(); QtConcurrent::run(f, 1,2).waitForFinished(); QtConcurrent::run(f, 1,2,3).waitForFinished(); QtConcurrent::run(f, 1,2,3,4).waitForFinished(); QtConcurrent::run(f, 1,2,3,4,5).waitForFinished(); } #endif }
void ImageWidget::updateImage(bool zoom, const QImage &image, bool valuesPresent[], int values[]) { if(zoom) { QImage imageNew = scaleImage(image); if(imageNew.isNull()) return; #ifndef QT_NO_CONCURRENT QFuture<QImage> future = QtConcurrent::run(this, &ImageWidget::scaleImage, image); imageNew = future.result(); #else QImage imageNew = scaleImage(image); #endif pixmap = QPixmap::fromImage(imageNew); } else { pixmap = QPixmap::fromImage(image); } for(int i=0; i<4; i++) { drawValues[i] = valuesPresent[i]; if(drawValues[i]) geoValues[i] = values[i]; else geoValues[i] = 0; } update(); }
void Integration::initEgl() { Q_ASSERT(m_eglDisplay == EGL_NO_DISPLAY); // This variant uses Wayland as the EGL platform qputenv("EGL_PLATFORM", "wayland"); m_eglDisplay = eglGetDisplay(waylandServer()->internalClientConection()->display()); if (m_eglDisplay == EGL_NO_DISPLAY) { return; } // call eglInitialize in a thread to not block QFuture<bool> future = QtConcurrent::run([this] () -> bool { EGLint major, minor; if (eglInitialize(m_eglDisplay, &major, &minor) == EGL_FALSE) { return false; } EGLint error = eglGetError(); if (error != EGL_SUCCESS) { return false; } return true; }); // TODO: make this better while (!future.isFinished()) { waylandServer()->internalClientConection()->flush(); QCoreApplication::processEvents(QEventLoop::WaitForMoreEvents); } if (!future.result()) { eglTerminate(m_eglDisplay); m_eglDisplay = EGL_NO_DISPLAY; } }
void EditTagDialog::SetSongsFinished(QFuture<QList<Data>> future) { if (!SetLoading(QString())) return; data_ = future.result(); if (data_.count() == 0) { // If there were no valid songs, disable everything ui_->song_list->setEnabled(false); ui_->tab_widget->setEnabled(false); // Show a summary with empty information UpdateSummaryTab(Song()); ui_->tab_widget->setCurrentWidget(ui_->summary_tab); SetSongListVisibility(false); return; } // Add the filenames to the list for (const Data& data : data_) { ui_->song_list->addItem(data.current_.basefilename()); } // Select all ui_->song_list->setCurrentRow(0); ui_->song_list->selectAll(); // Hide the list if there's only one song in it SetSongListVisibility(data_.count() != 1); }
void DocsetRegistry::_runQuery(const QString &query) { m_cancellationToken.reset(); QList<Docset *> enabledDocsets; const SearchQuery searchQuery = SearchQuery::fromString(query); if (searchQuery.hasKeywords()) { for (Docset *docset : qAsConst(m_docsets)) { if (searchQuery.hasKeywords(docset->keywords())) enabledDocsets << docset; } } else { enabledDocsets = docsets(); } QFuture<QList<SearchResult>> queryResultsFuture = QtConcurrent::mappedReduced(enabledDocsets, std::bind(&Docset::search, std::placeholders::_1, searchQuery.query(), std::ref(m_cancellationToken)), &MergeQueryResults); QList<SearchResult> results = queryResultsFuture.result(); if (m_cancellationToken.isCanceled()) return; std::sort(results.begin(), results.end()); if (m_cancellationToken.isCanceled()) return; emit searchCompleted(results); }
CC_FILE_ERROR BinFilter::loadFile(const char* filename, ccHObject& container, bool alwaysDisplayLoadDialog/*=true*/, bool* coordinatesShiftEnabled/*=0*/, double* coordinatesShift/*=0*/) { ccLog::Print("[BIN] Opening file '%s'...",filename); //opening file QFile in(filename); if (!in.open(QIODevice::ReadOnly)) return CC_FERR_READING; uint32_t firstBytes = 0; if (in.read((char*)&firstBytes,4)<0) return CC_FERR_READING; bool v1 = (strncmp((char*)&firstBytes,"CCB2",4) != 0); if (v1) { return LoadFileV1(in,container,static_cast<unsigned>(firstBytes),alwaysDisplayLoadDialog); //firstBytes == number of scans for V1 files! } else { if (alwaysDisplayLoadDialog) { QProgressDialog pDlg(QString("Loading: %1").arg(QFileInfo(filename).fileName()),QString(),0,0/*static_cast<int>(in.size())*/); pDlg.setWindowTitle("BIN file"); pDlg.show(); //concurrent call in a separate thread s_file = ∈ s_container = &container; QFuture<CC_FILE_ERROR> future = QtConcurrent::run(_LoadFileV2); while (!future.isFinished()) { #if defined(CC_WINDOWS) ::Sleep(500); #else usleep(500 * 1000); #endif if (alwaysDisplayLoadDialog) { pDlg.setValue(pDlg.value()+1); //pDlg.setValue(static_cast<int>(in.pos())); //DGM: in fact, the file reading part is just half of the work! QApplication::processEvents(); } } s_file = 0; s_container = 0; return future.result(); } else { return BinFilter::LoadFileV2(in,container); } } }
void PrettyImage::ImageScaled(QFuture<QImage> future) { thumbnail_ = QPixmap::fromImage(future.result()); state_ = State_Finished; updateGeometry(); update(); emit Loaded(); }
bool CatalogConnector::loadDataThreaded(IlwisObject *obj, const IOOptions &options){ kernel()->issues()->log(QString(TR("Scanning %1")).arg(source().url(true).toString()),IssueObject::itMessage); QVector<std::pair<CatalogExplorer *, IOOptions>> explorers; for(const auto& explorer : _dataProviders){ explorers.push_back({explorer.get(), options}); } QFuture<std::vector<Resource>> res = QtConcurrent::mappedReduced(explorers,loadExplorerData, gatherData); res.waitForFinished(); mastercatalog()->addItems(res.result()); return true; }
void windowLoadMiRNAF::on_buttonChooseMirnaF_clicked() { fileNameMiRNA=QFileDialog::getOpenFileName( this, tr("Choose File"), "", "FASTA files (*.fasta);;Text files (*.txt);;All files (*)" ); if(!fileNameMiRNA.isEmpty()){ ui->progressBar->show(); try { QFuture<bool> future = QtConcurrent::run(&QtExceptionWrapper::targetFinder_getMiRNAs,m_oTF,fileNameMiRNA.toStdString()); //m_oTF->getMiRNAs(fileNameMiRNA.toStdString()); this->FutureWatcher.setFuture(future); future.result(); //make visible labelFileSelectedMirna ui->labelFileSelectedMirna->setVisible(true); //change the value of labelFileSelectedMirna ui->labelFileSelectedMirna->setText(tr("Mirna File selected : ")+fileNameMiRNA); //make the button next accessible ui->NextAnalyzeResults->setEnabled(true); this->ui->progressBar->setMaximum(100); this->ui->progressBar->setValue(100); }catch(MyException const& e) { QMessageBox::warning(this,tr("Loading error"),e.what()); //hiding labelFileSelectedMirna ui->labelFileSelectedMirna->setVisible(false); //change the value of labelFileSelectedMirna ui->labelFileSelectedMirna->setText(tr("")); //make the button next disabled ui->NextAnalyzeResults->setEnabled(false); this->ui->progressBar->hide(); }catch(std::string const& e2) { QMessageBox::warning(this,tr("Loading error"),QString::fromStdString(e2)); //hiding labelFileSelectedMirna ui->labelFileSelectedMirna->setVisible(false); //change the value of labelFileSelectedMirna ui->labelFileSelectedMirna->setText(tr("")); //make the button next disabled ui->NextAnalyzeResults->setEnabled(false); this->ui->progressBar->hide(); } } else{ QMessageBox::warning(this,tr("File selected"),tr("No file selected")); } }
bool ActivitySessionData::setCurrentActivity(const QString &activityId) { QFuture<bool> rv; QMetaObject::invokeMethod(m_activitiesProxy, "setCurrentActivity", Qt::BlockingQueuedConnection, Q_RETURN_ARG(QFuture<bool>, rv), Q_ARG(QString, activityId)); rv.waitForFinished(); //TODO: this shows one of the weaknesses in the QFuture based APIs .... bool value = rv.results().isEmpty() ? false : rv.result(); return value; }
void DkThumbNailT::thumbLoaded() { QFuture<QImage> future = thumbWatcher.future(); img = future.result(); if (img.isNull() && forceLoad != force_exif_thumb) imgExists = false; fetching = false; DkSettings::resources.numThumbsLoading--; emit thumbLoadedSignal(img.isNull()); }
void DkThumbNailT::colorLoaded() { QFuture<QColor> future = colorWatcher.future(); meanColor = future.result(); if (meanColor != DkSettings::display.bgColorWidget) emit colorUpdated(); else colorExists = false; fetchingColor = false; qDebug() << "mean color: " << meanColor; }
void tst_QtConcurrentThreadEngine::runThroughStarter() { { ThreadEngineStarter<QString> starter = startThreadEngine(new StringResultUser()); QFuture<QString> f = starter.startAsynchronously(); QCOMPARE(f.result(), QString("Foo")); } { ThreadEngineStarter<QString> starter = startThreadEngine(new StringResultUser()); QString str = starter.startBlocking(); QCOMPARE(str, QString("Foo")); } }
QDomDocument* TeamWorkApi::FutureParseResponse( QString strName, QString strXml ){ strSomeError.clear(); QFuture<QDomDocument*> objFuture = QtConcurrent::run( this, &TeamWorkApi::ParseResponse, strName, strXml ); while( !objFuture.isFinished() ) QCoreApplication::processEvents( QEventLoop::AllEvents, 100 ); QDomDocument *pdomResult = objFuture.result(); if( 0 < strSomeError.length() ){ emit TmpmApiError( strSomeError ); return NULL; } return pdomResult; }
void LibraryModel::ResetAsyncQueryFinished( QFuture<LibraryModel::QueryResult> future) { const struct QueryResult result = future.result(); BeginReset(); root_->lazy_loaded = true; PostQuery(root_, result, false); if (init_task_id_ != -1) { app_->task_manager()->SetTaskFinished(init_task_id_); init_task_id_ = -1; } endResetModel(); }
void ImageWidget::updateImage(bool FitToSize, const QImage &image, bool valuesPresent[], int values[], const double &scaleFactor, bool selectStarted, QRect selectRect, bool selectSimpleView) { disconnected = false; selectionRect = selectRect; selectionStarted = selectStarted; simpleView = selectSimpleView; // in case of fit to parent widget, we calculate concurrently if possible if((FitToSize) || (qAbs(scaleFactor-1) > 0.01)) { #ifndef QT_NO_CONCURRENT QFuture<QImage> future = QtConcurrent::run(this, &ImageWidget::scaleImage, image, scaleFactor, FitToSize); imageNew = future.result(); #else imageNew = scaleImage(image, scalefactor, FitToSize); #endif // no scaling, just take the pointer } else { imageNew = image; } if(simpleView) { update(); return; } for(int i=0; i<4; i++) { drawValues[i] = valuesPresent[i]; if(drawValues[i]) { if(!FitToSize) { geoValues[i] = values[i] * scaleFactor; } else { double factorX = (double) this->size().width() / (double) image.size().width(); double factorY = (double) this->size().height() /(double) image.size().height(); double factor = qMin(factorX, factorY); //printf("(%d,%d) (%d,%d) (%f,%f)\n", this->size().width(), this->size().height(), // image.size().width(), image.size().height(), // factorX, factorY); geoValues[i] = (int) (((values[i]+0.5) * factor)); //printf("geovalues %d %f %d\n", values[i], factor, geoValues[i]); } } else geoValues[i] = 0; } update(); }
void Management::slaveBuildSize(int BuildID, QString buildMD5Value, int slaveId){ Build *theBuild = getBuildByID(BuildID); if(theBuild == 0){ //this point the build does not exist return; } QFuture<QString> future = QtConcurrent::run(this, &Management::getBuildMD5, theBuild); QString currentBuildMD5Value = future.result(); if(!buildMD5Value.compare(currentBuildMD5Value)){ setSlaveBuildIsSame(true, slaveId, theBuild->getBuildID()); } else{ setSlaveBuildIsSame(false, slaveId, theBuild->getBuildID()); } }
//============= // LUtils Functions //============= int LUtils::runCmd(QString cmd, QStringList args){ /*QProcess proc; proc.setProcessChannelMode(QProcess::MergedChannels); if(args.isEmpty()){ proc.start(cmd); }else{ proc.start(cmd, args); } //if(!proc.waitForStarted(30000)){ return 1; } //process never started - max wait of 30 seconds while(!proc.waitForFinished(300)){ if(proc.state() == QProcess::NotRunning){ break; } //somehow missed the finished signal QCoreApplication::processEvents(); } int ret = proc.exitCode(); return ret;*/ QFuture<QStringList> future = QtConcurrent::run(ProcessRun, cmd, args); return future.result()[0].toInt(); //turn it back into an integer return code }
PwDatabase::ErrorCode PwDatabase::transformKey(const QByteArray& masterSeed, const QByteArray& transformSeed, quint64 transformRounds, const QByteArray& combinedKey, QByteArray& aesKey) { setPhaseProgressRawTarget(transformRounds); QByteArray subKey1 = Util::deepCopy(combinedKey.left(SUBKEY_SIZE)); QByteArray subKey2 = Util::deepCopy(combinedKey.right(SUBKEY_SIZE)); unsigned char* pSubKey1 = reinterpret_cast<unsigned char*>(subKey1.data()); unsigned char* pSubKey2 = reinterpret_cast<unsigned char*>(subKey2.data()); const unsigned char* pTransformSeed = reinterpret_cast<const unsigned char*>(transformSeed.constData()); // One subkey is processed in a parallel thread, // another one -- synchronously here (to update the UI progress) QFuture<PwDatabase::ErrorCode> anotherTask = QtConcurrent::run(this, &PwDatabase::performKeyTransformRounds, pTransformSeed, pSubKey1, transformRounds, false); ErrorCode errCode = performKeyTransformRounds(pTransformSeed, pSubKey2, transformRounds, true); if (errCode != SUCCESS || anotherTask.result() != SUCCESS) { return errCode; } CryptoManager* cm = CryptoManager::instance(); QByteArray step2key; step2key.append(subKey1); step2key.append(subKey2); QByteArray transformedKey; int ec = cm->sha256(step2key, transformedKey); Util::safeClear(subKey1); Util::safeClear(subKey2); Util::safeClear(step2key); if (ec != SB_SUCCESS) return KEY_TRANSFORM_ERROR_2; QByteArray step3key(masterSeed); step3key.append(transformedKey); ec = cm->sha256(step3key, aesKey); Util::safeClear(transformedKey); Util::safeClear(step3key); if (ec != SB_SUCCESS) return KEY_TRANSFORM_ERROR_3; return SUCCESS; }
CC_FILE_ERROR BinFilter::saveToFile(ccHObject* root, const char* filename) { if (!root || !filename) return CC_FERR_BAD_ARGUMENT; QFile out(filename); if (!out.open(QIODevice::WriteOnly)) return CC_FERR_WRITING; QProgressDialog pDlg(QString("Please wait... saving in progress"),QString(),0,0); pDlg.setWindowTitle("BIN file"); pDlg.setModal(true); pDlg.show(); //concurrent call s_file = &out; s_container = root; QFuture<CC_FILE_ERROR> future = QtConcurrent::run(_SaveFileV2); while (!future.isFinished()) { #if defined(CC_WINDOWS) ::Sleep(500); #else usleep(500 * 1000); #endif pDlg.setValue(pDlg.value()+1); QApplication::processEvents(); } s_file = 0; s_container = 0; CC_FILE_ERROR result = future.result(); if (result == CC_FERR_NO_ERROR) ccLog::Print("[BIN] File %s saved successfully",filename); return result; }
CC_FILE_ERROR BinFilter::saveToFile(ccHObject* root, QString filename, SaveParameters& parameters) { if (!root || filename.isNull()) return CC_FERR_BAD_ARGUMENT; QFile out(filename); if (!out.open(QIODevice::WriteOnly)) return CC_FERR_WRITING; ccProgressDialog pDlg(false, parameters.parentWidget); pDlg.setMethodTitle(QObject::tr("BIN file")); pDlg.setInfo(QObject::tr("Please wait... saving in progress")); pDlg.setRange(0, 0); pDlg.setModal(true); pDlg.show(); //concurrent call s_file = &out; s_container = root; QFuture<CC_FILE_ERROR> future = QtConcurrent::run(_SaveFileV2); while (!future.isFinished()) { #if defined(CC_WINDOWS) ::Sleep(500); #else usleep(500 * 1000); #endif pDlg.setValue(pDlg.value()+1); QApplication::processEvents(); } s_file = 0; s_container = 0; CC_FILE_ERROR result = future.result(); return result; }
QStringList LUtils::getCmdOutput(QString cmd, QStringList args){ /*QProcess proc; QProcessEnvironment env = QProcessEnvironment::systemEnvironment(); env.insert("LANG", "C"); env.insert("LC_MESSAGES", "C"); proc.setProcessEnvironment(env); proc.setProcessChannelMode(QProcess::MergedChannels); if(args.isEmpty()){ proc.start(cmd); }else{ proc.start(cmd,args); } //if(!proc.waitForStarted(30000)){ return QStringList(); } //process never started - max wait of 30 seconds while(!proc.waitForFinished(300)){ if(proc.state() == QProcess::NotRunning){ break; } //somehow missed the finished signal QCoreApplication::processEvents(); } QStringList out = QString(proc.readAllStandardOutput()).split("\n"); return out;*/ QFuture<QStringList> future = QtConcurrent::run(ProcessRun, cmd, args); return future.result()[1].split("\n"); //Split the return message into lines }
void IcecastService::ParseDirectoryFinished( QFuture<IcecastBackend::StationList> future) { IcecastBackend::StationList all_stations = future.result(); sort(all_stations.begin(), all_stations.end(), StationSorter<IcecastBackend::Station>()); // Remove duplicates by name. These tend to be multiple URLs for the same // station. IcecastBackend::StationList::iterator it = unique(all_stations.begin(), all_stations.end(), StationEquality<IcecastBackend::Station>()); all_stations.erase(it, all_stations.end()); // Cluster stations by genre. QMultiHash<QString, IcecastBackend::Station*> genres; // Add stations. for (int i = 0; i < all_stations.count(); ++i) { IcecastBackend::Station& s = all_stations[i]; genres.insert(s.genre, &s); } QSet<QString> genre_set = genres.keys().toSet(); // Merge genres with only 1 or 2 stations into "Other". for (const QString& genre : genre_set) { if (genres.count(genre) < 3) { const QList<IcecastBackend::Station*>& small_genre = genres.values(genre); for (IcecastBackend::Station* s : small_genre) { s->genre = "Other"; } } } backend_->ClearAndAddStations(all_stations); app_->task_manager()->SetTaskFinished(load_directory_task_id_); load_directory_task_id_ = 0; }
void DeviceProperties::UpdateFormatsFinished(QFuture<bool> future) { updating_formats_ = false; if (!future.result()) { supported_formats_.clear(); } // Hide widgets if there are no supported types ui_->supported_formats_container->setVisible(!supported_formats_.isEmpty()); ui_->transcode_unsupported->setEnabled(!supported_formats_.isEmpty()); if (ui_->transcode_unsupported->isChecked() && supported_formats_.isEmpty()) { ui_->transcode_off->setChecked(true); } // Populate supported types list ui_->supported_formats->clear(); for (Song::FileType type : supported_formats_) { QListWidgetItem* item = new QListWidgetItem(Song::TextForFiletype(type)); ui_->supported_formats->addItem(item); } ui_->supported_formats->sortItems(); // Set the format combobox item TranscoderPreset preset = Transcoder::PresetForFileType( Song::FileType(index_.data(DeviceManager::Role_TranscodeFormat).toInt())); if (preset.type_ == Song::Type_Unknown) { // The user hasn't chosen a format for this device yet, so work our way down // a list of some preferred formats, picking the first one that is supported preset = Transcoder::PresetForFileType( Transcoder::PickBestFormat(supported_formats_)); } ui_->transcode_format->setCurrentIndex( ui_->transcode_format->findText(preset.name_)); ui_->formats_stack->setCurrentWidget(ui_->formats_page); }
T QxrdResultSerializer<T>::dequeue() { QcepMutexLocker lock(__FILE__, __LINE__, &m_Mutex); if (m_Results.size() > 0) { QFuture<T> val = m_Results.dequeue(); if (m_Results.size() > 0) { m_Watcher.setFuture(m_Results[0]); } if (m_Counter) { m_Counter->incValue(-1); } return val.result(); } else { if (m_Counter) { m_Counter->setValue(0); } return T(); } }
CC_FILE_ERROR BinFilter::loadFile(QString filename, ccHObject& container, LoadParameters& parameters) { ccLog::Print(QString("[BIN] Opening file '%1'...").arg(filename)); //opening file QFile in(filename); if (!in.open(QIODevice::ReadOnly)) return CC_FERR_READING; uint32_t firstBytes = 0; if (in.read((char*)&firstBytes,4) < 0) return CC_FERR_READING; bool v1 = (strncmp((char*)&firstBytes,"CCB",3) != 0); if (v1) { return LoadFileV1(in, container, static_cast<unsigned>(firstBytes), parameters); //firstBytes == number of scans for V1 files! } else { //Since ver 2.5.2, the 4th character of the header corresponds to 'load flags' int flags = 0; { QChar c(reinterpret_cast<char*>(&firstBytes)[3]); bool ok; flags = QString(c).toInt(&ok); if (!ok || flags > 8) { ccLog::Error(QString("Invalid file header (4th byte is '%1'?!)").arg(c)); return CC_FERR_WRONG_FILE_TYPE; } } //if (sizeof(PointCoordinateType) == 8 && strncmp((char*)&firstBytes,"CCB3",4) != 0) //{ // QMessageBox::information(0, QString("Wrong version"), QString("This file has been generated with the standard 'float' version!\nAt this time it cannot be read with the 'double' version."),QMessageBox::Ok); // return CC_FERR_WRONG_FILE_TYPE; //} //else if (sizeof(PointCoordinateType) == 4 && strncmp((char*)&firstBytes,"CCB2",4) != 0) //{ // QMessageBox::information(0, QString("Wrong version"), QString("This file has been generated with the new 'double' version!\nAt this time it cannot be read with the standard 'float' version."),QMessageBox::Ok); // return CC_FERR_WRONG_FILE_TYPE; //} if (parameters.alwaysDisplayLoadDialog) { ccProgressDialog pDlg(false, parameters.parentWidget); pDlg.setMethodTitle(QObject::tr("BIN file")); pDlg.setInfo(QObject::tr("Loading: %1").arg(QFileInfo(filename).fileName())); pDlg.setRange(0, 0); pDlg.show(); //concurrent call in a separate thread s_file = ∈ s_container = &container; s_flags = flags; QFuture<CC_FILE_ERROR> future = QtConcurrent::run(_LoadFileV2); while (!future.isFinished()) { #if defined(CC_WINDOWS) ::Sleep(500); #else usleep(500 * 1000); #endif pDlg.setValue(pDlg.value()+1); //pDlg.setValue(static_cast<int>(in.pos())); //DGM: in fact, the file reading part is just half of the work! QApplication::processEvents(); } s_file = 0; s_container = 0; return future.result(); } else { return BinFilter::LoadFileV2(in,container,flags); } } }
//! [1] extern void aFunctionWithArguments(int arg1, double arg2, const QString &string); int integer = ...; double floatingPoint = ...; QString string = ...; QFuture<void> future = QtConcurrent::run(aFunctionWithArguments, integer, floatingPoint, string); //! [1] //! [2] extern QString functionReturningAString(); QFuture<QString> future = QtConcurrent::run(functionReturningAString); ... QString result = future.result(); //! [2] //! [3] extern QString someFunction(const QByteArray &input); QByteArray bytearray = ...; QFuture<QString> future = QtConcurrent::run(someFunction, bytearray); ... QString result = future.result(); //! [3] //! [4]
void tst_QtConcurrentRun::returnValue() { QFuture<int> f; f = run(F(returnInt0)); QCOMPARE(f.result(), 10); A a; f = run(&a, F(&A::member0)); QCOMPARE(f.result(), 10); f = run(&a, F(&A::member1), 20); QCOMPARE(f.result(), 20); f = run(a, F(&A::member0)); QCOMPARE(f.result(), 10); f = run(a, F(&A::member1), 20); QCOMPARE(f.result(), 20); f = run(a); QCOMPARE(f.result(), 10); f = run(&a); QCOMPARE(f.result(), 10); f = run(a, 20); QCOMPARE(f.result(), 20); f = run(&a, 20); QCOMPARE(f.result(), 20); const AConst aConst = AConst(); f = run(&aConst, &AConst::member0); QCOMPARE(f.result(), 10); f = run(&aConst, F(&AConst::member1), 20); QCOMPARE(f.result(), 20); f = run(aConst, F(&AConst::member0)); QCOMPARE(f.result(), 10); f = run(aConst, F(&AConst::member1), 20); QCOMPARE(f.result(), 20); f = run(aConst); QCOMPARE(f.result(), 10); f = run(&aConst); QCOMPARE(f.result(), 10); f = run(aConst, 20); QCOMPARE(f.result(), 20); f = run(&aConst, 20); QCOMPARE(f.result(), 20); }