[#BloombergLP-bdlb-operator_not_eq-067]
= xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bdlb.adoc[bdlb]::operator!&equals;
:relfileprefix: ../../
:mrdocs:

Inequality operators

== Synopses

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

Return `true` if the underlying iterator of the specified `lhs` compares unequal 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_not_eq-01f.adoc[operator!&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_not_eq-01f.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_not_eq-076.adoc[operator!&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_not_eq-076.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_not_eq-08.adoc[operator!&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_not_eq-08.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` nullable objects do not have the same value, and `false` otherwise&period; Two nullable wrappers do not have the same value if one is null and the other is non&hyphen;null, or if bost are non&hyphen;null and the values of their underlying objects do not 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_not_eq-051.adoc[operator!&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_not_eq-051.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise&period; A nullable wrappers and a value of some type do not have the same value if either the nullable wrappers is null, or its underlying value does not compare 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_not_eq-0eb.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs);
----

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


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

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

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_not_eq-0c0.adoc[operator!&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_not_eq-0c0.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_not_eq-07c.adoc[operator!&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_not_eq-07c.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` nullable objects do not have the same value, and `false` otherwise&period; Two nullable wrappers do not have the same value if one is null and the other is non&hyphen;null, or if both are non&hyphen;null and the values of their underlying objects do not 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_not_eq-001.adoc[operator!&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_not_eq-001.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_not_eq-00d.adoc[operator!&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_not_eq-00d.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_not_eq-047d.adoc[operator!&equals;](
    LHS&lowbar;TYPE const& lhs,
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

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

Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise&period; Two `PcgRandomGenerator` objects do not have the same value if they would not 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_not_eq-0a6.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/PcgRandomGenerator.adoc[PcgRandomGenerator] const& lhs,
    xref:BloombergLP/bdlb/PcgRandomGenerator.adoc[PcgRandomGenerator] const& rhs);
----

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

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_not_eq-042.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/BigEndianInt16.adoc[BigEndianInt16] const& lhs,
    xref:BloombergLP/bdlb/BigEndianInt16.adoc[BigEndianInt16] const& rhs);
----

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

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_not_eq-06e.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/BigEndianUint16.adoc[BigEndianUint16] const& lhs,
    xref:BloombergLP/bdlb/BigEndianUint16.adoc[BigEndianUint16] const& rhs);
----

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

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_not_eq-02b.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/BigEndianInt32.adoc[BigEndianInt32] const& lhs,
    xref:BloombergLP/bdlb/BigEndianInt32.adoc[BigEndianInt32] const& rhs);
----

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

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_not_eq-029.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/BigEndianUint32.adoc[BigEndianUint32] const& lhs,
    xref:BloombergLP/bdlb/BigEndianUint32.adoc[BigEndianUint32] const& rhs);
----

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

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_not_eq-0b2.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/BigEndianInt64.adoc[BigEndianInt64] const& lhs,
    xref:BloombergLP/bdlb/BigEndianInt64.adoc[BigEndianInt64] const& rhs);
----

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

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_not_eq-01c.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/BigEndianUint64.adoc[BigEndianUint64] const& lhs,
    xref:BloombergLP/bdlb/BigEndianUint64.adoc[BigEndianUint64] const& rhs);
----

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

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_not_eq-07f.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/IndexSpan.adoc[IndexSpan] const& lhs,
    xref:BloombergLP/bdlb/IndexSpan.adoc[IndexSpan] const& rhs);
----

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

Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise&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_not_eq-098.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/TokenizerIterator.adoc[TokenizerIterator] const& lhs,
    xref:BloombergLP/bdlb/TokenizerIterator.adoc[TokenizerIterator] const& rhs);
----

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

Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise&period; A nullable object and a value of some type do not have the same value if either the nullable object is null, or its underlying value does not compare 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_not_eq-005.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs);
----

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

Return `true` if the specified `lhs` and `rhs` nullable objects do not have the same value, and `false` otherwise&period; Two nullable objects do not have the same value if one is null and the other is non&hyphen;null, or if both are non&hyphen;null and the values of their underlying objects do not 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_not_eq-060.adoc[operator!&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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

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

Return `true` if the specified nullable objects do not 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_not_eq-0a1.adoc[operator!&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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

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

Return `true` if the specified nullable objects do not 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_not_eq-03.adoc[operator!&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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

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

Return `true` if the specified nullable objects do not 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_not_eq-027.adoc[operator!&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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

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

Return `true` if the specified nullable object and `std&colon;&colon;optional` do not 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_not_eq-0476.adoc[operator!&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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi;
    &rcub;;
----

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

Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise&period; A nullable object and a value of some type do not have the same value if either the nullable object is null, or its underlying value does not compare 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_not_eq-044.adoc[operator!&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; rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi; &rcub;;
----

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

Return `true` if the specified `lhs` and `rhs` objects do not 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_not_eq-00a.adoc[operator!&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; &ast;rhs &rcub; &hyphen;&gt; NullableValue&lowbar;ConvertibleToBool&semi; &rcub;;
----

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

Return `false` if the specified `lhs` and `rhs` objects have the same value, and `true` 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_not_eq-0cc.adoc[operator!&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_not_eq-0cc.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` nullable objects do not have the same value, and `false` otherwise&period; Two nullable objects do not have the same value if one is null and the other is non&hyphen;null, or if both are non&hyphen;null and the values of their underlying objects do not 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_not_eq-011.adoc[operator!&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_not_eq-011.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` variant object does not have the same value as the specified `rhs` variant object, and `false` otherwise&period; Two variant objects do not have the same value if one is set and the other is unset, or if they are both set but hold objects that differ in type or value&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPES&gt;
bool
xref:BloombergLP/bdlb/operator_not_eq-045.adoc[operator!&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_not_eq-045.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects do not 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_not_eq-0bd.adoc[operator!&equals;](
    LHS&lowbar;TYPE const& lhs,
    xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue&lt;RHS&lowbar;TYPE&gt;] const& rhs);
----

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

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_not_eq-052.adoc[operator!&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_not_eq-052.adoc[_» more&period;&period;&period;_]#

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


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
template&lt;class TYPE&gt;
bool
xref:BloombergLP/bdlb/operator_not_eq-00f8.adoc[operator!&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_not_eq-00f8.adoc[_» more&period;&period;&period;_]#

If neither of the specified `lhs` and `rhs` contain a value, return `false`&period; If one contains a value, and the other does not, return `true`&period; Otherwise, return `lhs&period;value !&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_not_eq-0f.adoc[operator!&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_not_eq-0f.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified nullable objects do not 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_not_eq-07b.adoc[operator!&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_not_eq-07b.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and specified `rhs` guid objects have different values, and `false` otherwise&period; Two guid objects have different value if any of corresponding byte in their internal buffers differ&period;


[source,cpp,subs="verbatim,replacements,macros,-callouts"]
----
bool
xref:BloombergLP/bdlb/operator_not_eq-0ef.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/Guid.adoc[Guid] const& lhs,
    xref:BloombergLP/bdlb/Guid.adoc[Guid] const& rhs);
----

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

Return `true` if the specified `lhs` and `rhs` nullable objects do not have the same value, and `false` otherwise&period; Two nullable wrappers do not have the same value if one is null and the other is non&hyphen;null, or if both are non&hyphen;null and the values of their underlying objects do not 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_not_eq-0d.adoc[operator!&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_not_eq-0d.adoc[_» more&period;&period;&period;_]#

Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise&period; A nullable wrappers and a value of some type do not have the same value if either the nullable wrappers is null, or its underlying value does not compare 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_not_eq-00fa.adoc[operator!&equals;](
    xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef&lt;LHS&lowbar;TYPE&gt;] const& lhs,
    RHS&lowbar;TYPE const& rhs);
----

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


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