1 /*

     2 ******************************************************************************

     3 *   Copyright (C) 1997-2004, International Business Machines

     4 *   Corporation and others.  All Rights Reserved.

     5 ******************************************************************************

     6 *   Date        Name        Description

     7 *   03/22/00    aliu        Adapted from original C++ ICU Hashtable.

     8 *   07/06/01    aliu        Modified to support int32_t keys on

     9 *                           platforms with sizeof(void*) < 32.

    10 ******************************************************************************

    11 */

    12 

    13 #ifndef UHASH_H

    14 #define UHASH_H

    15 

    16 #include "unicode/utypes.h"

    17 

    18 /**

    19  * UHashtable stores key-value pairs and does moderately fast lookup

    20  * based on keys.  It provides a good tradeoff between access time and

    21  * storage space.  As elements are added to it, it grows to accomodate

    22  * them.  By default, the table never shrinks, even if all elements

    23  * are removed from it.

    24  *

    25  * Keys and values are stored as void* pointers.  These void* pointers

    26  * may be actual pointers to strings, objects, or any other structure

    27  * in memory, or they may simply be integral values cast to void*.

    28  * UHashtable doesn't care and manipulates them via user-supplied

    29  * functions.  These functions hash keys, compare keys, delete keys,

    30  * and delete values.  Some function pointers are optional (may be

    31  * NULL); others must be supplied.  Several prebuilt functions exist

    32  * to handle common key types.

    33  *

    34  * UHashtable ownership of keys and values is flexible, and controlled

    35  * by whether or not the key deleter and value deleter functions are

    36  * set.  If a void* key is actually a pointer to a deletable object,

    37  * then UHashtable can be made to delete that object by setting the

    38  * key deleter function pointer to a non-NULL value.  If this is done,

    39  * then keys passed to uhash_put() are owned by the hashtable and will

    40  * be deleted by it at some point, either as keys are replaced, or

    41  * when uhash_close() is finally called.  The same is true of values

    42  * and the value deleter function pointer.  Keys passed to methods

    43  * other than uhash_put() are never owned by the hashtable.

    44  *

    45  * NULL values are not allowed.  uhash_get() returns NULL to indicate

    46  * a key that is not in the table, and having a NULL value in the

    47  * table would generate an ambiguous result.  If a key and a NULL

    48  * value is passed to uhash_put(), this has the effect of doing a

    49  * uhash_remove() on that key.  This keeps uhash_get(), uhash_count(),

    50  * and uhash_nextElement() consistent with one another.

    51  *

    52  * To see everything in a hashtable, use uhash_nextElement() to

    53  * iterate through its contents.  Each call to this function returns a

    54  * UHashElement pointer.  A hash element contains a key, value, and

    55  * hashcode.  During iteration an element may be deleted by calling

    56  * uhash_removeElement(); iteration may safely continue thereafter.

    57  * The uhash_remove() function may also be safely called in

    58  * mid-iteration.  However, if uhash_put() is called during iteration

    59  * then the iteration will be out of sync.  Under no circumstances

    60  * should the UHashElement returned by uhash_nextElement be modified

    61  * directly.

    62  *

    63  * By default, the hashtable grows when necessary, but never shrinks,

    64  * even if all items are removed.  For most applications this is

    65  * optimal.  However, in a highly dynamic usage where memory is at a

    66  * premium, the table can be set to both grow and shrink by calling

    67  * uhash_setResizePolicy() with the policy U_GROW_AND_SHRINK.  In a

    68  * situation where memory is critical and the client wants a table

    69  * that does not grow at all, the constant U_FIXED can be used.

    70  */

    71 

    72 /********************************************************************

    73  * Data Structures

    74  ********************************************************************/

    75 

    76 U_CDECL_BEGIN

    77 

    78 /**

    79  * A key or value within the hashtable.  It may be either a 32-bit

    80  * integral value or an opaque void* pointer.  The void* pointer may

    81  * be smaller than 32 bits (e.g. 24 bits) or may be larger (e.g. 64

    82  * bits).  The hashing and comparison functions take a pointer to a

    83  * UHashTok, but the deleter receives the void* pointer within it.

    84  *

    85  * Because a UHashTok is the size of a native pointer or a 32-bit

    86  * integer, we pass it around by value.

    87  */

    88 union UHashTok {

    89     void*   pointer;

    90     int32_t integer;

    91 };

    92 typedef union UHashTok UHashTok;

    93 

    94 /**

    95  * This is a single hash element.

    96  */

    97 struct UHashElement {

    98     /* Reorder these elements to pack nicely if necessary */

    99     int32_t  hashcode;

   100     UHashTok value;

   101     UHashTok key;

   102 };

   103 typedef struct UHashElement UHashElement;

   104 

   105 /**

   106  * A hashing function.

   107  * @param key A key stored in a hashtable

   108  * @return A NON-NEGATIVE hash code for parm.

   109  */

   110 typedef int32_t U_CALLCONV UHashFunction(const UHashTok key);

   111 

   112 /**

   113  * A key comparison function.

   114  * @param key1 A key stored in a hashtable

   115  * @param key2 A key stored in a hashtable

   116  * @return TRUE if the two keys are equal.

   117  */

   118 typedef UBool U_CALLCONV UKeyComparator(const UHashTok key1,

   119                                         const UHashTok key2);

   120 

   121 /**

   122  * A function called by <TT>uhash_remove</TT>,

   123  * <TT>uhash_close</TT>, or <TT>uhash_put</TT> to delete

   124  * an existing key or value.

   125  * @param obj A key or value stored in a hashtable

   126  */

   127 typedef void U_CALLCONV UObjectDeleter(void* obj);

   128 

   129 /**

   130  * This specifies whether or not, and how, the hastable resizes itself.

   131  * See uhash_setResizePolicy().

   132  */

   133 enum UHashResizePolicy {

   134     U_GROW,            /* Grow on demand, do not shrink */

   135     U_GROW_AND_SHRINK, /* Grow and shrink on demand */

   136     U_FIXED            /* Never change size */

   137 };

   138 

   139 /**

   140  * The UHashtable struct.  Clients should treat this as an opaque data

   141  * type and manipulate it only through the uhash_... API.

   142  */

   143 struct UHashtable {

   144 

   145     /* Main key-value pair storage array */

   146 

   147     UHashElement *elements;

   148 

   149     /* Size parameters */

   150   

   151     int32_t     count;      /* The number of key-value pairs in this table.

   152                              * 0 <= count <= length.  In practice we

   153                              * never let count == length (see code). */

   154     int32_t     length;     /* The physical size of the arrays hashes, keys

   155                              * and values.  Must be prime. */

   156     int32_t     primeIndex;     /* Index into our prime table for length.

   157                                  * length == PRIMES[primeIndex] */

   158 

   159     /* Rehashing thresholds */

   160     

   161     int32_t     highWaterMark;  /* If count > highWaterMark, rehash */

   162     int32_t     lowWaterMark;   /* If count < lowWaterMark, rehash */

   163     float       highWaterRatio; /* 0..1; high water as a fraction of length */

   164     float       lowWaterRatio;  /* 0..1; low water as a fraction of length */

   165     

   166     /* Function pointers */

   167 

   168     UHashFunction *keyHasher;      /* Computes hash from key.

   169                                    * Never null. */

   170     UKeyComparator *keyComparator; /* Compares keys for equality.

   171                                    * Never null. */

   172     UObjectDeleter *keyDeleter;    /* Deletes keys when required.

   173                                    * If NULL won't do anything */

   174     UObjectDeleter *valueDeleter;  /* Deletes values when required.

   175                                    * If NULL won't do anything */

   176 };

   177 typedef struct UHashtable UHashtable;

   178 

   179 U_CDECL_END

   180 

   181 /********************************************************************

   182  * API

   183  ********************************************************************/

   184 

   185 /**

   186  * Initialize a new UHashtable.

   187  * @param keyHash A pointer to the key hashing function.  Must not be

   188  * NULL.

   189  * @param keyComp A pointer to the function that compares keys.  Must

   190  * not be NULL.

   191  * @param status A pointer to an UErrorCode to receive any errors.

   192  * @return A pointer to a UHashtable, or 0 if an error occurred.

   193  * @see uhash_openSize

   194  */

   195 U_CAPI UHashtable* U_EXPORT2 

   196 uhash_open(UHashFunction *keyHash,

   197            UKeyComparator *keyComp,

   198            UErrorCode *status);

   199 

   200 /**

   201  * Initialize a new UHashtable with a given initial size.

   202  * @param keyHash A pointer to the key hashing function.  Must not be

   203  * NULL.

   204  * @param keyComp A pointer to the function that compares keys.  Must

   205  * not be NULL.

   206  * @param size The initial capacity of this hash table.

   207  * @param status A pointer to an UErrorCode to receive any errors.

   208  * @return A pointer to a UHashtable, or 0 if an error occurred.

   209  * @see uhash_open

   210  */

   211 U_CAPI UHashtable* U_EXPORT2 

   212 uhash_openSize(UHashFunction *keyHash,

   213                UKeyComparator *keyComp,

   214                int32_t size,

   215                UErrorCode *status);

   216 

   217 /**

   218  * Close a UHashtable, releasing the memory used.

   219  * @param hash The UHashtable to close.

   220  */

   221 U_CAPI void U_EXPORT2 

   222 uhash_close(UHashtable *hash);

   223 

   224 

   225 

   226 /**

   227  * Set the function used to hash keys.

   228  * @param hash The UHashtable to set

   229  * @param fn the function to be used hash keys; must not be NULL

   230  * @return the previous key hasher; non-NULL

   231  */

   232 U_CAPI UHashFunction *U_EXPORT2 

   233 uhash_setKeyHasher(UHashtable *hash, UHashFunction *fn);

   234 

   235 /**

   236  * Set the function used to compare keys.  The default comparison is a

   237  * void* pointer comparison.

   238  * @param hash The UHashtable to set

   239  * @param fn the function to be used compare keys; must not be NULL

   240  * @return the previous key comparator; non-NULL

   241  */

   242 U_CAPI UKeyComparator *U_EXPORT2 

   243 uhash_setKeyComparator(UHashtable *hash, UKeyComparator *fn);

   244 

   245 /**

   246  * Set the function used to delete keys.  If this function pointer is

   247  * NULL, this hashtable does not delete keys.  If it is non-NULL, this

   248  * hashtable does delete keys.  This function should be set once

   249  * before any elements are added to the hashtable and should not be

   250  * changed thereafter.

   251  * @param hash The UHashtable to set

   252  * @param fn the function to be used delete keys, or NULL

   253  * @return the previous key deleter; may be NULL

   254  */

   255 U_CAPI UObjectDeleter *U_EXPORT2 

   256 uhash_setKeyDeleter(UHashtable *hash, UObjectDeleter *fn);

   257 

   258 /**

   259  * Set the function used to delete values.  If this function pointer

   260  * is NULL, this hashtable does not delete values.  If it is non-NULL,

   261  * this hashtable does delete values.  This function should be set

   262  * once before any elements are added to the hashtable and should not

   263  * be changed thereafter.

   264  * @param hash The UHashtable to set

   265  * @param fn the function to be used delete values, or NULL

   266  * @return the previous value deleter; may be NULL

   267  */

   268 U_CAPI UObjectDeleter *U_EXPORT2 

   269 uhash_setValueDeleter(UHashtable *hash, UObjectDeleter *fn);

   270 

   271 /**

   272  * Specify whether or not, and how, the hastable resizes itself.

   273  * By default, tables grow but do not shrink (policy U_GROW).

   274  * See enum UHashResizePolicy.

   275  * @param hash The UHashtable to set

   276  * @param policy The way the hashtable resizes itself, {U_GROW, U_GROW_AND_SHRINK, U_FIXED}

   277  */

   278 U_CAPI void U_EXPORT2 

   279 uhash_setResizePolicy(UHashtable *hash, enum UHashResizePolicy policy);

   280 

   281 /**

   282  * Get the number of key-value pairs stored in a UHashtable.

   283  * @param hash The UHashtable to query.

   284  * @return The number of key-value pairs stored in hash.

   285  */

   286 U_CAPI int32_t U_EXPORT2 

   287 uhash_count(const UHashtable *hash);

   288 

   289 /**

   290  * Put a (key=pointer, value=pointer) item in a UHashtable.  If the

   291  * keyDeleter is non-NULL, then the hashtable owns 'key' after this

   292  * call.  If the valueDeleter is non-NULL, then the hashtable owns

   293  * 'value' after this call.  Storing a NULL value is the same as

   294  * calling uhash_remove().

   295  * @param hash The target UHashtable.

   296  * @param key The key to store.

   297  * @param value The value to store, may be NULL (see above).

   298  * @param status A pointer to an UErrorCode to receive any errors.

   299  * @return The previous value, or NULL if none.

   300  * @see uhash_get

   301  */

   302 U_CAPI void* U_EXPORT2 

   303 uhash_put(UHashtable *hash,

   304           void *key,

   305           void *value,

   306           UErrorCode *status);

   307 

   308 /**

   309  * Put a (key=integer, value=pointer) item in a UHashtable.

   310  * keyDeleter must be NULL.  If the valueDeleter is non-NULL, then the

   311  * hashtable owns 'value' after this call.  Storing a NULL value is

   312  * the same as calling uhash_remove().

   313  * @param hash The target UHashtable.

   314  * @param key The integer key to store.

   315  * @param value The value to store, may be NULL (see above).

   316  * @param status A pointer to an UErrorCode to receive any errors.

   317  * @return The previous value, or NULL if none.

   318  * @see uhash_get

   319  */

   320 U_CAPI void* U_EXPORT2 

   321 uhash_iput(UHashtable *hash,

   322            int32_t key,

   323            void* value,

   324            UErrorCode *status);

   325 

   326 /**

   327  * Put a (key=pointer, value=integer) item in a UHashtable.  If the

   328  * keyDeleter is non-NULL, then the hashtable owns 'key' after this

   329  * call.  valueDeleter must be NULL.  Storing a 0 value is the same as

   330  * calling uhash_remove().

   331  * @param hash The target UHashtable.

   332  * @param key The key to store.

   333  * @param value The integer value to store.

   334  * @param status A pointer to an UErrorCode to receive any errors.

   335  * @return The previous value, or 0 if none.

   336  * @see uhash_get

   337  */

   338 U_CAPI int32_t U_EXPORT2 

   339 uhash_puti(UHashtable *hash,

   340            void* key,

   341            int32_t value,

   342            UErrorCode *status);

   343 

   344 /**

   345  * Put a (key=integer, value=integer) item in a UHashtable.  If the

   346  * keyDeleter is non-NULL, then the hashtable owns 'key' after this

   347  * call.  valueDeleter must be NULL.  Storing a 0 value is the same as

   348  * calling uhash_remove().

   349  * @param hash The target UHashtable.

   350  * @param key The key to store.

   351  * @param value The integer value to store.

   352  * @param status A pointer to an UErrorCode to receive any errors.

   353  * @return The previous value, or 0 if none.

   354  * @see uhash_get

   355  */

   356 U_CAPI int32_t U_EXPORT2 

   357 uhash_iputi(UHashtable *hash,

   358            int32_t key,

   359            int32_t value,

   360            UErrorCode *status);

   361 

   362 /**

   363  * Retrieve a pointer value from a UHashtable using a pointer key,

   364  * as previously stored by uhash_put().

   365  * @param hash The target UHashtable.

   366  * @param key A pointer key stored in a hashtable

   367  * @return The requested item, or NULL if not found.

   368  */

   369 U_CAPI void* U_EXPORT2 

   370 uhash_get(const UHashtable *hash, 

   371           const void *key);

   372 

   373 /**

   374  * Retrieve a pointer value from a UHashtable using a integer key,

   375  * as previously stored by uhash_iput().

   376  * @param hash The target UHashtable.

   377  * @param key An integer key stored in a hashtable

   378  * @return The requested item, or NULL if not found.

   379  */

   380 U_CAPI void* U_EXPORT2 

   381 uhash_iget(const UHashtable *hash,

   382            int32_t key);

   383 

   384 /**

   385  * Retrieve an integer value from a UHashtable using a pointer key,

   386  * as previously stored by uhash_puti().

   387  * @param hash The target UHashtable.

   388  * @param key A pointer key stored in a hashtable

   389  * @return The requested item, or 0 if not found.

   390  */

   391 U_CAPI int32_t U_EXPORT2 

   392 uhash_geti(const UHashtable *hash,

   393            const void* key);

   394 /**

   395  * Retrieve an integer value from a UHashtable using an integer key,

   396  * as previously stored by uhash_iputi().

   397  * @param hash The target UHashtable.

   398  * @param key An integer key stored in a hashtable

   399  * @return The requested item, or 0 if not found.

   400  */

   401 U_CAPI int32_t U_EXPORT2 

   402 uhash_igeti(const UHashtable *hash,

   403            int32_t key);

   404 

   405 /**

   406  * Remove an item from a UHashtable stored by uhash_put().

   407  * @param hash The target UHashtable.

   408  * @param key A key stored in a hashtable

   409  * @return The item removed, or NULL if not found.

   410  */

   411 U_CAPI void* U_EXPORT2 

   412 uhash_remove(UHashtable *hash,

   413              const void *key);

   414 

   415 /**

   416  * Remove an item from a UHashtable stored by uhash_iput().

   417  * @param hash The target UHashtable.

   418  * @param key An integer key stored in a hashtable

   419  * @return The item removed, or NULL if not found.

   420  */

   421 U_CAPI void* U_EXPORT2 

   422 uhash_iremove(UHashtable *hash,

   423               int32_t key);

   424 

   425 /**

   426  * Remove an item from a UHashtable stored by uhash_puti().

   427  * @param hash The target UHashtable.

   428  * @param key An key stored in a hashtable

   429  * @return The item removed, or 0 if not found.

   430  */

   431 U_CAPI int32_t U_EXPORT2 

   432 uhash_removei(UHashtable *hash,

   433               const void* key);

   434 

   435 /**

   436  * Remove an item from a UHashtable stored by uhash_iputi().

   437  * @param hash The target UHashtable.

   438  * @param key An integer key stored in a hashtable

   439  * @return The item removed, or 0 if not found.

   440  */

   441 U_CAPI int32_t U_EXPORT2 

   442 uhash_iremovei(UHashtable *hash,

   443                int32_t key);

   444 

   445 /**

   446  * Remove all items from a UHashtable.

   447  * @param hash The target UHashtable.

   448  */

   449 U_CAPI void U_EXPORT2 

   450 uhash_removeAll(UHashtable *hash);

   451 

   452 /**

   453  * Locate an element of a UHashtable.  The caller must not modify the

   454  * returned object.  The primary use of this function is to obtain the

   455  * stored key when it may not be identical to the search key.  For

   456  * example, if the compare function is a case-insensitive string

   457  * compare, then the hash key may be desired in order to obtain the

   458  * canonical case corresponding to a search key.

   459  * @param hash The target UHashtable.

   460  * @param key A key stored in a hashtable

   461  * @return a hash element, or NULL if the key is not found.

   462  */

   463 U_CAPI const UHashElement* U_EXPORT2 

   464 uhash_find(const UHashtable *hash, const void* key);

   465 

   466 /**

   467  * Iterate through the elements of a UHashtable.  The caller must not

   468  * modify the returned object.  However, uhash_removeElement() may be

   469  * called during iteration to remove an element from the table.

   470  * Iteration may safely be resumed afterwards.  If uhash_put() is

   471  * called during iteration the iteration will then be out of sync and

   472  * should be restarted.

   473  * @param hash The target UHashtable.

   474  * @param pos This should be set to -1 initially, and left untouched

   475  * thereafter.

   476  * @return a hash element, or NULL if no further key-value pairs

   477  * exist in the table.

   478  */

   479 U_CAPI const UHashElement* U_EXPORT2 

   480 uhash_nextElement(const UHashtable *hash,

   481                   int32_t *pos);

   482 

   483 /**

   484  * Remove an element, returned by uhash_nextElement(), from the table.

   485  * Iteration may be safely continued afterwards.

   486  * @param hash The hashtable

   487  * @param e The element, returned by uhash_nextElement(), to remove.

   488  * Must not be NULL.  Must not be an empty or deleted element (as long

   489  * as this was returned by uhash_nextElement() it will not be empty or

   490  * deleted).  Note: Although this parameter is const, it will be

   491  * modified.

   492  * @return the value that was removed.

   493  */

   494 U_CAPI void* U_EXPORT2 

   495 uhash_removeElement(UHashtable *hash, const UHashElement* e);

   496 

   497 /********************************************************************

   498  * UHashTok convenience

   499  ********************************************************************/

   500 

   501 /**

   502  * Return a UHashTok for an integer.

   503  * @param i The given integer

   504  * @return a UHashTok for an integer.

   505  */

   506 /*U_CAPI UHashTok U_EXPORT2 

   507 uhash_toki(int32_t i);*/

   508 

   509 /**

   510  * Return a UHashTok for a pointer.

   511  * @param p The given pointer

   512  * @return a UHashTok for a pointer.

   513  */

   514 /*U_CAPI UHashTok U_EXPORT2 

   515 uhash_tokp(void* p);*/

   516 

   517 /********************************************************************

   518  * UChar* and char* Support Functions

   519  ********************************************************************/

   520 

   521 /**

   522  * Generate a hash code for a null-terminated UChar* string.  If the

   523  * string is not null-terminated do not use this function.  Use

   524  * together with uhash_compareUChars.

   525  * @param key The string (const UChar*) to hash.

   526  * @return A hash code for the key.

   527  */

   528 U_CAPI int32_t U_EXPORT2 

   529 uhash_hashUChars(const UHashTok key);

   530 

   531 /**

   532  * Generate a hash code for a null-terminated char* string.  If the

   533  * string is not null-terminated do not use this function.  Use

   534  * together with uhash_compareChars.

   535  * @param key The string (const char*) to hash.

   536  * @return A hash code for the key.

   537  */

   538 U_CAPI int32_t U_EXPORT2 

   539 uhash_hashChars(const UHashTok key);

   540 

   541 /* Used by UnicodeString to compute its hashcode - Not public API. */

   542 U_CAPI int32_t U_EXPORT2 

   543 uhash_hashUCharsN(const UChar *key, int32_t length);

   544 

   545 /**

   546  * Generate a case-insensitive hash code for a null-terminated char*

   547  * string.  If the string is not null-terminated do not use this

   548  * function.  Use together with uhash_compareIChars.

   549  * @param key The string (const char*) to hash.

   550  * @return A hash code for the key.

   551  */

   552 U_CAPI int32_t U_EXPORT2

   553 uhash_hashIChars(const UHashTok key);

   554 

   555 /**

   556  * Comparator for null-terminated UChar* strings.  Use together with

   557  * uhash_hashUChars.

   558  * @param key1 The string for comparison

   559  * @param key2 The string for comparison

   560  * @return true if key1 and key2 are equal, return false otherwise.

   561  */

   562 U_CAPI UBool U_EXPORT2 

   563 uhash_compareUChars(const UHashTok key1, const UHashTok key2);

   564 

   565 /**

   566  * Comparator for null-terminated char* strings.  Use together with

   567  * uhash_hashChars.

   568  * @param key1 The string for comparison

   569  * @param key2 The string for comparison

   570  * @return true if key1 and key2 are equal, return false otherwise.

   571  */

   572 U_CAPI UBool U_EXPORT2 

   573 uhash_compareChars(const UHashTok key1, const UHashTok key2);

   574 

   575 /**

   576  * Case-insensitive comparator for null-terminated char* strings.  Use

   577  * together with uhash_hashIChars.

   578  * @param key1 The string for comparison

   579  * @param key2 The string for comparison

   580  * @return true if key1 and key2 are equal, return false otherwise.

   581  */

   582 U_CAPI UBool U_EXPORT2 

   583 uhash_compareIChars(const UHashTok key1, const UHashTok key2);

   584 

   585 /********************************************************************

   586  * UnicodeString Support Functions

   587  ********************************************************************/

   588 

   589 /**

   590  * Hash function for UnicodeString* keys.

   591  * @param key The string (const char*) to hash.

   592  * @return A hash code for the key.

   593  */

   594 U_CAPI int32_t U_EXPORT2 

   595 uhash_hashUnicodeString(const UHashTok key);

   596 

   597 /**

   598  * Hash function for UnicodeString* keys (case insensitive).

   599  * Make sure to use together with uhash_compareCaselessUnicodeString.

   600  * @param key The string (const char*) to hash.

   601  * @return A hash code for the key.

   602  */

   603 U_CAPI int32_t U_EXPORT2 

   604 uhash_hashCaselessUnicodeString(const UHashTok key);

   605 

   606 /**

   607  * Comparator function for UnicodeString* keys.

   608  * @param key1 The string for comparison

   609  * @param key2 The string for comparison

   610  * @return true if key1 and key2 are equal, return false otherwise.

   611  */

   612 U_CAPI UBool U_EXPORT2 

   613 uhash_compareUnicodeString(const UHashTok key1, const UHashTok key2);

   614 

   615 /**

   616  * Comparator function for UnicodeString* keys (case insensitive).

   617  * Make sure to use together with uhash_hashCaselessUnicodeString.

   618  * @param key1 The string for comparison

   619  * @param key2 The string for comparison

   620  * @return true if key1 and key2 are equal, return false otherwise.

   621  */

   622 U_CAPI UBool U_EXPORT2 

   623 uhash_compareCaselessUnicodeString(const UHashTok key1, const UHashTok key2);

   624 

   625 /**

   626  * Deleter function for UnicodeString* keys or values.

   627  * @param obj The object to be deleted

   628  */

   629 U_CAPI void U_EXPORT2 

   630 uhash_deleteUnicodeString(void *obj);

   631 

   632 /********************************************************************

   633  * int32_t Support Functions

   634  ********************************************************************/

   635 

   636 /**

   637  * Hash function for 32-bit integer keys.

   638  * @param key The string (const char*) to hash.

   639  * @return A hash code for the key.

   640  */

   641 U_CAPI int32_t U_EXPORT2 

   642 uhash_hashLong(const UHashTok key);

   643 

   644 /**

   645  * Comparator function for 32-bit integer keys.

   646  * @param key1 The integer for comparison

   647  * @param Key2 The integer for comparison

   648  * @return true if key1 and key2 are equal, return false otherwise

   649  */

   650 U_CAPI UBool U_EXPORT2 

   651 uhash_compareLong(const UHashTok key1, const UHashTok key2);

   652 

   653 /********************************************************************

   654  * Other Support Functions

   655  ********************************************************************/

   656 

   657 /**

   658  * Deleter for Hashtable objects.

   659  * @param obj The object to be deleted

   660  */

   661 U_CAPI void U_EXPORT2 

   662 uhash_deleteHashtable(void *obj);

   663 

   664 /**

   665  * Deleter for UVector objects.

   666  * @param obj The object to be deleted

   667  */

   668 U_CAPI void U_EXPORT2 

   669 uhash_deleteUVector(void *obj);

   670 

   671 /**

   672  * Deleter for any key or value allocated using uprv_malloc.  Calls

   673  * uprv_free.

   674  * @param obj The object to be deleted

   675  */

   676 U_CAPI void U_EXPORT2 

   677 uhash_freeBlock(void *obj);

   678 

   679 #endif