rw_hashmap<K,T,H,EQ,A>

Module:  Essential Tools Module   Group:  STL Extension-based Collection Classes

Does not inherit

• Local Index
• Synopsis
• Description
• Persistence
• Public Typedefs
• Public Constructors
• Public Destructor
• Public Operators
• Accessors
• Const Public Member Functions
• Mutators
• Special Methods for Maps

Members

begin() capacity() clear() const_iterator const_reference count() difference_type empty()

end() equal_by_keys() equal_range() erase() fill_ratio() find() insert() iterator

key_equal key_hash key_type lower_bound() operator=() operator==() operator[]() reference

resize() rw_hashmap<K,T,H,EQ,A>() size() size_type swap() upper_bound() value_type ~rw_hashmap<K,T,H,EQ,A>()

#include <rw/stdex/hashmap.h>
rw_hashmap<K,T,H,EQ,A=std::allocator<std::pair<const K,T>>>;

rw_hashmap<K,T,H,EQ,A> requires the C++ Standard Library.

Class rw_hashmap<K,T,H,EQ,A> maintains a collection of mappings between K and V, implemented as a hash table of pair<const K,V>. operator== must be defined for type V. Pairs with duplicate keys are not allowed. Two pairs having duplicate keys is 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,T,H,EQ,A> provides for iterators that reference its elements. Operations that alter the contents of rw_hashmap<K,T,H,EQ,A> may invalidate other iterators that reference the container. Since the contents of rw_hashmap<K,T,H,EQ,A> are in pseudo-random order, the only iterator ranges that will usually make sense are the results of calling equal_range(key), and the entire range from begin() to end().

None

typedef K key_type;
typedef Hash key_hash; 
typedef EQ key_equal; 
typedef pair<K,V> value_type; // or ... "const K"
typedef (unsigned) size_type; //from rw_slist<T,A>
typedef (int) difference_type; // from rw_slist<T,A>
typedef (value_type&) reference; 
typedef (const value_type&) const_reference; //from rw_slist<T,A>

Iterators over rw_hashmap<K,T,H,EQ,A> are forward iterators.

typedef (scoped Iterator) iterator;
typedef (scoped ConstIterator) const_iterator; 

rw_hashmap<K,T,H,EQ,A>(size_type sz = 1024, 
                        const Hash& h = Hash(), 
                        const EQ& eq = EQ());

Constructs an empty rw_hashmap<K,T,H,EQ,A> with sz slots, using h as the hash object, and eq as the equality comparator.

rw_hashmap<K,T,H,EQ,A>(const rw_hashmap<K,T,
                        H,EQ,A>& map);

Constructs an rw_hashmap<K,T,H,EQ,A> which is a copy of map. Each element from map will be copied into self.

rw_hashmap<K,T,H,EQ,A>(const_iterator first, 
                        const_iterator bound
                        size_type sz=1024,
                        const Hash& h = Hash(), 
                        const EQ& eq = EQ());

Constructs an rw_hashmap<K,T,H,EQ,A> with sz slots, using h as the hash object, and eq as the equality comparator, containing a copy of each pair referenced by the range starting with first and bounded by bound.

rw_hashmap<K,T,H,EQ,A>(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,T,H,EQ,A> with sz slots, using h as the hash object, and eq as the equality comparator, 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 will be inserted into self.

~rw_hashmap<K,T,H,EQ,A>();

Releases the memory used by the container's implementation.

rw_hashmap<K,T,H,EQ,A>&
operator=(const rw_hashmap<K,T,H,EQ,A>& rhs);

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
operator==(const rw_hashmap<K,T,H,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() described below.

V&
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).

iterator
begin();

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.

const_iterator
begin() const;

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
end();

The iterator returned marks the location "off the end" of self. It may not be dereferenced.

const_iterator
end() const;

The iterator returned marks the location "off the end" of self. It may not be dereferenced.

pair<const_iterator, const_iterator>
equal_range(const key_type key) const;

Returns pair<const_iterator, const_iterator>(lower_bound(key), upper_bound(key)). Upper and lower bound have special meaning for hash-based collections. See discussion elsewhere.

pair<iterator, iterator>
equal_range(const key_type key);

Returns pair<iterator, iterator>(lower_bound(key), upper_bound(key)). Upper and lower bound have special meaning for hash-based collections. See discussion elsewhere.

const_iterator
lower_bound(const key_type& key) const;

Returns the lower bound of key in self. This has a special meaning for hash-based collections. See discussion elsewhere.

iterator
lower_bound(const key_type& key);

Returns the lower bound of key in self. This has a special meaning for hash-based collections. See discussion elsewhere.

const_iterator
upper_bound(const key_type& key) const;

Returns the upper bound of key in self. This has a special meaning for hash-based collections. See discussion elsewhere.

iterator
upper_bound(const key_type& key);

Returns the upper bound of key in self. This has a special meaning for hash-based collections. See discussion elsewhere.

size_type
capacity() const;

Returns the number of slots in the hash table that self uses.

bool
empty() const;

Returns true if self is empty.

float
fill_ratio() const;

Returns the result of calculating size()/capacity().

size_type
size() const;

Returns the number of pairs currently held in self.

void
clear();

A synonym for erase(begin(),end());

size_type
erase(const key_type& key);

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.

iterator
erase(iterator iter);

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.

iterator
erase(iterator first, iterator bound);

Removes each element in the range which begins with first and is bound by bound. Returns an iterator referencing bound. If first does not reference an item in self (and if first and bound are not equal), the effect is undefined.

pair<iterator,bool>
insert(const value_type& val);

If there is no pair in self with first part EQ to the first part of val then 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.

size_type
insert(iterator ignore, const value_type& val);

If there is no pair in self with first part EQ to the first part of val then 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.

size_type
insert(const value_type* first, const value_type* bound);

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
insert(const_iterator first, const_iterator bound);

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.

void
swap(rw_hashmap<K,T,H,EQ,A>& other);

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.

size_type
count(const key_type& key) const;

Returns 1 if self contains a pair with its first element EQ to key, else 0.

bool
equal_by_keys(const rw_hashmap<K,T,H,EQ,A>& rhs) const;

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==().

const_iterator
find(const key_type& key) const;

Returns a const_iterator referencing the pair with key as its first element if such a pair is contained in self, else returns end().

iterator
find(const key_type& key);

Returns an iterator referencing the pair with key as its first element, if such a pair is contained in self, else returns end().

void
resize(size_type sz);

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.

© 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.