SourcePro C++ 12.0
SourcePro® C++ API Reference Guide
SourcePro C++
Documentation Home
SourcePro C++ 12.0 |
SourcePro® C++ API Reference Guide |
SourcePro C++ Documentation Home |
Maintains a collection of mappings between two types K and V, implemented as a hash table of std::pair<K,V> instances. More...
#include <rw/stdex/hashmap.h>
Public Types | |
| typedef std::pair< const K, V > | value_type |
| typedef K | key_type |
| typedef impl_type::size_type | size_type |
| typedef impl_type::difference_type | difference_type |
| typedef impl_type::reference | reference |
| typedef impl_type::const_reference | const_reference |
| typedef impl_type::Iterator | iterator |
| typedef impl_type::ConstIterator | const_iterator |
| typedef Hash | key_hash_type |
| typedef EQ | key_equal_type |
Public Member Functions | |
| rw_hashmap (size_type sz=1024, const Hash &h=Hash(), const EQ &eq=EQ()) | |
| rw_hashmap (const rw_hashmap< K, V, Hash, EQ, A > &map) | |
| rw_hashmap (rw_hashmap< K, V, Hash, EQ, A > &&lst) | |
| rw_hashmap (const value_type *first, const value_type *bound, size_type sz=1024, const Hash &h=Hash(), const EQ &eq=EQ()) | |
| rw_hashmap (const_iterator first, const_iterator bound, size_type sz=1024, const Hash &h=Hash(), const EQ &eq=EQ()) | |
| ~rw_hashmap () | |
| rw_hashmap< K, V, Hash, EQ, A > & | operator= (const rw_hashmap< K, V, Hash, EQ, A > &rhs) |
| rw_hashmap< K, V, Hash, EQ, A > & | operator= (rw_hashmap< K, V, Hash, EQ, A > &&rhs) |
| bool | operator== (const rw_hashmap< K, V, Hash, EQ, A > &rhs) const |
| V & | operator[] (const key_type &key) |
| iterator | begin () |
| const_iterator | begin () const |
| iterator | end () |
| const_iterator | end () const |
| bool | empty () const |
| bool | equal_by_keys (const rw_hashmap< K, V, Hash, EQ, A > &rhs) const |
| size_type | size () const |
| size_type | count (const key_type &key) const |
| const_iterator | find (const key_type &key) const |
| iterator | find (const key_type &key) |
| iterator | lower_bound (const key_type &key) |
| const_iterator | lower_bound (const key_type &key) const |
| iterator | upper_bound (const key_type &key) |
| const_iterator | upper_bound (const key_type &key) const |
| std::pair< iterator, iterator > | equal_range (const key_type &key) |
| std::pair< const_iterator, const_iterator > | equal_range (const key_type &key) const |
| size_type | capacity () const |
| float | fill_ratio () const |
| void | resize (size_t sz) |
| void | swap (rw_hashmap< K, V, Hash, EQ, A > &other) |
| std::pair< iterator, bool > | insert (const value_type &val) |
| iterator | insert (iterator location_hint, const value_type &val) |
| std::pair< iterator, bool > | insert (value_type &&val) |
| iterator | insert (iterator location_hint, value_type &&val) |
| size_type | insert (const value_type *first, const value_type *bound) |
| size_type | insert (const_iterator first, const_iterator bound) |
| size_type | erase (const key_type &key) |
| iterator | erase (iterator iter) |
| iterator | erase (iterator iter, iterator bound) |
| void | clear () |
Class rw_hashmap<K,V,H,EQ,A> maintains a collection of mappings between K and V, implemented as a hash table of std::pair<const K,V>. operator== must be defined for type V. Pairs with duplicate keys are not allowed. Two pairs having duplicate keys as the result of the EQ comparison, applied to the first element of each, is true.
Since this is a value based collection, objects are copied into and out of the collection.
As with all classes that meet the ANSI associative container specification, rw_hashmap<K,V,H,EQ,A> provides for iterators that reference its elements. Operations that alter the contents of rw_hashmap<K,V,H,EQ,A> may invalidate other iterators that reference the container. Since the contents of rw_hashmap<K,V,H,EQ,A> are in pseudo-random order, the only iterator ranges that will usually make sense are the results of calling equal_range(), and the entire range from begin() to end().
#include <rw/stdex/hashmap.h> rw_hashmap<K,V,H,EQ,A=std::allocator<std::pair<const K,V> > >;
None
| typedef impl_type::ConstIterator rw_hashmap< K, V, Hash, EQ, A >::const_iterator |
| typedef impl_type::const_reference rw_hashmap< K, V, Hash, EQ, A >::const_reference |
Typedef for a const reference to a value in this container.
| typedef impl_type::difference_type rw_hashmap< K, V, Hash, EQ, A >::difference_type |
Typedef for the type of result from subtracting two iterators obtained from this container.
| typedef impl_type::Iterator rw_hashmap< K, V, Hash, EQ, A >::iterator |
| typedef EQ rw_hashmap< K, V, Hash, EQ, A >::key_equal_type |
A typedef for the equality object.
| typedef Hash rw_hashmap< K, V, Hash, EQ, A >::key_hash_type |
A typedef for the hash object.
| typedef K rw_hashmap< K, V, Hash, EQ, A >::key_type |
A typedef for the type of key in an element of this container.
| typedef impl_type::reference rw_hashmap< K, V, Hash, EQ, A >::reference |
Typedef for a non-const reference to a value in this container.
| typedef impl_type::size_type rw_hashmap< K, V, Hash, EQ, A >::size_type |
Typedef for the type used to index into this container.
| typedef std::pair<const K,V> rw_hashmap< K, V, Hash, EQ, A >::value_type |
A typedef for the elements in this container.
| rw_hashmap< K, V, Hash, EQ, A >::rw_hashmap | ( | size_type | sz = 1024, |
|
| const Hash & | h = Hash(), |
|||
| const EQ & | eq = EQ() | |||
| ) | [inline] |
Constructs an empty rw_hashmap<K,V,H,EQ,A> with sz slots, using h as the hash object, and eq as the equality comparator.
| rw_hashmap< K, V, Hash, EQ, A >::rw_hashmap | ( | const rw_hashmap< K, V, Hash, EQ, A > & | map | ) | [inline] |
Constructs an rw_hashmap<K,V,H,EQ,A> that is a copy of map. Each element from map is copied into self.
| rw_hashmap< K, V, Hash, EQ, A >::rw_hashmap | ( | rw_hashmap< K, V, Hash, EQ, A > && | lst | ) | [inline] |
Move constructor. The constructed list takes ownership of the data owned by lst.
| rw_hashmap< K, V, Hash, EQ, A >::rw_hashmap | ( | const value_type * | first, | |
| const value_type * | bound, | |||
| size_type | sz = 1024, |
|||
| const Hash & | h = Hash(), |
|||
| const EQ & | eq = EQ() | |||
| ) |
Constructs an rw_hashmap<K,V,H,EQ,A> with sz slots, using h as the hash object, eq as the equality comparator, and containing a copy of each pair referenced by the range starting with first and bounded by bound. If there are items in the range for which the K parts of the pairs match EQ, then only the first such item is inserted into self.
| rw_hashmap< K, V, Hash, EQ, A >::rw_hashmap | ( | const_iterator | first, | |
| const_iterator | bound, | |||
| size_type | sz = 1024, |
|||
| const Hash & | h = Hash(), |
|||
| const EQ & | eq = EQ() | |||
| ) |
Constructs an rw_hashmap<K,V,H,EQ,A> with sz slots, using h as the hash object, eq as the equality comparator, and containing a copy of each pair referenced by the range starting with first and bounded by bound.
| rw_hashmap< K, V, Hash, EQ, A >::~rw_hashmap | ( | ) | [inline] |
Releases the memory used by the container's implementation.
| const_iterator rw_hashmap< K, V, Hash, EQ, A >::begin | ( | ) | const [inline] |
The iterator returned references the first item in self. If self is empty, the iterator is equal to end(). Note that because items are stored in pseudo-random order, this iterator might reference any item that has been stored in self.
| iterator rw_hashmap< K, V, Hash, EQ, A >::begin | ( | ) | [inline] |
The iterator returned references the first item in self. If self is empty, the iterator is equal to end(). Note that because items are stored in pseudo-random order, this iterator might reference any item that has been stored in self.
| size_type rw_hashmap< K, V, Hash, EQ, A >::capacity | ( | ) | const [inline] |
Returns the number of slots in the hash table that self uses.
| void rw_hashmap< K, V, Hash, EQ, A >::clear | ( | ) | [inline] |
A synonym for erase(begin(),end()) .
| size_type rw_hashmap< K, V, Hash, EQ, A >::count | ( | const key_type & | key | ) | const [inline] |
Returns 1 if self contains a pair with its first element EQ to key, else 0.
| bool rw_hashmap< K, V, Hash, EQ, A >::empty | ( | ) | const [inline] |
Returns true if self is empty.
| const_iterator rw_hashmap< K, V, Hash, EQ, A >::end | ( | ) | const [inline] |
The iterator returned marks the location "off the end" of self. It cannot be dereferenced.
| iterator rw_hashmap< K, V, Hash, EQ, A >::end | ( | ) | [inline] |
The iterator returned marks the location "off the end" of self. It cannot be dereferenced.
| bool rw_hashmap< K, V, Hash, EQ, A >::equal_by_keys | ( | const rw_hashmap< K, V, Hash, EQ, A > & | rhs | ) | const [inline] |
Returns true if self and rhs have the same size, and if for each value_type in self, there is a value_type in rhs such that the EQ object in self returns true when called for the first parts of those pairs. Note that this method does not compare the V (second) part of the pair of the items, so it will run slightly faster than operator==().
| std::pair<const_iterator,const_iterator> rw_hashmap< K, V, Hash, EQ, A >::equal_range | ( | const key_type & | key | ) | const [inline] |
Returns std::pair<const_iterator,const_iterator>(lower_bound(), upper_bound()). The methods, upper_bound() and lower_bound(), have special meaning for hash-based collections.
EQ to each other are in consecutive iterator locations. Thus, while equal_range() is useful, no other range (except the entire range of the hash table) is likely to be meaningful. | std::pair<iterator,iterator> rw_hashmap< K, V, Hash, EQ, A >::equal_range | ( | const key_type & | key | ) | [inline] |
Returns std::pair<iterator,iterator>(lower_bound(), upper_bound()). The methods, upper_bound() and lower_bound(), have special meaning for hash-based collections.
EQ to each other are in consecutive iterator locations. Thus, while equal_range() is useful, no other range (except the entire range of the hash table) is likely to be meaningful. | iterator rw_hashmap< K, V, Hash, EQ, A >::erase | ( | iterator | iter, | |
| iterator | bound | |||
| ) | [inline] |
Removes each element in the range which begins with first and is bounded by bound. Returns an iterator referencing bound. If iter does not reference an item in self (and if iter and bound are not equal), the effect is undefined.
| iterator rw_hashmap< K, V, Hash, EQ, A >::erase | ( | iterator | iter | ) | [inline] |
Removes the element referenced by iter and returns an iterator referencing the next element. If iter does not reference an item in self, the result is undefined.
| size_type rw_hashmap< K, V, Hash, EQ, A >::erase | ( | const key_type & | key | ) | [inline] |
If there is a pair in self for which the first part is EQ to key, that pair is removed, and 1 is returned. Otherwise, 0 is returned.
| float rw_hashmap< K, V, Hash, EQ, A >::fill_ratio | ( | ) | const [inline] |
Returns the result of calculating size() / capacity().
| iterator rw_hashmap< K, V, Hash, EQ, A >::find | ( | const key_type & | key | ) | [inline] |
Returns an iterator referencing the pair with key as its first element, if such a pair is contained in self, else returns end().
| const_iterator rw_hashmap< K, V, Hash, EQ, A >::find | ( | const key_type & | key | ) | const [inline] |
Returns an rw_hashmap<K,V,Hash,EQ,A>::const_iterator referencing the pair with key as its first element if such a pair is contained in self, else returns end().
| size_type rw_hashmap< K, V, Hash, EQ, A >::insert | ( | const_iterator | first, | |
| const_iterator | bound | |||
| ) | [inline] |
For each element in the range beginning with first and bounded by bound, if there is no pair in self with first part EQ to the first part of that element, the element is copied into self; or if there is such a pair, the element is skipped. Returns the number of elements inserted.
| size_type rw_hashmap< K, V, Hash, EQ, A >::insert | ( | const value_type * | first, | |
| const value_type * | bound | |||
| ) | [inline] |
For each element in the range beginning with first and bounded by bound, if there is no pair in self with first part EQ to the first part of that element, the element is copied into self; or if there is such a pair, the element is skipped. Returns the number of elements inserted.
| iterator rw_hashmap< K, V, Hash, EQ, A >::insert | ( | iterator | location_hint, | |
| value_type && | val | |||
| ) | [inline] |
If there is no pair in self with first part EQ to the first part of val, inserts val, returning 1. Otherwise, does nothing and returns 0. Note that the first argument is provided only for conformance with the ANSI associative container specification, and is ignored by the method since hash table look up can be done in constant time.
| std::pair<iterator,bool> rw_hashmap< K, V, Hash, EQ, A >::insert | ( | value_type && | val | ) | [inline] |
If there is no pair in self with first part EQ to the first part of val, inserts val, returning a pair with an iterator referencing the new element and true. Otherwise, returns a pair with an iterator referencing the matching value_type and false.
| iterator rw_hashmap< K, V, Hash, EQ, A >::insert | ( | iterator | location_hint, | |
| const value_type & | val | |||
| ) | [inline] |
If there is no pair in self with first part EQ to the first part of val, inserts val, returning 1. Otherwise, does nothing and returns 0. Note that the first argument is provided only for conformance with the ANSI associative container specification, and is ignored by the method since hash table look up can be done in constant time.
| std::pair<iterator,bool> rw_hashmap< K, V, Hash, EQ, A >::insert | ( | const value_type & | val | ) | [inline] |
If there is no pair in self with first part EQ to the first part of val, inserts val, returning a pair with an iterator referencing the new element and true. Otherwise, returns a pair with an iterator referencing the matching value_type and false.
| const_iterator rw_hashmap< K, V, Hash, EQ, A >::lower_bound | ( | const key_type & | key | ) | const [inline] |
Returns the lower bound of key in self. This has a special meaning for hash-based collections.
Since hash tables are intrinsically unordered, we have relaxed the meaning very slightly so that lower_bound() returns an iterator which points to one of the following:
EQ to key. | iterator rw_hashmap< K, V, Hash, EQ, A >::lower_bound | ( | const key_type & | key | ) | [inline] |
Returns the lower bound of key in self. This has a special meaning for hash-based collections.
Since hash tables are intrinsically unordered, we have relaxed the meaning very slightly so that lower_bound() returns an iterator which points to one of the following:
EQ to key. | rw_hashmap<K,V,Hash,EQ,A>& rw_hashmap< K, V, Hash, EQ, A >::operator= | ( | rw_hashmap< K, V, Hash, EQ, A > && | rhs | ) | [inline] |
Move assignment. Self takes ownership of the data owned by rhs.
| rw_hashmap<K,V,Hash,EQ,A>& rw_hashmap< K, V, Hash, EQ, A >::operator= | ( | const rw_hashmap< K, V, Hash, EQ, A > & | rhs | ) | [inline] |
Sets self to have the same capacity, Hash and EQ as rhs, removes all self's current contents, and replaces them with copies of the elements in rhs.
| bool rw_hashmap< K, V, Hash, EQ, A >::operator== | ( | const rw_hashmap< K, V, Hash, EQ, A > & | rhs | ) | const |
Returns true if self and rhs have the same number of elements, and for each value_type in self, there is a value_type in rhs that has a first part for which the EQ object in self returns true, and a second part for which operator==() returns true. The need to test both parts means that this operator is slightly slower than the method equal_by_keys().
| V& rw_hashmap< K, V, Hash, EQ, A >::operator[] | ( | const key_type & | key | ) |
Returns a reference to the V part of a pair held in self which has a part EQ to key, either by finding such a pair, or inserting one (in which case the reference is to an instance of V created by its default constructor).
| void rw_hashmap< K, V, Hash, EQ, A >::resize | ( | size_t | sz | ) | [inline] |
Resizes self's hash table to have sz slots and re-hashes all self's elements into the new table. Can be very expensive if self holds many elements.
| size_type rw_hashmap< K, V, Hash, EQ, A >::size | ( | ) | const [inline] |
Returns the number of pairs currently held in self.
| void rw_hashmap< K, V, Hash, EQ, A >::swap | ( | rw_hashmap< K, V, Hash, EQ, A > & | other | ) | [inline] |
Exchanges the contents of self with other including the Hash and EQ objects. This method does not copy or destroy any of the items exchanged but exchanges the underlying hash tables.
| const_iterator rw_hashmap< K, V, Hash, EQ, A >::upper_bound | ( | const key_type & | key | ) | const [inline] |
Returns the upper bound of key in self. This has a special meaning for hash-based collections.
Since hash tables are intrinsically unordered, we have relaxed the meaning very slightly so that upper_bound() returns an iterator which points to one of the following:
EQ to key. | iterator rw_hashmap< K, V, Hash, EQ, A >::upper_bound | ( | const key_type & | key | ) | [inline] |
Returns the upper bound of key in self. This has a special meaning for hash-based collections.
Since hash tables are intrinsically unordered, we have relaxed the meaning very slightly so that upper_bound() returns an iterator which points to one of the following:
EQ to key. © Copyright Rogue Wave Software, Inc. All Rights Reserved.
Rogue Wave and SourcePro are registered trademarks of Rogue Wave Software, Inc. in the United States and other countries. All other trademarks are the property of their respective owners.
Contact Rogue Wave about documentation or support issues.