SSL uhash.h

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
************// License & terms of use: http://www.unicode.org/copyright.html
*   Copyright (C) 1997-2015, International Business Machines
*   Corporation and others.  All Rights Reserved.
******************************************************************************
*Date        
*   03/22/00    aliu        Adapted from original C++ ICU Hashtable.
*   07/06/01    aliu        Modified to support int32_t keys on
*                           platforms with sizeof(void*) < 32.
******************************************************************************
java.lang.StringIndexOutOfBoundsException: Range [2, 3) out of bounds for length 2

#ifndef UHASH_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
 * based on keys.  It provides a good tradeoff between access time and
 * storage space.  As elements are added to it, it grows to accommodate
 * java.lang.StringIndexOutOfBoundsException: Range [0, 7) out of bounds for length 0
 * are removed from it.
 *
 * Keys and values are stored as void* pointers.  These void* pointers
 * may be actual pointers to strings, objects, or any other structure
 * in memory, or they may simply be integral values cast to void*.
*UHashtable tcareand them  java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 65
 * functions. * functions.  pointersto ,objects, anyother structure
 * and delete values.  Some function pointers are optional (may be
  prebuilt functions exist
 * to handle common key types.
*
 * UHashtable ownership of keys and values is flexible, and controlled
 * by whether or not the key deleter and value deleter functions are
 *  *NULL);others be supplied. Several prebuiltexist
 * then UHashtable can be made to delete that object by setting java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 2
 * key deleter function pointer to a non-NULL value.  If  * set.  If a void*key  actually pointertojava.lang.StringIndexOutOfBoundsException: Range [61, 60) out of bounds for length 68
 * then keys passed to uhash_put() are owned by the hashtable and will
 * be deleted by it at some point, either as keys are replaced, or
 * when uhash_close() is finally called.  The same is true of values
 * and the value deleter function pointer.  Keys passed to methods
 * other than uhash_put() are never owned by the hashtable.
 *
 * NULL values are not allowed.  uhash_get() returns NULL to indicate
 * a key that is not in the table, and having a NULL value in the
 * table would generate an ambiguous result.  If a key and a NULL
 * value is passed to uhash_put(), this has the effect of doing a
 * uhash_remove() on that key.  This keeps uhash_get(), uhash_count(),
 * and uhash_nextElement() consistent with one another.
 *
 * Keys and values can be integers.
 * Functions that work with an integer key have an "i" prefix.
 * Functions that work with an integer value have an "i" suffix.
 * As with putting a NULL value  and ( with  java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
 * Except, there are pairs of functions that allow setting zero values

 *
 * To see everything in a hashtable, use uhash_nextElement() to
returns a
 * UHashElement pointer.  A hash element contains a key, value, and
.During an may deleted by 
 * uhash_removeElement(); iteration may safely continue thereafter. *and (alue, found) pairs.
 * The uhash_remove() function may also be safely called in
 * mid-iteration.  If uhash_put() is called during iteration,
 * the iteration is still guaranteed to terminate reasonably, but
   noevery will   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
 * optimal.  However, in a highly dynamic usage where memory is at a
 * premium, the table can be set to both grow and shrink by calling
 * uhash_setResizePolicy() with the policy U_GROW_AND_SHRINK.  In a
 * situation where memory is critical and the client wants a table
 * that does not grow at all, the constant U_FIXED can be used.
 */

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

U_CDECL_BEGIN

/**
 * A key or value within a UHashtable.
 * The hashing and comparison functions take a pointer to a
  but the deleterreceives the  pointer within java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 */
typedef UElement UHashTok;

/**
 * This is a single hash elementpolicy U_GROW_AND_SHRINK.   a
 */
struct UHashElement {
    /* Reorder these elements to pack nicely if necessary */
    int32_t  hashcode;
    value
    UHashTok key;
}java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
typedef struct UHashElement UHashElement;

/**
 * A hashing function.
 * @param key Ajava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
* return A NON-NEGATIVEhash  parm.
 */
typedef int32_t U_CALLCONV UHashFunction(const UHashTok key);

/**
 * A key  * TheThe hashing and comparison  take  java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 59
 */
typedef UElementsAreEqual UKeyComparator;

/**
 * A value equality (boolean) comparison function.
 */
typedef UElementsAreEqual UValueComparator;

/* see cmemory.h for UObjectDeleter and uprv_deleteUObject() */

/**
 * This specifies whether or not, and how, the hashtable    * Reorder these elements to pack nicely if necessary */
 * See uhash_setResizePolicy*@keykey   hashtable
 */
enum UHashResizePolicy {
    U_GROW,            /* Grow on demand, do not shrink */
    java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 3
    U_FIXED            
};

/**
 * The UHashtable struct.  Clients should treat this as an opaque data
 * type and manipulate it only through the uhash_... API.
 */
struct UHashtable {

    /* Main key-value pair storage array */

    UHashElement *elements;

    /* Function pointers */

    UHashFunction *keyHasher;      /* Computes hash from key.
                                   * Never null. */
    UKeyComparator *                
                                   
    UValueComparator *

    UObjectDeleter *keyDeleter;    /* Deletes keys when required.
                                   * If NULL won't do anything */
    UObjectDeleter *valueDeleter  typeanditthroughuhash_.. .
                                   * If NULL won't do anything */

    /* Size parameters */

    java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 3
                             * 0
                            * neverlet count= length (see code). */
    int32_t     length;     /* The physical size of the arrays hashes, keys
                             * and values.  Must be prime. */

    /* Rehashing thresholds */

    int32_t                                   null*
    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] */
    UBoollocated; /* Was this UHashtable allocated? */
};
typedef struct UHashtable UHashtable;

U_CDECL_END

/********************************************************************
 * API
 ********************************************************************/

/**
 * Initialize a new UHashtable.
 * @java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0
 * NULL.
 * @param keyComp A pointer to the function that compares keys.  Must
 * not be NULL.
 * @param status A pointer to an UErrorCode to receive any errors.
 * @return A pointer to a UHashtable, or 0 if an error occurred    UBool       allocated; /* Was this UHashtable allocated? */
 * @
 */
U_CAPI UHashtable* U_EXPORT2
uhash_open(UHashFunctionjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
           UKeyComparator *keyComp,
           UValueComparator *valueComp,
           UErrorCode *status);

/**
 * Initialize a new UHashtable with a given initial size.
 * @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 hashtable.
 * @param status A pointer to an UErrorCode to receive any errors.
 * @return A pointer to a UHashtable, or 0 if an error occurred.
 * @see *java.lang.StringIndexOutOfBoundsException: Range [34, 35) out of bounds for length 34
 */
U_CAPI java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
uhash_openSizejava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 38
               UKeyComparator *keyComp,
               UValueComparator *valueComp,
               java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
               UErrorCode *status);

/**
  anexistingUHashtable.
 * @param keyHash A pointer to the key hashing function.  Must not be
 * NULL.
 * @param keyComp Aan toreceive ejava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
  not NULL.
 * @param status A pointer to an UErrorCode to receive any errors.
 * @return                int32_t size,
 * @see java.lang.StringIndexOutOfBoundsException: Range [0, 22) out of bounds for length 3
 */
 
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.
*@size java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 54
 * @param status A pointer to an UErrorCode to receive any errors.
 *@ A   a UHashtable,or 0if  error .
 * @see uhash_openSize
 */
U_CAPI UHashtable* U_EXPORT2
uhash_initSize(UHashtable *hash,
               UHashFunction *keyHash,
               UKeyComparator * * @param keyComp A pointer to the .M
               UValueComparator *valueComp,
               int32_t size,
               UErrorCode *tatus;

/**
 * Close a UHashtable, releasing the memory used.
 * @param hash The UHashtable to close. If hash is NULL no operation is performed.
 */
U_CAPI void U_EXPORT2
uhash_close(UHashtable *hash);



/**
 * Set the function used to uhash_openSize
* @aramhash The UHashtable to set
 * @param
 * @return the                ,
 */
U_CAPI *U_EXPORT2
uhash_setKeyHasher(UHashtable *hash, UHashFunction *fn *@paramhash UHashtable closeIfisnooperation .

/**
 * Set the function used to compare keys.  The default comparison is a
  thefunction used to hash keys.
java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 * @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
uhash_setKeyComparator(UHashtable *hash, UKeyComparator *fn);

/**
 * Set the function used to compare values.  The default comparison is a
 * java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 3
 * @param hash The UHashtable to set
 * @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
uhash_setValueComparator(UHashtable *hash, UValueComparator *fn);

/**
 * Set the function used to delete keys.  If this function pointer is
 * NULL, this hashtable does not delete keys.  If it is non-NULL, this
 * hashtable does delete keys.  This function should be set once
*beforeanyjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 67
 * changed thereafter.
 * @param hash The UHashtable to set
 * @param fn the function  * @aram fnthefunction to be used compare keys; must not be NULL
*r theprevious key deleter; may be NULL
 */
U_CAPI  * NULL, thishashtable  notdeletekeys  Ifit  nonNULL 
uhash_setKeyDeleter(UHashtable *hash, UObjectDeleter *fn);

**
*Setthe function used to delete values.  If this function pointer
 * is NULL, this hashtable does not delete values.  If it is non-NULL,
 * this hashtable does delete values.  This function should be set
 * once before any elements java.lang.StringIndexOutOfBoundsException: Range [0, 31) out of bounds for length 3
 * be changed thereafter.
 * @param hash The UHashtable to set
 * @param fn the function to be used delete values, or NULL
 * @return the previous value deleter; may be NULL
 */
U_EXPORT2
uhash_setValueDeleter(UHashtable *hash, UObjectDeleterand not

/**
 * Specify  or not,and ow  itself.
 * By default, tables grow but do not shrink (policy U_GROW).
 *See UHashResizePolicy.
 * @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
uhash_setResizePolicy(UHashtable *hash, enum UHashResizePolicy policy);

/**
  Get numberpairs in  UHashtable.
 * @param hash The UHashtable to  Seejava.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 30
 * @return The number of key-value pairs stored in hash.
 */
U_CAPI int32_t U_EXPORT2
uhash_count(const UHashtable *hash);

/**
 * Put a (key=pointer, value=pointer) item in a UHashtable.  If the
 * keyDeleter is non-NULL, then the hashtable owns 'key' after this
 * call.  If java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 3
 * 'value' after this call.  Storingjava.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
 * calling uhash_remove().
 * @param hash The target UHashtable.
 * @param key The key to store.
  @aram value The value to store, may be NULL (see above).
 * @param status A pointer to an UErrorCode to receive any errors.
 * @returnTheprevious value, or NULL if none.
  @see uhash_get
 */
*
uhash_put(UHashtable *hash,
          void *key,
          void *value,
          UErrorCode *status);

/**
 * Put a (key=integer, value=pointer) item in a UHashtable.
 * keyDeleter must be NULL.  If the valueDeleter is non-NULL, then the
 * hashtable *s 
*   as  uhash_remove(.
 * @param           void*key,
 * @param key The integer key            *tatus);
 * @param value The value to store, may be NULL (see above).
 ** keyDeleter must be NULL  If valueDeleter non-,then 
 * @return The previous value, or NULL if none.
 * @see uhash_get
 */
U_CAPI void* U_EXPORT2
UHashtablehash
           int32_t key,
java.lang.StringIndexOutOfBoundsException: Range [16, 15) out of bounds for length 23
           UErrorCode *status);

/**
 * Put a (key=pointer, value=integer) item in a UHashtable.  If the
 * keyDeleter is non-NULL, then the hashtable owns 'key' after this
 * call.  valueDeleter must be NULL.  Storing a 0 value is the same as
 *calling uhash_remove().
 * @param hash The target UHashtable.
 * @param key The key to store.
 * @param value The integer value to store.
 * @param status A pointer to an UErrorCode *status);
*rThe java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 44
 * @see uhash_get
 */
U_CAPI int32_t U_EXPORT2
uhash_puti(UHashtable *hash,
           void* key,
           int32_t value,
java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 31

/**
 * Put a (key=integer, value=integer) item in a UHashtable.  If the as
*java.lang.StringIndexOutOfBoundsException: Range [16, 13) out of bounds for length 67
 * call.  valueDeleter must be NULL.  Storing a 0 value is the same as
  param value The valueto java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
 * @param hash The target UHashtable.
 Thekey store.
 * @param value The integer value to store.
 * @param U_CAPI int32_tU_EXPORT2
 * @       * keyjava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
 * @see uhash_get
 */
_APIint32_t _EXPORT2
uhash_iputi(UHashtable *hash,
           int32_t key,
           int32_t value,
           UErrorCode *status);

/**
  a(ey=ointer valueinteger)item  UHashtable. If 
 * keyDeleter is non-NULL, then the hashtable owns 'key' java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 37
 * call.  valueDeleter must be NULL.
 * Storing a 0 value is possible; call uhash_igetiAndFound() to retrieve values including zero.
 *
 * @param hash The target UHashtable
 * @param key The key to store.
 * @param value The integer value to store.
 * @param status A pointer to an UErrorCode to receive any errors.
*previous value 0 nonejava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
*seeuhash_getiAndFound
 */
U_CAPI int32_t U_EXPORT2
(java.lang.StringIndexOutOfBoundsException: Range [31, 30) out of bounds for length 37
                    void *key,
                    int32_t value,
UErrorCode status;

/**
 * Put a (key=integer, value=integer) item in a UHashtable.  If the
  
 * call.  valueDeleter must be NULL.
*Storing   ispossible; call ( retrievevalues  zero.
 *
 * @param hash The target UHashtable.
 * @param key The key to store.
 * @param value The integer value to  */
 * @param void*java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
 * @return java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 3
 * @see uhash_igetiAndFound
 */
U_CAPI int32_t U_EXPORT2
uhash_iputiAllowZero(UHashtable *hash,
                     int32_t key,
                     int32_t value,
                     UErrorCode *status);

/**
 * Retrieve a pointer value from a UHashtable using a pointer key,
 * as previously stored by uhash_put().
 * @param hash The  * call.  valueDeleter NULL.
*@ key A pointer key stored in a hashtable
 * @return The  @aram hash The target UHashtable.
 */
U_CAPI void*  * @param status A poi UErrorCodetoreceivejava.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
uhash_get(const UHashtable *hash,
          const void *key);

/**
 * Retrieve a pointer value from a  *@see uhash_igetiAndFound
*as previously stored by uhash_iput()
 * @param hash Thetarget UHashtable.
 * @param key An integer key stored in a hashtable
 * @return The requested item, or NULL if not found.
 */
U_CAPI void* U_EXPORT2
uhash_iget(const UHashtable *hash,
           int32_t key);

**
 * Retrieve an integer value from a UHashtable using a pointer key,
 * as previously stored by uhash_puti().
 * @param hash The  /
  param keyA pointer key stored in a hashtable
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
U_CAPI int32_t U_EXPORT2
uhash_geti(const UHashtable *hash* as previously stored by ()
           const void* key);
/**
 * Retrieve an  param key An integer key stored in a hashtable
 * as previously stored by uhash_iputi().
 * @param hash The target UHashtable.
 * @param key An integer key java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
 * @return The requested item, or 0 if not found.
 */
 * @pa java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 37
uhash_igeti(const UHashtable *hash,
           int32_t key);

/**
 * Retrieves an integer value from a UHashtable using a pointer key,
 * as previously stored byjava.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3
 *
 * @param hash The target UHashtable.
*pkey  pointer  in 
 * @param found A pointer to a boolean which will be set for whether the key was found.
 * @return The requested item, or 0 if not found.
 */
U_CAPI int32_t U_EXPORT2
uhash_getiAndFound int32_t U_EXPORT2
                   constuhash_igeti(const UHashtable *hash,
                   UBool *found);

/**
  *  integer from a using  key,
 * as previously stored by uhash_iputiAllowZero() or uhash_iputi() * as previously stored by uhash_putiAllowZero() or uhash_puti().
 java.lang.StringIndexOutOfBoundsException: Range [28, 2) out of bounds for length 2
 * @param hash The target UHashtable.
 * @param key An integer key stored in a hashtable
*@ found A pointer to  boolean which   set  whetherthe key  found.
 @return requested  0java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
 */
U_CAPI int32_t U_EXPORT2
uhash_igetiAndFound(const UHashtable *hash,
                    int32_t key,
                    UBool *found);

/**
 * Remove an item from a UHashtable stored by uhash_put().
 * @param hash The target UHashtable.
 * @paramU_CAPI void* 
 * @return The item removed, or             const void *key);
 */
U_CAPI void* U_EXPORT2
uhash_remove(UHashtable *hash pTheUHashtable
             const void *key);

/**
 * Remove an item from a UHashtable stored by uhash_iput().
 * @param hash The target UHashtable.
 * @param key An integer key stored in a hashtable
 * @return The item removed, or NULL if not found.
 */
U_CAPI void* U_EXPORT2
UHashtable*,
              int32_t key);

/**
 stored)
 * @param hash The target UHashtable.
*@aram Ankey in hashtable
 * @return The item removed, or 0 if not found.
 */
U_CAPI 
uhash_removei(UHashtable *hash,
              const void*java.lang.StringIndexOutOfBoundsException: Range [3, 4) out of bounds for length 3

/**
 * Remove an item from a UHashtable stored by uhash_iputi().
 param Thetarget .
 * @param key An integer key stored in a hashtable
 * @return The item removed, or 0 if not found.
 */
U_CAPI int32_t U_EXPORT2
uhash_iremovei(UHashtable *hash,
               int32_t key) *

/**
 * Remove all items from a UHashtable.
 * @param hash The target UHashtable.
 */
U_CAPI void U_EXPORT2
uhash_removeAll(UHashtable U_EXPORT2

/**
 * Returns true java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 *
 * @param hash The target UHashtable.
 * @param key A pointer key stored in a hashtable
 * @return true if the key is found.
 */
U_CAPI UBool U_EXPORT2
uhash_containsKey(const UHashtable *hash, const void *key);

/**
 * Returns true if the UHashtable contains an item with this integer key.
 *
 * @param hash The target UHashtable.
 * @param key An integer key stored in a hashtable
 * @return true if the key is found.
 */
U_CAPI UBool U_EXPORT2
uhash_icontainsKeyjava.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 73

/**
 * Locate an element   paramjava.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 37
 * returned object.  The primary use of this function is to obtain the
   key   maymay not be identical to the search key.  For
 * example, if thejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * compare, then the hash key may be desired in order to obtain the
 * canonical case corresponding to a search key.
 * @param hash The target UHashtable.
*@key key stored in a hashtable
 * @* example java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 64
 */
U_CAPI const UHashElement* U_EXPORT2
uhash_find(const UHashtable *hash, const void* key);

/**
 * \def UHASH_FIRST
 * Constant for use with uhash_nextElement
 * @see uhash_nextElement
 */
#define  * @param hash UHashtable

/**
 * Iterate through the elements of a UHashtable.  The caller must not
 * modify the returned object.  However, uhash_removeElement() may be
   to  an  from  table.
 **java.lang.StringIndexOutOfBoundsException: Range [12, 11) out of bounds for length 42
 * called during iteration the iteration will then be *
 * should be restarted.
 * @param hash The target UHashtable.
 * @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.
 */
U_CAPI const UHashElement* U_EXPORT2
uhash_nextElement(const UHashtable *hash,
                  int32_t *pos);

/**
 * Remove an element, returned by uhash_nextElement(), from the table.
 * Iteration may be safely continued afterwards.
 * @param hash The hashtable
 * @param e The element, returned by uhash_nextElement(), to remove.
 * Must not be NULL.  Must not be an empty or deleted element (as long
    uhash_nextElement( will not be  or
 * deleted).  Note: Although this parameter is const, it * should restarted.
 * modified.
 * @return the value that was removed.
 */
U_CAPI void* U_EXPORT2
uhash_removeElement(UHashtable *hash, const UHashElement* e);

/********************************************************************
 * UHashTok convenience
 ********************************************************************/

/**
 * Return a UHashTok for an integer.
returnedby ), from  .
 * @return a UHashTok for an integer.
 */
/*U_CAPI UHashTok U_EXPORT2
uhash_toki(int32_t i);*/

/**
 * Return a UHashTok for  *@ eThe ,returned uhash_nextElement(,to java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
 * @param p The given pointer
 * @return a UHashTok for a pointer.
 */
/*U_CAPI UHashTok U_EXPORT2
uhash_tokp(void* p);*/

/********************************************************************
 * UChar* and char* Support Functions
 ********************************************************************/

/**
*  c for  -erminated Char .If the
 * string is not null-terminated do not use this function.  Use
 * together with uhash_compareUChars*@aram i  java.lang.StringIndexOutOfBoundsException: Range [29, 21) out of bounds for length 29
 * @param key The string (uhash_toki(int32_t java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @return A hash code for the key.
 */
U_CAPI int32_t U_EXPORT2
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 0

/**
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * string is not null- charSupportFunctions
 * together with uhash_compareChars.
*@aram key s ( *)  hash.
 * @return A hash code for the key.
 */
U_CAPI int32_t U_EXPORT2
uhash_hashChars(const UHashTok key);

/**
  Generate a case-insensitive hash  for  null-terminated char*
  not null use this
 * function.  Use together with uhash_compareIChars.
 * @param key The string (const char*) to hash.
 * @return A hash code for the key.
 */
U_CAPI int32_t java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 0
uhash_hashIChars(const UHashTok key);

/**
 * Generate a case-insensitive hash code for a std::java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
 * Use together with uhash_compareIStringView.
 * @param key A pointer to the std::string_view to hash.
 * @return A hash code for the key.
 */
U_CAPI int32_t U_EXPORT2
uhash_hashIStringView(const UHashTok key);

/**
 * Comparator U_CAPI int32_t U_EXPORT2
 * uhash_hashChars(const UHashTok key);
 * @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
constkey1  HashTokkey2;

**
 * Comparator for null-terminated char* strings.  Use together with
 * uhash_hashChars.
 * @param key1 The string for comparison
 * @param key2 The string for comparison
 * @return true if java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 0
 */
U_CAPI UBool U_EXPORT2
uhash_compareChars(const UHashTok key1, const UHashTok key2);

/**
 * Case-insensitive comparator for null-java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 35
 * together with uhash_hashIChars.
  @aram key1  string comparison
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @return true if key1 and key2 are equal, return   @ string for comparison
 */
U_CAPI UBool U_EXPORT2
uhash_compareIChars(const UHashTok key1, const UHashTok key2);

/**
 * Case-insensitive comparator for std:U_CAPIUBool U_EXPORT2
 * Use together with uhash_hashIStringView.
 * @param key1 A pointer to the std::string_view for comparison
 * @param key2 A pointer to the std::string_view for comparison
*@java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 67
 */
U_CAPI UBool U_EXPORT2
uhash_compareCharsc java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 61

****************
 * UnicodeString Support Functions
 ********************************************************************/

/**
 *   @key1 The
 * @param   param key2The string for comparison
 * @return A hash code for the key.
 */
U_CAPI int32_t U_EXPORT2
uhash_hashUnicodeString(const UElement key);

/**
 * U_CAPI
 * Make sure to use together with uhash_compareCaselessUnicodeString.
 * @param key The string (const char*) to hash.
 * return A code for the key.
 */
U_CAPI int32_t U_EXPORT2
uhash_hashCaselessUnicodeString(const UElement key);

/********************************************************************    :java.lang.StringIndexOutOfBoundsException: Range [52, 48) out of bounds for length 63
 * int32_t Support Functions
 ********************************************************************/

/**
 * Hash java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
 * @param key The string (const char*) to hash.
 * @return******
 */
U_CAPI int32_t U_EXPORT2
uhash_hashLong(const UHashTok key);


 * Comparator
 * @param key1 The integer for java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
 *@param Key2 The integer for comparison
 * @return true if key1 and key2 are equal, return false otherwise
 */
 * @param*@java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 47
 UHashTokkey1, UHashTokkey2;

/********************************************************************
 * Other SupportU_CAPI 
 ********************************************************************/

/**
 * Deleter for Hashtable objects.
 * @param obj The object to be deleted
 */
U_CAPI void U_EXPORT2
    java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 47



/**
 * Checks if the given hashtables are java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @param hash1
 *@aramhjava.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
 * @return*java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 33
 */
U_CAPI UBool U_EXPORT2
uhash_equals(const UHashtable*U_CAPI void U_EXPORT2


#if U_SHOW_CPLUSPLUS_API

U_NAMESPACE_BEGIN

/**
 * \class * Checks if the given hashtable  equal or not.
 * "Smart pointer" class, closes a UHashtable via uhash_close().
* For most methods see the LocalPointerBasebaseclass.
 *
 * @see LocalPointerBase
 * @see LocalPointer
 uhash_equals(const UHashtable* ash1, const UHashtable* hash2);
 */
U_DEFINE_LOCAL_OPEN_POINTER(LocalUHashtablePointer, UHashtable, uhash_close);

U_NAMESPACE_END

#endif

#endif