home *** CD-ROM | disk | FTP | other *** search
/ QBasic & Borland Pascal & C / Delphi5.iso / C / BC_502 / INC.PAK / STDMUTEX.H < prev    next >
Encoding:
C/C++ Source or Header  |  1997-05-06  |  6.5 KB  |  228 lines
  1. #ifndef __RWSTD_MUTEX_H__
  2. #define __RWSTD_MUTEX_H__
  3. /* $Revision:   8.4  $ */
  4.  
  5. /*
  6.  * Declarations for class RWSTDMutex and RWSTDGuard.
  7.  *
  8.  * $Id: stdmutex.h,v 1.7 1995/09/08 23:45:09 smithey Exp $
  9.  *
  10.  ***************************************************************************
  11.  *
  12.  * (c) Copyright 1994, 1995 Rogue Wave Software, Inc.
  13.  * ALL RIGHTS RESERVED
  14.  *
  15.  * The software and information contained herein are proprietary to, and
  16.  * comprise valuable trade secrets of, Rogue Wave Software, Inc., which
  17.  * intends to preserve as trade secrets such software and information.
  18.  * This software is furnished pursuant to a written license agreement and
  19.  * may be used, copied, transmitted, and stored only in accordance with
  20.  * the terms of such license and with the inclusion of the above copyright
  21.  * notice.  This software and information or any other copies thereof may
  22.  * not be provided or otherwise made available to any other person.
  23.  *
  24.  * Notwithstanding any other lease or license that may pertain to, or
  25.  * accompany the delivery of, this computer software and information, the
  26.  * rights of the Government regarding its use, reproduction and disclosure
  27.  * are as set forth in Section 52.227-19 of the FARS Computer
  28.  * Software-Restricted Rights clause.
  29.  *
  30.  * Use, duplication, or disclosure by the Government is subject to
  31.  * restrictions as set forth in subparagraph (c)(1)(ii) of the Rights in
  32.  * Technical Data and Computer Software clause at DFARS 252.227-7013.
  33.  * Contractor/Manufacturer is Rogue Wave Software, Inc.,
  34.  * P.O. Box 2328, Corvallis, Oregon 97339.
  35.  *
  36.  * This computer software and information is distributed with "restricted
  37.  * rights."  Use, duplication or disclosure is subject to restrictions as
  38.  * set forth in NASA FAR SUP 18-52.227-79 (April 1985) "Commercial
  39.  * Computer Software-Restricted Rights (April 1985)."  If the Clause at
  40.  * 18-52.227-74 "Rights in Data General" is specified in the contract,
  41.  * then the "Alternate III" clause applies.
  42.  *
  43.  ***************************************************************************
  44.  *
  45.  * This class is a portable implementation of a simple mutex lock
  46.  * to be used for synchronizing multiple threads within a single process.
  47.  * It is not suitable for use among threads of different processes.
  48.  * This code was taken from the tools mutex.h.
  49.  *
  50.  ***************************************************************************/
  51.  
  52. #include <stdcomp.h>
  53.  
  54. #ifndef __RWSTDDEFS_H__
  55. #include <stddefs.h>
  56. #endif
  57.  
  58. #ifdef RWSTD_MULTI_THREAD /* This class only relevant in MT situation */
  59.  
  60. #if defined(sun)          /* assuming Solaris 2.1 or greater */
  61. #include <synch.h>
  62. typedef mutex_t RWSTDMutexType;
  63. #elif defined(RW_POSIX_THREADS)
  64. #include <pthread.h>
  65. typedef pthread_mutex_t RWSTDMutexType;
  66. #define RWSTD_NEEDS_SEM_INIT
  67. #elif defined(__WIN32__)
  68. #include <windows.h>
  69. typedef HANDLE RWSTDMutexType;
  70. #elif defined(__OS2__)
  71. #define INCL_DOSSEMAPHORES
  72. #define RWSTD_NEEDS_SEM_INIT
  73. #include <os2.h>
  74. typedef HMTX RWSTDMutexType;
  75. const char* __rw_mutex_exception = "Thread synchronization exception.";
  76. #else
  77. #error Class RWSTDMutex is not yet supported in this environment
  78. #endif
  79.  
  80. class RWSTDMutex
  81. {
  82.   private:
  83.  
  84.     RWSTDMutexType mutex;
  85. #if defined(RWSTD_NEEDS_SEM_INIT)
  86.     int initFlag;
  87. #endif
  88.  
  89.     void init ();
  90.     //
  91.     // Disallow copying and assignment.
  92.     //
  93.     RWSTDMutex (const RWSTDMutex&);
  94.     RWSTDMutex& operator= (const RWSTDMutex&);
  95.  
  96. public:
  97.  
  98.   enum StaticCtor { staticCtor };
  99.  
  100.   RWSTDMutex ();             // Construct the mutex.
  101.   RWSTDMutex (StaticCtor);   // Some statics need special handling.
  102.   ~RWSTDMutex ();            // Destroy the mutex.
  103.  
  104.   void acquire ();           // Acquire the mutex.
  105.   void release ();           // Release the mutex.
  106. };
  107.  
  108. class RWSTDGuard
  109. {
  110.   private:
  111.  
  112.     RWSTDMutex& rwmutex;
  113.  
  114.   public:
  115.  
  116.     RWSTDGuard  (RWSTDMutex& m);  // Acquire the mutex.
  117.     ~RWSTDGuard ();               // Release the mutex.
  118. };
  119.  
  120. /*
  121. ** For those OSs that require a non-zero mutex, we must treat static
  122. ** mutexes specially; they may not be initialized when we need them.
  123. ** For efficiency, we do conditional compilation in several methods
  124. ** based on that need.
  125. */
  126.  
  127. inline RWSTDMutex::RWSTDMutex (RWSTDMutex::StaticCtor)
  128. {
  129.     //
  130.     // Empty, because acquire() may already have been used.
  131.     //
  132. }
  133.  
  134. inline RWSTDMutex::~RWSTDMutex ()
  135. {
  136. #if defined(RWSTD_NEEDS_SEM_INIT)
  137.     if (0 == initFlag)
  138.         return;
  139.     else
  140.         initFlag = 0;
  141. #endif
  142. #if defined(sun)
  143.     mutex_destroy(&mutex);
  144. #elif defined(RW_POSIX_THREADS)
  145.     pthread_mutex_destroy(&mutex);
  146. #elif defined(__WIN32__)
  147.     CloseHandle(mutex);
  148. #elif defined(__OS2__)
  149.     APIRET rv;
  150.     RWSTD_THROW(0 != (rv = DosCloseMutexSem(mutex)),
  151.                 runtime_error,
  152.                 __rw_mutex_exception);
  153. #endif
  154. }
  155.  
  156. void inline RWSTDMutex::init ()
  157. {
  158. #if defined(sun)
  159.     mutex_init(&mutex, USYNC_THREAD, NULL);
  160. #elif defined(RW_POSIX_THREADS)
  161.     pthread_mutex_init(&mutex, pthread_mutexattr_default);
  162. #elif defined(__WIN32__)
  163.     mutex = CreateMutex(NULL, FALSE, NULL);
  164. #elif defined(__OS2__)
  165.     APIRET rv;
  166.     RWSTD_THROW(0 != (rv = DosCreateMutexSem(0,&mutex,DC_SEM_SHARED,FALSE)),
  167.                 runtime_error,
  168.                 __rw_mutex_exception);
  169. #endif
  170. #if defined(RWSTD_NEEDS_SEM_INIT)
  171.     initFlag = 1;
  172. #endif
  173. }
  174.  
  175. inline RWSTDMutex::RWSTDMutex () { init(); }  // Initialize the mutex.
  176.  
  177. inline void RWSTDMutex::acquire ()
  178. {
  179. #if defined(RWSTD_NEEDS_SEM_INIT)
  180.     if(0 == initFlag)
  181.         init();
  182. #endif
  183. #if defined(sun)
  184.     mutex_lock(&mutex);
  185. #elif defined(RW_POSIX_THREADS)
  186.     pthread_mutex_lock(&mutex);
  187. #elif defined(__WIN32__)
  188.     WaitForSingleObject(mutex,INFINITE);
  189. #elif defined(__OS2__)
  190.     APIRET rv;
  191.     RWSTD_THROW(0 != (rv = DosRequestMutexSem(mutex, SEM_INDEFINITE_WAIT)),
  192.                 runtime_error,
  193.                 __rw_mutex_exception);
  194. #endif
  195. }
  196.  
  197. inline void RWSTDMutex::release ()
  198. {
  199. #if defined(sun)
  200.     mutex_unlock(&mutex);
  201. #elif defined(RW_POSIX_THREADS)
  202.     pthread_mutex_unlock(&mutex);
  203. #elif defined(__WIN32__)
  204.     ReleaseMutex(mutex);
  205. #elif defined(__OS2__)
  206.     APIRET rv;
  207.     RWSTD_THROW(0 != (rv = DosReleaseMutexSem(mutex)),
  208.                 runtime_error,
  209.                 __rw_mutex_exception);
  210. #endif
  211. }
  212.  
  213. inline RWSTDGuard::RWSTDGuard (RWSTDMutex& m) : rwmutex(m)
  214. {
  215.     rwmutex.acquire();
  216. }
  217.  
  218. inline RWSTDGuard::~RWSTDGuard () { rwmutex.release(); }
  219.  
  220.  
  221. #define STDGUARD(a) RWSTDGuard(a)
  222. #else
  223. #define STDGUARD(a)
  224. #endif  /*RWSTD_MULTI_THREAD*/
  225. #endif  /*__RWSTD_MUTEX_H__*/
  226.  
  227.  
  228.