[#BloombergLP-bdlb-operator_eq-064] = xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bdlb.adoc[bdlb]::operator== :relfileprefix: ../../ :mrdocs: Equality operators == 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class FUNCTOR, class ITERATOR> bool xref:BloombergLP/bdlb/operator_eq-0f63.adoc[operator==]( xref:BloombergLP/bdlb/TransformIterator.adoc[TransformIterator<FUNCTOR, ITERATOR>] const& lhs, xref:BloombergLP/bdlb/TransformIterator.adoc[TransformIterator<FUNCTOR, ITERATOR>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0f63.adoc[_» more..._]# See the overload above for contract. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-06b.adoc[operator==]( LHS_TYPE const& lhs, xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-06b.adoc[_» more..._]# Return `true` if the specified `lhs` is null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_eq-013ae.adoc[operator==]( xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef<TYPE>] const& lhs, xref:bsl/nullopt_t.adoc[bsl::nullopt_t] const&) noexcept; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-013ae.adoc[_» more..._]# Return `true` if the specified `rhs` is null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_eq-053.adoc[operator==]( xref:bsl/nullopt_t.adoc[bsl::nullopt_t] const&, xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef<TYPE>] const& rhs) noexcept; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-053.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-01c.adoc[operator==]( xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef<LHS_TYPE>] const& lhs, xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-01c.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-04f.adoc[operator==]( xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef<LHS_TYPE>] const& lhs, RHS_TYPE const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-04f.adoc[_» more..._]# See the overload above for contract. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-013a0.adoc[operator==]( LHS_TYPE const& lhs, xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-013a0.adoc[_» more..._]# Return `true` if the specified `lhs` is null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_eq-03cc.adoc[operator==]( xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef<TYPE>] const& lhs, xref:bsl/nullopt_t.adoc[bsl::nullopt_t] const&) noexcept; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-03cc.adoc[_» more..._]# Return `true` if the specified `rhs` is null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_eq-06c.adoc[operator==]( xref:bsl/nullopt_t.adoc[bsl::nullopt_t] const&, xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef<TYPE>] const& rhs) noexcept; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-06c.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-003.adoc[operator==]( xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef<LHS_TYPE>] const& lhs, xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-003.adoc[_» more..._]# See the overload above for contract. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-06d.adoc[operator==]( xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef<LHS_TYPE>] const& lhs, xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-06d.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-0a9.adoc[operator==]( xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef<LHS_TYPE>] const& lhs, RHS_TYPE const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0a9.adoc[_» more..._]# 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()`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-04c.adoc[operator==]( xref:BloombergLP/bdlb/PcgRandomGenerator.adoc[PcgRandomGenerator] const& lhs, xref:BloombergLP/bdlb/PcgRandomGenerator.adoc[PcgRandomGenerator] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-04c.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-006.adoc[operator==]( xref:BloombergLP/bdlb/BigEndianInt16.adoc[BigEndianInt16] const& lhs, xref:BloombergLP/bdlb/BigEndianInt16.adoc[BigEndianInt16] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-006.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-022e.adoc[operator==]( xref:BloombergLP/bdlb/BigEndianUint16.adoc[BigEndianUint16] const& lhs, xref:BloombergLP/bdlb/BigEndianUint16.adoc[BigEndianUint16] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-022e.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-0d8.adoc[operator==]( xref:BloombergLP/bdlb/BigEndianInt32.adoc[BigEndianInt32] const& lhs, xref:BloombergLP/bdlb/BigEndianInt32.adoc[BigEndianInt32] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0d8.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-0221.adoc[operator==]( xref:BloombergLP/bdlb/BigEndianUint32.adoc[BigEndianUint32] const& lhs, xref:BloombergLP/bdlb/BigEndianUint32.adoc[BigEndianUint32] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0221.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-00d.adoc[operator==]( xref:BloombergLP/bdlb/BigEndianInt64.adoc[BigEndianInt64] const& lhs, xref:BloombergLP/bdlb/BigEndianInt64.adoc[BigEndianInt64] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-00d.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-0c8.adoc[operator==]( xref:BloombergLP/bdlb/BigEndianUint64.adoc[BigEndianUint64] const& lhs, xref:BloombergLP/bdlb/BigEndianUint64.adoc[BigEndianUint64] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0c8.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-0b.adoc[operator==]( xref:BloombergLP/bdlb/IndexSpan.adoc[IndexSpan] const& lhs, xref:BloombergLP/bdlb/IndexSpan.adoc[IndexSpan] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0b.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-026.adoc[operator==]( xref:BloombergLP/bdlb/TokenizerIterator.adoc[TokenizerIterator] const& lhs, xref:BloombergLP/bdlb/TokenizerIterator.adoc[TokenizerIterator] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-026.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class t_TYPE, unsigned int t_NUM_BITS> bool xref:BloombergLP/bdlb/operator_eq-05a.adoc[operator==]( xref:BloombergLP/bdlb/NullableAllocatedValue_PointerBitsPair.adoc[NullableAllocatedValue_PointerBitsPair<t_TYPE, t_NUM_BITS>] const& lhs, xref:BloombergLP/bdlb/NullableAllocatedValue_PointerBitsPair.adoc[NullableAllocatedValue_PointerBitsPair<t_TYPE, t_NUM_BITS>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-05a.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPES> bool xref:BloombergLP/bdlb/operator_eq-0fc.adoc[operator==]( xref:BloombergLP/bdlb/VariantImp.adoc[VariantImp<TYPES>] const& lhs, xref:BloombergLP/bdlb/VariantImp.adoc[VariantImp<TYPES>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0fc.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-0aa.adoc[operator==]( xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue<LHS_TYPE>] const& lhs, xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue<RHS_TYPE>] const& rhs) requires requires { { *lhs == *rhs } ‐> NullableValue_ConvertibleToBool; }; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0aa.adoc[_» more..._]# Return `true` if the specified nullable objects have the same value, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-0f6c.adoc[operator==]( xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue<LHS_TYPE>] const& lhs, xref:bsl/optional-072.adoc[bsl::optional<RHS_TYPE>] const& rhs) requires requires { { *lhs == *rhs } ‐> NullableValue_ConvertibleToBool; }; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0f6c.adoc[_» more..._]# Return `true` if the specified nullable objects have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-047.adoc[operator==]( xref:bsl/optional-072.adoc[bsl::optional<LHS_TYPE>] const& lhs, xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue<RHS_TYPE>] const& rhs) requires requires { { *lhs == *rhs } ‐> NullableValue_ConvertibleToBool; }; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-047.adoc[_» more..._]# Return `true` if the specified nullable objects have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-070.adoc[operator==]( xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue<LHS_TYPE>] const& lhs, std::optional<RHS_TYPE> const& rhs) requires requires { { *lhs == *rhs } ‐> NullableValue_ConvertibleToBool; }; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-070.adoc[_» more..._]# Return `true` if the specified nullable objects have the same value, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-00e.adoc[operator==]( std::optional<LHS_TYPE> const& lhs, xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue<RHS_TYPE>] const& rhs) requires requires { { *lhs == *rhs } ‐> NullableValue_ConvertibleToBool; }; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-00e.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-0da.adoc[operator==]( xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue<LHS_TYPE>] const& lhs, RHS_TYPE const& rhs) requires (!NullableValue_DerivedFromOptional<RHS_TYPE>) && requires { { *lhs == rhs } ‐> NullableValue_ConvertibleToBool; }; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0da.adoc[_» more..._]# Return `true` if the specified value and nullable object compare equal, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-0a8.adoc[operator==]( LHS_TYPE const& lhs, xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue<RHS_TYPE>] const& rhs) requires (!NullableValue_DerivedFromOptional<LHS_TYPE>) && requires { { lhs == *rhs } ‐> NullableValue_ConvertibleToBool; }; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0a8.adoc[_» more..._]# Return `true` if the specified `value` is null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> constexpr bool xref:BloombergLP/bdlb/operator_eq-0108.adoc[operator==]( xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue<TYPE>] const& value, xref:bsl/nullopt_t.adoc[bsl::nullopt_t] const&) noexcept; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0108.adoc[_» more..._]# Grant the equality comparison operator access to this class's private members. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-0101.adoc[operator==]( xref:BloombergLP/bdlb/VariantImp.adoc[VariantImp<VARIANT_TYPES>] const&, xref:BloombergLP/bdlb/VariantImp.adoc[VariantImp<VARIANT_TYPES>] const&); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0101.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-0c3.adoc[operator==]( xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue<LHS_TYPE>] const& lhs, xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0c3.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-078.adoc[operator==]( xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue<LHS_TYPE>] const& lhs, RHS_TYPE const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-078.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-02a.adoc[operator==]( LHS_TYPE const& lhs, xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-02a.adoc[_» more..._]# Return `true` if the specified `lhs` is null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_eq-056.adoc[operator==]( xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue<TYPE>] const& lhs, xref:bsl/nullopt_t.adoc[bsl::nullopt_t] const&) noexcept; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-056.adoc[_» more..._]# Return `true` if the specified `rhs` is null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_eq-0e.adoc[operator==]( xref:bsl/nullopt_t.adoc[bsl::nullopt_t] const&, xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue<TYPE>] const& rhs) noexcept; ---- [.small]#xref:BloombergLP/bdlb/operator_eq-0e.adoc[_» more..._]# 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()`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-03c1.adoc[operator==]( xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue<LHS_TYPE>] const& lhs, xref:bsl/optional-072.adoc[bsl::optional<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-03c1.adoc[_» more..._]# Return `true` if the specified nullable objects have the same value, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-052.adoc[operator==]( xref:bsl/optional-072.adoc[bsl::optional<LHS_TYPE>] const& lhs, xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-052.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_eq-03b.adoc[operator==]( xref:BloombergLP/bdlb/Guid.adoc[Guid] const& lhs, xref:BloombergLP/bdlb/Guid.adoc[Guid] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-03b.adoc[_» more..._]# 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_eq-07f.adoc[operator==]( xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef<LHS_TYPE>] const& lhs, xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_eq-07f.adoc[_» more..._]# [.small]#Created with https://www.mrdocs.com[MrDocs]#