[#BloombergLP-bslstl-HashTableBucketIterator]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bslstl.adoc[bslstl]::HashTableBucketIterator
:relfileprefix: ../../
:mrdocs:

== Synopsis

Declared in `&lt;bslstl&lowbar;hashtablebucketiterator&period;h&gt;`

[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class VALUE&lowbar;TYPE,
    class DIFFERENCE&lowbar;TYPE&gt;
class HashTableBucketIterator;
----

== Type Aliases

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/HashTableBucketIterator/difference_type.adoc[`difference&lowbar;type`] 
| This `typedef` is an alias to `DIFFERENCE&lowbar;TYPE`&period;
| xref:BloombergLP/bslstl/HashTableBucketIterator/iterator_category.adoc[`iterator&lowbar;category`] 
| Standard iterator defined types &lsqb;24&period;4&period;2&rsqb;&period;
| xref:BloombergLP/bslstl/HashTableBucketIterator/pointer.adoc[`pointer`] 
| This `typedef` is an alias to `VALUE&lowbar;TYPE &ast;`&period;
| xref:BloombergLP/bslstl/HashTableBucketIterator/reference.adoc[`reference`] 
| Reference type for the iterator&apos;s value type&period;
| xref:BloombergLP/bslstl/HashTableBucketIterator/value_type.adoc[`value&lowbar;type`] 
| This `typedef` is an alias for the iterator&apos;s value type&period;
|===


== Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/HashTableBucketIterator/2constructor-0c.adoc[`HashTableBucketIterator`]         [.small]#[constructor]#
| Constructors
| xref:BloombergLP/bslstl/HashTableBucketIterator/operator_assign.adoc[`operator&equals;`] 
| Copy the value of the specified `rhs` of another (compatible) `HashTableBucketIterator` type, (e&period;g&period;, a mutable iterator of the same type) to this iterator&period; Return a reference to this modifiable object&period; Note that this method may be the copy&hyphen;assignment operator (inhibiting the implicit declaration of a copy&hyphen;assignment operator above), or may be an additional overload&period;
| xref:BloombergLP/bslstl/HashTableBucketIterator/bucket.adoc[`bucket`] 
| Return the address of the hash table bucket referred to by this iterator&period; Note that this method is an implementation detail intended for debugging purposes only, and is not part of the C&plus;&plus; standard&period;
| xref:BloombergLP/bslstl/HashTableBucketIterator/node.adoc[`node`] 
| Return the address of the node holding the element at which this iterator is positioned, or 0 if this iterator is positioned after the end of a bucket&period; Note that this method is an implementation detail and is not part of the C&plus;&plus; standard&period;
| xref:BloombergLP/bslstl/HashTableBucketIterator/operator_star.adoc[`operator&ast;`] 
| Return a reference providing modifiable access to the element (of the template parameter `VALUE&lowbar;TYPE`) at which this iterator is positioned&period; The behavior is undefined unless the iterator refers to a valid (not yet erased) element in a hash table bucket&period; Note that this iterator is invalidated when the underlying hash table is rehashed&period;
| xref:BloombergLP/bslstl/HashTableBucketIterator/operator_inc.adoc[`operator&plus;&plus;`] 
| Move this iterator to the next element in the hash table bucket and return a reference providing modifiable access to this iterator&period; The behavior is undefined unless the iterator refers to a valid (not yet erased) element in a bucket&period; Note that this iterator is invalidated when the underlying hash table is rehashed&period;
| xref:BloombergLP/bslstl/HashTableBucketIterator/operator_ptr.adoc[`operator&hyphen;&gt;`] 
| Return the address of the element (of the template parameter `VALUE&lowbar;TYPE`) at which this iterator is positioned&period; The behavior is undefined unless the iterator refers to a valid (not yet erased) element a hash table bucket&period; Note that this iterator is invalidated when the underlying hash table is rehashed&period;
|===


== Non-Member Functions

[cols="1,4"]
|===
| Name| Description
| xref:BloombergLP/bslstl/operator_not_eq-00.adoc[`operator!&equals;`]
| Same as the preceding overload&period;
| xref:BloombergLP/bslstl/operator_not_eq-062ef.adoc[`operator!&equals;`]
| Same as the preceding overload&period;
| xref:BloombergLP/bslstl/operator_not_eq-09f.adoc[`operator!&equals;`]
| Same as the preceding overload&period;
| xref:BloombergLP/bslstl/operator_not_eq-0bf.adoc[`operator!&equals;`]
| Return `true` if the specified `lhs` and the specified `rhs` iterators do not have the same value and `false` otherwise&period; Two iterators do not have the same value if they refer to the different elements in the same hash table, or if either (but not both) of the iterators are positioned after the end of a hash table bucket&period;
| xref:BloombergLP/bslstl/operator_inc-0d9.adoc[`operator&plus;&plus;`]
| Move the specified `iter` to the next element in the hash table bucket and return the value of `iter` prior to this call&period; The behavior is undefined unless `iter` refers to a valid (not yet erased) element in a bucket&period; Note that `iter` is invalidated when the underlying hash table is rehashed&period;
| xref:BloombergLP/bslstl/operator_eq-040.adoc[`operator&equals;&equals;`]
| Same as the preceding overload&period;
| xref:BloombergLP/bslstl/operator_eq-04e.adoc[`operator&equals;&equals;`]
| Same as the preceding overload&period;
| xref:BloombergLP/bslstl/operator_eq-0b.adoc[`operator&equals;&equals;`]
| Return `true` if the specified `lhs` and the specified `rhs` iterators have the same value and `false` otherwise&period; Two iterators have the same value if they refer to the same element in the same hash table, or if both iterators are positioned after the end of a hash table bucket&period;
| xref:BloombergLP/bslstl/operator_eq-0e.adoc[`operator&equals;&equals;`]
| Same as the preceding overload&period;
|===


[.small]#Created with https://www.mrdocs.com[MrDocs]#
