BloombergLP::bslstl::HashTableIterator

Synopsis

Declared in <bslstl_hashtableiterator.h>

template<
    class VALUE_TYPE,
    class DIFFERENCE_TYPE>
class HashTableIterator;

Name	Description
`difference_type`	Iterator difference type.
`iterator_category`	Standard iterator defined types [24.4.2].
`pointer`	This `typedef` is an alias to `VALUE_TYPE *`.
`reference`	This `typedef` is an alias to `VALUE_TYPE&`.
`value_type`	This `typedef` is an alias to the non-`const` form of `VALUE_TYPE`.

Name	Description
`HashTableIterator` [constructor]	Constructors
`~HashTableIterator` [destructor]	Destroy this object.
`operator=`	Assign to this object the value of the specified `rhs` object, and a return a reference providing modifiable access to this object.
`node`	Return the address of the node at which this iterator is positioned in the list, or 0 if this iterator is positioned after the end of a list. Note that this method is an implementation detail and is not part of the C++ standard.
`operator*`	Return a reference providing modifiable access to the value (of the template parameter `VALUE_TYPE`) of the node at which this iterator is positioned. The behavior is undefined unless the iterator refers to a valid (not yet erased) node the list.
`operator++`	Move this iterator to the next node in the list and return a reference providing modifiable access to this iterator. The behavior is undefined unless the iterator refers to a valid (not yet erased) node in the list.
`operator->`	Return the address of the value (of the template parameter `VALUE_TYPE`) of the element at which this iterator is positioned. The behavior is undefined unless the iterator refers to a valid (not yet erased) node the list.

Name	Description
`operator!=`	Same as the preceding overload.
`operator!=`	Same as the preceding overload.
`operator!=`	Same as the preceding overload.
`operator!=`	Return `true` if the specified `lhs` and the specified `rhs` iterators do not have the same value and `false` otherwise. Two iterators do not have the same value if they refer to the different nodes in the same list, or if either (but not both) of the iterators are at the past-the-end position of the tree.
`operator++`	Move the specified `iter` to the next node in the list and return value of `iter` prior to this call. The behavior is undefined unless `iter` refers to a valid (not yet erased) node a the list.
`operator==`	Same as the preceding overload.
`operator==`	Same as the preceding overload.
`operator==`	Same as the preceding overload.
`operator==`	Return `true` if the specified `lhs` and the specified `rhs` iterators have the same value and `false` otherwise. Two iterators have the same value if they refer to the same node in the same list, or if both iterators are at the past-the-end position of the tree.