icuSources/common/unicode/uclean.h

   1 /*
   2 ******************************************************************************
   3 *                                                                            *
   4 * Copyright (C) 2001-2005, International Business Machines                   *
   5 *                Corporation and others. All Rights Reserved.                *
   6 *                                                                            *
   7 ******************************************************************************
   8 *   file name:  uclean.h
   9 *   encoding:   US-ASCII
  10 *   tab size:   8 (not used)
  11 *   indentation:4
  12 *
  13 *   created on: 2001July05
  14 *   created by: George Rhoten
  15 */
  16
  17 #ifndef __UCLEAN_H__
  18 #define __UCLEAN_H__
  19
  20 #include "unicode/utypes.h"
  21 /**
  22  * \file
  23  * \brief C API: Initialize and clean up ICU
  24  */
  25
  26 /**
  27  *  Initialize ICU. The description further below applies to ICU 2.6 to ICU 3.4.
  28  *  Starting with ICU 3.4, u_init() needs not be called any more for
  29  *  ensuring thread safety, but it can give an indication for whether ICU
  30  *  can load its data. In ICU 3.4, it will try to load the converter alias table
  31  *  (cnvalias.icu) and give an error code if that fails.
  32  *  This may change in the future.
  33  *  <p>
  34  *  For ensuring the availability of necessary data, an application should
  35  *  open the service objects (converters, collators, etc.) that it will use
  36  *  and check for error codes there.
  37  *  <p>
  38  *  Documentation for ICU 2.6 to ICU 3.4:
  39  *  <p>
  40  *  This function loads and initializes data items
  41  *  that are required internally by various ICU functions.  Use of this explicit
  42  *  initialization is required in multi-threaded applications; in
  43  *  single threaded apps, use is optional, but incurs little additional
  44  *  cost, and is thus recommended.
  45  *  <p>
  46  *  In multi-threaded applications, u_init() should be called  in the
  47  *  main thread before starting additional threads, or, alternatively
  48  *  it can be called in each individual thread once, before other ICU
  49  *  functions are called in that thread.  In this second scenario, the
  50  *  application must guarantee that the first call to u_init() happen
  51  *  without contention, in a single thread only.
  52  *  <p>
  53  *  If <code>u_setMemoryFunctions()</code> or
  54  *  <code>u_setMutexFunctions</code> are needed (uncommon), they must be
  55  *  called _before_ <code>u_init()</code>.
  56  *  <p>
  57  *  Extra, repeated, or otherwise unneeded calls to u_init() do no harm,
  58  *  other than taking a small amount of time.
  59  *
  60  * @param status An ICU UErrorCode parameter. It must not be <code>NULL</code>.
  61  *    An Error will be returned if some required part of ICU data can not
  62  *    be loaded or initialized.
  63  *    The function returns immediately if the input error code indicates a
  64  *    failure, as usual.
  65  *
  66  * @stable ICU 2.6
  67  */
  68 U_STABLE void U_EXPORT2
  69 u_init(UErrorCode *status);
  70
  71 /**
  72  * Clean up the system resources, such as allocated memory or open files,
  73  * used in all ICU libraries. This will free/delete all memory owned by the
  74  * ICU libraries, and return them to their original load state. All open ICU
  75  * items (collators, resource bundles, converters, etc.) must be closed before
  76  * calling this function, otherwise ICU may not free its allocated memory
  77  * (e.g. close your converters and resource bundles before calling this
  78  * function). Generally, this function should be called once just before
  79  * an application exits. For applications that dynamically load and unload
  80  * the ICU libraries (relatively uncommon), u_cleanup() should be called
  81  * just before the library unload.
  82  * <p>
  83  * u_cleanup() also clears any ICU heap functions, mutex functions or
  84  * trace functions that may have been set for the process.
  85  * This has the effect of restoring ICU to its initial condition, before
  86  * any of these override functions were installed.  Refer to
  87  * u_setMemoryFunctions(), u_setMutexFunctions and
  88  * utrace_setFunctions().  If ICU is to be reinitialized after after
  89  * calling u_cleanup(), these runtime override functions will need to
  90  * be set up again if they are still required.
  91  * <p>
  92  * u_cleanup() is not thread safe.  All other threads should stop using ICU
  93  * before calling this function.
  94  * <p>
  95  * Any open ICU items will be left in an undefined state by u_cleanup(),
  96  * and any subsequent attempt to use such an item will give unpredictable
  97  * results.
  98  * <p>
  99  * After calling u_cleanup(), an application may continue to use ICU by
 100  * calling u_init().  An application must invoke u_init() first from one single
 101  * thread before allowing other threads call u_init().  All threads existing
 102  * at the time of the first thread's call to u_init() must also call
 103  * u_init() themselves before continuing with other ICU operations.
 104  * <p>
 105  * The use of u_cleanup() just before an application terminates is optional,
 106  * but it should be called only once for performance reasons. The primary
 107  * benefit is to eliminate reports of memory or resource leaks originating
 108  * in ICU code from the results generated by heap analysis tools.
 109  * <p>
 110  * <strong>Use this function with great care!</strong>
 111  * </p>
 112  *
 113  * @stable ICU 2.0
 114  * @system
 115  */
 116 U_STABLE void U_EXPORT2
 117 u_cleanup(void);
 118
 119
 120
 121
 122 /**
 123   * An opaque pointer type that represents an ICU mutex.
 124   * For user-implemented mutexes, the value will typically point to a
 125   *  struct or object that implements the mutex.
 126   * @stable ICU 2.8
 127   * @system
 128   */
 129 typedef void *UMTX;
 130
 131 /**
 132   *  Function Pointer type for a user supplied mutex initialization function.
 133   *  The user-supplied function will be called by ICU whenever ICU needs to create a
 134   *  new mutex.  The function implementation should create a mutex, and store a pointer
 135   *  to something that uniquely identifies the mutex into the UMTX that is supplied
 136   *  as a paramter.
 137   *  @param context user supplied value, obtained from from u_setMutexFunctions().
 138   *  @param mutex   Receives a pointer that identifies the new mutex.
 139   *                 The mutex init function must set the UMTX to a non-null value.
 140   *                 Subsequent calls by ICU to lock, unlock, or destroy a mutex will
 141   *                 identify the mutex by the UMTX value.
 142   *  @param status  Error status.  Report errors back to ICU by setting this variable
 143   *                 with an error code.
 144   *  @stable ICU 2.8
 145   *  @system
 146   */
 147 typedef void U_CALLCONV UMtxInitFn (const void *context, UMTX  *mutex, UErrorCode* status);
 148
 149
 150 /**
 151   *  Function Pointer type for a user supplied mutex functions.
 152   *  One of the  user-supplied functions with this signature will be called by ICU
 153   *  whenever ICU needs to lock, unlock, or destroy a mutex.
 154   *  @param context user supplied value, obtained from from u_setMutexFunctions().
 155   *  @param mutex   specify the mutex on which to operate.
 156   *  @stable ICU 2.8
 157   *  @system
 158   */
 159 typedef void U_CALLCONV UMtxFn   (const void *context, UMTX  *mutex);
 160
 161
 162 /**
 163   *  Set the functions that ICU will use for mutex operations
 164   *  Use of this function is optional; by default (without this function), ICU will
 165   *  directly access system functions for mutex operations
 166   *  This function can only be used when ICU is in an initial, unused state, before
 167   *  u_init() has been called.
 168   *  This function may be used even when ICU has been built without multi-threaded
 169   *  support  (see ICU_USE_THREADS pre-processor variable, umutex.h)
 170   *  @param context This pointer value will be saved, and then (later) passed as
 171   *                 a parameter to the user-supplied mutex functions each time they
 172   *                 are called.
 173   *  @param init    Pointer to a mutex initialization function.  Must be non-null.
 174   *  @param destroy Pointer to the mutex destroy function.  Must be non-null.
 175   *  @param lock    pointer to the mutex lock function.  Must be non-null.
 176   *  @param unlock  Pointer to the mutex unlock function.  Must be non-null.
 177   *  @param status  Receives error values.
 178   *  @stable ICU 2.8
 179   *  @system
 180   */
 181 U_STABLE void U_EXPORT2
 182 u_setMutexFunctions(const void *context, UMtxInitFn *init, UMtxFn *destroy, UMtxFn *lock, UMtxFn *unlock,
 183                     UErrorCode *status);
 184
 185
 186 /**
 187   *  Pointer type for a user supplied atomic increment or decrement function.
 188   *  @param context user supplied value, obtained from from u_setAtomicIncDecFunctions().
 189   *  @param p   Pointer to a 32 bit int to be incremented or decremented
 190   *  @return    The value of the variable after the inc or dec operation.
 191   *  @stable ICU 2.8
 192   *  @system
 193   */
 194 typedef int32_t U_CALLCONV UMtxAtomicFn(const void *context, int32_t *p);
 195
 196 /**
 197  *  Set the functions that ICU will use for atomic increment and decrement of int32_t values.
 198  *  Use of this function is optional; by default (without this function), ICU will
 199  *  use its own internal implementation of atomic increment/decrement.
 200  *  This function can only be used when ICU is in an initial, unused state, before
 201  *  u_init() has been called.
 202  *  @param context This pointer value will be saved, and then (later) passed as
 203  *                 a parameter to the increment and decrement functions each time they
 204  *                 are called.  This function can only be called
 205  *  @param inc     Pointer to a function to do an atomic increment operation.  Must be non-null.
 206  *  @param dec     Pointer to a function to do an atomic decrement operation.  Must be non-null.
 207  *  @param status  Receives error values.
 208  *  @stable ICU 2.8
 209  *  @system
 210  */
 211 U_STABLE void U_EXPORT2
 212 u_setAtomicIncDecFunctions(const void *context, UMtxAtomicFn *inc, UMtxAtomicFn *dec,
 213                     UErrorCode *status);
 214
 215
 216
 217 /**
 218   *  Pointer type for a user supplied memory allocation function.
 219   *  @param context user supplied value, obtained from from u_setMemoryFunctions().
 220   *  @param size    The number of bytes to be allocated
 221   *  @return        Pointer to the newly allocated memory, or NULL if the allocation failed.
 222   *  @stable ICU 2.8
 223   *  @system
 224   */
 225 typedef void *U_CALLCONV UMemAllocFn(const void *context, size_t size);
 226 /**
 227   *  Pointer type for a user supplied memory re-allocation function.
 228   *  @param context user supplied value, obtained from from u_setMemoryFunctions().
 229   *  @param size    The number of bytes to be allocated
 230   *  @return        Pointer to the newly allocated memory, or NULL if the allocation failed.
 231   *  @stable ICU 2.8
 232   *  @system
 233   */
 234 typedef void *U_CALLCONV UMemReallocFn(const void *context, void *mem, size_t size);
 235 /**
 236   *  Pointer type for a user supplied memory free  function.  Behavior should be
 237   *  similar the standard C library free().
 238   *  @param context user supplied value, obtained from from u_setMemoryFunctions().
 239   *  @param mem     Pointer to the memory block to be resized
 240   *  @param size    The new size for the block
 241   *  @return        Pointer to the resized memory block, or NULL if the resizing failed.
 242   *  @stable ICU 2.8
 243   *  @system
 244   */
 245 typedef void  U_CALLCONV UMemFreeFn (const void *context, void *mem);
 246
 247 /**
 248  *  Set the functions that ICU will use for memory allocation.
 249  *  Use of this function is optional; by default (without this function), ICU will
 250  *  use the standard C library malloc() and free() functions.
 251  *  This function can only be used when ICU is in an initial, unused state, before
 252  *  u_init() has been called.
 253  *  @param context This pointer value will be saved, and then (later) passed as
 254  *                 a parameter to the memory functions each time they
 255  *                 are called.
 256  *  @param a       Pointer to a user-supplied malloc function.
 257  *  @param r       Pointer to a user-supplied realloc function.
 258  *  @param f       Pointer to a user-supplied free function.
 259  *  @param status  Receives error values.
 260  *  @stable ICU 2.8
 261  *  @system
 262  */
 263 U_STABLE void U_EXPORT2
 264 u_setMemoryFunctions(const void *context, UMemAllocFn *a, UMemReallocFn *r, UMemFreeFn *f,
 265                     UErrorCode *status);
 266
 267 #endif