source/common/hash.h

   1 // Copyright (C) 2016 and later: Unicode, Inc. and others.
   2 // License & terms of use: http://www.unicode.org/copyright.html
   3 /*
   4 ******************************************************************************
   5 *   Copyright (C) 1997-2014, International Business Machines
   6 *   Corporation and others.  All Rights Reserved.
   7 ******************************************************************************
   8 *   Date        Name        Description
   9 *   03/28/00    aliu        Creation.
  10 ******************************************************************************
  11 */
  12
  13 #ifndef HASH_H
  14 #define HASH_H
  15
  16 #include "unicode/unistr.h"
  17 #include "unicode/uobject.h"
  18 #include "cmemory.h"
  19 #include "uhash.h"
  20
  21 U_NAMESPACE_BEGIN
  22
  23 /**
  24  * Hashtable is a thin C++ wrapper around UHashtable, a general-purpose void*
  25  * hashtable implemented in C.  Hashtable is designed to be idiomatic and
  26  * easy-to-use in C++.
  27  *
  28  * Hashtable is an INTERNAL CLASS.
  29  */
  30 class U_COMMON_API Hashtable : public UMemory {
  31     UHashtable* hash;
  32     UHashtable hashObj;
  33
  34     inline void init(UHashFunction *keyHash, UKeyComparator *keyComp, UValueComparator *valueComp, UErrorCode& status);
  35
  36 public:
  37     /**
  38      * Construct a hashtable
  39      * @param ignoreKeyCase If true, keys are case insensitive.
  40      * @param status Error code
  41     */
  42     Hashtable(UBool ignoreKeyCase, UErrorCode& status);
  43
  44     /**
  45      * Construct a hashtable
  46      * @param keyComp Comparator for comparing the keys
  47      * @param valueComp Comparator for comparing the values
  48      * @param status Error code
  49     */
  50     Hashtable(UKeyComparator *keyComp, UValueComparator *valueComp, UErrorCode& status);
  51
  52     /**
  53      * Construct a hashtable
  54      * @param status Error code
  55     */
  56     Hashtable(UErrorCode& status);
  57
  58     /**
  59      * Construct a hashtable, _disregarding any error_.  Use this constructor
  60      * with caution.
  61      */
  62     Hashtable();
  63
  64     /**
  65      * Non-virtual destructor; make this virtual if Hashtable is subclassed
  66      * in the future.
  67      */
  68     ~Hashtable();
  69
  70     UObjectDeleter *setValueDeleter(UObjectDeleter *fn);
  71
  72     int32_t count() const;
  73
  74     void* put(const UnicodeString& key, void* value, UErrorCode& status);
  75
  76     int32_t puti(const UnicodeString& key, int32_t value, UErrorCode& status);
  77
  78     void* get(const UnicodeString& key) const;
  79
  80     int32_t geti(const UnicodeString& key) const;
  81
  82     void* remove(const UnicodeString& key);
  83
  84     int32_t removei(const UnicodeString& key);
  85
  86     void removeAll(void);
  87
  88     const UHashElement* find(const UnicodeString& key) const;
  89
  90     /**
  91      * @param pos - must be UHASH_FIRST on first call, and untouched afterwards.
  92      * @see uhash_nextElement
  93      */
  94     const UHashElement* nextElement(int32_t& pos) const;
  95
  96     UKeyComparator* setKeyComparator(UKeyComparator*keyComp);
  97
  98     UValueComparator* setValueComparator(UValueComparator* valueComp);
  99
 100     UBool equals(const Hashtable& that) const;
 101 private:
 102     Hashtable(const Hashtable &other); // forbid copying of this class
 103     Hashtable &operator=(const Hashtable &other); // forbid copying of this class
 104 };
 105
 106 /*********************************************************************
 107  * Implementation
 108  ********************************************************************/
 109
 110 inline void Hashtable::init(UHashFunction *keyHash, UKeyComparator *keyComp,
 111                             UValueComparator *valueComp, UErrorCode& status) {
 112     if (U_FAILURE(status)) {
 113         return;
 114     }
 115     uhash_init(&hashObj, keyHash, keyComp, valueComp, &status);
 116     if (U_SUCCESS(status)) {
 117         hash = &hashObj;
 118         uhash_setKeyDeleter(hash, uprv_deleteUObject);
 119     }
 120 }
 121
 122 inline Hashtable::Hashtable(UKeyComparator *keyComp, UValueComparator *valueComp,
 123                  UErrorCode& status) : hash(0) {
 124     init( uhash_hashUnicodeString, keyComp, valueComp, status);
 125 }
 126 inline Hashtable::Hashtable(UBool ignoreKeyCase, UErrorCode& status)
 127  : hash(0)
 128 {
 129     init(ignoreKeyCase ? uhash_hashCaselessUnicodeString
 130                         : uhash_hashUnicodeString,
 131             ignoreKeyCase ? uhash_compareCaselessUnicodeString
 132                         : uhash_compareUnicodeString,
 133             NULL,
 134             status);
 135 }
 136
 137 inline Hashtable::Hashtable(UErrorCode& status)
 138  : hash(0)
 139 {
 140     init(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, status);
 141 }
 142
 143 inline Hashtable::Hashtable()
 144  : hash(0)
 145 {
 146     UErrorCode status = U_ZERO_ERROR;
 147     init(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, status);
 148 }
 149
 150 inline Hashtable::~Hashtable() {
 151     if (hash != NULL) {
 152         uhash_close(hash);
 153     }
 154 }
 155
 156 inline UObjectDeleter *Hashtable::setValueDeleter(UObjectDeleter *fn) {
 157     return uhash_setValueDeleter(hash, fn);
 158 }
 159
 160 inline int32_t Hashtable::count() const {
 161     return uhash_count(hash);
 162 }
 163
 164 inline void* Hashtable::put(const UnicodeString& key, void* value, UErrorCode& status) {
 165     return uhash_put(hash, new UnicodeString(key), value, &status);
 166 }
 167
 168 inline int32_t Hashtable::puti(const UnicodeString& key, int32_t value, UErrorCode& status) {
 169     return uhash_puti(hash, new UnicodeString(key), value, &status);
 170 }
 171
 172 inline void* Hashtable::get(const UnicodeString& key) const {
 173     return uhash_get(hash, &key);
 174 }
 175
 176 inline int32_t Hashtable::geti(const UnicodeString& key) const {
 177     return uhash_geti(hash, &key);
 178 }
 179
 180 inline void* Hashtable::remove(const UnicodeString& key) {
 181     return uhash_remove(hash, &key);
 182 }
 183
 184 inline int32_t Hashtable::removei(const UnicodeString& key) {
 185     return uhash_removei(hash, &key);
 186 }
 187
 188 inline const UHashElement* Hashtable::find(const UnicodeString& key) const {
 189     return uhash_find(hash, &key);
 190 }
 191
 192 inline const UHashElement* Hashtable::nextElement(int32_t& pos) const {
 193     return uhash_nextElement(hash, &pos);
 194 }
 195
 196 inline void Hashtable::removeAll(void) {
 197     uhash_removeAll(hash);
 198 }
 199
 200 inline UKeyComparator* Hashtable::setKeyComparator(UKeyComparator*keyComp){
 201     return uhash_setKeyComparator(hash, keyComp);
 202 }
 203
 204 inline UValueComparator* Hashtable::setValueComparator(UValueComparator* valueComp){
 205     return uhash_setValueComparator(hash, valueComp);
 206 }
 207
 208 inline UBool Hashtable::equals(const Hashtable& that)const{
 209    return uhash_equals(hash, that.hash);
 210 }
 211 U_NAMESPACE_END
 212
 213 #endif
 214