75f1522155
work to do, but it's about time to give this code more exposure. git-svn-id: file:///srv/svn/repos/haiku/haiku/trunk@33176 a95241bf-73f2-0310-859d-f6bbb57e9c96
268 lines
12 KiB
C
268 lines
12 KiB
C
/*
|
|
******************************************************************************
|
|
* *
|
|
* Copyright (C) 2001-2005, International Business Machines *
|
|
* Corporation and others. All Rights Reserved. *
|
|
* *
|
|
******************************************************************************
|
|
* file name: uclean.h
|
|
* encoding: US-ASCII
|
|
* tab size: 8 (not used)
|
|
* indentation:4
|
|
*
|
|
* created on: 2001July05
|
|
* created by: George Rhoten
|
|
*/
|
|
|
|
#ifndef __UCLEAN_H__
|
|
#define __UCLEAN_H__
|
|
|
|
#include "unicode/utypes.h"
|
|
/**
|
|
* \file
|
|
* \brief C API: Initialize and clean up ICU
|
|
*/
|
|
|
|
/**
|
|
* Initialize ICU. The description further below applies to ICU 2.6 to ICU 3.4.
|
|
* Starting with ICU 3.4, u_init() needs not be called any more for
|
|
* ensuring thread safety, but it can give an indication for whether ICU
|
|
* can load its data. In ICU 3.4, it will try to load the converter alias table
|
|
* (cnvalias.icu) and give an error code if that fails.
|
|
* This may change in the future.
|
|
* <p>
|
|
* For ensuring the availability of necessary data, an application should
|
|
* open the service objects (converters, collators, etc.) that it will use
|
|
* and check for error codes there.
|
|
* <p>
|
|
* Documentation for ICU 2.6 to ICU 3.4:
|
|
* <p>
|
|
* This function loads and initializes data items
|
|
* that are required internally by various ICU functions. Use of this explicit
|
|
* initialization is required in multi-threaded applications; in
|
|
* single threaded apps, use is optional, but incurs little additional
|
|
* cost, and is thus recommended.
|
|
* <p>
|
|
* In multi-threaded applications, u_init() should be called in the
|
|
* main thread before starting additional threads, or, alternatively
|
|
* it can be called in each individual thread once, before other ICU
|
|
* functions are called in that thread. In this second scenario, the
|
|
* application must guarantee that the first call to u_init() happen
|
|
* without contention, in a single thread only.
|
|
* <p>
|
|
* If <code>u_setMemoryFunctions()</code> or
|
|
* <code>u_setMutexFunctions</code> are needed (uncommon), they must be
|
|
* called _before_ <code>u_init()</code>.
|
|
* <p>
|
|
* Extra, repeated, or otherwise unneeded calls to u_init() do no harm,
|
|
* other than taking a small amount of time.
|
|
*
|
|
* @param status An ICU UErrorCode parameter. It must not be <code>NULL</code>.
|
|
* An Error will be returned if some required part of ICU data can not
|
|
* be loaded or initialized.
|
|
* The function returns immediately if the input error code indicates a
|
|
* failure, as usual.
|
|
*
|
|
* @stable ICU 2.6
|
|
*/
|
|
U_STABLE void U_EXPORT2
|
|
u_init(UErrorCode *status);
|
|
|
|
/**
|
|
* Clean up the system resources, such as allocated memory or open files,
|
|
* used in all ICU libraries. This will free/delete all memory owned by the
|
|
* ICU libraries, and return them to their original load state. All open ICU
|
|
* items (collators, resource bundles, converters, etc.) must be closed before
|
|
* calling this function, otherwise ICU may not free its allocated memory
|
|
* (e.g. close your converters and resource bundles before calling this
|
|
* function). Generally, this function should be called once just before
|
|
* an application exits. For applications that dynamically load and unload
|
|
* the ICU libraries (relatively uncommon), u_cleanup() should be called
|
|
* just before the library unload.
|
|
* <p>
|
|
* u_cleanup() also clears any ICU heap functions, mutex functions or
|
|
* trace functions that may have been set for the process.
|
|
* This has the effect of restoring ICU to its initial condition, before
|
|
* any of these override functions were installed. Refer to
|
|
* u_setMemoryFunctions(), u_setMutexFunctions and
|
|
* utrace_setFunctions(). If ICU is to be reinitialized after after
|
|
* calling u_cleanup(), these runtime override functions will need to
|
|
* be set up again if they are still required.
|
|
* <p>
|
|
* u_cleanup() is not thread safe. All other threads should stop using ICU
|
|
* before calling this function.
|
|
* <p>
|
|
* Any open ICU items will be left in an undefined state by u_cleanup(),
|
|
* and any subsequent attempt to use such an item will give unpredictable
|
|
* results.
|
|
* <p>
|
|
* After calling u_cleanup(), an application may continue to use ICU by
|
|
* calling u_init(). An application must invoke u_init() first from one single
|
|
* thread before allowing other threads call u_init(). All threads existing
|
|
* at the time of the first thread's call to u_init() must also call
|
|
* u_init() themselves before continuing with other ICU operations.
|
|
* <p>
|
|
* The use of u_cleanup() just before an application terminates is optional,
|
|
* but it should be called only once for performance reasons. The primary
|
|
* benefit is to eliminate reports of memory or resource leaks originating
|
|
* in ICU code from the results generated by heap analysis tools.
|
|
* <p>
|
|
* <strong>Use this function with great care!</strong>
|
|
* </p>
|
|
*
|
|
* @stable ICU 2.0
|
|
* @system
|
|
*/
|
|
U_STABLE void U_EXPORT2
|
|
u_cleanup(void);
|
|
|
|
|
|
|
|
|
|
/**
|
|
* An opaque pointer type that represents an ICU mutex.
|
|
* For user-implemented mutexes, the value will typically point to a
|
|
* struct or object that implements the mutex.
|
|
* @stable ICU 2.8
|
|
* @system
|
|
*/
|
|
typedef void *UMTX;
|
|
|
|
/**
|
|
* Function Pointer type for a user supplied mutex initialization function.
|
|
* The user-supplied function will be called by ICU whenever ICU needs to create a
|
|
* new mutex. The function implementation should create a mutex, and store a pointer
|
|
* to something that uniquely identifies the mutex into the UMTX that is supplied
|
|
* as a paramter.
|
|
* @param context user supplied value, obtained from from u_setMutexFunctions().
|
|
* @param mutex Receives a pointer that identifies the new mutex.
|
|
* The mutex init function must set the UMTX to a non-null value.
|
|
* Subsequent calls by ICU to lock, unlock, or destroy a mutex will
|
|
* identify the mutex by the UMTX value.
|
|
* @param status Error status. Report errors back to ICU by setting this variable
|
|
* with an error code.
|
|
* @stable ICU 2.8
|
|
* @system
|
|
*/
|
|
typedef void U_CALLCONV UMtxInitFn (const void *context, UMTX *mutex, UErrorCode* status);
|
|
|
|
|
|
/**
|
|
* Function Pointer type for a user supplied mutex functions.
|
|
* One of the user-supplied functions with this signature will be called by ICU
|
|
* whenever ICU needs to lock, unlock, or destroy a mutex.
|
|
* @param context user supplied value, obtained from from u_setMutexFunctions().
|
|
* @param mutex specify the mutex on which to operate.
|
|
* @stable ICU 2.8
|
|
* @system
|
|
*/
|
|
typedef void U_CALLCONV UMtxFn (const void *context, UMTX *mutex);
|
|
|
|
|
|
/**
|
|
* Set the functions that ICU will use for mutex operations
|
|
* Use of this function is optional; by default (without this function), ICU will
|
|
* directly access system functions for mutex operations
|
|
* This function can only be used when ICU is in an initial, unused state, before
|
|
* u_init() has been called.
|
|
* This function may be used even when ICU has been built without multi-threaded
|
|
* support (see ICU_USE_THREADS pre-processor variable, umutex.h)
|
|
* @param context This pointer value will be saved, and then (later) passed as
|
|
* a parameter to the user-supplied mutex functions each time they
|
|
* are called.
|
|
* @param init Pointer to a mutex initialization function. Must be non-null.
|
|
* @param destroy Pointer to the mutex destroy function. Must be non-null.
|
|
* @param lock pointer to the mutex lock function. Must be non-null.
|
|
* @param unlock Pointer to the mutex unlock function. Must be non-null.
|
|
* @param status Receives error values.
|
|
* @stable ICU 2.8
|
|
* @system
|
|
*/
|
|
U_STABLE void U_EXPORT2
|
|
u_setMutexFunctions(const void *context, UMtxInitFn *init, UMtxFn *destroy, UMtxFn *lock, UMtxFn *unlock,
|
|
UErrorCode *status);
|
|
|
|
|
|
/**
|
|
* Pointer type for a user supplied atomic increment or decrement function.
|
|
* @param context user supplied value, obtained from from u_setAtomicIncDecFunctions().
|
|
* @param p Pointer to a 32 bit int to be incremented or decremented
|
|
* @return The value of the variable after the inc or dec operation.
|
|
* @stable ICU 2.8
|
|
* @system
|
|
*/
|
|
typedef int32_t U_CALLCONV UMtxAtomicFn(const void *context, int32_t *p);
|
|
|
|
/**
|
|
* Set the functions that ICU will use for atomic increment and decrement of int32_t values.
|
|
* Use of this function is optional; by default (without this function), ICU will
|
|
* use its own internal implementation of atomic increment/decrement.
|
|
* This function can only be used when ICU is in an initial, unused state, before
|
|
* u_init() has been called.
|
|
* @param context This pointer value will be saved, and then (later) passed as
|
|
* a parameter to the increment and decrement functions each time they
|
|
* are called. This function can only be called
|
|
* @param inc Pointer to a function to do an atomic increment operation. Must be non-null.
|
|
* @param dec Pointer to a function to do an atomic decrement operation. Must be non-null.
|
|
* @param status Receives error values.
|
|
* @stable ICU 2.8
|
|
* @system
|
|
*/
|
|
U_STABLE void U_EXPORT2
|
|
u_setAtomicIncDecFunctions(const void *context, UMtxAtomicFn *inc, UMtxAtomicFn *dec,
|
|
UErrorCode *status);
|
|
|
|
|
|
|
|
/**
|
|
* Pointer type for a user supplied memory allocation function.
|
|
* @param context user supplied value, obtained from from u_setMemoryFunctions().
|
|
* @param size The number of bytes to be allocated
|
|
* @return Pointer to the newly allocated memory, or NULL if the allocation failed.
|
|
* @stable ICU 2.8
|
|
* @system
|
|
*/
|
|
typedef void *U_CALLCONV UMemAllocFn(const void *context, size_t size);
|
|
/**
|
|
* Pointer type for a user supplied memory re-allocation function.
|
|
* @param context user supplied value, obtained from from u_setMemoryFunctions().
|
|
* @param size The number of bytes to be allocated
|
|
* @return Pointer to the newly allocated memory, or NULL if the allocation failed.
|
|
* @stable ICU 2.8
|
|
* @system
|
|
*/
|
|
typedef void *U_CALLCONV UMemReallocFn(const void *context, void *mem, size_t size);
|
|
/**
|
|
* Pointer type for a user supplied memory free function. Behavior should be
|
|
* similar the standard C library free().
|
|
* @param context user supplied value, obtained from from u_setMemoryFunctions().
|
|
* @param mem Pointer to the memory block to be resized
|
|
* @param size The new size for the block
|
|
* @return Pointer to the resized memory block, or NULL if the resizing failed.
|
|
* @stable ICU 2.8
|
|
* @system
|
|
*/
|
|
typedef void U_CALLCONV UMemFreeFn (const void *context, void *mem);
|
|
|
|
/**
|
|
* Set the functions that ICU will use for memory allocation.
|
|
* Use of this function is optional; by default (without this function), ICU will
|
|
* use the standard C library malloc() and free() functions.
|
|
* This function can only be used when ICU is in an initial, unused state, before
|
|
* u_init() has been called.
|
|
* @param context This pointer value will be saved, and then (later) passed as
|
|
* a parameter to the memory functions each time they
|
|
* are called.
|
|
* @param a Pointer to a user-supplied malloc function.
|
|
* @param r Pointer to a user-supplied realloc function.
|
|
* @param f Pointer to a user-supplied free function.
|
|
* @param status Receives error values.
|
|
* @stable ICU 2.8
|
|
* @system
|
|
*/
|
|
U_STABLE void U_EXPORT2
|
|
u_setMemoryFunctions(const void *context, UMemAllocFn *a, UMemReallocFn *r, UMemFreeFn *f,
|
|
UErrorCode *status);
|
|
|
|
#endif
|