[#BloombergLP-bdlb-operator_not_eq-067] = xref:BloombergLP.adoc[BloombergLP]::xref:BloombergLP/bdlb.adoc[bdlb]::operator!= :relfileprefix: ../../ :mrdocs: Inequality operators == Synopses Declared in `<bdlb_bigendian.h>` Return `true` if the underlying iterator of the specified `lhs` compares unequal 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_not_eq-01f.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_not_eq-01f.adoc[_» more..._]# Return `true` if the specified `lhs` is not null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-076.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_not_eq-076.adoc[_» more..._]# Return `true` if the specified `rhs` is not null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-08.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_not_eq-08.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` nullable objects do not have the same value, and `false` otherwise. Two nullable wrappers do not have the same value if one is null and the other is non‐null, or if bost are non‐null and the values of their underlying objects do not 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_not_eq-051.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_not_eq-051.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise. 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. 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_not_eq-0eb.adoc[operator!=]( xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef<LHS_TYPE>] const& lhs, RHS_TYPE const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_not_eq-0eb.adoc[_» more..._]# [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-096.adoc[operator!=]( LHS_TYPE const& lhs, xref:BloombergLP/bdlb/ConstNullableValueRef.adoc[ConstNullableValueRef<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_not_eq-096.adoc[_» more..._]# Return `true` if the specified `lhs` is not null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-0c0.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_not_eq-0c0.adoc[_» more..._]# Return `true` if the specified `rhs` is not null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-07c.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_not_eq-07c.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` nullable objects do not have the same value, and `false` otherwise. Two nullable wrappers do not have the same value if one is null and the other is non‐null, or if both are non‐null and the values of their underlying objects do not 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_not_eq-001.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_not_eq-001.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_not_eq-00d.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_not_eq-00d.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_not_eq-047d.adoc[operator!=]( LHS_TYPE const& lhs, xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_not_eq-047d.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise. 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()`. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_not_eq-0a6.adoc[operator!=]( 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..._]# Return `true` if the specified `lhs` and `rhs` `BigEndianInt16` objects do not have the same value, and `false` otherwise. Two `BigEndianInt16` objects do not have the same value if and only if the respective integral network byte‐order values that they represent do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_not_eq-042.adoc[operator!=]( 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..._]# Return `true` if the specified `lhs` and `rhs` `BigEndianUint16` objects do not have the same value, and `false` otherwise. Two `BigEndianUint16` objects do not have the same value if and only if the respective integral network byte‐order values that they represent do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_not_eq-06e.adoc[operator!=]( 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..._]# Return `true` if the specified `lhs` and `rhs` `BigEndianInt32` objects do not have the same value, and `false` otherwise. Two `BigEndianInt32` objects do not have the same value if and only if the respective integral network byte‐order values that they represent do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_not_eq-02b.adoc[operator!=]( 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..._]# Return `true` if the specified `lhs` and `rhs` `BigEndianUint32` objects do not have the same value, and `false` otherwise. Two `BigEndianUint32` objects do not have the same value if and only if the respective integral network byte‐order values that they represent do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_not_eq-029.adoc[operator!=]( 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..._]# Return `true` if the specified `lhs` and `rhs` `BigEndianInt64` objects do not have the same value, and `false` otherwise. Two `BigEndianInt64` objects do not have the same value if and only if the respective integral network byte‐order values that they represent do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_not_eq-0b2.adoc[operator!=]( 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..._]# Return `true` if the specified `lhs` and `rhs` `BigEndianUint64` objects do not have the same value, and `false` otherwise. Two `BigEndianUint64` objects do not have the same value if and only if the respective integral network byte‐order values that they represent do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_not_eq-01c.adoc[operator!=]( 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..._]# Return `true` if the specified `lhs` and `rhs` index span objects do not have the same value, and `false` otherwise. Two index span objects do not have the same value if either their position or length attributes do not compare equal. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_not_eq-07f.adoc[operator!=]( 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..._]# Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise. 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_not_eq-098.adoc[operator!=]( 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..._]# Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise. 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. 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_not_eq-005.adoc[operator!=]( xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue<LHS_TYPE>] const& lhs, RHS_TYPE const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_not_eq-005.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` nullable objects do not have the same value, and `false` otherwise. Two nullable objects do not have the same value if one is null and the other is non‐null, or if both are non‐null and the values of their underlying objects do not 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_not_eq-060.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_not_eq-060.adoc[_» more..._]# Return `true` if the specified nullable objects do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-0a1.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_not_eq-0a1.adoc[_» more..._]# Return `true` if the specified nullable objects do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-03.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_not_eq-03.adoc[_» more..._]# Return `true` if the specified nullable objects do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-027.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_not_eq-027.adoc[_» more..._]# Return `true` if the specified nullable object and `std::optional` do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-0476.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_not_eq-0476.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise. 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. 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_not_eq-044.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_not_eq-044.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects do not 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_not_eq-00a.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_not_eq-00a.adoc[_» more..._]# Return `false` if the specified `lhs` and `rhs` objects have the same value, and `true` 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_not_eq-0cc.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_not_eq-0cc.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` nullable objects do not have the same value, and `false` otherwise. Two nullable objects do not have the same value if one is null and the other is non‐null, or if both are non‐null and the values of their underlying objects do not 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_not_eq-011.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_not_eq-011.adoc[_» more..._]# Return `true` if the specified `lhs` variant object does not have the same value as the specified `rhs` variant object, and `false` otherwise. 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. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPES> bool xref:BloombergLP/bdlb/operator_not_eq-045.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_not_eq-045.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects do not 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_not_eq-0bd.adoc[operator!=]( LHS_TYPE const& lhs, xref:BloombergLP/bdlb/NullableAllocatedValue.adoc[NullableAllocatedValue<RHS_TYPE>] const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_not_eq-0bd.adoc[_» more..._]# Return `true` if the specified `lhs` is not null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-052.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_not_eq-052.adoc[_» more..._]# Return `true` if the specified `rhs` is not null, and `false` otherwise. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template<class TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-00f8.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_not_eq-00f8.adoc[_» more..._]# If neither of the specified `lhs` and `rhs` contain a value, return `false`. If one contains a value, and the other does not, return `true`. 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_not_eq-0f.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_not_eq-0f.adoc[_» more..._]# Return `true` if the specified nullable objects do not have the same value. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- template< class LHS_TYPE, class RHS_TYPE> bool xref:BloombergLP/bdlb/operator_not_eq-07b.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_not_eq-07b.adoc[_» more..._]# Return `true` if the specified `lhs` and specified `rhs` guid objects have different values, and `false` otherwise. Two guid objects have different value if any of corresponding byte in their internal buffers differ. [source,cpp,subs="verbatim,replacements,macros,-callouts"] ---- bool xref:BloombergLP/bdlb/operator_not_eq-0ef.adoc[operator!=]( 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..._]# Return `true` if the specified `lhs` and `rhs` nullable objects do not have the same value, and `false` otherwise. Two nullable wrappers do not have the same value if one is null and the other is non‐null, or if both are non‐null and the values of their underlying objects do not 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_not_eq-0d.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_not_eq-0d.adoc[_» more..._]# Return `true` if the specified `lhs` and `rhs` objects do not have the same value, and `false` otherwise. 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. 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_not_eq-00fa.adoc[operator!=]( xref:BloombergLP/bdlb/NullableValueRef.adoc[NullableValueRef<LHS_TYPE>] const& lhs, RHS_TYPE const& rhs); ---- [.small]#xref:BloombergLP/bdlb/operator_not_eq-00fa.adoc[_» more..._]# [.small]#Created with https://www.mrdocs.com[MrDocs]#