Thread.h

Go to the documentation of this file.

/*
 * Thread.h
 *
 * Smalltalk like class library for C++
 * Thread wrapper. Header.
 *
 * Copyright (c) 2003-2006 Milan Cermak
 */
/*
 * This library is free software; you can redistribute it and/or
 * modify it under the terms of the GNU Lesser General Public
 * License as published by the Free Software Foundation; either
 * version 2.1 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
 * Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public
 * License along with this library; if not, write to the Free Software
 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */
#ifndef __THREAD_H
#define __THREAD_H

#if !defined(_REENTRANT)
#  define _REENTRANT
#endif
#include <pthread.h>

#include <stlib/Object.h>
#include <stlib/Array.h>
#include <stlib/Set.h>
#include <stlib/String.h>

#include <stlib/Callback0.h>
#include <stlib/Callback1.h>

namespace OS {

class Thread : public Core::Object
{
  protected:
    Callback<void> *_receiver;   // what to do in the thread
    Array *_arguments;

    pthread_t hThread;           // odkaz na vlakno
    pthread_cond_t runCond;      // podminka behu vlakna
    pthread_mutex_t mutVar;
    bool runningThread;          // Priznak behu vlakna

    static Set threads;

  public:
    Thread(Callback<void> *receiver);
    virtual ~Thread(void);

  private:
    static void *threadProc(void *);

  public:
    /* Class-accessing protocol */
    virtual String *className(void) const;

    /* Instance creation protocol */
    static Thread *fork(Callback<void> *receiver);
    static Thread *fork(Callback<void> *receiver, Array *arguments);

    template <class TReceiver>
    static Thread *fork(TReceiver *receiver, void (TReceiver::*execFunc)(void))
    {
        Callback0<TReceiver,void> *callback;
        callback = new Callback0<TReceiver,void>(receiver, execFunc);
        return fork(callback);
    }

    template <class TReceiver>
    static Thread *fork(TReceiver *receiver, void (TReceiver::*execFunc)(Array *),
                        Array *args)
    {
        Callback1<TReceiver,void,Array*> *callback;
        callback = new Callback1<TReceiver,void,Array*>(receiver, execFunc);
        return fork(callback, args);
    }

    /* Initialize-release protocol */
    static void finalizeThreads(void);

    /* Accessing protocol */
    virtual void arguments(Array *);

    virtual void resume(void);
    virtual void run(void);
    virtual void finalize(void);
    virtual void suspend(void);
    virtual void terminate(void);
    virtual void yield(void);

    /* Testing protocol */
    virtual bool isRunning(void);
};

};

#endif /* __THREAD_H */

---