qtconcurrent

Im trying to use std::bind to bind this to method that is used in QtConcurrent::blockingMapped Header: class TuringMachine { private: TRTable table; std::set<ConfigNode*> currentConfigs; //function object std::function<std::set<ConfigNode*>( const TuringMachine*, ConfigNode*)> step_f; //method it will hold std::set<ConfigNode *> step(TuringMachine* this_m ,ConfigNode *parent); std::set<ConfigNode*>& makeStep(); } Source: TuringMachine::TuringMachine(/**/) { step_f = std::bind(&TuringMachine::step, this, std::placeholders::_1); } std::set<ConfigNode*> &TuringMachine::makeStep(){ auto configSet

Is it possible to stop a Thread by its associated QFuture Object ? Currently i've been starting a video capturing process like this. this->cameraThreadRepresentation = QtConcurrent::run(this,&MainWindow::startLiveCapturing); Inside the startLiveCapturing-Method an infinite loop is running that captures images and displays them. So if the user wants to stop that process he should simply press a button and that operation stops. But it seems that i can not stop this thread by calling the cancel method like this ? this->cameraThreadRepresentation.cancel(); What i am doing wrong and how can i stop

Im developing an application in Qt which, at some point, process a bunch of videos. It works fine but it had only a 40-60% of the cpu usage during the process phase so i tried to make it multithreaded. I used QtConcurrent cause his 'high leveness' instead a more traditional thread management, my code is simply: for(int i = 0; i < totalVideos; i++) { QFuture<ResultClass *> futureToken = QtConcurrent::run(this, process, listOfVideos.takeFirst()); QFutureWatcher<ResultClass *>* fw = new QFutureWatcher<ResultClass *>(); connect(fw, SIGNAL(finished()), this, SLOT(manageResult)); fw->setFuture

I'm trying to create a Tile rendering program. Heres some basic code. Header class Tile: public QGraphicsItem { public: Tile(void); ~Tile(void); QGraphicsPixmapItem *tileItem; void update(QPainter *painter, const QStyleOptionGraphicsItem *option,QWidget *widget); protected: QRectF boundingRect() const; void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,QWidget *widget); }; CPP: .Constructor etc . . void Tile::paint(QPainter *painter, const QStyleOptionGraphicsItem *option,QWidget *widget) { if(tileItem==NULL) { qDebug()<<"Loading Pixmap"; QPixmap p("c:\\qt\\tile\\tile0-0.png"

Let's say I call QtConcurrent::run() which runs a function in a worker thread, and in that function I dynamically allocate several QObjects (for later use). Since they were created in the worker thread, their thread affinity should be that of the worker thread. However, once the worker thread terminates, the QObject thread affinity should no longer be valid. The question: Does Qt automatically move the QObjects into the parent thread, or are we responsible in moving them to a valid thread before the worker thread terminates? QThread is not documented to automatically move any QObject s when it

My project is to create a small program which demonstrates the work of a search engine: indexing and returning result for arbitrary queries. I've done the work with the indexer part and now I want to improve it with indexing multiple files at once. The MainWindow class is here: class MainWindow : public QMainWindow { Q_OBJECT ..... private: Indexer * indexer; QStringList fileList; .... void index(QStringList list); void add(const QString &filename); } This is the implementation of add ( add need to access fileList to avoid index the same files again, thus it can not be static method): void

I create a QFuture that I want to use to parallelize calls to a member function. More precisely, I have a class solveParallel with .h : class solverParallel { public: solverParallelData(Manager* mgr_); virtual ~solverParallel(void); void runCompute(solveModel * model_); bool resultComput(); private: Manager *myMgr; QFuture<bool> myFutureCompute; }; where the methode runCompute() is creating the myFutureCompute member. .cpp looks like solveParallel::solveParallel(Manager* mgr_) :m_mgr(mgr_) { } solverParallel::~solverParallel(void){} void solverParallel::runCompute(solveModel* model) {

I can't seem to be able to associate QtConcurrent::run() with a method (function member of a class) only with a simple function. How can I do this? With a regular function I cannot emit signals and its a drag. Why would anyone find this a better alternative to QThread is beyond me and would like some input. Kyle Lutz Yes, this is possible (and quite easy). Here is an example (from the Qt documentation): // call 'QStringList QString::split(const QString &sep, SplitBehavior behavior, Qt::CaseSensitivity cs) const' in a separate thread QString string = ...; QFuture<QStringList> future =