weaver.h

/* -*- C++ -*-
 
   This file declares the Weaver, Job and Thread classes.
 
   $ Author: Mirko Boehm $
   $ Copyright: (C) 2004, Mirko Boehm $
   $ Contact: mirko@kde.org
         http://www.kde.org
         http://www.hackerbuero.org $
   $ License: LGPL with the following explicit clarification:
         This code may be linked against any version of the TQt toolkit
         from Troll Tech, Norway. $
 
*/
 
#ifndef WEAVER_H
#define WEAVER_H
 
extern "C"
{
#include <stdarg.h>
#include <unistd.h>
#include <stdio.h>
}
 
#include <tqobject.h>
#include <tqptrlist.h>
#include <tqthread.h>
#include <tqwaitcondition.h>
#include <tqmutex.h>
#include <tqevent.h>
 
#include <tdepimmacros.h>
 
namespace KPIM {
namespace ThreadWeaver {
 
    KDE_EXPORT extern bool Debug;
    KDE_EXPORT extern int DebugLevel;
 
    KDE_EXPORT inline void setDebugLevel (bool debug, int level)
        {
            Debug = debug;
            DebugLevel = level;
        }
 
    KDE_EXPORT inline void debug(int severity, const char * cformat, ...)
#ifdef __GNUC__
        __attribute__ ( (format (printf, 2, 3 ) ) )
#endif
;
 
    KDE_EXPORT inline void debug(int severity, const char * cformat, ...)
    {
        if ( Debug == true && ( severity<=DebugLevel || severity == 0) )
        {
            static TQMutex mutex;
            TQString text;
 
            mutex.lock();
            va_list ap;
            va_start( ap, cformat );
            vprintf (cformat, ap);
            va_end (ap);
            mutex.unlock();
        }
    }
 
 
    class Thread;
    class Job;
 
    class KDE_EXPORT Event : public TQCustomEvent
    {
    public:
        enum Action {
            NoAction = 0,
            Finished, 
            Suspended, 
            ThreadStarted,
            ThreadExiting,
            ThreadBusy,
            ThreadSuspended,
            JobStarted,
            JobFinished,
            JobSPR, 
            JobAPR  
        };
        Event ( Action = NoAction, Thread * = 0, Job *job = 0);
        static int type ();
        Thread* thread () const;
        Job* job () const;
        Action action () const;
    private:
        Action m_action;
        Thread *m_thread;
        Job *m_job;
        static const int Type;
    };
 
    class KDE_EXPORT Job : public TQObject
    {
        Q_OBJECT
  
    public:
        Job(TQObject* parent=0, const char* name=0);
 
        virtual ~Job();
 
        virtual void execute(Thread*);
 
        virtual bool isFinished() const;
 
        void wakeAPR ();
 
        virtual void processEvent ( Event* );
 
    signals:
        void started ();
        void done ();
        void SPR ();
        void APR ();
    protected:
        void lock();
        void unlock();
        virtual void run () = 0;
        Thread *thread();
        virtual void setFinished(bool status);
        void triggerSPR ();
        void triggerAPR ();
 
        bool m_finished;
 
        TQMutex *m_mutex;
 
        Thread * m_thread;
 
        TQWaitCondition *m_wc;
    };
 
    class Weaver;
 
    class KDE_EXPORT Thread : public TQThread
    {
    public:
        Thread(Weaver *parent);
 
        ~Thread();
 
        void run();
 
        /* Provide the msleep() method (protected in TQThread) to be
           available  for executed jobs. */
        void msleep(unsigned long msec);
 
        unsigned int id() const;
 
        void post (Event::Action, Job* = 0);
 
    private:
        Weaver *m_parent;
 
        const unsigned int m_id;
 
        static unsigned int sm_Id;
 
        static unsigned int makeId();
    };
 
    class KDE_EXPORT Weaver : public TQObject
    {
        Q_OBJECT
  
    public:
        Weaver (TQObject* parent=0, const char* name=0,
                int inventoryMin = 4, // minimal number of provided threads
                int inventoryMax = 32); // maximum number of provided threads
        virtual ~Weaver ();
        virtual void enqueue (Job*);
        void enqueue (TQPtrList<Job> jobs);
        virtual bool dequeue (Job*);
        virtual void dequeue ();
        // virtual void jobFinished(Thread *);
        virtual void finish();
        virtual void suspend (bool state);
        bool isEmpty () const;
        bool isIdle () const;
        int queueLength ();
        virtual Job* applyForWork (Thread *thread, Job *previous);
        void lock ();
        void unlock ();
               void post (Event::Action, Thread* = 0, Job* = 0);
        int threads () const;
    signals:
        void finished ();
        void suspended ();
        void jobDone (Job*);
// The following signals are used mainly for debugging purposes.
        void threadCreated (Thread *);
        void threadDestroyed (Thread *);
        void threadBusy (Thread *);
        void threadSuspended (Thread *);
 
    protected:
        void assignJobs();
        bool event ( TQEvent* );
        TQPtrList<Thread> m_inventory;
        TQPtrList<Job> m_assignments;
        int m_active;
        int m_inventoryMin;
        int m_inventoryMax;
        TQWaitCondition m_jobAvailable;
        TQWaitCondition m_jobFinished;
        bool m_shuttingDown;
        bool m_running;
        bool m_suspend;
    private:
        TQMutex *m_mutex;
    };
} // namespace ThreadWeaver
} // namespace KPIM
 
#endif // defined WEAVER_H