BloombergLP::bdlb::operator==

Synopses

Declared in <bdlb_bigendian.h>

Return true if the underlying iterator of the specified lhs compares equal to the underlying iterator of the specified rhs, and false otherwise. The behavior is undefined if comparing the underlying iterators in this way is undefined. Note that the functors are not compared.

template<
    class FUNCTOR,
    class ITERATOR>
bool
operator==(
    TransformIterator<FUNCTOR, ITERATOR> const& lhs,
    TransformIterator<FUNCTOR, ITERATOR> const& rhs);

See the overload above for contract.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    LHS_TYPE const& lhs,
    NullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified lhs is null, and false otherwise.

template<class TYPE>
bool
operator==(
    NullableValueRef<TYPE> const& lhs,
    bsl::nullopt_t const&) noexcept;

Return true if the specified rhs is null, and false otherwise.

template<class TYPE>
bool
operator==(
    bsl::nullopt_t const&,
    NullableValueRef<TYPE> const& rhs) noexcept;

Return true if the specified lhs and rhs nullable wrappers have the same value, and false otherwise. Two nullable wrappers have the same value if both targets are null, or if both are non-null and the values of their underlying objects compare equal. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    ConstNullableValueRef<LHS_TYPE> const& lhs,
    ConstNullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified lhs and rhs objects have the same value, and false otherwise. A nullable wrapper and a value of some type have the same value if the nullable wrapper is non-null and the underlying value of it's target compares equal to the other value. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    ConstNullableValueRef<LHS_TYPE> const& lhs,
    RHS_TYPE const& rhs);

See the overload above for contract.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    LHS_TYPE const& lhs,
    ConstNullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified lhs is null, and false otherwise.

template<class TYPE>
bool
operator==(
    ConstNullableValueRef<TYPE> const& lhs,
    bsl::nullopt_t const&) noexcept;

Return true if the specified rhs is null, and false otherwise.

template<class TYPE>
bool
operator==(
    bsl::nullopt_t const&,
    ConstNullableValueRef<TYPE> const& rhs) noexcept;

Return true if the specified lhs and rhs nullable wrappers have the same value, and false otherwise. Two nullable wrappers have the same value if both targets are null, or if both are non-null and the values of their underlying objects compare equal. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    ConstNullableValueRef<LHS_TYPE> const& lhs,
    NullableValueRef<RHS_TYPE> const& rhs);

See the overload above for contract.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    NullableValueRef<LHS_TYPE> const& lhs,
    ConstNullableValueRef<RHS_TYPE> const& rhs);

Return true if the specified lhs and rhs objects have the same value, and false otherwise. A nullable wrapper and a value of some type have the same value if the nullable wrapper is non-null and the underlying value of it's target compares equal to the other value. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    NullableValueRef<LHS_TYPE> const& lhs,
    RHS_TYPE const& rhs);

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two PcgRandomGenerator objects have the same value if they would produce the same sequence of random numbers from subsequent invocations of generate().

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

Return true if the specified lhs and rhs BigEndianInt16 objects have the same value, and false otherwise. Two BigEndianInt16 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

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

Return true if the specified lhs and rhs BigEndianUint16 objects have the same value, and false otherwise. Two BigEndianUint16 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

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

Return true if the specified lhs and rhs BigEndianInt32 objects have the same value, and false otherwise. Two BigEndianInt32 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

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

Return true if the specified lhs and rhs BigEndianUint32 objects have the same value, and false otherwise. Two BigEndianUint32 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

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

Return true if the specified lhs and rhs BigEndianInt64 objects have the same value, and false otherwise. Two BigEndianInt64 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

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

Return true if the specified lhs and rhs BigEndianUint64 objects have the same value, and false otherwise. Two BigEndianUint64 objects have the same value if and only if the respective integral network byte-order values that they represent have the same value.

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

Return true if the specified lhs and rhs index span objects have the same value, and false otherwise. Two index span objects have the same value if their position and length attributes compare equal.

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

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two TokenizerIterator objects have the same value if both of them are pointing to the same token within the same tokenized string or if they both point past the tokenized string. The behaviour is undefined unless the iterators returned by the same Tokenizer object, or if the underlying input has been modified or destroyed since any of those objects were created.

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

Return true if the specified lhs and rhs objects have the same value, and false otherwise. Two NullableAllocatedValue_PointerBitsPair objects have the same value when their pointer and flags are the same.

template<
    class t_TYPE,
    unsigned int t_NUM_BITS>
bool
operator==(
    NullableAllocatedValue_PointerBitsPair<t_TYPE, t_NUM_BITS> const& lhs,
    NullableAllocatedValue_PointerBitsPair<t_TYPE, t_NUM_BITS> const& rhs);

Return true if the specified lhs variant object has the same value as the specified rhs variant object, and false otherwise. Two variant objects have the same value if they are both set and hold objects of the same type and same value, or are both unset.

template<class TYPES>
bool
operator==(
    VariantImp<TYPES> const& lhs,
    VariantImp<TYPES> const& rhs);

Return true if the specified lhs and rhs nullable objects have the same value, and false otherwise. Two nullable objects have the same value if both are null, or if both are non-null and the values of their underlying objects compare equal. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    NullableValue<LHS_TYPE> const& lhs,
    NullableValue<RHS_TYPE> const& rhs)
requires requires {
        { *lhs == *rhs } -> NullableValue_ConvertibleToBool;
    };

Return true if the specified nullable objects have the same value, and false otherwise.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    NullableValue<LHS_TYPE> const& lhs,
    bsl::optional<RHS_TYPE> const& rhs)
requires requires {
        { *lhs == *rhs } -> NullableValue_ConvertibleToBool;
    };

Return true if the specified nullable objects have the same value.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    bsl::optional<LHS_TYPE> const& lhs,
    NullableValue<RHS_TYPE> const& rhs)
requires requires {
        { *lhs == *rhs } -> NullableValue_ConvertibleToBool;
    };

Return true if the specified nullable objects have the same value.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    NullableValue<LHS_TYPE> const& lhs,
    std::optional<RHS_TYPE> const& rhs)
requires requires {
        { *lhs == *rhs } -> NullableValue_ConvertibleToBool;
    };

Return true if the specified nullable objects have the same value, and false otherwise.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    std::optional<LHS_TYPE> const& lhs,
    NullableValue<RHS_TYPE> const& rhs)
requires requires {
        { *lhs == *rhs } -> NullableValue_ConvertibleToBool;
    };

Return true if the specified lhs and rhs objects have the same value, and false otherwise. A nullable object and a value of some type have the same value if the nullable object is non-null and its underlying value compares equal to the other value. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    NullableValue<LHS_TYPE> const& lhs,
    RHS_TYPE const& rhs)
requires (!NullableValue_DerivedFromOptional<RHS_TYPE>) &&
    requires { { *lhs == rhs } -> NullableValue_ConvertibleToBool; };

Return true if the specified value and nullable object compare equal, and false otherwise.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    LHS_TYPE const& lhs,
    NullableValue<RHS_TYPE> const& rhs)
requires (!NullableValue_DerivedFromOptional<LHS_TYPE>) &&
    requires { { lhs == *rhs } -> NullableValue_ConvertibleToBool; };

Return true if the specified value is null, and false otherwise.

template<class TYPE>
constexpr
bool
operator==(
    NullableValue<TYPE> const& value,
    bsl::nullopt_t const&) noexcept;

Grant the equality comparison operator access to this class's private members.

bool
operator==(
    VariantImp<VARIANT_TYPES> const&,
    VariantImp<VARIANT_TYPES> const&);

Return true if the specified lhs and rhs nullable objects have the same value, and false otherwise. Two nullable objects have the same value if both are null, or if both are non-null and the values of their underlying objects compare equal. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    NullableAllocatedValue<LHS_TYPE> const& lhs,
    NullableAllocatedValue<RHS_TYPE> const& rhs);

Return true if the specified lhs and rhs objects have the same value, and false otherwise. A nullable object and a value of some type have the same value if the nullable object is non-null and its underlying value compares equal to the other value. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    NullableAllocatedValue<LHS_TYPE> const& lhs,
    RHS_TYPE const& rhs);

Return true if the specified lhs and rhs objects have the same value, and false otherwise.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    LHS_TYPE const& lhs,
    NullableAllocatedValue<RHS_TYPE> const& rhs);

Return true if the specified lhs is null, and false otherwise.

template<class TYPE>
bool
operator==(
    NullableAllocatedValue<TYPE> const& lhs,
    bsl::nullopt_t const&) noexcept;

Return true if the specified rhs is null, and false otherwise.

template<class TYPE>
bool
operator==(
    bsl::nullopt_t const&,
    NullableAllocatedValue<TYPE> const& rhs) noexcept;

If neither of the specified lhs and rhs contain a value, return true. If one contains a value, and the other does not, return false. Otherwise, return lhs.value == rhs.value().

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    NullableAllocatedValue<LHS_TYPE> const& lhs,
    bsl::optional<RHS_TYPE> const& rhs);

Return true if the specified nullable objects have the same value, and false otherwise.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    bsl::optional<LHS_TYPE> const& lhs,
    NullableAllocatedValue<RHS_TYPE> const& rhs);

Return true if the specified lhs and specified rhs guid objects have the same value, and false otherwise. Two guid objects have the same value if each corresponding byte in their internal buffers are equal.

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

Return true if the specified lhs and rhs nullable wrappers have the same value, and false otherwise. Two nullable wrappers have the same value if both targets are null, or if both are non-null and the values of their underlying objects compare equal. Note that this function will fail to compile if LHS_TYPE and RHS_TYPE are not compatible.

template<
    class LHS_TYPE,
    class RHS_TYPE>
bool
operator==(
    NullableValueRef<LHS_TYPE> const& lhs,
    NullableValueRef<RHS_TYPE> const& rhs);