[#BloombergLP-bdlb-operator_eq-064]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bdlb.adoc[bdlb]::operator&equals;&equals;
:relfileprefix: ../../
:mrdocs:

Equality operators

== Synopses

Declared in `&lt;bdlb&lowbar;bigendian&period;h&gt;`

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class FUNCTOR,
    class ITERATOR&gt;
bool
xref:BloombergLP/bdlb/operator_eq-0f63.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/TransformIterator.adoc[TransformIterator&lt;FUNCTOR, ITERATOR&gt;] const& lhs,
    xref:BloombergLP/bdlb/TransformIterator.adoc[TransformIterator&lt;FUNCTOR, ITERATOR&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0f63.adoc[_» more&period;&period;&period;_]#

See the overload above for contract&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-06b.adoc[operator&equals;&equals;](
    LHS&lowbar;TYPE const& lhs,
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-06b.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` is null, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-013ae.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;TYPE&gt;] const& lhs,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-013ae.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `rhs` is null, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-053.adoc[operator&equals;&equals;](
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&,
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;TYPE&gt;] const& rhs) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-053.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` nullable wrappers have the same value, and `false` otherwise&period; Two nullable wrappers have the same value if both targets are null, or if both are non&hyphen;null and the values of their underlying objects compare equal&period; Note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-01c.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-01c.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise&period; A nullable wrapper and a value of some type have the same value if the nullable wrapper is non&hyphen;null and the underlying value of it&apos;s target compares equal to the other value&period; Note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-04f.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-04f.adoc[_» more&period;&period;&period;_]#

See the overload above for contract&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-013a0.adoc[operator&equals;&equals;](
    LHS&lowbar;TYPE const& lhs,
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-013a0.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` is null, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-03cc.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;TYPE&gt;] const& lhs,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-03cc.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `rhs` is null, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-06c.adoc[operator&equals;&equals;](
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&,
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;TYPE&gt;] const& rhs) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-06c.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` nullable wrappers have the same value, and `false` otherwise&period; Two nullable wrappers have the same value if both targets are null, or if both are non&hyphen;null and the values of their underlying objects compare equal&period; Note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-003.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-003.adoc[_» more&period;&period;&period;_]#

See the overload above for contract&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-06d.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-06d.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise&period; A nullable wrapper and a value of some type have the same value if the nullable wrapper is non&hyphen;null and the underlying value of it&apos;s target compares equal to the other value&period; Note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-0a9.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0a9.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-04c.adoc[operator&equals;&equals;](
    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&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` `BigEndianInt16` objects have the same value, and `false` otherwise&period; Two `BigEndianInt16` objects have the same value if and only if the respective integral network byte&hyphen;order values that they represent have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-006.adoc[operator&equals;&equals;](
    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&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` `BigEndianUint16` objects have the same value, and `false` otherwise&period; Two `BigEndianUint16` objects have the same value if and only if the respective integral network byte&hyphen;order values that they represent have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-022e.adoc[operator&equals;&equals;](
    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&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` `BigEndianInt32` objects have the same value, and `false` otherwise&period; Two `BigEndianInt32` objects have the same value if and only if the respective integral network byte&hyphen;order values that they represent have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-0d8.adoc[operator&equals;&equals;](
    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&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` `BigEndianUint32` objects have the same value, and `false` otherwise&period; Two `BigEndianUint32` objects have the same value if and only if the respective integral network byte&hyphen;order values that they represent have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-0221.adoc[operator&equals;&equals;](
    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&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` `BigEndianInt64` objects have the same value, and `false` otherwise&period; Two `BigEndianInt64` objects have the same value if and only if the respective integral network byte&hyphen;order values that they represent have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-00d.adoc[operator&equals;&equals;](
    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&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` `BigEndianUint64` objects have the same value, and `false` otherwise&period; Two `BigEndianUint64` objects have the same value if and only if the respective integral network byte&hyphen;order values that they represent have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-0c8.adoc[operator&equals;&equals;](
    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&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-0b.adoc[operator&equals;&equals;](
    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&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise&period; 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&period; 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&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-026.adoc[operator&equals;&equals;](
    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&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise&period; Two `NullableAllocatedValue&lowbar;PointerBitsPair` objects have the same value when their pointer and flags are the same&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class t&lowbar;TYPE,
    unsigned int t&lowbar;NUM&lowbar;BITS&gt;
bool
xref:BloombergLP/bdlb/operator_eq-05a.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableAllocatedValue_PointerBitsPair.adoc[NullableAllocatedValue&lowbar;PointerBitsPair&lt;t&lowbar;TYPE, t&lowbar;NUM&lowbar;BITS&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableAllocatedValue_PointerBitsPair.adoc[NullableAllocatedValue&lowbar;PointerBitsPair&lt;t&lowbar;TYPE, t&lowbar;NUM&lowbar;BITS&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-05a.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` variant object has the same value as the specified `rhs` variant object, and `false` otherwise&period; 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&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPES&gt;
bool
xref:BloombergLP/bdlb/operator_eq-0fc.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/VariantImp.adoc[VariantImp&lt;TYPES&gt;] const& lhs,
    xref:BloombergLP/bdlb/VariantImp.adoc[VariantImp&lt;TYPES&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0fc.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` nullable objects have the same value, and `false` otherwise&period; Two nullable objects have the same value if both are null, or if both are non&hyphen;null and the values of their underlying objects compare equal&period; Note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-0aa.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;RHS&lowbar;TYPE&gt;] const& rhs)
requires requires &lcub;
        &lcub; &ast;lhs &equals;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0aa.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified nullable objects have the same value, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-0f6c.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:bsl/optional-072.adoc[bsl::optional&lt;RHS&lowbar;TYPE&gt;] const& rhs)
requires requires &lcub;
        &lcub; &ast;lhs &equals;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0f6c.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified nullable objects have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-047.adoc[operator&equals;&equals;](
    xref:bsl/optional-072.adoc[bsl::optional&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;RHS&lowbar;TYPE&gt;] const& rhs)
requires requires &lcub;
        &lcub; &ast;lhs &equals;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-047.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified nullable objects have the same value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-070.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    std::optional&lt;RHS&lowbar;TYPE&gt; const& rhs)
requires requires &lcub;
        &lcub; &ast;lhs &equals;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-070.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified nullable objects have the same value, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-00e.adoc[operator&equals;&equals;](
    std::optional&lt;LHS&lowbar;TYPE&gt; const& lhs,
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;RHS&lowbar;TYPE&gt;] const& rhs)
requires requires &lcub;
        &lcub; &ast;lhs &equals;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-00e.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise&period; A nullable object and a value of some type have the same value if the nullable object is non&hyphen;null and its underlying value compares equal to the other value&period; Note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-0da.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs)
requires (!NullableValue&lowbar;DerivedFromOptional&lt;RHS&lowbar;TYPE&gt;) &amp;&amp;
    requires &lcub; &lcub; &ast;lhs &equals;&equals; rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi; &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0da.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified value and nullable object compare equal, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-0a8.adoc[operator&equals;&equals;](
    LHS&lowbar;TYPE const& lhs,
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;RHS&lowbar;TYPE&gt;] const& rhs)
requires (!NullableValue&lowbar;DerivedFromOptional&lt;LHS&lowbar;TYPE&gt;) &amp;&amp;
    requires &lcub; &lcub; lhs &equals;&equals; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi; &rcub;;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0a8.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `value` is null, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
constexpr
bool
xref:BloombergLP/bdlb/operator_eq-0108.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableValue.adoc[NullableValue&lt;TYPE&gt;] const& value,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0108.adoc[_» more&period;&period;&period;_]#

Grant the equality comparison operator access to this class&apos;s private members&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-0101.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/VariantImp.adoc[VariantImp&lt;VARIANT&lowbar;TYPES&gt;] const&,
    xref:BloombergLP/bdlb/VariantImp.adoc[VariantImp&lt;VARIANT&lowbar;TYPES&gt;] const&);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0101.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` nullable objects have the same value, and `false` otherwise&period; Two nullable objects have the same value if both are null, or if both are non&hyphen;null and the values of their underlying objects compare equal&period; Note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-0c3.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0c3.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise&period; A nullable object and a value of some type have the same value if the nullable object is non&hyphen;null and its underlying value compares equal to the other value&period; Note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-078.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-078.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects have the same value, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-02a.adoc[operator&equals;&equals;](
    LHS&lowbar;TYPE const& lhs,
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-02a.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` is null, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-056.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;TYPE&gt;] const& lhs,
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-056.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `rhs` is null, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-0e.adoc[operator&equals;&equals;](
    xref:bsl/nullopt_t.adoc[bsl::nullopt&lowbar;t] const&,
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;TYPE&gt;] const& rhs) noexcept;
----

[.small]#xref:BloombergLP/bdlb/operator_eq-0e.adoc[_» more&period;&period;&period;_]#

If neither of the specified `lhs` and `rhs` contain a value, return `true`&period; If one contains a value, and the other does not, return `false`&period; Otherwise, return `lhs&period;value &equals;&equals; rhs&period;value()`&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-03c1.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:bsl/optional-072.adoc[bsl::optional&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-03c1.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified nullable objects have the same value, and `false` otherwise&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-052.adoc[operator&equals;&equals;](
    xref:bsl/optional-072.adoc[bsl::optional&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-052.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_eq-03b.adoc[operator&equals;&equals;](
    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&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` nullable wrappers have the same value, and `false` otherwise&period; Two nullable wrappers have the same value if both targets are null, or if both are non&hyphen;null and the values of their underlying objects compare equal&period; Note that this function will fail to compile if `LHS&lowbar;TYPE` and `RHS&lowbar;TYPE` are not compatible&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;
    class LHS&lowbar;TYPE,
    class RHS&lowbar;TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_eq-07f.adoc[operator&equals;&equals;](
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

[.small]#xref:BloombergLP/bdlb/operator_eq-07f.adoc[_» more&period;&period;&period;_]#


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