Equality operators
Synopses
Declared in <bslstl_bidirectionaliterator.h>
Return true if the specified lhs iterator has the same value as the specified rhs iterator, and false otherwise. Two iterators have the same value if they refer to the same element, or both have the past‐the‐ end value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.
template<
class T1,
class T2,
class ITER_IMP,
class TAG_TYPE>
bool
operator==(
ForwardIterator<T1, ITER_IMP, TAG_TYPE> const& lhs,
ForwardIterator<T2, ITER_IMP, TAG_TYPE> const& rhs);Return true if the specified lhs iterator has the same value as the specified rhs iterator, and false otherwise. Two iterators have the same value if they refer to the same element, or both have the past‐the‐ end value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.
template<
class T1,
class T2,
class ITER_IMP,
class TAG_TYPE>
bool
operator==(
BidirectionalIterator<T1, ITER_IMP, TAG_TYPE> const& lhs,
BidirectionalIterator<T2, ITER_IMP, TAG_TYPE> const& rhs);Return true if the specified lhs iterator has the same value as the specified rhs iterator, and false otherwise. Two iterators have the same value if they refer to the same element, or both have the past‐the‐ end value for the underlying sequence. The behavior is undefined unless both iterators refer to the same underlying sequence.
template<
class T1,
class T2,
class ITER_IMP,
class TAG_TYPE>
bool
operator==(
RandomAccessIterator<T1, ITER_IMP, TAG_TYPE> const& lhs,
RandomAccessIterator<T2, ITER_IMP, TAG_TYPE> const& rhs);Return whether the specified iterators refer to the same tree node.
bool
operator==(
TreeIterator<VALUE1, NODEPTR, DIFF> const&,
TreeIterator<VALUE2, NODEPTR, DIFF> const&);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 position in the same tree, or if both iterators are at an invalid position in the tree (i.e., the end of the tree, or the default constructed value).
template<
class VALUE1,
class VALUE2,
class NODEPTR,
class DIFF>
bool
operator==(
TreeIterator<VALUE1, NODEPTR, DIFF> const& lhs,
TreeIterator<VALUE2, NODEPTR, DIFF> const& rhs);Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two HashTable objects have the same value if they have the same number of elements, and for every subset of elements in lhs having keys that compare equal (according to that hash table's comparator), a corresponding subset of elements exists in rhs, having the same number of elements, where, for some permutation of the lhs subset, every element in that subset compares equal (using operator==) to the corresponding element in the rhs subset. The behavior is undefined unless both the hasher and comparator of lhs and rhs return the same value for every valid input. Note that this method requires that the ValueType of the parameterized KEY_CONFIG be "equality‐comparable" (see {Requirements on KEY_CONFIG}).
template<
class KEY_CONFIG,
class HASHER,
class COMPARATOR,
class ALLOCATOR>
bool
operator==(
HashTable<KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR> const& lhs,
HashTable<KEY_CONFIG, HASHER, COMPARATOR, ALLOCATOR> const& rhs);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 element in the same hash table, or if both iterators are positioned after the end of a hash table bucket.
template<
class VALUE_TYPE,
class DIFFERENCE_TYPE>
bool
operator==(
HashTableBucketIterator<VALUE_TYPE, DIFFERENCE_TYPE> const& lhs,
HashTableBucketIterator<VALUE_TYPE, DIFFERENCE_TYPE> const& rhs);Same as the preceding overload.
template<
class VALUE_TYPE,
class DIFFERENCE_TYPE>
bool
operator==(
HashTableBucketIterator<VALUE_TYPE, DIFFERENCE_TYPE> const& lhs,
HashTableBucketIterator<VALUE_TYPE const, DIFFERENCE_TYPE> const& rhs);Same as the preceding overload.
template<
class VALUE_TYPE,
class DIFFERENCE_TYPE>
bool
operator==(
HashTableBucketIterator<VALUE_TYPE const, DIFFERENCE_TYPE> const& lhs,
HashTableBucketIterator<VALUE_TYPE, DIFFERENCE_TYPE> const& rhs);Same as the preceding overload.
template<
class VALUE_TYPE,
class DIFFERENCE_TYPE>
bool
operator==(
HashTableBucketIterator<VALUE_TYPE const, DIFFERENCE_TYPE> const& lhs,
HashTableBucketIterator<VALUE_TYPE const, DIFFERENCE_TYPE> const& rhs);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.
template<
class VALUE_TYPE,
class DIFFERENCE_TYPE>
bool
operator==(
HashTableIterator<VALUE_TYPE, DIFFERENCE_TYPE> const& lhs,
HashTableIterator<VALUE_TYPE, DIFFERENCE_TYPE> const& rhs);Same as the preceding overload.
template<
class VALUE_TYPE,
class DIFFERENCE_TYPE>
bool
operator==(
HashTableIterator<VALUE_TYPE, DIFFERENCE_TYPE> const& lhs,
HashTableIterator<VALUE_TYPE const, DIFFERENCE_TYPE> const& rhs);Same as the preceding overload.
template<
class VALUE_TYPE,
class DIFFERENCE_TYPE>
bool
operator==(
HashTableIterator<VALUE_TYPE const, DIFFERENCE_TYPE> const& lhs,
HashTableIterator<VALUE_TYPE, DIFFERENCE_TYPE> const& rhs);Same as the preceding overload.
template<
class VALUE_TYPE,
class DIFFERENCE_TYPE>
bool
operator==(
HashTableIterator<VALUE_TYPE const, DIFFERENCE_TYPE> const& lhs,
HashTableIterator<VALUE_TYPE const, DIFFERENCE_TYPE> const& rhs);Created with MrDocs