FXThread.h

Go to the documentation of this file.

#ifdef FX_FOXCOMPAT

/********************************************************************************
*                                                                               *
*                 M u l i t h r e a d i n g   S u p p o r t                     *
*                                                                               *
*********************************************************************************
* Copyright (C) 2004,2006 by Jeroen van der Zijp.   All Rights Reserved.        *
*********************************************************************************
* 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.    *
*********************************************************************************
* $Id: FXThread.h,v 1.40.2.2 2006/07/26 15:25:53 fox Exp $                          *
********************************************************************************/
#ifndef FXTHREAD_H
#define FXTHREAD_H

namespace FX {


// Thread ID type
#ifndef WIN32
typedef unsigned long FXThreadID;
#else
typedef void*         FXThreadID;
#endif


class FXCondition;
class QThreadFXThread;


class FXAPI FXMutex {
  friend class FXCondition;
private:
  FXuval data[24];
private:
  FXMutex(const FXMutex&);
  FXMutex &operator=(const FXMutex&);
public:

  FXMutex(FXbool recursive=FALSE);

  void lock();

  FXbool trylock();

  FXbool locked();

  void unlock();

  ~FXMutex();
  };


class FXAPI FXMutexLock {
private:
  FXMutex& mtx;
private:
  FXMutexLock();
  FXMutexLock(const FXMutexLock&);
  FXMutexLock& operator=(const FXMutexLock&);
public:

  FXMutexLock(FXMutex& m):mtx(m){ lock(); }

  FXMutex& mutex(){ return mtx; }

  void lock(){ mtx.lock(); }

  FXbool trylock(){ return mtx.trylock(); }

  FXbool locked(){ return mtx.locked(); }

  void unlock(){ mtx.unlock(); }

  ~FXMutexLock(){ unlock(); }
  };


class FXAPI FXCondition {
private:
  FXuval data[12];
private:
  FXCondition(const FXCondition&);
  FXCondition& operator=(const FXCondition&);
public:

  FXCondition();

  void wait(FXMutex& mtx);

  FXbool wait(FXMutex& mtx,FXlong nsec);

  void signal();

  void broadcast();

  ~FXCondition();
  };


class FXAPI FXSemaphore {
private:
  FXuval data[16];
private:
  FXSemaphore(const FXSemaphore&);
  FXSemaphore& operator=(const FXSemaphore&);
public:

  FXSemaphore(FXint initial=1);

  void wait();

  FXbool trywait();

  void post();

  ~FXSemaphore();
  };


class FXAPI FXThread {
private:
  friend class QThreadFXThread;
  QThreadFXThread *r;
private:
  FXThread(const FXThread&);
  FXThread &operator=(const FXThread&);
protected:

  virtual FXint run() = 0;

public:

  FXThread();

  FXThreadID id() const;

  FXbool running() const;

  FXbool start(unsigned long stacksize=0);

  FXbool join();

  FXbool join(FXint& code);

  FXbool cancel();

  FXbool detach();

  static void exit(FXint code=0);

  static void yield();

  static FXlong time();

  static void sleep(FXlong nsec);

  static void wakeat(FXlong nsec);

  static FXThread* self();

  static FXThreadID current();

  void priority(FXint prio);

  FXint priority();

  virtual ~FXThread();
  };

}

#endif
#endif

---

(C) 2002-2009 Niall Douglas. Some parts (C) to assorted authors.