plasma-framework/private/runnerjobs_p.h
Aaron Seigo f6f8d8b2ee when setAllowedRunners is called, call loadRunners, which now also allows for being called while a search is in progress
loadRunners intelligently only unloads those runners with are no longer to be loaded, so this is a performance win.
it now also checks to see if there are pending jobs for the runners to be deleted (if any) and if so it creates a delayed
deleter for them -> no crashes
2011-11-22 12:17:06 +01:00

145 lines
3.4 KiB
C++

/*
* Copyright (C) 2007, 2009 Ryan P. Bitanga <ryan.bitanga@gmail.com>
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU Library General Public License as
* published by the Free Software Foundation; either version 2, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details
*
* You should have received a copy of the GNU Library General Public
* License along with this program; if not, write to the
* Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef PLASMA_RUNNERJOBS_P_H
#define PLASMA_RUNNERJOBS_P_H
#include <QHash>
#include <QMutex>
#include <QSet>
#include <Weaver/Job.h>
#include <Weaver/QueuePolicy.h>
#include "abstractrunner.h"
using ThreadWeaver::Job;
class QTimer;
namespace Plasma {
// Queue policies
// QueuePolicy that only allows a job to be executed after
// waiting in the queue for the specified timeout
class DelayedRunnerPolicy : public ThreadWeaver::QueuePolicy
{
public:
~DelayedRunnerPolicy();
static DelayedRunnerPolicy &instance();
bool canRun(Job *job);
void free(Job *job);
void release(Job *job);
void destructed(Job *job);
private:
DelayedRunnerPolicy();
QMutex m_mutex;
};
// QueuePolicy that limits the instances of a particular runner
class DefaultRunnerPolicy : public ThreadWeaver::QueuePolicy
{
public:
~DefaultRunnerPolicy();
static DefaultRunnerPolicy &instance();
void setCap(int cap)
{
m_cap = cap;
}
int cap() const
{
return m_cap;
}
bool canRun(Job *job);
void free(Job *job);
void release(Job *job);
void destructed(Job *job);
private:
DefaultRunnerPolicy();
int m_cap;
QHash<QString, int> m_runCounts;
QMutex m_mutex;
};
/* ThreadWeaver work around:
* There is no method exposed that allows us to inform
* ThreadWeaver that a previously unavailable job is now
* available; thus, we use an empty job to wake up the threads
*/
class DummyJob : public ThreadWeaver::Job
{
public:
DummyJob(QObject *parent) : Job(parent) {}
~DummyJob() {}
private:
void run() {}
};
/*
* FindMatchesJob class
* Class to run queries in different threads
*/
class FindMatchesJob : public Job
{
public:
FindMatchesJob(Plasma::AbstractRunner *runner,
Plasma::RunnerContext *context, QObject *parent = 0);
~FindMatchesJob();
int priority() const;
Plasma::AbstractRunner* runner() const;
QTimer* delayTimer() const;
void setDelayTimer(QTimer *timer);
protected:
void run();
private:
Plasma::RunnerContext m_context;
Plasma::AbstractRunner *m_runner;
QTimer *m_timer;
};
class DelayedJobCleaner : public QObject
{
public:
DelayedJobCleaner(const QSet<FindMatchesJob*> &jobs, const QSet<AbstractRunner *> &runners = QSet<AbstractRunner *>());
~DelayedJobCleaner();
private Q_SLOTS:
void jobDone(ThreadWeaver::Job*);
void checkIfFinished();
private:
ThreadWeaver::WeaverInterface *m_weaver;
QSet<FindMatchesJob*> m_jobs;
QSet<AbstractRunner *> m_runners;
};
}
#endif // PLASMA_RUNNERJOBS_P_H