ICU-62107.0.1.tar.gz

[apple/icu.git] / icuSources / common / uhash.h

diff --git a/icuSources/common/uhash.h b/icuSources/common/uhash.h
index b5f3a67db3fec0f44f75fecaec5337e62473fb69..e423454c034191578e545163701a2b5476094171 100644 (file)
--- a/icuSources/common/uhash.h
+++ b/icuSources/common/uhash.h
@@ -1,6 +1,8 @@
+// © 2016 and later: Unicode, Inc. and others.
+// License & terms of use: http://www.unicode.org/copyright.html

 /*
 ******************************************************************************
 /*
 ******************************************************************************

-*   Copyright (C) 1997-2006, International Business Machines
+*   Copyright (C) 1997-2015, International Business Machines

 *   Corporation and others.  All Rights Reserved.
 ******************************************************************************
 *   Date        Name        Description
 *   Corporation and others.  All Rights Reserved.
 ******************************************************************************
 *   Date        Name        Description


@@ -14,6 +16,9 @@
 #define UHASH_H
 
 #include "unicode/utypes.h"
 #define UHASH_H
 
 #include "unicode/utypes.h"

+#include "cmemory.h"
+#include "uelement.h"
+#include "unicode/localpointer.h"

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


@@ -55,10 +60,13 @@
  * hashcode.  During iteration an element may be deleted by calling
  * uhash_removeElement(); iteration may safely continue thereafter.
  * The uhash_remove() function may also be safely called in
  * hashcode.  During iteration an element may be deleted by calling
  * uhash_removeElement(); iteration may safely continue thereafter.
  * The uhash_remove() function may also be safely called in

- * mid-iteration.  However, if uhash_put() is called during iteration
- * then the iteration will be out of sync.  Under no circumstances
- * should the UHashElement returned by uhash_nextElement be modified
- * directly.
+ * mid-iteration.  If uhash_put() is called during iteration,
+ * the iteration is still guaranteed to terminate reasonably, but
+ * there is no guarantee that every element will be returned or that
+ * some won't be returned more than once.
+ *
+ * Under no circumstances should the UHashElement returned by
+ * uhash_nextElement be modified directly.

  *
  * By default, the hashtable grows when necessary, but never shrinks,
  * even if all items are removed.  For most applications this is
  *
  * By default, the hashtable grows when necessary, but never shrinks,
  * even if all items are removed.  For most applications this is


@@ -76,20 +84,11 @@
 U_CDECL_BEGIN
 
 /**
 U_CDECL_BEGIN
 
 /**

- * A key or value within the hashtable.  It may be either a 32-bit
- * integral value or an opaque void* pointer.  The void* pointer may
- * be smaller than 32 bits (e.g. 24 bits) or may be larger (e.g. 64
- * bits).  The hashing and comparison functions take a pointer to a
+ * A key or value within a UHashtable.
+ * The hashing and comparison functions take a pointer to a

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

- *
- * Because a UHashTok is the size of a native pointer or a 32-bit
- * integer, we pass it around by value.

  */
  */

-union UHashTok {
-    void*   pointer;
-    int32_t integer;
-};
-typedef union UHashTok UHashTok;
+typedef UElement UHashTok;

 
 /**
  * This is a single hash element.
 
 /**
  * This is a single hash element.


@@ -110,28 +109,16 @@ typedef struct UHashElement UHashElement;
 typedef int32_t U_CALLCONV UHashFunction(const UHashTok key);
 
 /**
 typedef int32_t U_CALLCONV UHashFunction(const UHashTok key);
 
 /**

- * A key comparison function.
- * @param key1 A key stored in a hashtable
- * @param key2 A key stored in a hashtable
- * @return TRUE if the two keys are equal.
- */
-typedef UBool U_CALLCONV UKeyComparator(const UHashTok key1,
-                                        const UHashTok key2);
-/**
- * A key comparison function.
- * @param val1 A key stored in a hashtable
- * @param val2 A key stored in a hashtable
- * @return TRUE if the two keys are equal.
+ * A key equality (boolean) comparison function.

  */
  */

-typedef UBool U_CALLCONV UValueComparator(const UHashTok val1,
-                                          const UHashTok val2);
+typedef UElementsAreEqual UKeyComparator;
+

 /**
 /**

- * A function called by <TT>uhash_remove</TT>,
- * <TT>uhash_close</TT>, or <TT>uhash_put</TT> to delete
- * an existing key or value.
- * @param obj A key or value stored in a hashtable
+ * A value equality (boolean) comparison function.

  */
  */

-typedef void U_CALLCONV UObjectDeleter(void* obj);
+typedef UElementsAreEqual UValueComparator;
+
+/* see cmemory.h for UObjectDeleter and uprv_deleteUObject() */

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


@@ -167,22 +154,22 @@ struct UHashtable {
                                    * If NULL won't do anything */
 
     /* Size parameters */
                                    * If NULL won't do anything */
 
     /* Size parameters */

-  
+

     int32_t     count;      /* The number of key-value pairs in this table.
                              * 0 <= count <= length.  In practice we
                              * never let count == length (see code). */
     int32_t     length;     /* The physical size of the arrays hashes, keys
                              * and values.  Must be prime. */
     int32_t     count;      /* The number of key-value pairs in this table.
                              * 0 <= count <= length.  In practice we
                              * never let count == length (see code). */
     int32_t     length;     /* The physical size of the arrays hashes, keys
                              * and values.  Must be prime. */

-    int32_t     primeIndex;     /* Index into our prime table for length.
-                                 * length == PRIMES[primeIndex] */

 
     /* Rehashing thresholds */
 
     /* Rehashing thresholds */

-    
+

     int32_t     highWaterMark;  /* If count > highWaterMark, rehash */
     int32_t     lowWaterMark;   /* If count < lowWaterMark, rehash */
     float       highWaterRatio; /* 0..1; high water as a fraction of length */
     float       lowWaterRatio;  /* 0..1; low water as a fraction of length */
     int32_t     highWaterMark;  /* If count > highWaterMark, rehash */
     int32_t     lowWaterMark;   /* If count < lowWaterMark, rehash */
     float       highWaterRatio; /* 0..1; high water as a fraction of length */
     float       lowWaterRatio;  /* 0..1; low water as a fraction of length */

-    
+
+    int8_t      primeIndex;     /* Index into our prime table for length.
+                                 * length == PRIMES[primeIndex] */

     UBool       allocated; /* Was this UHashtable allocated? */
 };
 typedef struct UHashtable UHashtable;
     UBool       allocated; /* Was this UHashtable allocated? */
 };
 typedef struct UHashtable UHashtable;


@@ -203,7 +190,7 @@ U_CDECL_END
  * @return A pointer to a UHashtable, or 0 if an error occurred.
  * @see uhash_openSize
  */
  * @return A pointer to a UHashtable, or 0 if an error occurred.
  * @see uhash_openSize
  */

-U_CAPI UHashtable* U_EXPORT2 
+U_CAPI UHashtable* U_EXPORT2

 uhash_open(UHashFunction *keyHash,
            UKeyComparator *keyComp,
            UValueComparator *valueComp,
 uhash_open(UHashFunction *keyHash,
            UKeyComparator *keyComp,
            UValueComparator *valueComp,


@@ -220,7 +207,7 @@ uhash_open(UHashFunction *keyHash,
  * @return A pointer to a UHashtable, or 0 if an error occurred.
  * @see uhash_open
  */
  * @return A pointer to a UHashtable, or 0 if an error occurred.
  * @see uhash_open
  */

-U_CAPI UHashtable* U_EXPORT2 
+U_CAPI UHashtable* U_EXPORT2

 uhash_openSize(UHashFunction *keyHash,
                UKeyComparator *keyComp,
                UValueComparator *valueComp,
 uhash_openSize(UHashFunction *keyHash,
                UKeyComparator *keyComp,
                UValueComparator *valueComp,


@@ -237,18 +224,37 @@ uhash_openSize(UHashFunction *keyHash,
  * @return A pointer to a UHashtable, or 0 if an error occurred.
  * @see uhash_openSize
  */
  * @return A pointer to a UHashtable, or 0 if an error occurred.
  * @see uhash_openSize
  */

-U_CAPI UHashtable* U_EXPORT2 
+U_CAPI UHashtable* U_EXPORT2

 uhash_init(UHashtable *hash,
            UHashFunction *keyHash,
            UKeyComparator *keyComp,
            UValueComparator *valueComp,
            UErrorCode *status);
 
 uhash_init(UHashtable *hash,
            UHashFunction *keyHash,
            UKeyComparator *keyComp,
            UValueComparator *valueComp,
            UErrorCode *status);
 

+/**
+ * Initialize an existing UHashtable.
+ * @param keyHash A pointer to the key hashing function.  Must not be
+ * NULL.
+ * @param keyComp A pointer to the function that compares keys.  Must
+ * not be NULL.
+ * @param size The initial capacity of this hash table.
+ * @param status A pointer to an UErrorCode to receive any errors.
+ * @return A pointer to a UHashtable, or 0 if an error occurred.
+ * @see uhash_openSize
+ */
+U_CAPI UHashtable* U_EXPORT2
+uhash_initSize(UHashtable *hash,
+               UHashFunction *keyHash,
+               UKeyComparator *keyComp,
+               UValueComparator *valueComp,
+               int32_t size,
+               UErrorCode *status);
+

 /**
  * Close a UHashtable, releasing the memory used.
 /**
  * Close a UHashtable, releasing the memory used.

- * @param hash The UHashtable to close.
+ * @param hash The UHashtable to close. If hash is NULL no operation is performed.

  */
  */

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uhash_close(UHashtable *hash);
 
 
 uhash_close(UHashtable *hash);
 
 


@@ -259,7 +265,7 @@ uhash_close(UHashtable *hash);
  * @param fn the function to be used hash keys; must not be NULL
  * @return the previous key hasher; non-NULL
  */
  * @param fn the function to be used hash keys; must not be NULL
  * @return the previous key hasher; non-NULL
  */

-U_CAPI UHashFunction *U_EXPORT2 
+U_CAPI UHashFunction *U_EXPORT2

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


@@ -269,7 +275,7 @@ uhash_setKeyHasher(UHashtable *hash, UHashFunction *fn);
  * @param fn the function to be used compare keys; must not be NULL
  * @return the previous key comparator; non-NULL
  */
  * @param fn the function to be used compare keys; must not be NULL
  * @return the previous key comparator; non-NULL
  */

-U_CAPI UKeyComparator *U_EXPORT2 
+U_CAPI UKeyComparator *U_EXPORT2

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


@@ -279,7 +285,7 @@ uhash_setKeyComparator(UHashtable *hash, UKeyComparator *fn);
  * @param fn the function to be used compare keys; must not be NULL
  * @return the previous key comparator; non-NULL
  */
  * @param fn the function to be used compare keys; must not be NULL
  * @return the previous key comparator; non-NULL
  */

-U_CAPI UValueComparator *U_EXPORT2 
+U_CAPI UValueComparator *U_EXPORT2

 uhash_setValueComparator(UHashtable *hash, UValueComparator *fn);
 
 /**
 uhash_setValueComparator(UHashtable *hash, UValueComparator *fn);
 
 /**


@@ -292,7 +298,7 @@ uhash_setValueComparator(UHashtable *hash, UValueComparator *fn);
  * @param fn the function to be used delete keys, or NULL
  * @return the previous key deleter; may be NULL
  */
  * @param fn the function to be used delete keys, or NULL
  * @return the previous key deleter; may be NULL
  */

-U_CAPI UObjectDeleter *U_EXPORT2 
+U_CAPI UObjectDeleter *U_EXPORT2

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


@@ -305,7 +311,7 @@ uhash_setKeyDeleter(UHashtable *hash, UObjectDeleter *fn);
  * @param fn the function to be used delete values, or NULL
  * @return the previous value deleter; may be NULL
  */
  * @param fn the function to be used delete values, or NULL
  * @return the previous value deleter; may be NULL
  */

-U_CAPI UObjectDeleter *U_EXPORT2 
+U_CAPI UObjectDeleter *U_EXPORT2

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


@@ -315,7 +321,7 @@ uhash_setValueDeleter(UHashtable *hash, UObjectDeleter *fn);
  * @param hash The UHashtable to set
  * @param policy The way the hashtable resizes itself, {U_GROW, U_GROW_AND_SHRINK, U_FIXED}
  */
  * @param hash The UHashtable to set
  * @param policy The way the hashtable resizes itself, {U_GROW, U_GROW_AND_SHRINK, U_FIXED}
  */

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

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


@@ -323,7 +329,7 @@ uhash_setResizePolicy(UHashtable *hash, enum UHashResizePolicy policy);
  * @param hash The UHashtable to query.
  * @return The number of key-value pairs stored in hash.
  */
  * @param hash The UHashtable to query.
  * @return The number of key-value pairs stored in hash.
  */

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uhash_count(const UHashtable *hash);
 
 /**
 uhash_count(const UHashtable *hash);
 
 /**


@@ -339,7 +345,7 @@ uhash_count(const UHashtable *hash);
  * @return The previous value, or NULL if none.
  * @see uhash_get
  */
  * @return The previous value, or NULL if none.
  * @see uhash_get
  */

-U_CAPI void* U_EXPORT2 
+U_CAPI void* U_EXPORT2

 uhash_put(UHashtable *hash,
           void *key,
           void *value,
 uhash_put(UHashtable *hash,
           void *key,
           void *value,


@@ -357,7 +363,7 @@ uhash_put(UHashtable *hash,
  * @return The previous value, or NULL if none.
  * @see uhash_get
  */
  * @return The previous value, or NULL if none.
  * @see uhash_get
  */

-U_CAPI void* U_EXPORT2 
+U_CAPI void* U_EXPORT2

 uhash_iput(UHashtable *hash,
            int32_t key,
            void* value,
 uhash_iput(UHashtable *hash,
            int32_t key,
            void* value,


@@ -375,7 +381,7 @@ uhash_iput(UHashtable *hash,
  * @return The previous value, or 0 if none.
  * @see uhash_get
  */
  * @return The previous value, or 0 if none.
  * @see uhash_get
  */

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uhash_puti(UHashtable *hash,
            void* key,
            int32_t value,
 uhash_puti(UHashtable *hash,
            void* key,
            int32_t value,


@@ -393,7 +399,7 @@ uhash_puti(UHashtable *hash,
  * @return The previous value, or 0 if none.
  * @see uhash_get
  */
  * @return The previous value, or 0 if none.
  * @see uhash_get
  */

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uhash_iputi(UHashtable *hash,
            int32_t key,
            int32_t value,
 uhash_iputi(UHashtable *hash,
            int32_t key,
            int32_t value,


@@ -406,8 +412,8 @@ uhash_iputi(UHashtable *hash,
  * @param key A pointer key stored in a hashtable
  * @return The requested item, or NULL if not found.
  */
  * @param key A pointer key stored in a hashtable
  * @return The requested item, or NULL if not found.
  */

-U_CAPI void* U_EXPORT2 
-uhash_get(const UHashtable *hash, 
+U_CAPI void* U_EXPORT2
+uhash_get(const UHashtable *hash,

           const void *key);
 
 /**
           const void *key);
 
 /**


@@ -417,7 +423,7 @@ uhash_get(const UHashtable *hash,
  * @param key An integer key stored in a hashtable
  * @return The requested item, or NULL if not found.
  */
  * @param key An integer key stored in a hashtable
  * @return The requested item, or NULL if not found.
  */

-U_CAPI void* U_EXPORT2 
+U_CAPI void* U_EXPORT2

 uhash_iget(const UHashtable *hash,
            int32_t key);
 
 uhash_iget(const UHashtable *hash,
            int32_t key);
 


@@ -428,7 +434,7 @@ uhash_iget(const UHashtable *hash,
  * @param key A pointer key stored in a hashtable
  * @return The requested item, or 0 if not found.
  */
  * @param key A pointer key stored in a hashtable
  * @return The requested item, or 0 if not found.
  */

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uhash_geti(const UHashtable *hash,
            const void* key);
 /**
 uhash_geti(const UHashtable *hash,
            const void* key);
 /**


@@ -438,7 +444,7 @@ uhash_geti(const UHashtable *hash,
  * @param key An integer key stored in a hashtable
  * @return The requested item, or 0 if not found.
  */
  * @param key An integer key stored in a hashtable
  * @return The requested item, or 0 if not found.
  */

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uhash_igeti(const UHashtable *hash,
            int32_t key);
 
 uhash_igeti(const UHashtable *hash,
            int32_t key);
 


@@ -448,7 +454,7 @@ uhash_igeti(const UHashtable *hash,
  * @param key A key stored in a hashtable
  * @return The item removed, or NULL if not found.
  */
  * @param key A key stored in a hashtable
  * @return The item removed, or NULL if not found.
  */

-U_CAPI void* U_EXPORT2 
+U_CAPI void* U_EXPORT2

 uhash_remove(UHashtable *hash,
              const void *key);
 
 uhash_remove(UHashtable *hash,
              const void *key);
 


@@ -458,7 +464,7 @@ uhash_remove(UHashtable *hash,
  * @param key An integer key stored in a hashtable
  * @return The item removed, or NULL if not found.
  */
  * @param key An integer key stored in a hashtable
  * @return The item removed, or NULL if not found.
  */

-U_CAPI void* U_EXPORT2 
+U_CAPI void* U_EXPORT2

 uhash_iremove(UHashtable *hash,
               int32_t key);
 
 uhash_iremove(UHashtable *hash,
               int32_t key);
 


@@ -468,7 +474,7 @@ uhash_iremove(UHashtable *hash,
  * @param key An key stored in a hashtable
  * @return The item removed, or 0 if not found.
  */
  * @param key An key stored in a hashtable
  * @return The item removed, or 0 if not found.
  */

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uhash_removei(UHashtable *hash,
               const void* key);
 
 uhash_removei(UHashtable *hash,
               const void* key);
 


@@ -478,7 +484,7 @@ uhash_removei(UHashtable *hash,
  * @param key An integer key stored in a hashtable
  * @return The item removed, or 0 if not found.
  */
  * @param key An integer key stored in a hashtable
  * @return The item removed, or 0 if not found.
  */

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uhash_iremovei(UHashtable *hash,
                int32_t key);
 
 uhash_iremovei(UHashtable *hash,
                int32_t key);
 


@@ -486,7 +492,7 @@ uhash_iremovei(UHashtable *hash,
  * Remove all items from a UHashtable.
  * @param hash The target UHashtable.
  */
  * Remove all items from a UHashtable.
  * @param hash The target UHashtable.
  */

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uhash_removeAll(UHashtable *hash);
 
 /**
 uhash_removeAll(UHashtable *hash);
 
 /**


@@ -500,9 +506,16 @@ uhash_removeAll(UHashtable *hash);
  * @param key A key stored in a hashtable
  * @return a hash element, or NULL if the key is not found.
  */
  * @param key A key stored in a hashtable
  * @return a hash element, or NULL if the key is not found.
  */

-U_CAPI const UHashElement* U_EXPORT2 
+U_CAPI const UHashElement* U_EXPORT2

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

+/**
+ * \def UHASH_FIRST
+ * Constant for use with uhash_nextElement
+ * @see uhash_nextElement
+ */
+#define UHASH_FIRST (-1)
+

 /**
  * Iterate through the elements of a UHashtable.  The caller must not
  * modify the returned object.  However, uhash_removeElement() may be
 /**
  * Iterate through the elements of a UHashtable.  The caller must not
  * modify the returned object.  However, uhash_removeElement() may be


@@ -511,12 +524,12 @@ uhash_find(const UHashtable *hash, const void* key);
  * called during iteration the iteration will then be out of sync and
  * should be restarted.
  * @param hash The target UHashtable.
  * called during iteration the iteration will then be out of sync and
  * should be restarted.
  * @param hash The target UHashtable.

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

  * thereafter.
  * @return a hash element, or NULL if no further key-value pairs
  * exist in the table.
  */
  * thereafter.
  * @return a hash element, or NULL if no further key-value pairs
  * exist in the table.
  */

-U_CAPI const UHashElement* U_EXPORT2 
+U_CAPI const UHashElement* U_EXPORT2

 uhash_nextElement(const UHashtable *hash,
                   int32_t *pos);
 
 uhash_nextElement(const UHashtable *hash,
                   int32_t *pos);
 


@@ -531,7 +544,7 @@ uhash_nextElement(const UHashtable *hash,
  * modified.
  * @return the value that was removed.
  */
  * modified.
  * @return the value that was removed.
  */

-U_CAPI void* U_EXPORT2 
+U_CAPI void* U_EXPORT2

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


@@ -543,7 +556,7 @@ uhash_removeElement(UHashtable *hash, const UHashElement* e);
  * @param i The given integer
  * @return a UHashTok for an integer.
  */
  * @param i The given integer
  * @return a UHashTok for an integer.
  */

-/*U_CAPI UHashTok U_EXPORT2 
+/*U_CAPI UHashTok U_EXPORT2

 uhash_toki(int32_t i);*/
 
 /**
 uhash_toki(int32_t i);*/
 
 /**


@@ -551,7 +564,7 @@ uhash_toki(int32_t i);*/
  * @param p The given pointer
  * @return a UHashTok for a pointer.
  */
  * @param p The given pointer
  * @return a UHashTok for a pointer.
  */

-/*U_CAPI UHashTok U_EXPORT2 
+/*U_CAPI UHashTok U_EXPORT2

 uhash_tokp(void* p);*/
 
 /********************************************************************
 uhash_tokp(void* p);*/
 
 /********************************************************************


@@ -565,7 +578,7 @@ uhash_tokp(void* p);*/
  * @param key The string (const UChar*) to hash.
  * @return A hash code for the key.
  */
  * @param key The string (const UChar*) to hash.
  * @return A hash code for the key.
  */

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uhash_hashUChars(const UHashTok key);
 
 /**
 uhash_hashUChars(const UHashTok key);
 
 /**


@@ -575,13 +588,9 @@ uhash_hashUChars(const UHashTok key);
  * @param key The string (const char*) to hash.
  * @return A hash code for the key.
  */
  * @param key The string (const char*) to hash.
  * @return A hash code for the key.
  */

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uhash_hashChars(const UHashTok key);
 
 uhash_hashChars(const UHashTok key);
 

-/* Used by UnicodeString to compute its hashcode - Not public API. */
-U_CAPI int32_t U_EXPORT2 
-uhash_hashUCharsN(const UChar *key, int32_t length);
-

 /**
  * Generate a case-insensitive hash code for a null-terminated char*
  * string.  If the string is not null-terminated do not use this
 /**
  * Generate a case-insensitive hash code for a null-terminated char*
  * string.  If the string is not null-terminated do not use this


@@ -599,7 +608,7 @@ uhash_hashIChars(const UHashTok key);
  * @param key2 The string for comparison
  * @return true if key1 and key2 are equal, return false otherwise.
  */
  * @param key2 The string for comparison
  * @return true if key1 and key2 are equal, return false otherwise.
  */

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uhash_compareUChars(const UHashTok key1, const UHashTok key2);
 
 /**
 uhash_compareUChars(const UHashTok key1, const UHashTok key2);
 
 /**


@@ -609,7 +618,7 @@ uhash_compareUChars(const UHashTok key1, const UHashTok key2);
  * @param key2 The string for comparison
  * @return true if key1 and key2 are equal, return false otherwise.
  */
  * @param key2 The string for comparison
  * @return true if key1 and key2 are equal, return false otherwise.
  */

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uhash_compareChars(const UHashTok key1, const UHashTok key2);
 
 /**
 uhash_compareChars(const UHashTok key1, const UHashTok key2);
 
 /**


@@ -619,7 +628,7 @@ uhash_compareChars(const UHashTok key1, const UHashTok key2);
  * @param key2 The string for comparison
  * @return true if key1 and key2 are equal, return false otherwise.
  */
  * @param key2 The string for comparison
  * @return true if key1 and key2 are equal, return false otherwise.
  */

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uhash_compareIChars(const UHashTok key1, const UHashTok key2);
 
 /********************************************************************
 uhash_compareIChars(const UHashTok key1, const UHashTok key2);
 
 /********************************************************************


@@ -631,8 +640,8 @@ uhash_compareIChars(const UHashTok key1, const UHashTok key2);
  * @param key The string (const char*) to hash.
  * @return A hash code for the key.
  */
  * @param key The string (const char*) to hash.
  * @return A hash code for the key.
  */

-U_CAPI int32_t U_EXPORT2 
-uhash_hashUnicodeString(const UHashTok key);
+U_CAPI int32_t U_EXPORT2
+uhash_hashUnicodeString(const UElement key);

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


@@ -640,34 +649,8 @@ uhash_hashUnicodeString(const UHashTok key);
  * @param key The string (const char*) to hash.
  * @return A hash code for the key.
  */
  * @param key The string (const char*) to hash.
  * @return A hash code for the key.
  */

-U_CAPI int32_t U_EXPORT2 
-uhash_hashCaselessUnicodeString(const UHashTok key);
-
-/**
- * Comparator function for UnicodeString* keys.
- * @param key1 The string for comparison
- * @param key2 The string for comparison
- * @return true if key1 and key2 are equal, return false otherwise.
- */
-U_CAPI UBool U_EXPORT2 
-uhash_compareUnicodeString(const UHashTok key1, const UHashTok key2);
-
-/**
- * Comparator function for UnicodeString* keys (case insensitive).
- * Make sure to use together with uhash_hashCaselessUnicodeString.
- * @param key1 The string for comparison
- * @param key2 The string for comparison
- * @return true if key1 and key2 are equal, return false otherwise.
- */
-U_CAPI UBool U_EXPORT2 
-uhash_compareCaselessUnicodeString(const UHashTok key1, const UHashTok key2);
-
-/**
- * Deleter function for UnicodeString* keys or values.
- * @param obj The object to be deleted
- */
-U_CAPI void U_EXPORT2 
-uhash_deleteUnicodeString(void *obj);
+U_CAPI int32_t U_EXPORT2
+uhash_hashCaselessUnicodeString(const UElement key);

 
 /********************************************************************
  * int32_t Support Functions
 
 /********************************************************************
  * int32_t Support Functions


@@ -678,7 +661,7 @@ uhash_deleteUnicodeString(void *obj);
  * @param key The string (const char*) to hash.
  * @return A hash code for the key.
  */
  * @param key The string (const char*) to hash.
  * @return A hash code for the key.
  */

-U_CAPI int32_t U_EXPORT2 
+U_CAPI int32_t U_EXPORT2

 uhash_hashLong(const UHashTok key);
 
 /**
 uhash_hashLong(const UHashTok key);
 
 /**


@@ -687,7 +670,7 @@ uhash_hashLong(const UHashTok key);
  * @param Key2 The integer for comparison
  * @return true if key1 and key2 are equal, return false otherwise
  */
  * @param Key2 The integer for comparison
  * @return true if key1 and key2 are equal, return false otherwise
  */

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uhash_compareLong(const UHashTok key1, const UHashTok key2);
 
 /********************************************************************
 uhash_compareLong(const UHashTok key1, const UHashTok key2);
 
 /********************************************************************


@@ -698,23 +681,10 @@ uhash_compareLong(const UHashTok key1, const UHashTok key2);
  * Deleter for Hashtable objects.
  * @param obj The object to be deleted
  */
  * Deleter for Hashtable objects.
  * @param obj The object to be deleted
  */

-U_CAPI void U_EXPORT2 
+U_CAPI void U_EXPORT2

 uhash_deleteHashtable(void *obj);
 
 uhash_deleteHashtable(void *obj);
 

-/**
- * Deleter for UVector objects.
- * @param obj The object to be deleted
- */
-U_CAPI void U_EXPORT2 
-uhash_deleteUVector(void *obj);
-
-/**
- * Deleter for any key or value allocated using uprv_malloc.  Calls
- * uprv_free.
- * @param obj The object to be deleted
- */
-U_CAPI void U_EXPORT2 
-uhash_freeBlock(void *obj);
+/* Use uprv_free() itself as a deleter for any key or value allocated using uprv_malloc. */

 
 /**
  * Checks if the given hash tables are equal or not.
 
 /**
  * Checks if the given hash tables are equal or not.


@@ -722,7 +692,27 @@ uhash_freeBlock(void *obj);
  * @param hash2
  * @return true if the hashtables are equal and false if not.
  */
  * @param hash2
  * @return true if the hashtables are equal and false if not.
  */

-U_CAPI UBool U_EXPORT2 
+U_CAPI UBool U_EXPORT2

 uhash_equals(const UHashtable* hash1, const UHashtable* hash2);
 
 uhash_equals(const UHashtable* hash1, const UHashtable* hash2);
 

+
+#if U_SHOW_CPLUSPLUS_API
+
+U_NAMESPACE_BEGIN
+
+/**
+ * \class LocalUHashtablePointer
+ * "Smart pointer" class, closes a UHashtable via uhash_close().
+ * For most methods see the LocalPointerBase base class.
+ *
+ * @see LocalPointerBase
+ * @see LocalPointer
+ * @stable ICU 4.4
+ */
+U_DEFINE_LOCAL_OPEN_POINTER(LocalUHashtablePointer, UHashtable, uhash_close);
+
+U_NAMESPACE_END
+
+#endif // U_SHOW_CPLUSPLUS_API
+

 #endif
 #endif