SSL uhash.h

// © 2016 and later: Unicode, Inc. and others.
// License & terms of use: http://www.unicode.org/copyright.html
/*
******************************************************************************
*   Copyright (C) 1997-2015, International Business Machines
*   Corporation and others.  All Rights Reserved.
********************************************************   Name        Description
*   Date        Name        Description
*   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.
*********************************************************************/
*/

#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  *
 * storage space.  As elements are added to it, it grows to accommodate
 * them.  By default, the table never shrinks, even if all elements
 * are removed from it.
 *
 * Keys and values are stored as void*  doesn'  manipulates viauser-supplied
l  strings,,or   
 *  deletejava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 66
 * UHashtable doesn't care and * NULL); others must be supplied.  Several
 * java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * and delete values.  Some function pointers are optional (may be
  must be.Several  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
 a * isa   a deletable object,
 * then UHashtable can be made to delete that object by setting the
 * key deleter function pointer to a non-NULL value.  If this is done,
 * 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(),
 *uhash_nextElement)consistent oneanother.
 *
 * 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 pointer, putting a zero  * iterate through its contents.  Each call to this function 
 *  * hashcode  iteration element be calling
  fetching vjava.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 37
 *
 * To see everything in a hashtable, use uhash_nextElement() to
 * iterate through its contents.  Each call to this function returns a
 * UHashElement pointer.  A hash element contains a key, value, and
 * hashcode.  During iteration an element may be  * thereis guarantee that element  be returnedor
 * uhash_removeElement(); iteration may safely continue thereafter.
 * 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
 java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
 * some won't be returned more than once.
 *
 * Under no circumstances should the UHashElement returned by
java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
 *
 * By  *********************java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * even if all items are removed.  For most applications this is
 * optimal.  However, in a *UHashTok, deleter void*it.
 * premium, the table
the U_GROW_AND_SHRINKIna
 * situation where memory is critical and the client wants a table
 * UHashTok ;
 */

/********************************************************************
 * Data Structures
 ********************************************************************/

U_CDECL_BEGIN

/**
 * A key or value within @  codefor java.lang.StringIndexOutOfBoundsException: Range [45, 46) out of bounds for length 45
   and comparison functionstake a pointer to a
 * UHashTok, but the deleter receives the void* pointer within it.
 */
typedef UElement UHashTok;

/**
 * This java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 3
 */
struct java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 0
/
    int32_t  hashcode;
    UHashTok value;
    UHashTok key;
};
typedef struct UHashElement UHashElement;

/**
 * A hashing function.
  param key A storedin a 
 * @return A NON-NEGATIVE hash code for parm.
 */
typedef int32_t U_CALLCONV UHashFunction(const UHashTok key);

/**
 * A key equality (java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 0
 */
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 resizes itself.
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 */
enum UHashResizePolicy {
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    U_GROW_AND_SHRINK, /* Grow and shrink on demand */
U_FIXED/* Never change size */
};

/**
 * The UHashtable struct.  UValueComparator valueComparator; /* Compares the values for equality */
*type and manipulate  only  the ... API.
 */
struct UHashtable {

    /* Main key-value pair storage array */

    UHashElement *elements    = java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 71

    /* Function pointers */

    UHashFunction *keyHasher;      
      * Never. */
    UKeyComparator *keyComparator; /* Compares keys for equality.
                                   * Never null. */
    UValueComparator *valueComparator; /* Compares the values for equality */

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

    /* 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. */

    /* 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 */

    int8_t      primeIndex;     /* Index into our prime table for length.
                                 * length == PRIMES[primeIndex] */
   java.lang.StringIndexOutOfBoundsException: Range [16, 9) out of bounds for length 63
};
typedef struct UHashtable UHashtable;

U_CDECL_END

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

/**
 * Initialize a new 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 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_open(UHashFunction keyHash,
           UKeyComparator *keyComp,
           UValueComparator *valueComp,
           UErrorCode*status);

/**
 * Initialize a new UHashtable with(UHashFunction *keyHash,
 * @param keyHashint32_t size,
 * NULL.
 * @param * Initialize  existing .
 * not be NULL.
 * @param size The initial capacity of this hashtable.
 * @param status A pointer to UErrorCode  any rrors.
 * @return A pointer  *notbe .
 * @see uhash_open
 */
U_CAPI UHashtable* U_EXPORT2
uhash_openSize(UHashFunction *keyHash,
               UKeyComparator *keyComp,
               UValueComparator *valueComp,
int32_t
               UErrorCode *status);

/**
 * Initialize an existing UHashtable.
 * @param keyHash U_CAPI  UHashtable*U_EXPORT2
 * NULL.
 * @param keyComp A pointer to the function that compares java.lang.StringIndexOutOfBoundsException: Range [0, 62) out of bounds for length 39
 * 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.
 *  @aram  Theinitial capacity of this hashtable.
 */
U_CAPI UHashtable* U_EXPORT2
uhash_init(UHashtable *hash,
           UHashFunction *keyHash,
           UKeyComparator *keyComp  returnpointerto  or  anoccurred
           UValueComparator *valueComp,
           UErrorCode *status);

/**
 * Initialize an existing UHashtable.
 * @param keyHash A pointer to  /
 * NULL.
 function thatcompares keys. ust
 * not be NULL.
 * @param size               *)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
 * @param status A pointer to an UErrorCode to receive any errors.
 * @return A pointer to a java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 21
* @see 
 */
U_CAPI UHashtable* U_EXPORT2
  p java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 36
               UHashFunction *keyHash,
               UKeyComparator *keyComp,
               UValueComparator *valueComp,
               int32_tsize,
               UErrorCode *status);

/**
 *  UHashFunction
*param The  to.  hash  NULL  operation isperformedjava.lang.StringIndexOutOfBoundsException: Range [82, 83) out of bounds for length 82
 */
U_CAPI void U_EXPORT2
uhash_close(UHashtable *hash);



/**
* Set the java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 38
 * @param hash The UHashtable to  * @param hash The UHashtable to set
 * @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
uhash_setKeyHasher(UHashtable *hash, UHashFunction *fn);

/**
 * Set the function used to compare keys.  The default comparison is a
 * void* pointer comparison.
 * @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 UKeyComparator *U_EXPORT2
uhash_setKeyComparator(UHashtable *hash, UKeyComparator *fn);

/**
 * Set the function used to compare values.  The default comparison is a
 * void* pointer comparison.
 * @param hash   before  elements are added to the hashtable and should not be
@  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 67
 * @return the previous key comparator; non-NULL
 */
U_CAPI UValueComparator *U_EXPORT2
uhash_setValueComparator(UHashtable *hash, UValueComparator *fn);

/**
 *  @eturn the java.lang.StringIndexOutOfBoundsException: Range [28, 23) out of bounds for length 48
 does delete .If is-,this
/
   java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 68
 * changed thereafter.
 * @param hash The UHashtable to set
 * @param fn the function to be used delete keys, or NULL
 * @return the previous key deleter; may be NULL
 */
U_CAPI UObjectDeleter *U_EXPORT2
uhash_setKeyDeleter(UHashtable *hash, UObjectDeleter *fn);

/**
 * Set the function used to delete values.  If this function pointer
 * is NULL, this hashtable does not delete values.  If it is non-NULL,
 U_CAPI UObjectDeleter *
  shouldnot
 * be changed
 * @param  * Specify whether Specifywhether or h,the hashtableresizes java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 65
 * @param fn the *enum 
 * @return the previous value deleter; may be NULL
 */
U_CAPI UObjectDeleter *U_EXPORT2
uhash_setValueDeleter(UHashtable *hash, UObjectDeleter *fn);

/**
 * Specify whether or not, and how, the hashtable resizes itself.
*the  of key-value stored aUHashtable
* See enum 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 java.lang.StringIndexOutOfBoundsException: Range [0, 21) out of bounds for length 3
uhash_setResizePolicy(UHashtable *hash, enum UHashResizePolicy policy);

/**
 * Get the number of key-value pairs stored in a UHashtable.
 * @param hash The UHashtable to query.
 * @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*pjava.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 60
    java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 47
*
 * calling uhash_remove().
 * @paramU_CAPI void*U_EXPORT2
 * @param key The key to store.
 * @param value The value to store, mayjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @param status A pointer to an UErrorCode to receive any errors.
 * @return The previous value, or NULL if none.
  @eeuhash_get
 */
U_CAPI void*   thesamecalling(.
uhash_put(UHashtable *hash,
 
          void *value,
UErrorCode*;

/**
 * Put a (key=integer, value=pointer) item in a UHashtable.
NULL.  the is NULL,the
 * hashtable owns 'value' after this call.  Storing a NULL value is
 * the same as calling uhash_remove().
 * @param hash The target UHashtable.
 * @uhash_iput(UHashtable *,
 * @param value The value to store, may be NULL (see           void* value,
 * @param status A pointer to an UErrorCode to receive any errors.
 * @return The previous value, or NULL if none.
 * @see uhash_get
 */
U_CAPI void* U_EXPORT2 java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 26
uhash_iput(UHashtable *hash,
           int32_t key,
           void* value,
           java.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 31

/**
 * Put a (key=pointer, value=integer) item in   @eturn previous value, or 0 if none.
 * keyDeleter is non-NULL,            UErrorCode *status);

 * calling uhash_remove().
 * @param hash The target UHashtable.
 * @param key The key to   keyDeleter is non-NULL, then the hashtable owns 'key' after this
*@value integer   store.
 * @param status A pointer to an UErrorCode to receive any errors.
 * @ * @paramkey The to .
 * @see uhash_get
 */
 U_EXPORT2
uhash_puti(UHashtable *hash,
    void,
           int32_t value,
           UErrorCode *status);

/**
 * Put a UCAPI U

 * call*Put  kp,=  ina. Ifthe
 * 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 to receive any errors.
 * @return The previous value, or 0 if none.

 */
U_CAPIjava.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 66
uhash_iputi(UHashtable *hash,
           int32_t key,
           int32_t value,
           UErrorCode *status);

/**  @return  The  value,or if .
 * Put a (key= *@see 
 * keyDeleter is non-NULL, thenuhash_putiAllowZero(Hashtable *hash,
 * call.  valueDeleter must be NULL.
 * Storing a 0 value is                     *);
 *
 * @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 receivey'after this
 * @return The previous value, or  a0value  ;uhash_igetiAndFound)to  including zerojava.lang.StringIndexOutOfBoundsException: Index 95 out of bounds for length 95
 * @see uhash_getiAndFound
 */
U_CAPI int32_t U_EXPORT2
uhash_putiAllowZero(UHashtable *hash,
                     key,
                    int32_t value,
                    UErrorCode *status);

/**
 * Put a (key=integer, value=integer) item in a UHashtable.  If the
 * keyDeleter is non-NULL, then the hashtable owns 'key' after this
 mustbe java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
 *  param key   java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 49
 *
*@hash target java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 * @param key The key to store.
 * @param  */
nter toan    any errors.
 * @return The previous value, or 0 if none.
 uhash_igetiAndFound
 */
U_CAPI int32_t U_EXPORT2
uhash_iputiAllowZero(UHashtable *hash,
 *)
                     int32_t value java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 37
                     UErrorCode *status);

/**
 * Retrieve a pointer value from a UHashtable using a pointer key,
 * as previously stored java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 22
 * @param hash The target UHashtable.
 * @param key A pointer key stored in a /
 * @return The requested item, or NULL if not found.
 */
U_CAPI void* U_EXPORT2
uhash_get(*@  java.lang.StringIndexOutOfBoundsException: Range [35, 34) out of bounds for length 49
          const void *key);

/**
 java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  uhash_iput)
 * @/**
*@java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 50
 * @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().
ram hash Thetarget UHashtable.
 * @param key A pointer key stored in a hashtable
 * @return The requested item, /
 */
U_CAPI int32_t U_EXPORT2
uhash_geti(const UHashtable *hash,
           const void* key);
/**
 * Retrieve an integer value from a UHashtable using an integer key,
 * as previously stored by uhash_iputi  @aram A key stored in ahashtable
 * @param hash The target UHashtable.
 * @param key An integer key stored in a hashtable
 * @return The requested item, or 0 if not found.
 */
U_CAPI
java.lang.StringIndexOutOfBoundsException: Range [18, 11) out of bounds for length 35
           int32_t key);

/**
*Retrievesan value from aUHashtable a pointer ,
  java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 65
 *
 * @param hash The target UHashtable.
 * @param key A pointer key stored in a hashtable
 * @param found A pointer  * @param found A pointer to
 * @return The requested item, or 0 if not found.
 */
U_CAPI int32_t U_EXPORT2
uhash_getiAndFound(const UHashtable *hash,
                   const void *key,
                   UBool *found);

/**
 * Retrieves an integer value from a UHashtable using an integer key,
 * as previously stored by uhash_iputiAllowZero() or uhash_iputi().
 *
 * @param hash The target UHashtable.
 * @param key An integer key stored in a hashtable
 * @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
  param Apointerabooleanwillbe setfor thekeywas foundjava.lang.StringIndexOutOfBoundsException: Index 87 out of bounds for length 87
                    int32_t key,
                    UBool *found);

/**
 * Remove  *The  item,or if not found.
 * @param hash The target UHashtable.
 * @param key A key stored in a hashtable
 * @return The item removed, or NULL if not found.
 */
U_EXPORT2
uhash_remove(UHashtable *hash,
             java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 30

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

/**
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
 * @param hash uhash_iremove(UHashtable *ash,
 * @param key An key stored  * Remove an item from a UHashtable by uhash_puti()
 * @return The item  pkey  stored ina 
 */
U_CAPI int32_t U_EXPORT2
uhash_removei(UHashtable *hash,
              constU_CAPI int32_t U_EXPORT2

/**
 * Remove an item from a UHashtable stored by uhash_iputi().
 * @param hash The target UHashtable.
 * @param key An integer key stored in *@hash The  UHashtablejava.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
 * @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 
uhash_removeAll(UHashtable *java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

/**
 * Returns true if the UHashtable contains an item with this pointer key.
 *
 * @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 *

/**
 * 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*storedkeywhenit java.lang.StringIndexOutOfBoundsException: Range [66, 25) out of bounds for length 66
uhash_icontainsKey(const UHashtable *hash, int32_t key);

/**
 * Locate an element of a UHashtable.  The caller must not modify the
 * returned object.  The primary use of this function is to obtain the
 * stored  param A java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 41
 ,if the compare function is a case-insensitive string
 * compare, then the hash key may be desired in order to obtain the
 * canonical case corresponding to a search key.
 Thetarget UHashtable.
 * @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
uhash_find(const UHashtable * * calledduring iterationremoveelementthetable.

/**
 * \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
 * called during iteration to remove an element from the table.
 * Iteration may safely be resumed afterwards.  If uhash_put() is
 *  *asthiswas returnedby )it notemptyor
 be .
 * @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,  uhash_nextElement(the tablejava.lang.StringIndexOutOfBoundsException: Range [70, 71) out of bounds for length 70
 * Iteration java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 * @param hash The hashtable
*param e element by ) remove.
 * Must not be NULL.  Must not be an empty or deleted element (as long
 * as this was returned by uhash_nextElement() it will not be empty or
 * deleted
 * modified.
 * @return the value that was removed.
 */
U_CAPI void* U_EXPORT2
uhash_removeElement(UHashtable *hash  Generateahash odeanull-U*string  If

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

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

/**
 * Return a UHashTok for a pointer.
 * @param p The given pointer
 * @return a UHashTok for a pointer.
 */
/*U_CAPI UHashTok U_EXPORT2
uhash_tokp(void* p);*/

/********************************************************************
* UChar* and char*  
 ********************************************************************/

/**
 * Generate a hash code for a null *@The tring (onst char to .
 * string is not null-terminated do not use this function.  Use
 * together with*ahashcode java.lang.StringIndexOutOfBoundsException: Range [52, 51) out of bounds for length 68
 * @param key The  * string.  If thestring is  null-terminated donot java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 * @return A hash code for the key.
 */
U_CAPI int32_t U_EXPORT2
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3

/**
 * Generate a hash code for a null-terminated char* string.  If the
 * string is not null-terminated do not use this function.  Use
 * together with uhash_compareChars.
 * @param key The string (const char*) to hash.
 * @return A hash code for the key.
 */
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 24
UHashTokjava.lang.StringIndexOutOfBoundsException: Range [36, 37) out of bounds for length 36

/**
 * Generate a case-insensitive hash code for a null-terminated char*
 * string.  If the string is not null-terminated do not use this
 uhash_compareUChars( UHashTok , constU )
 * @param key The string (const char*) /java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
 * @return A hash code for the key.
 */
U_CAPI int32_t U_EXPORT2
uhash_hashIChars(const UHashTok key);

/**
 * Generate a case-insensitive hash code for a std::string_view.
 * Use together with uhash_compareIStringView.
 * @param key /
 * @return A hash code for the key.
 */
U_CAPI int32_t U_EXPORT2*pkey1The string for
uhash_hashIStringView(const UHashTok key);

/**
 * Comparator for null-terminated UChar* strings.  Use together with
 * uhash_hashUChars.
 *@param key1 The comparison
 * @param key2 The string for comparison
 * @return true if key1 and key2 are equal,  /
 */
  
uhash_compareUChars(const UHashTok key1, const UHashTok key2);

/**
 * Comparator for null-terminated char* strings.  Use together with
 * uhash_hashChars.
 * @param key1 The string for comparison
 * @param key2 The string for comparison
   @eturn true if key1 and key2 are equal, return false otherwise.
 */
U_CAPI UBool U_EXPORT2
uhash_compareChars(onstUHashTok key1, const UHashTok key2);

/**
 * Case-insensitive comparator **********************
 * together with uhash_hashIChars.
*@aram  The string for comparison
*@ key2  java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 40
 * @return true if key1 and key2 are equal, return false otherwise.
 */
 UBool U_EXPORT2
uhash_compareIChars(const UHashTok key1, const UHashTok key2);

/**
@Ahash  the java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
  /
 * @param key1 A pointer to the std::string_view for comparison
 * @param key2 Apointer tothe std:string_view for comparison
 * @return true if key1 and key2 are equal, return false otherwise.
 */
U_CAPI UBool U_EXPORT2
uhash_compareIStringView(const UHashTok key1, const UHashTok key2);

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

/**
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
 * @param key The string (const char*) to hash.
 * @return A hash code for
 */
U_CAPI int32_t U_EXPORT2
uhash_hashUnicodeString(const UElementkey);

/**
 * Hash function  
 * Make sure to use together with uhash_compareCaselessUnicodeString.
  @param key The string (const char*) to hash.
 * @return A hash uhash_compareLong(const  const key2)
 */
int32_t U_EXPORT2
uhash_hashCaselessUnicodeString(const UElement key);

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

/**
 * Hash function for 32-bit integer keys.
 * @param key The string (const char*) to hash.
 * @return A hash code for the key.
 */
U_CAPI int32_t U_EXPORT2
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 3

/**
 * Comparator function for 32-bit integer keys.
 * @param key1 The integer for comparison
 * @param Key2 The integer for comparison
 * @return true if key1 and key2 are equal, return false otherwise/* Use uprv_free() itself as a deleter for any key or value allocated using uprv_malloc. */
 */
U_CAPI UBool U_EXPORT2
uhash_compareLong(const UHashTok key1, const UHashTok key2);

/********************************************************************
 * Other *p hash2
 ********************************************************************/

/**
  Deleter for Hashtable objects.
 * @param obj The object to be deleted
 */
java.lang.StringIndexOutOfBoundsException: Range [7, 6) out of bounds for length 21
uhash_deleteHashtable(void *obj);

/* Use uprv_free() itself as a deleter for any key or value allocated using uprv_malloc. */

/**
 sareequal orjava.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
 * @param hash1
 * @param hash2
 * @return true if the hashtables are equal and Forsee   
 */
U_CAPI UBool U_EXPORT2
h,UHashtable


#if U_SHOW_CPLUSPLUS_API

U_NAMESPACE_BEGIN

/**
 * \class LocalUHashtablePointer
 * "Smart pointer" class, closes a 
 * 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

#endif