| /* |
| ********************************************************************** |
| * Copyright (C) 1997-2001, International Business Machines |
| * Corporation and others. All Rights Reserved. |
| ********************************************************************** |
| * |
| * File UMUTEX.H |
| * |
| * Modification History: |
| * |
| * Date Name Description |
| * 04/02/97 aliu Creation. |
| * 04/07/99 srl rewrite - C interface, multiple mutices |
| * 05/13/99 stephen Changed to umutex (from cmutex) |
| ****************************************************************************** |
| */ |
| |
| #ifndef UMUTEX_H |
| #define UMUTEX_H |
| |
| #include "unicode/utypes.h" |
| |
| /** |
| * Mutex data type. |
| * @internal |
| */ |
| typedef void *UMTX; |
| |
| /* APP_NO_THREADS is an old symbol. We'll honour it if present. */ |
| #ifdef APP_NO_THREADS |
| # define ICU_USE_THREADS 0 |
| #endif |
| |
| /* Default: use threads. */ |
| #ifndef ICU_USE_THREADS |
| # define ICU_USE_THREADS 1 |
| #endif |
| |
| /* |
| * Code within this library which accesses protected data should |
| * instantiate a Mutex object while doing so. Notice that there is |
| * only one coarse-grained lock which applies to this entire library, |
| * so keep locking short and sweet. |
| * |
| * For example: |
| * |
| * void Function(int arg1, int arg2) |
| * { |
| * static Object* foo; // Shared read-write object |
| * Mutex mutex; |
| * foo->Method(); |
| * // When 'mutex' goes out of scope and gets destroyed here |
| * // the lock is released |
| * } |
| * |
| * Note: Do NOT use the form 'Mutex mutex();' as that merely |
| * forward-declares a function returning a Mutex. This is a common |
| * mistake which silently slips through the compiler!! */ |
| |
| |
| /* Lock a mutex. Pass in NULL if you want the (ick) Single Global |
| Mutex. |
| * @param mutex The given mutex to be locked |
| */ |
| U_CAPI void U_EXPORT2 umtx_lock ( UMTX* mutex ); |
| |
| /* Unlock a mutex. Pass in NULL if you want the single global |
| mutex. |
| * @param mutex The given mutex to be unlocked |
| */ |
| U_CAPI void U_EXPORT2 umtx_unlock ( UMTX* mutex ); |
| |
| /* Initialize a mutex. Use it this way: |
| umtx_init( &aMutex ); |
| * @param mutex The given mutex to be initialized |
| */ |
| U_CAPI void U_EXPORT2 umtx_init ( UMTX* mutex ); |
| |
| /* Destroy a mutex. This will free the resources of a mutex. |
| Use it this way: |
| umtx_destroy( &aMutex ); |
| * @param mutex The given mutex to be destroyed |
| */ |
| U_CAPI void U_EXPORT2 umtx_destroy( UMTX *mutex ); |
| |
| /* Is a mutex initialized? This function isn't normally needed |
| because umtx_lock will initialize the mutex for you. |
| Use it this way: |
| umtx_isInitialized( &aMutex ); */ |
| U_CAPI UBool U_EXPORT2 umtx_isInitialized( UMTX *mutex ); |
| |
| /* |
| * Atomic Increment and Decrement of an int32_t value. |
| * |
| * Return Values: |
| * If the result of the operation is zero, the return zero. |
| * If the result of the operation is not zero, the sign of returned value |
| * is the same as the sign of the result, but the returned value itself may |
| * be different from the result of the operation. |
| */ |
| U_CAPI int32_t U_EXPORT2 umtx_atomic_inc(int32_t *); |
| U_CAPI int32_t U_EXPORT2 umtx_atomic_dec(int32_t *); |
| |
| |
| #endif /*_CMUTEX*/ |
| /*eof*/ |
| |
| |
| |