BloombergLP::bdlc::operator==

Synopses

Declared in <bdlc_bitarray.h>

Return true if the specified a and b are equal. Two FlatHashTable_IteratorImp objects are equal if they both refer to the same element of the underlying flat hash table, or are both not dereferenceable. The behavior is undefined unless a and b refer to the same FlatHashTable.

template<class ENTRY>
bool
operator==(
    FlatHashTable_IteratorImp<ENTRY> const& a,
    FlatHashTable_IteratorImp<ENTRY> const& b);

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two FlatHashSet objects have the same value if their sizes are the same and each element contained in one is equal to an element of the other. The hash and equality functors are not involved in the comparison.

template<
    class KEY,
    class HASH,
    class EQUAL>
bool
operator==(
    FlatHashSet<KEY, HASH, EQUAL> const& a,
    FlatHashSet<KEY, HASH, EQUAL> const& b);

Return whether the sets have the same contents.

template<>
bool
operator==(
    FlatHashSet const&,
    FlatHashSet const&);

Return true if the specified lhs and rhs index clerks have the same value, and false otherwise. Two IndexClerk objects have the same value if they have the same nextNewIndex() and would always generate the same sequence of integer indices.

bool
operator==(
    IndexClerk const& lhs,
    IndexClerk const& rhs);

Return true if lhs and rhs have the same value and false otherwise. Two iterators have the same value if they refer to the same element of the same container or if they both have the end iterator value for the same container. The behavior is undefined unless lhs and rhs refer to the same container and are non-singular (i.e., are not default-constructed or copies of singular iterators).

bool
operator==(
    IndexClerkIter const& lhs,
    IndexClerkIter const& rhs);

Return true if the specified lhs and rhs queues have the same value, and false otherwise. Two queues have the same value if they have the same length and the same element value at each respective index position.

template<class T>
bool
operator==(
    Queue<T> const& lhs,
    Queue<T> const& rhs);

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two FlatHashMap objects have the same value if their sizes are the same and each element contained in one is equal to an element of the other. The hash and equality functors are not involved in the comparison.

template<
    class KEY,
    class VALUE,
    class HASH,
    class EQUAL>
bool
operator==(
    FlatHashMap<KEY, VALUE, HASH, EQUAL> const& lhs,
    FlatHashMap<KEY, VALUE, HASH, EQUAL> const& rhs);

Return whether the maps have the same key/value contents.

template<>
bool
operator==(
    FlatHashMap const&,
    FlatHashMap const&);

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two FlatHashTable objects have the same value if they have the same number of entries, and for each entry that is contained in lhs there is a entry contained in rhs having the same value. Note that this method requires the (template parameter) type ENTRY to be equality-comparable.

template<
    class KEY,
    class ENTRY,
    class ENTRY_UTIL,
    class HASH,
    class EQUAL>
bool
operator==(
    FlatHashTable<KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL> const& lhs,
    FlatHashTable<KEY, ENTRY, ENTRY_UTIL, HASH, EQUAL> const& rhs);

template<>
bool
operator==<>(
    PackedIntArrayConstIterator const&,
    PackedIntArrayConstIterator const&);

template<>
bool
operator==<>(
    FlatHashTable_IteratorImp const&,
    FlatHashTable_IteratorImp const&);

Return true if the specified lhs and rhs arrays have the same value, and false otherwise. Two CompactedArray arrays have the same value if they have the same length, and all corresponding elements (those at the same indices) have the same value.

template<class TYPE>
bool
operator==(
    CompactedArray<TYPE> const& lhs,
    CompactedArray<TYPE> const& rhs);

Return true if the underlying object value of the specified lhs is the same as the underlying object value of the specified rhs, and false otherwise. Note that the reference counts are intentionally ignored.

template<class TYPE>
bool
operator==(
    CompactedArray_CountedValue<TYPE> const& lhs,
    CompactedArray_CountedValue<TYPE> const& rhs);

Return true if the specified lhs and rhs iterators have the same value, and false otherwise. Two CompactedArray_ConstIterator iterators have the same value if they both have the default value, or neither has the default value and they reference the same location in the same array.

template<class TYPE>
bool
operator==(
    CompactedArray_ConstIterator<TYPE> const& lhs,
    CompactedArray_ConstIterator<TYPE> const& rhs);

Return whether the iterators refer to the same position (see free operator==).

template<>
bool
operator==(
    CompactedArray_ConstIterator const&,
    CompactedArray_ConstIterator const&);

Return true if the specified lhs and rhs arrays have the same value, and false otherwise. Two arrays have the same value if they have the same length, and corresponding bits at each bit position have the same value.

bool
operator==(
    BitArray const& lhs,
    BitArray const& rhs);

Return true if the specified lhs and rhs arrays have the same value, and false otherwise. Two PackedIntArray arrays have the same value if they have the same length, and all corresponding elements (those at the same indices) have the same value.

template<class TYPE>
bool
operator==(
    PackedIntArray<TYPE> const& lhs,
    PackedIntArray<TYPE> const& rhs);

Return true if the specified lhs and rhs iterators have the same value, and false otherwise. Two PackedIntArrayConstIterator iterators have the same value if they refer to the same array, and have the same index.

template<class TYPE>
bool
operator==(
    PackedIntArrayConstIterator<TYPE> const& lhs,
    PackedIntArrayConstIterator<TYPE> const& rhs);