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-2015, 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 717 718 #endif 719