rwlogo
SourcePro C++ 12.0

SourcePro® C++ API Reference Guide



   SourcePro C++
Documentation Home

rw_hashset< T, Hash, EQ, A > Class Template Reference
[STL Extension-based Collections]

Maintains a collection of some type A, in which there cannot be more than one occurrence of some given instance of A. More...

#include <rw/stdex/hashset.h>

Inherited by rw_internal_hashset< T, Hash, EQ, A >.

List of all members.

Public Types

typedef T value_type
typedef Hash key_hash_type
typedef EQ key_equal_type
typedef impl_type::const_reference reference
typedef impl_type::const_reference const_reference
typedef impl_type::const_iterator iterator
typedef impl_type::const_iterator const_iterator
typedef impl_type::size_type size_type
typedef impl_type::difference_type difference_type

Public Member Functions

 rw_hashset (const value_type *first, const value_type *bound, size_type sz=1024, const Hash &h=key_hash_type(), const EQ &eq=key_equal_type())
 rw_hashset (const_iterator first, const_iterator bound, size_type sz=1024, const Hash &h=key_hash_type(), const EQ &eq=key_equal_type())
 rw_hashset (size_type sz=1024, const Hash &h=key_hash_type(), const EQ &eq=key_equal_type())
 rw_hashset (const rw_hashset< T, Hash, EQ, A > &set)
 rw_hashset (rw_hashset< T, Hash, EQ, A > &&set)
 ~rw_hashset ()
rw_hashset< T, Hash, EQ, A > & operator= (const rw_hashset< T, Hash, EQ, A > &rhs)
rw_hashset< T, Hash, EQ, A > & operator= (rw_hashset< T, Hash, EQ, A > &&rhs)
bool operator== (const rw_hashset< T, Hash, EQ, A > &rhs) const
iterator begin () const
iterator end () const
bool empty () const
size_type size () const
size_type count (const_reference key) const
iterator find (const_reference key) const
iterator lower_bound (const_reference key) const
iterator upper_bound (const_reference key) const
std::pair< iterator, iteratorequal_range (const_reference key) const
size_type capacity () const
float fill_ratio () const
void resize (size_type sz)
void swap (rw_hashset< T, Hash, EQ, A > &other)
std::pair< iterator, bool > insert (const_reference val)
std::pair< iterator, bool > insert (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_reference key)
iterator erase (iterator iter)
iterator erase (iterator first, iterator bound)
void clear ()

Detailed Description

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
class rw_hashset< T, Hash, EQ, A >

Class rw_hashset<T,H,EQ,A> maintains a collection of T, implemented as a hash table in which there may not be more than one instance of any given T. 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_hashset<T,H,EQ,A> provides for iterators that reference its elements. Operations that alter the contents of rw_hashset<T,H,EQ,A> may invalidate other iterators that reference the container. Since the contents of rw_hashset<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(), and the entire range from begin() to end().

Synopsis

 #include <rw/stdex/hashset.h>
 rw_hashset<T,H,EQ,A=std::allocator<T> >;

Persistence

None


Member Typedef Documentation

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
typedef impl_type::const_iterator rw_hashset< T, Hash, EQ, A >::const_iterator

The typedef for the const iterator.

Note:
Iterators over rw_hashset<T,H,EQ,A> are forward iterators.
template<class T, class Hash, class EQ, class A = std:: allocator < T >>
typedef impl_type::const_reference rw_hashset< T, Hash, EQ, A >::const_reference

Typedef for a const reference to a value in this container.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
typedef impl_type::difference_type rw_hashset< T, Hash, EQ, A >::difference_type

Typedef for the type of difference between iterators.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
typedef impl_type::const_iterator rw_hashset< T, Hash, EQ, A >::iterator

The typedef for the non-const iterator.

Note:
Iterators over rw_hashset<T,H,EQ,A> are forward iterators.
template<class T, class Hash, class EQ, class A = std:: allocator < T >>
typedef EQ rw_hashset< T, Hash, EQ, A >::key_equal_type

A typedef for the equality object.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
typedef Hash rw_hashset< T, Hash, EQ, A >::key_hash_type

A typedef for the hash object.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
typedef impl_type::const_reference rw_hashset< T, Hash, EQ, A >::reference

Typedef for a non-const reference to a value in this container.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
typedef impl_type::size_type rw_hashset< T, Hash, EQ, A >::size_type

Typedef for the type used to index into this container.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
typedef T rw_hashset< T, Hash, EQ, A >::value_type

A typedef for the type of value in this container.


Constructor & Destructor Documentation

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
rw_hashset< T, Hash, EQ, A >::rw_hashset ( const value_type first,
const value_type bound,
size_type  sz = 1024,
const Hash &  h = key_hash_type(),
const EQ &  eq = key_equal_type() 
)

Constructs an rw_hashset<T,H,EQ,A> with sz slots, using h as the hash object, eq as the equality comparator, and containing a copy of each item referenced by the range starting with first and bounded by bound. If there are items in the range that test EQ, only the first such item will be inserted into self.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
rw_hashset< T, Hash, EQ, A >::rw_hashset ( const_iterator  first,
const_iterator  bound,
size_type  sz = 1024,
const Hash &  h = key_hash_type(),
const EQ &  eq = key_equal_type() 
)

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

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
rw_hashset< T, Hash, EQ, A >::rw_hashset ( size_type  sz = 1024,
const Hash &  h = key_hash_type (),
const EQ &  eq = key_equal_type () 
) [inline]

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

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
rw_hashset< T, Hash, EQ, A >::rw_hashset ( const rw_hashset< T, Hash, EQ, A > &  set  )  [inline]

Constructs an rw_hashset<T,H,EQ,A> that is a copy of set. Each element from set is copied into self.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
rw_hashset< T, Hash, EQ, A >::rw_hashset ( rw_hashset< T, Hash, EQ, A > &&  set  )  [inline]

Move constructor. The constructed list takes ownership of the data owned by set.

Condition:
This method is only available on platforms with rvalue reference support.
template<class T, class Hash, class EQ, class A = std:: allocator < T >>
rw_hashset< T, Hash, EQ, A >::~rw_hashset (  )  [inline]

The destructor releases the memory used by the container's implementation.


Member Function Documentation

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
iterator rw_hashset< T, 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.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
size_type rw_hashset< T, Hash, EQ, A >::capacity (  )  const [inline]

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

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
void rw_hashset< T, Hash, EQ, A >::clear (  )  [inline]

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

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
size_type rw_hashset< T, Hash, EQ, A >::count ( const_reference  key  )  const [inline]

Returns 1 if self contains key, else 0.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
bool rw_hashset< T, Hash, EQ, A >::empty (  )  const [inline]

Returns true if self is empty.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
iterator rw_hashset< T, Hash, EQ, A >::end (  )  const [inline]

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

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
std::pair<iterator,iterator> rw_hashset< T, Hash, EQ, A >::equal_range ( const_reference  key  )  const [inline]

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

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
iterator rw_hashset< T, Hash, EQ, A >::erase ( iterator  first,
iterator  bound 
) [inline]

Removes each element in the range which begins with first and is bounded 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.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
iterator rw_hashset< T, 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.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
size_type rw_hashset< T, Hash, EQ, A >::erase ( const_reference  key  )  [inline]

If there is an item EQ to key, it is removed, and 1 is returned. Otherwise, 0 is returned.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
float rw_hashset< T, Hash, EQ, A >::fill_ratio (  )  const [inline]

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

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
iterator rw_hashset< T, Hash, EQ, A >::find ( const_reference  key  )  const [inline]

Returns an iterator referencing key if it is contained in self, else returns end().

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
size_type rw_hashset< T, 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 item in self EQ to that element, the element is copied into self; or if there is such an element, it is skipped. Returns the number of elements inserted.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
size_type rw_hashset< T, 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 item in self EQ to that element, the element is copied into self; or if there is such an element, it is skipped. Returns the number of elements inserted.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
std::pair<iterator,bool> rw_hashset< T, Hash, EQ, A >::insert ( value_type &&  val  )  [inline]

If there is no item in self EQ to 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.

Condition:
This method is only available on platforms with rvalue reference support.
template<class T, class Hash, class EQ, class A = std:: allocator < T >>
std::pair<iterator,bool> rw_hashset< T, Hash, EQ, A >::insert ( const_reference  val  )  [inline]

If there is no item in self EQ to 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.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
iterator rw_hashset< T, Hash, EQ, A >::lower_bound ( const_reference  key  )  const [inline]

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

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
rw_hashset<T,Hash,EQ,A>& rw_hashset< T, Hash, EQ, A >::operator= ( rw_hashset< T, Hash, EQ, A > &&  rhs  )  [inline]

Move assignment. Self takes ownership of the data owned by rhs.

Condition:
This method is only available on platforms with rvalue reference support.
template<class T, class Hash, class EQ, class A = std:: allocator < T >>
rw_hashset<T,Hash,EQ,A>& rw_hashset< T, Hash, EQ, A >::operator= ( const rw_hashset< T, 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.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
bool rw_hashset< T, Hash, EQ, A >::operator== ( const rw_hashset< T, Hash, EQ, A > &  rhs  )  const [inline]

Returns true if self and rhs have the same number of elements, and for each item in self there is an item in rhs which tests EQ.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
void rw_hashset< T, Hash, EQ, A >::resize ( size_type  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.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
size_type rw_hashset< T, Hash, EQ, A >::size (  )  const [inline]

Returns the number of items currently held in self.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
void rw_hashset< T, Hash, EQ, A >::swap ( rw_hashset< T, 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.

template<class T, class Hash, class EQ, class A = std:: allocator < T >>
iterator rw_hashset< T, Hash, EQ, A >::upper_bound ( const_reference  key  )  const [inline]

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

 All Classes Functions Variables Typedefs Enumerations Enumerator Friends

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