WeaverImpl.h

Go to the documentation of this file.

/* -*- C++ -*-

This file implements the public interfaces of the WeaverImpl class.

$ Author: Mirko Boehm $
$ Copyright: (C) 2005-2013 Mirko Boehm $
$ Contact: mirko@kde.org
http://www.kde.org
http://creative-destruction.me $

   This library 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 of the License, or (at your option) any later version.

   This library 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
   Library General Public License for more details.

   You should have received a copy of the GNU Library General Public License
   along with this library; see the file COPYING.LIB.  If not, write to
   the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
   Boston, MA 02110-1301, USA.

$Id: WeaverImpl.h 32 2005-08-17 08:38:01Z mirko $
*/
#ifndef WeaverImpl_H
#define WeaverImpl_H

#include <QtCore/QObject>
#include <QtCore/QWaitCondition>

#ifndef THREADWEAVER_PRIVATE_API
#define THREADWEAVER_PRIVATE_API
#endif

#include "State.h"
#include "WeaverInterface.h"

namespace ThreadWeaver {

    class Job;
    class Thread;
    class WeaverObserver;

    class WeaverImpl : public WeaverInterface
    {
        Q_OBJECT
    public:
        explicit WeaverImpl (QObject* parent=0 );
        virtual ~WeaverImpl ();
    const State& state() const;

        void setMaximumNumberOfThreads( int cap );
        int maximumNumberOfThreads() const;
        int currentNumberOfThreads () const;


        void setState( StateId );
        void registerObserver ( WeaverObserver* );
        virtual void enqueue (Job*);
        virtual bool dequeue (Job*);
        virtual void dequeue ();
    virtual void finish();
        virtual void suspend( );
        virtual void resume();
        bool isEmpty () const;
    bool isIdle () const;
        int queueLength () const;
        virtual Job* applyForWork (Thread *thread, Job *previous);
        void blockThreadUntilJobsAreBeingAssigned(Thread *th);
    void waitForAvailableJob(Thread *th);
        void incActiveThreadCount();
        void decActiveThreadCount();
        int activeThreadCount();
        Job* takeFirstAvailableJob(Job* previous);
        void assignJobs();
        void requestAbort();

        void dumpJobs();

    Q_SIGNALS:
        void threadStarted ( ThreadWeaver::Thread* );
        void threadExited ( ThreadWeaver::Thread* );
        void threadSuspended ( ThreadWeaver::Thread* );
        void threadBusy ( ThreadWeaver::Thread*,  ThreadWeaver::Job* j);

        // FIXME (0.7) this seems to be unnecessary
        // some more private Q_SIGNALS: There are situations where other threads
        // call functions of (this). In this case, there may be confusion
        // about whether to handle the signals synchronously or not. The
        // following signals are asynchroneoulsy connected to their siblings.
        void asyncThreadSuspended( ThreadWeaver::Thread* );

    protected:
        void adjustActiveThreadCount ( int diff );
        virtual Thread* createThread();
        // @TODO: add code to raise inventory size over inventoryMin
        // @TODO: add code to quit unnecessary threads
        void adjustInventory ( int noOfNewJobs );
//  void lock ();
//  /** Unlock. See lock(). */
//  void unlock ();
        QList<Thread*> m_inventory;
        QList<Job*> m_assignments;
    int m_active;
        int m_inventoryMax;
        QWaitCondition m_jobAvailable;
    QWaitCondition m_jobFinished;

    private:
    QMutex *m_mutex;

    QMutex* m_finishMutex;

    QMutex* m_jobAvailableMutex;

    // @TODO: make state objects static
    State*  m_state;
    State *m_states[NoOfStates];
    };

} // namespace ThreadWeaver

#endif // WeaverImpl_H