Search  

---

C:/temp/src/j2k/Deprecated/Posix.old/Lock.hpp

Go to the documentation of this file.

#ifndef __J2K__PThread_Lock_HPP__
#define __J2K__PThread_Lock_HPP__

/*
 * When constructed, this object acquires (by default) an
 * exclusive lock from the Mutex passed to it in its constructor.
 * When the object goes out of scope, it releases the lock.  This
 * makes it convenient to synchronize whole methods, because the
 * lock will be released even if an exception is thrown.  For
 * example:
 *
 * class Foo {
 * public:
 *     void bar() {
 *         Lock lock(mutex);
 *         // do some stuff that could throw exceptions...
 *     }
 *
 * private:
 *     Mutex mutex;
 * };
 *
 * This class is not reference-counted; each instance is intended to be
 * encapsulated by one method, as a local variable.
 */

#include <j2k/Fred/Boolean.hpp>
#include <j2k/Fred/StdTypes.hpp>

class Lock {
public:
  Lock(Mutex& mutex, BOOL autoLock = TRUE);

  // Releases the Mutex's lock, if it holds one.
  virtual ~Lock();

  // Get the Mutex's lock, if it doesn't hold one.
  void get();

  // Releases the Mutex's lock, if it holds one.
  void release();

 /* Waits for another thread to call notify() or notifyAll()
  * on a Lock for the same Mutex.
  * The calling thread must already have the lock.
  */
  void wait();

 /* Notifies one thread waiting for this mutex.
  * The calling thread must already have the lock.
  */
  void notify();

 /* Notifies all threads waiting for this mutex.
  * The calling thread must already have the lock.
  */
  void notifyAll();

private:
  Lock();
  Lock(const Lock&);
  Lock& operator=(Lock&);

  Mutex& mutex;
  BOOL locked;
};

#endif

---