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 
init(UHashFunction * keyHash,UKeyComparator * keyComp,UValueComparator * valueComp,UErrorCode & status)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 
Hashtable(UKeyComparator * keyComp,UValueComparator * valueComp,UErrorCode & status)122 inline Hashtable::Hashtable(UKeyComparator *keyComp, UValueComparator *valueComp,
123                  UErrorCode& status) : hash(0) {
124     init( uhash_hashUnicodeString, keyComp, valueComp, status);
125 }
Hashtable(UBool ignoreKeyCase,UErrorCode & status)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 
Hashtable(UErrorCode & status)137 inline Hashtable::Hashtable(UErrorCode& status)
138  : hash(0)
139 {
140     init(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, status);
141 }
142 
Hashtable()143 inline Hashtable::Hashtable()
144  : hash(0)
145 {
146     UErrorCode status = U_ZERO_ERROR;
147     init(uhash_hashUnicodeString, uhash_compareUnicodeString, NULL, status);
148 }
149 
~Hashtable()150 inline Hashtable::~Hashtable() {
151     if (hash != NULL) {
152         uhash_close(hash);
153     }
154 }
155 
setValueDeleter(UObjectDeleter * fn)156 inline UObjectDeleter *Hashtable::setValueDeleter(UObjectDeleter *fn) {
157     return uhash_setValueDeleter(hash, fn);
158 }
159 
count()160 inline int32_t Hashtable::count() const {
161     return uhash_count(hash);
162 }
163 
put(const UnicodeString & key,void * value,UErrorCode & status)164 inline void* Hashtable::put(const UnicodeString& key, void* value, UErrorCode& status) {
165     return uhash_put(hash, new UnicodeString(key), value, &status);
166 }
167 
puti(const UnicodeString & key,int32_t value,UErrorCode & status)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 
get(const UnicodeString & key)172 inline void* Hashtable::get(const UnicodeString& key) const {
173     return uhash_get(hash, &key);
174 }
175 
geti(const UnicodeString & key)176 inline int32_t Hashtable::geti(const UnicodeString& key) const {
177     return uhash_geti(hash, &key);
178 }
179 
remove(const UnicodeString & key)180 inline void* Hashtable::remove(const UnicodeString& key) {
181     return uhash_remove(hash, &key);
182 }
183 
removei(const UnicodeString & key)184 inline int32_t Hashtable::removei(const UnicodeString& key) {
185     return uhash_removei(hash, &key);
186 }
187 
find(const UnicodeString & key)188 inline const UHashElement* Hashtable::find(const UnicodeString& key) const {
189     return uhash_find(hash, &key);
190 }
191 
nextElement(int32_t & pos)192 inline const UHashElement* Hashtable::nextElement(int32_t& pos) const {
193     return uhash_nextElement(hash, &pos);
194 }
195 
removeAll(void)196 inline void Hashtable::removeAll(void) {
197     uhash_removeAll(hash);
198 }
199 
setKeyComparator(UKeyComparator * keyComp)200 inline UKeyComparator* Hashtable::setKeyComparator(UKeyComparator*keyComp){
201     return uhash_setKeyComparator(hash, keyComp);
202 }
203 
setValueComparator(UValueComparator * valueComp)204 inline UValueComparator* Hashtable::setValueComparator(UValueComparator* valueComp){
205     return uhash_setValueComparator(hash, valueComp);
206 }
207 
equals(const Hashtable & that)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 
215