| /* |
| ******************************************************************** |
| * COPYRIGHT: |
| * (C) Copyright Taligent, Inc., 1996 |
| * (C) Copyright International Business Machines Corporation, 1999 |
| * Licensed Material - Program-Property of IBM - All Rights Reserved. |
| * US Government Users Restricted Rights - Use, duplication, or disclosure |
| * restricted by GSA ADP Schedule Contract with IBM Corp. |
| * |
| ******************************************************************** |
| */ |
| |
| /* |
| * ========================================================================== |
| * Copyright (c) 1995 Taligent, Inc. All Rights Reserved. |
| * @version 1.0 23/10/96 |
| * @author Helena Shih |
| * Based on Taligent international support for java |
| * Modification History : |
| * |
| * Date Name Description |
| * 2/5/97 aliu Added CompactIntArray streamIn and streamOut methods. |
| * 05/07/97 helena Added isBogus() |
| * 04/26/99 Madhu Ported to C for C Implementation |
| */ |
| |
| #ifndef UCMP32_H |
| #define UCMP32_H |
| |
| |
| #include "utypes.h" |
| |
| #include "filestrm.h" |
| |
| /** |
| * class CompactATypeArray : use only on primitive data types |
| * Provides a compact way to store information that is indexed by Unicode |
| * values, such as character properties, types, keyboard values, etc.This |
| * is very useful when you have a block of Unicode data that contains |
| * significant values while the rest of the Unicode data is unused in the |
| * application or when you have a lot of redundance, such as where all 21,000 |
| * Han ideographs have the same value. However, lookup is much faster than a |
| * hash table. |
| * <P> |
| * A compact array of any primitive data type serves two purposes: |
| * <UL type = round> |
| * <LI>Fast access of the indexed values. |
| * <LI>Smaller memory footprint. |
| * </UL> |
| * <P> |
| * The index array always points into particular parts of the data array |
| * it is initially set up to point at regular block boundaries |
| * The following example uses blocks of 4 for simplicity |
| * <PRE> |
| * Example: Expanded |
| * BLOCK 0 1 2 3 4 |
| * INDEX 0 4 8 12 16 ... |
| * ARRAY abcdeababcdezyabcdea... |
| * | | | | | |... |
| * </PRE> |
| * <P> |
| * After compression, the index will point to various places in the data array |
| * wherever there is a runs of the same elements as in the original |
| * <PRE> |
| * Example: Compressed |
| * BLOCK 0 1 2 3 4 |
| * INDEX 0 4 1 8 2 ... |
| * ARRAY abcdeabazyabc... |
| * </PRE> |
| * <P> |
| * If you look at the example, index number 2 in the expanded version points |
| * to data position number 8, which has elements "bcde". In the compressed |
| * version, index number 2 points to data position 1, which also has "bcde" |
| * @see CompactByteArray |
| * @see CompactIntArray |
| * @see CompactCharArray |
| * @see CompactStringArray |
| * @version $Revision: 1.1 $ 8/25/98 |
| * @author Helena Shih |
| */ |
| /*====================================*/ |
| /*CompactIntArray |
| * Provides a compact way to store information that is indexed by Unicode values, |
| * such as character properties, types, keyboard values, etc. |
| * The ATypes are used by value, so should be small, integers or pointers. |
| *==================================== |
| */ |
| typedef struct{ |
| int32_t* fArray; |
| uint16_t* fIndex; |
| int32_t fCount; |
| bool_t fCompact; |
| bool_t fBogus; |
| } CompactIntArray; |
| |
| CAPI int32_t U_EXPORT2 ucmp32_getkUnicodeCount(void); |
| CAPI int32_t U_EXPORT2 ucmp32_getkBlockCount(void); |
| |
| |
| /** |
| * |
| * Construct an empty CompactIntArray. |
| * @param defaultValue the default value for all characters not explicitly in the array |
| */ |
| CAPI CompactIntArray* U_EXPORT2 ucmp32_open(int32_t defaultValue); |
| |
| /** |
| * Construct a CompactIntArray from a pre-computed index and values array. The values |
| * will be adobped by the CompactIntArray. Note: for speed, the compact method will |
| * only re-use blocks in the values array that are on a block boundary. The pre-computed |
| * arrays passed in to this constructor may re-use blocks at any position in the values |
| * array. |
| * @param indexArray the index array to be adopted |
| * @param newValues the value array to be adobptd |
| * @param count the number of entries in the value array |
| * @see compact |
| */ |
| CAPI CompactIntArray* U_EXPORT2 ucmp32_openAdopt(uint16_t *indexArray, |
| int32_t *newValues, |
| int32_t count); |
| |
| CAPI void U_EXPORT2 ucmp32_close(CompactIntArray* array); |
| |
| /** |
| * Returns TRUE if the creation of the compact array fails. |
| */ |
| |
| CAPI bool_t U_EXPORT2 ucmp32_isBogus(const CompactIntArray* array); |
| /** |
| * |
| * Get the mapped value of a Unicode character. |
| * @param index the character to get the mapped value with |
| * @return the mapped value of the given character |
| */ |
| CAPI int32_t U_EXPORT2 ucmp32_get(CompactIntArray* array, uint16_t index); |
| CAPI uint32_t U_EXPORT2 ucmp32_getu(CompactIntArray* array, uint16_t index); |
| |
| /** |
| * Set a new value for a Unicode character. |
| * Set automatically expands the array if it is compacted. |
| * @param index the character to set the mapped value with |
| * @param value the new mapped value |
| */ |
| CAPI void U_EXPORT2 ucmp32_set(CompactIntArray *array, |
| UChar index, |
| int32_t value); |
| |
| /** |
| * |
| * Set new values for a range of Unicode character. |
| * @param start the starting offset of the range |
| * @param end the ending offset of the range |
| * @param value the new mapped value |
| */ |
| CAPI void U_EXPORT2 ucmp32_setRange(CompactIntArray* array, |
| UChar start, |
| UChar end, |
| int32_t value); |
| |
| /** |
| * Compact the array. The value of cycle determines how large the overlap can be. |
| * A cycle of 1 is the most compacted, but takes the most time to do. |
| * If values stored in the array tend to repeat in cycles of, say, 16, |
| * then using that will be faster than cycle = 1, and get almost the |
| * same compression. |
| */ |
| CAPI void U_EXPORT2 ucmp32_compact(CompactIntArray* array, int32_t cycle); |
| /** |
| * Expands the compacted array. |
| * Takes the array back to a 65536 element array |
| */ |
| |
| CAPI void U_EXPORT2 ucmp32_expand(CompactIntArray* array); |
| /** |
| * |
| * Get the number of elements in the value array. |
| * @return the number of elements in the value array. |
| */ |
| CAPI uint32_t U_EXPORT2 ucmp32_getCount(const CompactIntArray* array); |
| |
| /** |
| * |
| * Get the address of the value array. |
| * @return the address of the value array |
| */ |
| CAPI const int32_t* U_EXPORT2 ucmp32_getArray(const CompactIntArray* array); |
| |
| /** |
| * |
| * Get the address of the index array. |
| * @return the address of the index array |
| */ |
| CAPI const uint16_t* U_EXPORT2 ucmp32_getIndex(const CompactIntArray* array); |
| |
| CAPI void U_EXPORT2 ucmp32_streamIn( CompactIntArray* array, FileStream* is); |
| CAPI void U_EXPORT2 ucmp32_streamOut(CompactIntArray* array, FileStream* os); |
| |
| |
| |
| |
| #endif |
| |
| |
| |
| |
| |