Merge "Update deprecated libprivilege-control API functions." into tizen
[platform/framework/native/appfw.git] / inc / FBaseColMultiHashMap.h
1 //
2 // Copyright (c) 2012 Samsung Electronics Co., Ltd.
3 //
4 // Licensed under the Apache License, Version 2.0 (the License);
5 // you may not use this file except in compliance with the License.
6 // You may obtain a copy of the License at
7 //
8 // http://www.apache.org/licenses/LICENSE-2.0
9 //
10 // Unless required by applicable law or agreed to in writing, software
11 // distributed under the License is distributed on an "AS IS" BASIS,
12 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 // See the License for the specific language governing permissions and
14 // limitations under the License.
15 //
16
17 /**
18  * @file                FBaseColMultiHashMap.h
19  * @brief               This is the header file for the %MultiHashMap class.
20  *
21  * This header file contains the declarations of the %MultiHashMap class.
22  */
23 #ifndef _FBASE_COL_MULTI_HASH_MAP_H_
24 #define _FBASE_COL_MULTI_HASH_MAP_H_
25
26 #include <FBaseObject.h>
27 #include <FBaseColIComparer.h>
28 #include <FBaseColIHashCodeProvider.h>
29 #include <FBaseColIMultiMap.h>
30
31 namespace Tizen { namespace Base { namespace Collection
32 {
33
34 class _MultiHashMapEntry;
35
36 /**
37  * @class MultiHashMap
38  * @brief This class represents a collection of associated keys and values that are organized based on the hash code of the key.
39  *
40  * @since 2.0
41  *
42  *  The %MultiHashMap class represents a collection of associated keys and values that are organized based on the hash code of the key.
43  * There is no limit on the number of elements with the same key, but duplicated elements with the same key are not allowed.
44  * The key and value cannot be @c null.
45  * @n
46  * For more information on the class features, see <a href="../org.tizen.native.appprogramming/html/guide/base/hashmap_multihashmap.htm">HashMap and MultiHashMap</a>.
47  *
48  * The following example demonstrates how to use the %MultiHashMap class.
49  *
50  * @code
51  *      #include <FBase.h>
52  *
53  *      using namespace Tizen::Base;
54  *      using namespace Tizen::Base::Collection;
55  *
56  *      void
57  *      MyClass::MultiHashMapSample(void)
58  *      {
59  *              MultiHashMap map(SingleObjectDeleter);
60  *
61  *              // Constructs a MultiHashMap instance with default values for capacity, load factor, hash code provider, and comparer
62  *              map.Construct();
63  *
64  *              map.Add(new String(L"Zero"), new Integer(0));           // map.GetCount() : 1, map : (Zero -> 0)
65  *              map.Add(new String(L"One"), new Integer(1));            // map.GetCount() : 2, map : (Zero -> 0), (one -> 1)
66  *              map.Add(new String(L"Two"), new Integer(2));            // map.GetCount() : 3, map : (Zero -> 0), (one -> 1), (Two -> 2)
67  *              map.Add(new String(L"Two"), new Integer(20));           // map.GetCount() : 4, map : (Zero -> 0), (One -> 1), (Two -> 2, 20)
68  *
69  *              // Gets values with the specified key
70  *              Integer*        pValue = null;
71  *              IEnumerator *pValueEnum = map.GetValuesN(String(L"Two"));
72  *              while(pValueEnum->MoveNext() == E_SUCCESS)
73  *              {
74  *                      pValue = static_cast< Integer* > (pValueEnum->GetCurrent());
75  *              }
76  *
77  *              delete pValueEnum;
78  *
79  *              // Removes values with the specified key     // String(L"Two"), Integer(2), Integer(20) are removed
80  *              map.Remove(String(L"Two"));
81  *
82  *              // Uses an enumerator to access elements in the map
83  *              IMapEnumerator* pMapEnum = map.GetMapEnumeratorN();
84  *              String* pKey = null;
85  *              while (pMapEnum->MoveNext() == E_SUCCESS)
86  *              {
87  *                      pKey = static_cast< String* > (pMapEnum->GetKey());
88  *                      pValue = static_cast< Integer* > (pMapEnum->GetValue());
89  *              }
90  *
91  *              delete pMapEnum;
92  *
93  *              // Deallocates all objects
94  *              // Because the destructor calls RemoveAll() internally, you do not need to call RemoveAll() to destroy all elements at the end.
95  *              // map.RemoveAll();
96  *      }
97  * @endcode
98  */
99 class _OSP_EXPORT_ MultiHashMap
100         : public IMultiMap
101         , public Object
102 {
103 public:
104         using IMultiMap::Add;
105         using IMultiMap::Remove;
106         using IMultiMap::RemoveAll;
107         using IMultiMap::SetValue;
108         using IMultiMap::Contains;
109         using IMultiMap::ContainsKey;
110
111         /**
112          * The object is not fully constructed after this constructor is called. For full construction, @n
113          * the Construct() method must be called right after calling this constructor.
114          *
115          * @since 2.0
116          *
117          * @param[in]   deleter The function pointer to type of the element deleter
118          * @remarks     To create an owning collection, set the element deleter value as @c SingleObjectDeleter. This gives the collection the ownership of elements and the collection will destroy elements. @n
119          *                      On the other hand, to create a non-owning collection, you do not need to set the element deleter value, as @c NoOpDeleter is the default element deleter.
120          *                      It means that you do not transfer the ownership of elements to the collection.
121          * @see         NoOpDeleter()
122          * @see         SingleObjectDeleter()
123          * @see         ArrayDeleter()
124          */
125         explicit MultiHashMap(DeleterFunctionType deleter = NoOpDeleter);
126
127         /**
128          * This destructor overrides Tizen::Base::Object::~Object().
129          *
130          * @since 2.0
131          */
132         virtual ~MultiHashMap(void);
133
134         /**
135          * Initializes a new instance of %MultiHashMap with the specified capacity and load factor.
136          *
137          * @since 2.0
138          *
139          * @return              An error code
140          * @param[in]   capacity                The initial capacity
141          * @param[in]   loadFactor              The maximum ratio of elements to buckets
142          * @exception   E_SUCCESS               The method is successful.
143          * @exception   E_INVALID_ARG   A specified input parameter is invalid, or
144          *                                                              the @c capacity or the @c loadFactor is negative.
145          * @remarks             The GetHashCode() method of the key object is used for hashing and the
146          *                              Equals() method of the key object is used for comparing the keys.
147          * @see                 MultiHashMap()
148          */
149         result Construct(int capacity = 16, float loadFactor = 0.75);
150
151         /**
152          * Initializes a new instance of %MultiHashMap by copying the elements of the given map.
153          *
154          * @since 2.0
155          *
156          * @return              An error code
157          * @param[in]   map                             The map to copy
158          * @param[in]   loadFactor              The maximum ratio of elements to buckets @n
159          *                                                              If it is @c 0, the default load factor(0.75) is used.
160          * @exception   E_SUCCESS                       The method is successful.
161          * @exception   E_INVALID_ARG           The specified @c loadFactor is negative.
162          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation, or
163          *                                                                      the @c map is modified during the operation of this method.
164          * @remarks             This method performs a shallow copy. It copies just the pointer; not the element itself.
165          * @see                 MultiHashMap()
166          */
167         result Construct(const IMultiMap& map, float loadFactor = 0.75);
168
169
170         /**
171          * Initializes a new instance of the %MultiHashMap class, with the specified initial capacity, load factor, hash code provider, and comparer.
172          *
173          * @since 2.0
174          *
175          * @return              An error code
176          * @param[in]   capacity        The initial capacity @n
177          *                                                      If it is @c 0, the default capacity (16) is used.
178          * @param[in]   loadFactor      The maximum ratio of elements to buckets @n
179          *                                                      If it is @c 0, the default load factor (0.75) is used.
180          * @param[in]   provider        An instance of the IHashCodeProvider derived class that supplies the hash codes
181          *                                                      for all keys in this map
182          * @param[in]   comparer        An instance of the IComparer derived class to use when comparing keys
183          * @exception   E_SUCCESS               The method is successful.
184          * @exception   E_INVALID_ARG   A specified input parameter is invalid, or
185          *                                                              the @c capacity or the @c loadFactor is negative.
186          * @remarks             The instances of hash code provider and comparer will not be deallocated later from this map.
187          * @see                 MultiHashMap()
188          */
189         result Construct(int capacity, float loadFactor, const IHashCodeProvider& provider, const IComparer& comparer);
190
191         /**
192          * Initializes a new instance of the %MultiHashMap class by copying the elements of the specified map,
193          * with the specified load factor, hash code provider, and comparer.
194          *
195          * @since 2.0
196          *
197          * @return              An error code
198          * @param[in]   map                     A map to copy
199          * @param[in]   loadFactor      The maximum ratio of elements to buckets @n
200          *                                                      If it is @c 0, the default load factor (0.75) is used.
201          * @param[in]   provider        An instance of the IHashCodeProvider derived class that supplies the hash codes
202          *                                                      for all keys in this map
203          * @param[in]   comparer        An instance of the IComparer derived class to use when comparing keys
204          * @exception   E_SUCCESS                       The method is successful.
205          * @exception   E_INVALID_ARG           A specified input parameter is invalid, or
206          *                                                                      the @c loadFactor is negative.
207          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation, or
208          *                                                                      the @c map is modified during the operation of this method.
209          * @remarks             This method performs a shallow copy. It copies just the pointer; not the element itself.
210          *                      The instances of hash code provider and comparer will not be deallocated later from this map.
211          * @see                 MultiHashMap()
212          */
213         result Construct(const IMultiMap& map, float loadFactor, const IHashCodeProvider& provider, const IComparer& comparer);
214
215         /**
216          * Adds the specified key-value pair to this map.
217          *
218          * @since 2.0
219          *
220          * @return              An error code
221          * @param[in]   pKey    The pointer to key to add
222          * @param[in]   pValue  The pointer to corresponding value to add
223          * @exception   E_SUCCESS                       The method is successful.
224          * @exception   E_OBJ_ALREADY_EXIST     The specified pair of @c pKey and @c pValue already exists.
225          * @exception   E_INVALID_ARG           A specified input parameter is invalid, or
226          *                                                                      the comparer has failed to compare the keys.
227          * @remarks             This method performs a shallow copy. It adds just the pointer; not the element itself.
228          * @see                 Remove()
229          */
230         virtual result Add(Object* pKey, Object* pValue);
231
232         /**
233          * Gets an enumerator of this map.
234          *
235          * @since 2.0
236          *
237          * @return              An enumerator (an instance of the IEnumerator derived class) of this map, @n
238          *                              else @c null if some exception occurs
239          * @remarks             If the key has multiple values, the enumeration proceeds as follows: {A: a}, {B: b}, {B: c}, {B, d}, {C: e}, ...
240          *                              The specific error code can be accessed using the GetLastResult() method.
241          * @see                 IMapEnumerator
242          */
243         virtual IEnumerator* GetEnumeratorN(void) const;
244
245         /**
246          * Gets an enumerator of this map.
247          *
248          * @since 2.0
249          *
250          * @return              An enumerator (an instance of the IMapEnumerator derived class) of this map, @n
251          *                              else @c null if some exception occurs
252          * @remarks             If the key has multiple values, the enumeration proceeds as follows: {A: a}, {B: b}, {B: c}, {B, d}, {C: e}, ...
253          *                      The specific error code can be accessed using the GetLastResult() method.
254          * @see                 IEnumerator
255          */
256         virtual IMapEnumerator* GetMapEnumeratorN(void) const;
257
258         /**
259          * Gets an enumerator of the values associated with the specified key.
260          *
261          * @since 2.0
262          *
263          * @return              An enumerator (an instance of the IEnumerator derived class) of the values associated with the specified key, @n
264          *                              else @c null if some exception occurs
265          * @param[in]   key                             A key to locate
266          * @exception   E_SUCCESS                       The method is successful.
267          * @exception   E_INVALID_ARG           A specified input parameter is invalid, or
268          *                                                                      the comparer has failed to compare the keys.
269          * @exception   E_OBJ_NOT_FOUND         The specified @c key is not found in the map.
270          * @remarks             The specific error code can be accessed using the GetLastResult() method.
271          * @see                 SetValue()
272          */
273         virtual IEnumerator* GetValuesN(const Object& key) const;
274
275         /**
276          * Gets a list of all unique keys in this map.
277          *
278          * @since 2.0
279          *
280          * @return              A list of all unique keys in this map
281          * @remarks             The %IList stores just the pointers to the elements in the map, not the elements themselves.
282          *                              The specific error code can be accessed using the GetLastResult() method.
283          * @see                 GetValuesN()
284          */
285         virtual IList* GetKeysN(void) const;
286
287         /**
288          * Gets a list of all the values in this map.
289          *
290          * @since 2.0
291          *
292          * @return              A list of all the values in this map
293          * @remarks             The IList stores just the pointers to the elements in the map, not the elements themselves.
294          *                              The specific error code can be accessed using the GetLastResult() method.
295          * @see                 GetKeysN()
296          */
297         virtual IList* GetValuesN(void) const;
298
299         /**
300          * Removes all the values with the specified key.
301          *
302          * @since 2.0
303          *
304          * @return              An error code
305          * @param[in]   key                                     The key to remove
306          * @exception   E_SUCCESS                       The method is successful.
307          * @exception   E_INVALID_ARG           A specified input parameter is invalid, or
308          *                                                                      the comparer has failed to compare keys.
309          * @exception   E_OBJ_NOT_FOUND         The specified @c key is not found in the map.
310          * @see                 Add()
311          */
312         virtual result Remove(const Object& key);
313
314         /**
315          * Removes the specified value associated with the specified key.
316          *
317          * @since 2.0
318          *
319          * @return              An error code
320          * @param[in]   key             The key whose mapping is to remove from the map
321          * @param[in]   value   The value to remove
322          * @exception   E_SUCCESS                       The method is successful.
323          * @exception   E_INVALID_ARG           A specified input parameter is invalid, or
324          *                                                                      the comparer has failed to compare the keys.
325          * @exception   E_OBJ_NOT_FOUND         The specified @c key and @c value pair is not found in the map.
326          * @remarks             The specified key is also removed if there are no more values associated with it.
327          * @see                 Add()
328          */
329         virtual result Remove(const Object& key, const Object& value);
330
331         /**
332          * Removes all the object pointers in the @c collection. @n
333          *
334          * @since 2.0
335          *
336          * @remarks             This method can be called before deleting @c collection.
337          */
338         virtual void RemoveAll(void);
339
340         /**
341          * Sets the value associated with the given key with a new value.
342          *
343          * @since 2.0
344          *
345          * @return              An error code
346          * @param[in]   key                     The key for which the associated value needs to replace
347          * @param[in]   value           The value to replace
348          * @param[in]   pNewValue       The pointer to new value to replace the existing value
349          * @exception   E_SUCCESS                       The method is successful.
350          * @exception   E_INVALID_ARG           A specified input parameter is invalid, or
351          *                                                                      the comparer has failed to compare the keys.
352          * @exception   E_OBJ_NOT_FOUND         The specified @c key and @c value pair is not found in the map.
353          * @remarks             To add a new key-value pair, use the Add() method.
354          * @see                 Add()
355          * @see                 GetValuesN()
356          */
357         virtual result SetValue(const Object& key, const Object& value, Object* pNewValue);
358
359         /**
360          * Gets the number of values currently stored in this map.
361          *
362          * @since 2.0
363          *
364          * @return              The number of values currently stored in this map
365          */
366         virtual int GetCount(void) const;
367
368         /**
369          * Gets the number of values whose key matches the key.
370          *
371          * @since 2.0
372          *
373          * @return              An error code
374          * @param[in]   key     A key to locate
375          * @param[out]  count   The number of values whose key is the @c key
376          * @exception   E_SUCCESS                       The method is successful.
377          * @exception   E_INVALID_ARG           A specified input parameter is invalid, or
378          *                                                                      the comparer has failed to compare the keys.
379          * @exception   E_OBJ_NOT_FOUND         The specified @c key is not found in the map.
380          */
381         virtual result GetCount(const Object& key, int& count) const;
382
383         /**
384          * Checks whether the map contains the specified key and value.
385          *
386          * @since 2.0
387          *
388          * @return              @c true if the map contains the specified key and value pair, @n
389          *                              else @c false
390          * @param[in]   key             The key to locate
391          * @param[in]   value   The value to locate
392          * @exception   E_SUCCESS               The method is successful.
393          * @exception   E_INVALID_ARG   A specified input parameter is invalid, or
394          *                                                              the comparer has failed to compare the keys.
395          * @remarks             The specific error code can be accessed using the GetLastResult() method.
396          * @see                 ContainsKey()
397          * @see                 ContainsValue()
398          */
399         virtual bool Contains(const Object& key, const Object& value) const;
400
401         /**
402          * Checks whether the map contains the specified key.
403          *
404          * @since 2.0
405          *
406          * @return              @c true if the map contains the specified key, @n
407          *                              else @c false
408          * @param[in]   key                     The key to locate
409          * @exception   E_SUCCESS               The method is successful.
410          * @exception   E_INVALID_ARG   A specified input parameter is invalid, or
411          *                                                              the comparer has failed to compare the keys.
412          * @remarks             The specific error code can be accessed using the GetLastResult() method.
413          * @see                 ContainsValue()
414          * @see                 Contains()
415          */
416         virtual bool ContainsKey(const Object& key) const;
417
418         /**
419          * Checks whether the map contains the specified value.
420          *
421          * @since 2.0
422          *
423          * @return              @c true if the map contains the specified value, @n
424          *                              else @c false
425          * @param[in]   value   The value to locate
426          *
427          * @see                         ContainsKey()
428          * @see                         Contains()
429          */
430         virtual bool ContainsValue(const Object& value) const;
431
432         /**
433          * Compares the specified instance to the current instance for equality.
434          *
435          * @since 2.0
436          *
437          * @return              @c true if the two instances are equal, @n
438          *                              @c false
439          * @param[in]   obj The object to compare with the current instance
440          * @remarks             This method returns @c true only if the specified object is also an instance of %MultiHashMap class,
441          *                              both maps have the same number of elements, and both maps contain the same elements.
442          */
443         virtual bool Equals(const Object& obj) const;
444
445         /**
446          * Gets the hash value of the current instance.
447          *
448          * @since 2.0
449          *
450          * @return      The hash value of the current instance
451          * @remarks     The two Tizen::Base::Object::Equals() instances must return the same hash value. For better performance, @n
452          *                      the used hash function must generate a random distribution for all inputs.
453          */
454         virtual int GetHashCode(void) const;
455
456         /**
457          * Gets the element deleter of the collection.
458          *
459          * @since 2.0
460          *
461          * @return              A function pointer to the existing element deleter
462          */
463         virtual DeleterFunctionType GetDeleter(void) const;
464
465 private:
466         /**
467          * The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying of objects.
468          *
469          * @param[in]   map An instance of %MultiHashMap to initialize the current instance
470          */
471         MultiHashMap(const MultiHashMap& map);
472
473         /**
474          * The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit copying of objects.
475          *
476          * @param[in]   map An instance of %MultiHashMap
477          */
478         MultiHashMap& operator =(const MultiHashMap& map);
479
480         /**
481          * Copies all the pairs from the specified map to this map.
482          *
483          * @return              An error code
484          * @param[in]   map                                     The map to copy
485          * @exception   E_SUCCESS                       The method is successful.
486          * @exception   E_INVALID_OPERATION     The current state of the instance prohibits the execution of the specified operation. @n
487          *                                                                      The @c map is modified during the operation of this method.
488          */
489         result AddAll(const IMultiMap& map);
490
491         /**
492          * Gets a hash value for the specified object.
493          *
494          * @return              An @c int hash value for the specified object
495          * @param[in]   obj     The object to get hash value
496          */
497         int Hash(const Object& obj) const;
498
499         /**
500          * Rehashes the contents of this map into a new array with a
501          * larger capacity. @n
502          * This method is called automatically when the number of keys in this map reaches its threshold.
503          *
504          * @return              An error code
505          * @param[in]   newCapacity             The new capacity @n
506          *                                                              It must be a power of two and be greater than current capacity.
507          * @exception   E_SUCCESS               The method is successful.
508          */
509         result Resize(int newCapacity);
510
511         /**
512          * Clears all key-value pairs in this map.
513          */
514         void Reset(void);
515
516         /**
517          * Sets the element deleter of the collection.
518          *
519          * @since 2.0
520          *
521          * @param[in]   deleter A function pointer to the element deleter to set
522          */
523         virtual void SetDeleter(DeleterFunctionType deleter);
524
525         _MultiHashMapEntry** __pTable;
526         int __count;
527         int __capacity;
528         float __loadFactor;
529         int __threshold;
530         IHashCodeProvider* __pProvider;
531         IComparer* __pComparer;
532         bool __needToRemoveProviderComparer;
533         int __modCount;
534         DeleterFunctionType __deleter;
535         static const int DEFAULT_CAPACITY = 16;
536         static const float DEFAULT_LOAD_FACTOR;
537
538         friend class _MultiHashMapEnumerator;
539         friend class _MultiHashMapImpl;
540         class _MultiHashMapImpl* __pMultiHashMapImpl;
541
542 }; // MultiHashMap
543
544 }}} // Tizen::Base::Collection
545
546 #endif //_FBASE_COL_MULTI_HASH_MAP_H_