icuSources/common/uhash.h

   1 // © 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 ******************************************************************************
   5 *   Copyright (C) 1997-2016, International Business Machines
   6 *   Corporation and others.  All Rights Reserved.
   7 ******************************************************************************
   8 *   Date        Name        Description
   9 *   03/22/00    aliu        Adapted from original C++ ICU Hashtable.
  10 *   07/06/01    aliu        Modified to support int32_t keys on
  11 *                           platforms with sizeof(void*) < 32.
  12 ******************************************************************************
  13 */
  14
  15 #ifndef UHASH_H
  16 #define UHASH_H
  17
  18 #include "unicode/utypes.h"
  19 #include "cmemory.h"
  20 #include "uelement.h"
  21 #include "unicode/localpointer.h"
  22
  23 /**
  24  * UHashtable stores key-value pairs and does moderately fast lookup
  25  * based on keys.  It provides a good tradeoff between access time and
  26  * storage space.  As elements are added to it, it grows to accomodate
  27  * them.  By default, the table never shrinks, even if all elements
  28  * are removed from it.
  29  *
  30  * Keys and values are stored as void* pointers.  These void* pointers
  31  * may be actual pointers to strings, objects, or any other structure
  32  * in memory, or they may simply be integral values cast to void*.
  33  * UHashtable doesn't care and manipulates them via user-supplied
  34  * functions.  These functions hash keys, compare keys, delete keys,
  35  * and delete values.  Some function pointers are optional (may be
  36  * NULL); others must be supplied.  Several prebuilt functions exist
  37  * to handle common key types.
  38  *
  39  * UHashtable ownership of keys and values is flexible, and controlled
  40  * by whether or not the key deleter and value deleter functions are
  41  * set.  If a void* key is actually a pointer to a deletable object,
  42  * then UHashtable can be made to delete that object by setting the
  43  * key deleter function pointer to a non-NULL value.  If this is done,
  44  * then keys passed to uhash_put() are owned by the hashtable and will
  45  * be deleted by it at some point, either as keys are replaced, or
  46  * when uhash_close() is finally called.  The same is true of values
  47  * and the value deleter function pointer.  Keys passed to methods
  48  * other than uhash_put() are never owned by the hashtable.
  49  *
  50  * NULL values are not allowed.  uhash_get() returns NULL to indicate
  51  * a key that is not in the table, and having a NULL value in the
  52  * table would generate an ambiguous result.  If a key and a NULL
  53  * value is passed to uhash_put(), this has the effect of doing a
  54  * uhash_remove() on that key.  This keeps uhash_get(), uhash_count(),
  55  * and uhash_nextElement() consistent with one another.
  56  *
  57  * To see everything in a hashtable, use uhash_nextElement() to
  58  * iterate through its contents.  Each call to this function returns a
  59  * UHashElement pointer.  A hash element contains a key, value, and
  60  * hashcode.  During iteration an element may be deleted by calling
  61  * uhash_removeElement(); iteration may safely continue thereafter.
  62  * The uhash_remove() function may also be safely called in
  63  * mid-iteration.  If uhash_put() is called during iteration,
  64  * the iteration is still guaranteed to terminate reasonably, but
  65  * there is no guarantee that every element will be returned or that
  66  * some won't be returned more than once.
  67  *
  68  * Under no circumstances should the UHashElement returned by
  69  * uhash_nextElement be modified directly.
  70  *
  71  * By default, the hashtable grows when necessary, but never shrinks,
  72  * even if all items are removed.  For most applications this is
  73  * optimal.  However, in a highly dynamic usage where memory is at a
  74  * premium, the table can be set to both grow and shrink by calling
  75  * uhash_setResizePolicy() with the policy U_GROW_AND_SHRINK.  In a
  76  * situation where memory is critical and the client wants a table
  77  * that does not grow at all, the constant U_FIXED can be used.
  78  */
  79
  80 /********************************************************************
  81  * Data Structures
  82  ********************************************************************/
  83
  84 U_CDECL_BEGIN
  85
  86 /**
  87  * A key or value within a UHashtable.
  88  * The hashing and comparison functions take a pointer to a
  89  * UHashTok, but the deleter receives the void* pointer within it.
  90  */
  91 typedef UElement UHashTok;
  92
  93 /**
  94  * This is a single hash element.
  95  */
  96 struct UHashElement {
  97     /* Reorder these elements to pack nicely if necessary */
  98     int32_t  hashcode;
  99     UHashTok value;
 100     UHashTok key;
 101 };
 102 typedef struct UHashElement UHashElement;
 103
 104 /**
 105  * A hashing function.
 106  * @param key A key stored in a hashtable
 107  * @return A NON-NEGATIVE hash code for parm.
 108  */
 109 typedef int32_t U_CALLCONV UHashFunction(const UHashTok key);
 110
 111 /**
 112  * A key equality (boolean) comparison function.
 113  */
 114 typedef UElementsAreEqual UKeyComparator;
 115
 116 /**
 117  * A value equality (boolean) comparison function.
 118  */
 119 typedef UElementsAreEqual UValueComparator;
 120
 121 /* see cmemory.h for UObjectDeleter and uprv_deleteUObject() */
 122
 123 /**
 124  * This specifies whether or not, and how, the hastable resizes itself.
 125  * See uhash_setResizePolicy().
 126  */
 127 enum UHashResizePolicy {
 128     U_GROW,            /* Grow on demand, do not shrink */
 129     U_GROW_AND_SHRINK, /* Grow and shrink on demand */
 130     U_FIXED            /* Never change size */
 131 };
 132
 133 /**
 134  * The UHashtable struct.  Clients should treat this as an opaque data
 135  * type and manipulate it only through the uhash_... API.
 136  */
 137 struct UHashtable {
 138
 139     /* Main key-value pair storage array */
 140
 141     UHashElement *elements;
 142
 143     /* Function pointers */
 144
 145     UHashFunction *keyHasher;      /* Computes hash from key.
 146                                    * Never null. */
 147     UKeyComparator *keyComparator; /* Compares keys for equality.
 148                                    * Never null. */
 149     UValueComparator *valueComparator; /* Compares the values for equality */
 150
 151     UObjectDeleter *keyDeleter;    /* Deletes keys when required.
 152                                    * If NULL won't do anything */
 153     UObjectDeleter *valueDeleter;  /* Deletes values when required.
 154                                    * If NULL won't do anything */
 155
 156     /* Size parameters */
 157
 158     int32_t     count;      /* The number of key-value pairs in this table.
 159                              * 0 <= count <= length.  In practice we
 160                              * never let count == length (see code). */
 161     int32_t     length;     /* The physical size of the arrays hashes, keys
 162                              * and values.  Must be prime. */
 163
 164     /* Rehashing thresholds */
 165
 166     int32_t     highWaterMark;  /* If count > highWaterMark, rehash */
 167     int32_t     lowWaterMark;   /* If count < lowWaterMark, rehash */
 168     float       highWaterRatio; /* 0..1; high water as a fraction of length */
 169     float       lowWaterRatio;  /* 0..1; low water as a fraction of length */
 170
 171     int8_t      primeIndex;     /* Index into our prime table for length.
 172                                  * length == PRIMES[primeIndex] */
 173     UBool       allocated; /* Was this UHashtable allocated? */
 174 };
 175 typedef struct UHashtable UHashtable;
 176
 177 U_CDECL_END
 178
 179 /********************************************************************
 180  * API
 181  ********************************************************************/
 182
 183 /**
 184  * Initialize a new UHashtable.
 185  * @param keyHash A pointer to the key hashing function.  Must not be
 186  * NULL.
 187  * @param keyComp A pointer to the function that compares keys.  Must
 188  * not be NULL.
 189  * @param status A pointer to an UErrorCode to receive any errors.
 190  * @return A pointer to a UHashtable, or 0 if an error occurred.
 191  * @see uhash_openSize
 192  */
 193 U_CAPI UHashtable* U_EXPORT2
 194 uhash_open(UHashFunction *keyHash,
 195            UKeyComparator *keyComp,
 196            UValueComparator *valueComp,
 197            UErrorCode *status);
 198
 199 /**
 200  * Initialize a new UHashtable with a given initial size.
 201  * @param keyHash A pointer to the key hashing function.  Must not be
 202  * NULL.
 203  * @param keyComp A pointer to the function that compares keys.  Must
 204  * not be NULL.
 205  * @param size The initial capacity of this hash table.
 206  * @param status A pointer to an UErrorCode to receive any errors.
 207  * @return A pointer to a UHashtable, or 0 if an error occurred.
 208  * @see uhash_open
 209  */
 210 U_CAPI UHashtable* U_EXPORT2
 211 uhash_openSize(UHashFunction *keyHash,
 212                UKeyComparator *keyComp,
 213                UValueComparator *valueComp,
 214                int32_t size,
 215                UErrorCode *status);
 216
 217 /**
 218  * Initialize an existing UHashtable.
 219  * @param keyHash A pointer to the key hashing function.  Must not be
 220  * NULL.
 221  * @param keyComp A pointer to the function that compares keys.  Must
 222  * not be NULL.
 223  * @param status A pointer to an UErrorCode to receive any errors.
 224  * @return A pointer to a UHashtable, or 0 if an error occurred.
 225  * @see uhash_openSize
 226  */
 227 U_CAPI UHashtable* U_EXPORT2
 228 uhash_init(UHashtable *hash,
 229            UHashFunction *keyHash,
 230            UKeyComparator *keyComp,
 231            UValueComparator *valueComp,
 232            UErrorCode *status);
 233
 234 /**
 235  * Initialize an existing UHashtable.
 236  * @param keyHash A pointer to the key hashing function.  Must not be
 237  * NULL.
 238  * @param keyComp A pointer to the function that compares keys.  Must
 239  * not be NULL.
 240  * @param size The initial capacity of this hash table.
 241  * @param status A pointer to an UErrorCode to receive any errors.
 242  * @return A pointer to a UHashtable, or 0 if an error occurred.
 243  * @see uhash_openSize
 244  */
 245 U_CAPI UHashtable* U_EXPORT2
 246 uhash_initSize(UHashtable *hash,
 247                UHashFunction *keyHash,
 248                UKeyComparator *keyComp,
 249                UValueComparator *valueComp,
 250                int32_t size,
 251                UErrorCode *status);
 252
 253 /**
 254  * Close a UHashtable, releasing the memory used.
 255  * @param hash The UHashtable to close. If hash is NULL no operation is performed.
 256  */
 257 U_CAPI void U_EXPORT2
 258 uhash_close(UHashtable *hash);
 259
 260
 261
 262 /**
 263  * Set the function used to hash keys.
 264  * @param hash The UHashtable to set
 265  * @param fn the function to be used hash keys; must not be NULL
 266  * @return the previous key hasher; non-NULL
 267  */
 268 U_CAPI UHashFunction *U_EXPORT2
 269 uhash_setKeyHasher(UHashtable *hash, UHashFunction *fn);
 270
 271 /**
 272  * Set the function used to compare keys.  The default comparison is a
 273  * void* pointer comparison.
 274  * @param hash The UHashtable to set
 275  * @param fn the function to be used compare keys; must not be NULL
 276  * @return the previous key comparator; non-NULL
 277  */
 278 U_CAPI UKeyComparator *U_EXPORT2
 279 uhash_setKeyComparator(UHashtable *hash, UKeyComparator *fn);
 280
 281 /**
 282  * Set the function used to compare values.  The default comparison is a
 283  * void* pointer comparison.
 284  * @param hash The UHashtable to set
 285  * @param fn the function to be used compare keys; must not be NULL
 286  * @return the previous key comparator; non-NULL
 287  */
 288 U_CAPI UValueComparator *U_EXPORT2
 289 uhash_setValueComparator(UHashtable *hash, UValueComparator *fn);
 290
 291 /**
 292  * Set the function used to delete keys.  If this function pointer is
 293  * NULL, this hashtable does not delete keys.  If it is non-NULL, this
 294  * hashtable does delete keys.  This function should be set once
 295  * before any elements are added to the hashtable and should not be
 296  * changed thereafter.
 297  * @param hash The UHashtable to set
 298  * @param fn the function to be used delete keys, or NULL
 299  * @return the previous key deleter; may be NULL
 300  */
 301 U_CAPI UObjectDeleter *U_EXPORT2
 302 uhash_setKeyDeleter(UHashtable *hash, UObjectDeleter *fn);
 303
 304 /**
 305  * Set the function used to delete values.  If this function pointer
 306  * is NULL, this hashtable does not delete values.  If it is non-NULL,
 307  * this hashtable does delete values.  This function should be set
 308  * once before any elements are added to the hashtable and should not
 309  * be changed thereafter.
 310  * @param hash The UHashtable to set
 311  * @param fn the function to be used delete values, or NULL
 312  * @return the previous value deleter; may be NULL
 313  */
 314 U_CAPI UObjectDeleter *U_EXPORT2
 315 uhash_setValueDeleter(UHashtable *hash, UObjectDeleter *fn);
 316
 317 /**
 318  * Specify whether or not, and how, the hastable resizes itself.
 319  * By default, tables grow but do not shrink (policy U_GROW).
 320  * See enum UHashResizePolicy.
 321  * @param hash The UHashtable to set
 322  * @param policy The way the hashtable resizes itself, {U_GROW, U_GROW_AND_SHRINK, U_FIXED}
 323  */
 324 U_CAPI void U_EXPORT2
 325 uhash_setResizePolicy(UHashtable *hash, enum UHashResizePolicy policy);
 326
 327 /**
 328  * Get the number of key-value pairs stored in a UHashtable.
 329  * @param hash The UHashtable to query.
 330  * @return The number of key-value pairs stored in hash.
 331  */
 332 U_CAPI int32_t U_EXPORT2
 333 uhash_count(const UHashtable *hash);
 334
 335 /**
 336  * Put a (key=pointer, value=pointer) item in a UHashtable.  If the
 337  * keyDeleter is non-NULL, then the hashtable owns 'key' after this
 338  * call.  If the valueDeleter is non-NULL, then the hashtable owns
 339  * 'value' after this call.  Storing a NULL value is the same as
 340  * calling uhash_remove().
 341  * @param hash The target UHashtable.
 342  * @param key The key to store.
 343  * @param value The value to store, may be NULL (see above).
 344  * @param status A pointer to an UErrorCode to receive any errors.
 345  * @return The previous value, or NULL if none.
 346  * @see uhash_get
 347  */
 348 U_CAPI void* U_EXPORT2
 349 uhash_put(UHashtable *hash,
 350           void *key,
 351           void *value,
 352           UErrorCode *status);
 353
 354 /**
 355  * Put a (key=integer, value=pointer) item in a UHashtable.
 356  * keyDeleter must be NULL.  If the valueDeleter is non-NULL, then the
 357  * hashtable owns 'value' after this call.  Storing a NULL value is
 358  * the same as calling uhash_remove().
 359  * @param hash The target UHashtable.
 360  * @param key The integer key to store.
 361  * @param value The value to store, may be NULL (see above).
 362  * @param status A pointer to an UErrorCode to receive any errors.
 363  * @return The previous value, or NULL if none.
 364  * @see uhash_get
 365  */
 366 U_CAPI void* U_EXPORT2
 367 uhash_iput(UHashtable *hash,
 368            int32_t key,
 369            void* value,
 370            UErrorCode *status);
 371
 372 /**
 373  * Put a (key=pointer, value=integer) item in a UHashtable.  If the
 374  * keyDeleter is non-NULL, then the hashtable owns 'key' after this
 375  * call.  valueDeleter must be NULL.  Storing a 0 value is the same as
 376  * calling uhash_remove().
 377  * @param hash The target UHashtable.
 378  * @param key The key to store.
 379  * @param value The integer value to store.
 380  * @param status A pointer to an UErrorCode to receive any errors.
 381  * @return The previous value, or 0 if none.
 382  * @see uhash_get
 383  */
 384 U_CAPI int32_t U_EXPORT2
 385 uhash_puti(UHashtable *hash,
 386            void* key,
 387            int32_t value,
 388            UErrorCode *status);
 389
 390 /**
 391  * Put a (key=integer, value=integer) item in a UHashtable.  If the
 392  * keyDeleter is non-NULL, then the hashtable owns 'key' after this
 393  * call.  valueDeleter must be NULL.  Storing a 0 value is the same as
 394  * calling uhash_remove().
 395  * @param hash The target UHashtable.
 396  * @param key The key to store.
 397  * @param value The integer value to store.
 398  * @param status A pointer to an UErrorCode to receive any errors.
 399  * @return The previous value, or 0 if none.
 400  * @see uhash_get
 401  */
 402 U_CAPI int32_t U_EXPORT2
 403 uhash_iputi(UHashtable *hash,
 404            int32_t key,
 405            int32_t value,
 406            UErrorCode *status);
 407
 408 /**
 409  * Retrieve a pointer value from a UHashtable using a pointer key,
 410  * as previously stored by uhash_put().
 411  * @param hash The target UHashtable.
 412  * @param key A pointer key stored in a hashtable
 413  * @return The requested item, or NULL if not found.
 414  */
 415 U_CAPI void* U_EXPORT2
 416 uhash_get(const UHashtable *hash,
 417           const void *key);
 418
 419 /**
 420  * Retrieve a pointer value from a UHashtable using a integer key,
 421  * as previously stored by uhash_iput().
 422  * @param hash The target UHashtable.
 423  * @param key An integer key stored in a hashtable
 424  * @return The requested item, or NULL if not found.
 425  */
 426 U_CAPI void* U_EXPORT2
 427 uhash_iget(const UHashtable *hash,
 428            int32_t key);
 429
 430 /**
 431  * Retrieve an integer value from a UHashtable using a pointer key,
 432  * as previously stored by uhash_puti().
 433  * @param hash The target UHashtable.
 434  * @param key A pointer key stored in a hashtable
 435  * @return The requested item, or 0 if not found.
 436  */
 437 U_CAPI int32_t U_EXPORT2
 438 uhash_geti(const UHashtable *hash,
 439            const void* key);
 440 /**
 441  * Retrieve an integer value from a UHashtable using an integer key,
 442  * as previously stored by uhash_iputi().
 443  * @param hash The target UHashtable.
 444  * @param key An integer key stored in a hashtable
 445  * @return The requested item, or 0 if not found.
 446  */
 447 U_CAPI int32_t U_EXPORT2
 448 uhash_igeti(const UHashtable *hash,
 449            int32_t key);
 450
 451 /**
 452  * Remove an item from a UHashtable stored by uhash_put().
 453  * @param hash The target UHashtable.
 454  * @param key A key stored in a hashtable
 455  * @return The item removed, or NULL if not found.
 456  */
 457 U_CAPI void* U_EXPORT2
 458 uhash_remove(UHashtable *hash,
 459              const void *key);
 460
 461 /**
 462  * Remove an item from a UHashtable stored by uhash_iput().
 463  * @param hash The target UHashtable.
 464  * @param key An integer key stored in a hashtable
 465  * @return The item removed, or NULL if not found.
 466  */
 467 U_CAPI void* U_EXPORT2
 468 uhash_iremove(UHashtable *hash,
 469               int32_t key);
 470
 471 /**
 472  * Remove an item from a UHashtable stored by uhash_puti().
 473  * @param hash The target UHashtable.
 474  * @param key An key stored in a hashtable
 475  * @return The item removed, or 0 if not found.
 476  */
 477 U_CAPI int32_t U_EXPORT2
 478 uhash_removei(UHashtable *hash,
 479               const void* key);
 480
 481 /**
 482  * Remove an item from a UHashtable stored by uhash_iputi().
 483  * @param hash The target UHashtable.
 484  * @param key An integer key stored in a hashtable
 485  * @return The item removed, or 0 if not found.
 486  */
 487 U_CAPI int32_t U_EXPORT2
 488 uhash_iremovei(UHashtable *hash,
 489                int32_t key);
 490
 491 /**
 492  * Remove all items from a UHashtable.
 493  * @param hash The target UHashtable.
 494  */
 495 U_CAPI void U_EXPORT2
 496 uhash_removeAll(UHashtable *hash);
 497
 498 /**
 499  * Locate an element of a UHashtable.  The caller must not modify the
 500  * returned object.  The primary use of this function is to obtain the
 501  * stored key when it may not be identical to the search key.  For
 502  * example, if the compare function is a case-insensitive string
 503  * compare, then the hash key may be desired in order to obtain the
 504  * canonical case corresponding to a search key.
 505  * @param hash The target UHashtable.
 506  * @param key A key stored in a hashtable
 507  * @return a hash element, or NULL if the key is not found.
 508  */
 509 U_CAPI const UHashElement* U_EXPORT2
 510 uhash_find(const UHashtable *hash, const void* key);
 511
 512 /**
 513  * \def UHASH_FIRST
 514  * Constant for use with uhash_nextElement
 515  * @see uhash_nextElement
 516  */
 517 #define UHASH_FIRST (-1)
 518
 519 /**
 520  * Iterate through the elements of a UHashtable.  The caller must not
 521  * modify the returned object.  However, uhash_removeElement() may be
 522  * called during iteration to remove an element from the table.
 523  * Iteration may safely be resumed afterwards.  If uhash_put() is
 524  * called during iteration the iteration will then be out of sync and
 525  * should be restarted.
 526  * @param hash The target UHashtable.
 527  * @param pos This should be set to UHASH_FIRST initially, and left untouched
 528  * thereafter.
 529  * @return a hash element, or NULL if no further key-value pairs
 530  * exist in the table.
 531  */
 532 U_CAPI const UHashElement* U_EXPORT2
 533 uhash_nextElement(const UHashtable *hash,
 534                   int32_t *pos);
 535
 536 /**
 537  * Remove an element, returned by uhash_nextElement(), from the table.
 538  * Iteration may be safely continued afterwards.
 539  * @param hash The hashtable
 540  * @param e The element, returned by uhash_nextElement(), to remove.
 541  * Must not be NULL.  Must not be an empty or deleted element (as long
 542  * as this was returned by uhash_nextElement() it will not be empty or
 543  * deleted).  Note: Although this parameter is const, it will be
 544  * modified.
 545  * @return the value that was removed.
 546  */
 547 U_CAPI void* U_EXPORT2
 548 uhash_removeElement(UHashtable *hash, const UHashElement* e);
 549
 550 /********************************************************************
 551  * UHashTok convenience
 552  ********************************************************************/
 553
 554 /**
 555  * Return a UHashTok for an integer.
 556  * @param i The given integer
 557  * @return a UHashTok for an integer.
 558  */
 559 /*U_CAPI UHashTok U_EXPORT2
 560 uhash_toki(int32_t i);*/
 561
 562 /**
 563  * Return a UHashTok for a pointer.
 564  * @param p The given pointer
 565  * @return a UHashTok for a pointer.
 566  */
 567 /*U_CAPI UHashTok U_EXPORT2
 568 uhash_tokp(void* p);*/
 569
 570 /********************************************************************
 571  * UChar* and char* Support Functions
 572  ********************************************************************/
 573
 574 /**
 575  * Generate a hash code for a null-terminated UChar* string.  If the
 576  * string is not null-terminated do not use this function.  Use
 577  * together with uhash_compareUChars.
 578  * @param key The string (const UChar*) to hash.
 579  * @return A hash code for the key.
 580  */
 581 U_CAPI int32_t U_EXPORT2
 582 uhash_hashUChars(const UHashTok key);
 583
 584 /**
 585  * Generate a hash code for a null-terminated char* string.  If the
 586  * string is not null-terminated do not use this function.  Use
 587  * together with uhash_compareChars.
 588  * @param key The string (const char*) to hash.
 589  * @return A hash code for the key.
 590  */
 591 U_CAPI int32_t U_EXPORT2
 592 uhash_hashChars(const UHashTok key);
 593
 594 /**
 595  * Generate a case-insensitive hash code for a null-terminated char*
 596  * string.  If the string is not null-terminated do not use this
 597  * function.  Use together with uhash_compareIChars.
 598  * @param key The string (const char*) to hash.
 599  * @return A hash code for the key.
 600  */
 601 U_CAPI int32_t U_EXPORT2
 602 uhash_hashIChars(const UHashTok key);
 603
 604 /**
 605  * Comparator for null-terminated UChar* strings.  Use together with
 606  * uhash_hashUChars.
 607  * @param key1 The string for comparison
 608  * @param key2 The string for comparison
 609  * @return true if key1 and key2 are equal, return false otherwise.
 610  */
 611 U_CAPI UBool U_EXPORT2
 612 uhash_compareUChars(const UHashTok key1, const UHashTok key2);
 613
 614 /**
 615  * Comparator for null-terminated char* strings.  Use together with
 616  * uhash_hashChars.
 617  * @param key1 The string for comparison
 618  * @param key2 The string for comparison
 619  * @return true if key1 and key2 are equal, return false otherwise.
 620  */
 621 U_CAPI UBool U_EXPORT2
 622 uhash_compareChars(const UHashTok key1, const UHashTok key2);
 623
 624 /**
 625  * Case-insensitive comparator for null-terminated char* strings.  Use
 626  * together with uhash_hashIChars.
 627  * @param key1 The string for comparison
 628  * @param key2 The string for comparison
 629  * @return true if key1 and key2 are equal, return false otherwise.
 630  */
 631 U_CAPI UBool U_EXPORT2
 632 uhash_compareIChars(const UHashTok key1, const UHashTok key2);
 633
 634 /********************************************************************
 635  * UnicodeString Support Functions
 636  ********************************************************************/
 637
 638 /**
 639  * Hash function for UnicodeString* keys.
 640  * @param key The string (const char*) to hash.
 641  * @return A hash code for the key.
 642  */
 643 U_CAPI int32_t U_EXPORT2
 644 uhash_hashUnicodeString(const UElement key);
 645
 646 /**
 647  * Hash function for UnicodeString* keys (case insensitive).
 648  * Make sure to use together with uhash_compareCaselessUnicodeString.
 649  * @param key The string (const char*) to hash.
 650  * @return A hash code for the key.
 651  */
 652 U_CAPI int32_t U_EXPORT2
 653 uhash_hashCaselessUnicodeString(const UElement key);
 654
 655 /********************************************************************
 656  * int32_t Support Functions
 657  ********************************************************************/
 658
 659 /**
 660  * Hash function for 32-bit integer keys.
 661  * @param key The string (const char*) to hash.
 662  * @return A hash code for the key.
 663  */
 664 U_CAPI int32_t U_EXPORT2
 665 uhash_hashLong(const UHashTok key);
 666
 667 /**
 668  * Comparator function for 32-bit integer keys.
 669  * @param key1 The integer for comparison
 670  * @param Key2 The integer for comparison
 671  * @return true if key1 and key2 are equal, return false otherwise
 672  */
 673 U_CAPI UBool U_EXPORT2
 674 uhash_compareLong(const UHashTok key1, const UHashTok key2);
 675
 676 /********************************************************************
 677  * Other Support Functions
 678  ********************************************************************/
 679
 680 /**
 681  * Deleter for Hashtable objects.
 682  * @param obj The object to be deleted
 683  */
 684 U_CAPI void U_EXPORT2
 685 uhash_deleteHashtable(void *obj);
 686
 687 /* Use uprv_free() itself as a deleter for any key or value allocated using uprv_malloc. */
 688
 689 /**
 690  * Checks if the given hash tables are equal or not.
 691  * @param hash1
 692  * @param hash2
 693  * @return true if the hashtables are equal and false if not.
 694  */
 695 U_CAPI UBool U_EXPORT2
 696 uhash_equals(const UHashtable* hash1, const UHashtable* hash2);
 697
 698
 699 #if U_SHOW_CPLUSPLUS_API
 700
 701 U_NAMESPACE_BEGIN
 702
 703 /**
 704  * \class LocalUHashtablePointer
 705  * "Smart pointer" class, closes a UHashtable via uhash_close().
 706  * For most methods see the LocalPointerBase base class.
 707  *
 708  * @see LocalPointerBase
 709  * @see LocalPointer
 710  * @stable ICU 4.4
 711  */
 712 U_DEFINE_LOCAL_OPEN_POINTER(LocalUHashtablePointer, UHashtable, uhash_close);
 713
 714 U_NAMESPACE_END
 715
 716 #endif // U_SHOW_CPLUSPLUS_API
 717
 718 #endif