This structure may grow in the future, indicated by the
* size field.
ICU data must be at least 8-aligned, and should be 16-aligned. * The UDataInfo struct begins 4 bytes after the start of the data item, * so it is 4-aligned. * *
The platform data property fields help determine if a data * file can be efficiently used on a given machine. * The particular fields are of importance only if the data * is affected by the properties - if there is integer data * with word sizes > 1 byte, char* text, or UChar* text.
* *The implementation for the udata_open[Choice]()
* functions may reject data based on the value in isBigEndian.
* No other field is used by the udata API implementation.
The dataFormat may be used to identify
* the kind of data, e.g. a converter table.
The formatVersion field should be used to
* make sure that the format can be interpreted.
* It may be a good idea to check only for the one or two highest
* of the version elements to allow the data memory to
* get more or somewhat rearranged contents, for as long
* as the using code can still interpret the older contents.
The dataVersion field is intended to be a
* common place to store the source version of the data;
* for data from the Unicode character database, this could
* reflect the Unicode version.
udata_openChoice().
* @param type The type of the data as passed into udata_openChoice().
* It may be NULL.
* @param name The name of the data as passed into udata_openChoice().
* @param pInfo A pointer to the UDataInfo structure
* of data that has been loaded and will be returned
* by udata_openChoice() if this function
* returns TRUE.
* @return TRUE if the current data memory is acceptable
* @stable ICU 2.0
*/
typedef UBool U_CALLCONV
UDataMemoryIsAcceptable(void *context,
const char *type, const char *name,
const UDataInfo *pInfo);
/**
* Convenience function.
* This function works the same as udata_openChoice
* except that any data that matches the type and name
* is assumed to be acceptable.
* @param path Specifies an absolute path and/or a basename for the
* finding of the data in the file system.
* NULL for ICU data.
* @param type A string that specifies the type of data to be loaded.
* For example, resource bundles are loaded with type "res",
* conversion tables with type "cnv".
* This may be NULL or empty.
* @param name A string that specifies the name of the data.
* @param pErrorCode An ICU UErrorCode parameter. It must not be NULL.
* @return A pointer (handle) to a data memory object, or NULL
* if an error occurs. Call udata_getMemory()
* to get a pointer to the actual data.
*
* @see udata_openChoice
* @stable ICU 2.0
*/
U_STABLE UDataMemory * U_EXPORT2
udata_open(const char *path, const char *type, const char *name,
UErrorCode *pErrorCode);
/**
* Data loading function.
* This function is used to find and load efficiently data for
* ICU and applications using ICU.
* It provides an abstract interface that allows to specify a data
* type and name to find and load the data.
*
* The implementation depends on platform properties and user preferences * and may involve loading shared libraries (DLLs), mapping * files into memory, or fopen()/fread() files. * It may also involve using static memory or database queries etc. * Several or all data items may be combined into one entity * (DLL, memory-mappable file).
* *The data is always preceded by a header that includes
* a UDataInfo structure.
* The caller's isAcceptable() function is called to make
* sure that the data is useful. It may be called several times if it
* rejects the data and there is more than one location with data
* matching the type and name.
If path==NULL, then ICU data is loaded.
* Otherwise, it is separated into a basename and a basename-less directory string.
* The basename is used as the data package name, and the directory is
* logically prepended to the ICU data directory string.
For details about ICU data loading see the User Guide * Data Management chapter. (http://icu-project.org/userguide/icudata.html)
* * @param path Specifies an absolute path and/or a basename for the * finding of the data in the file system. *NULL for ICU data.
* @param type A string that specifies the type of data to be loaded.
* For example, resource bundles are loaded with type "res",
* conversion tables with type "cnv".
* This may be NULL or empty.
* @param name A string that specifies the name of the data.
* @param isAcceptable This function is called to verify that loaded data
* is useful for the client code. If it returns FALSE
* for all data items, then udata_openChoice()
* will return with an error.
* @param context Arbitrary parameter to be passed into isAcceptable.
* @param pErrorCode An ICU UErrorCode parameter. It must not be NULL.
* @return A pointer (handle) to a data memory object, or NULL
* if an error occurs. Call udata_getMemory()
* to get a pointer to the actual data.
* @stable ICU 2.0
*/
U_STABLE UDataMemory * U_EXPORT2
udata_openChoice(const char *path, const char *type, const char *name,
UDataMemoryIsAcceptable *isAcceptable, void *context,
UErrorCode *pErrorCode);
/**
* Close the data memory.
* This function must be called to allow the system to
* release resources associated with this data memory.
* @param pData The pointer to data memory object
* @stable ICU 2.0
*/
U_STABLE void U_EXPORT2
udata_close(UDataMemory *pData);
#if U_SHOW_CPLUSPLUS_API
U_NAMESPACE_BEGIN
/**
* \class LocalUDataMemoryPointer
* "Smart pointer" class, closes a UDataMemory via udata_close().
* For most methods see the LocalPointerBase base class.
*
* @see LocalPointerBase
* @see LocalPointer
* @stable ICU 4.4
*/
U_DEFINE_LOCAL_OPEN_POINTER(LocalUDataMemoryPointer, UDataMemory, udata_close);
U_NAMESPACE_END
#endif
/**
* Get the pointer to the actual data inside the data memory.
* The data is read-only.
*
* ICU data must be at least 8-aligned, and should be 16-aligned.
*
* @param pData The pointer to data memory object
* @stable ICU 2.0
*/
U_STABLE const void * U_EXPORT2
udata_getMemory(UDataMemory *pData);
/**
* Get the information from the data memory header.
* This allows to get access to the header containing
* platform data properties etc. which is not part of
* the data itself and can therefore not be accessed
* via the pointer that udata_getMemory() returns.
*
* @param pData pointer to the data memory object
* @param pInfo pointer to a UDataInfo object;
* its size field must be set correctly,
* typically to sizeof(UDataInfo).
*
* *pInfo will be filled with the UDataInfo structure
* in the data memory object. If this structure is smaller than
* pInfo->size, then the size will be
* adjusted and only part of the structure will be filled.
* @stable ICU 2.0
*/
U_STABLE void U_EXPORT2
udata_getInfo(UDataMemory *pData, UDataInfo *pInfo);
/**
* This function bypasses the normal ICU data loading process and
* allows you to force ICU's system data to come out of a user-specified
* area in memory.
*
* ICU data must be at least 8-aligned, and should be 16-aligned.
* See http://userguide.icu-project.org/icudata
*
* The format of this data is that of the icu common data file, as is
* generated by the pkgdata tool with mode=common or mode=dll.
* You can read in a whole common mode file and pass the address to the start of the
* data, or (with the appropriate link options) pass in the pointer to
* the data that has been loaded from a dll by the operating system,
* as shown in this code:
*
* extern const char U_IMPORT U_ICUDATA_ENTRY_POINT [];
* // U_ICUDATA_ENTRY_POINT is same as entry point specified to pkgdata tool
* UErrorCode status = U_ZERO_ERROR;
*
* udata_setCommonData(&U_ICUDATA_ENTRY_POINT, &status);
*
* It is important that the declaration be as above. The entry point
* must not be declared as an extern void*.
*
* Starting with ICU 4.4, it is possible to set several data packages,
* one per call to this function.
* udata_open() will look for data in the multiple data packages in the order
* in which they were set.
* The position of the linked-in or default-name ICU .data package in the
* search list depends on when the first data item is loaded that is not contained
* in the already explicitly set packages.
* If data was loaded implicitly before the first call to this function
* (for example, via opening a converter, constructing a UnicodeString
* from default-codepage data, using formatting or collation APIs, etc.),
* then the default data will be first in the list.
*
* This function has no effect on application (non ICU) data. See udata_setAppData()
* for similar functionality for application data.
*
* @param data pointer to ICU common data
* @param err outgoing error status U_USING_DEFAULT_WARNING, U_UNSUPPORTED_ERROR
* @stable ICU 2.0
*/
U_STABLE void U_EXPORT2
udata_setCommonData(const void *data, UErrorCode *err);
/**
* This function bypasses the normal ICU data loading process for application-specific
* data and allows you to force the it to come out of a user-specified
* pointer.
*
* ICU data must be at least 8-aligned, and should be 16-aligned.
* See http://userguide.icu-project.org/icudata
*
* The format of this data is that of the icu common data file, like 'icudt26l.dat'
* or the corresponding shared library (DLL) file.
* The application must read in or otherwise construct an image of the data and then
* pass the address of it to this function.
*
*
* Warning: setAppData will set a U_USING_DEFAULT_WARNING code if
* data with the specifed path that has already been opened, or
* if setAppData with the same path has already been called.
* Any such calls to setAppData will have no effect.
*
*
* @param packageName the package name by which the application will refer
* to (open) this data
* @param data pointer to the data
* @param err outgoing error status U_USING_DEFAULT_WARNING, U_UNSUPPORTED_ERROR
* @see udata_setCommonData
* @stable ICU 2.0
*/
U_STABLE void U_EXPORT2
udata_setAppData(const char *packageName, const void *data, UErrorCode *err);
/**
* Possible settings for udata_setFileAccess()
* @see udata_setFileAccess
* @stable ICU 3.4
*/
typedef enum UDataFileAccess {
/** ICU looks for data in single files first, then in packages. (default) @stable ICU 3.4 */
UDATA_FILES_FIRST,
/** An alias for the default access mode. @stable ICU 3.4 */
UDATA_DEFAULT_ACCESS = UDATA_FILES_FIRST,
/** ICU only loads data from packages, not from single files. @stable ICU 3.4 */
UDATA_ONLY_PACKAGES,
/** ICU loads data from packages first, and only from single files
if the data cannot be found in a package. @stable ICU 3.4 */
UDATA_PACKAGES_FIRST,
/** ICU does not access the file system for data loading. @stable ICU 3.4 */
UDATA_NO_FILES,
#ifndef U_HIDE_DEPRECATED_API
/**
* Number of real UDataFileAccess values.
* @deprecated ICU 58 The numeric value may change over time, see ICU ticket #12420.
*/
UDATA_FILE_ACCESS_COUNT
#endif // U_HIDE_DEPRECATED_API
} UDataFileAccess;
/**
* This function may be called to control how ICU loads data. It must be called
* before any ICU data is loaded, including application data loaded with
* ures/ResourceBundle or udata APIs. This function is not multithread safe.
* The results of calling it while other threads are loading data are undefined.
* @param access The type of file access to be used
* @param status Error code.
* @see UDataFileAccess
* @stable ICU 3.4
*/
U_STABLE void U_EXPORT2
udata_setFileAccess(UDataFileAccess access, UErrorCode *status);
U_CDECL_END
#endif