parallelworkers.h

Go to the documentation of this file.

/* ============================================================
 *
 * This file is a part of digiKam project
 * https://www.digikam.org
 *
 * Date        : 2012-01-13
 * Description : Multithreaded worker objects, working in parallel
 *
 * Copyright (C) 2010-2012 by Marcel Wiesweg <marcel dot wiesweg at gmx dot de>
 *
 * This program is free software; you can redistribute it
 * and/or modify it under the terms of the GNU 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.
 *
 * ============================================================ */
 
#ifndef DIGIKAM_PARALLEL_WORKERS_H
#define DIGIKAM_PARALLEL_WORKERS_H
 
// Qt includes
 
#include <QObject>
 
// Local includes
 
#include "digikam_export.h"
#include "workerobject.h"
 
namespace Digikam
{
 
class DIGIKAM_EXPORT ParallelWorkers
{
 
public:
 
    explicit ParallelWorkers();
    virtual ~ParallelWorkers();
 
    void schedule();
    void deactivate(WorkerObject::DeactivatingMode mode = WorkerObject::FlushSignals);
    void wait();
 
    void setPriority(QThread::Priority priority);
 
    bool optimalWorkerCountReached()                            const;
 
    static int optimalWorkerCount();
 
public:
 
 
    bool connect(const char* signal,
                 const QObject* receiver,
                 const char* method,
                 Qt::ConnectionType type = Qt::AutoConnection)  const;
 
protected:
 
    void add(WorkerObject* const worker);
 
    // Internal implementation
 
    int replacementQtMetacall(QMetaObject::Call _c, int _id, void** _a);
    const QMetaObject* replacementMetaObject()                  const;
 
    virtual QObject* asQObject()                                                        = 0;
 
    virtual int WorkerObjectQtMetacall(QMetaObject::Call _c, int _id, void** _a)        = 0;
 
    virtual const QMetaObject* mocMetaObject()                  const                   = 0;
 
    int replacementStaticQtMetacall(QMetaObject::Call _c, int _id, void** _a);
    typedef void (*StaticMetacallFunction)(QObject*, QMetaObject::Call, int, void**);
    virtual StaticMetacallFunction staticMetacallPointer()                              = 0;
 
protected:
 
    QList<WorkerObject*>   m_workers;
    int                    m_currentIndex;
    QMetaObject*           m_replacementMetaObject;
 
    StaticMetacallFunction m_originalStaticMetacall;
 
private:
 
    // Disable
    ParallelWorkers(const ParallelWorkers&)            = delete;
    ParallelWorkers& operator=(const ParallelWorkers&) = delete;
};
 
// -------------------------------------------------------------------------------------------------
 
template <class A>
 
class ParallelAdapter : public A, public ParallelWorkers
{
public:
 
    explicit ParallelAdapter()
    {
    }
 
    ~ParallelAdapter()                                                   override
    {
    }
 
    void add(A* const worker)
    {
        ParallelWorkers::add(worker);
    }
 
    // Internal Implementation
    // I know this is a hack
 
    int WorkerObjectQtMetacall(QMetaObject::Call _c, int _id, void** _a) override
    {
        return WorkerObject::qt_metacall(_c, _id, _a);
    }
 
    const QMetaObject* mocMetaObject()                             const override
    {
        return A::metaObject();
    }
 
    static void qt_static_metacall(QObject* o, QMetaObject::Call _c, int _id, void** _a)
    {
        static_cast<ParallelAdapter*>(o)->replacementStaticQtMetacall(_c, _id, _a);
    }
 
    StaticMetacallFunction staticMetacallPointer()                      override
    {
        return qt_static_metacall;
    }
 
    const QMetaObject* metaObject()                                const override
    {
        return ParallelWorkers::replacementMetaObject();
    }
 
    int qt_metacall(QMetaObject::Call _c, int _id, void** _a)            override
    {
        return ParallelWorkers::replacementQtMetacall(_c, _id, _a);
    }
 
    QObject* asQObject()                                                 override
    {
        return this;
    }
 
    void schedule()
    {
        ParallelWorkers::schedule();
    }
 
    void deactivate(WorkerObject::DeactivatingMode mode = WorkerObject::FlushSignals)
    {
        ParallelWorkers::deactivate(mode);
    }
 
    void wait()
    {
        ParallelWorkers::wait();
    }
 
    bool connect(const char* signal,
                 const QObject* receiver,
                 const char* method,
                 Qt::ConnectionType type = Qt::AutoConnection)     const
    {
        return ParallelWorkers::connect(signal, receiver, method, type);
    }
 
private:
 
    // Disable
    ParallelAdapter(const ParallelAdapter&)            = delete;
    ParallelAdapter& operator=(const ParallelAdapter&) = delete;
};
 
} // namespace Digikam
 
#endif // DIGIKAM_PARALLEL_WORKERS_H