BloombergLP::bdlb::operator!=

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.

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

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

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

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

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

Return true if the specified lhs and rhs nullable 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.

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

Return true if the specified lhs and rhs objects 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.

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

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

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

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

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

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

Return true if the specified lhs and rhs nullable 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.

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

See the overload above for contract.

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

See the overload above for contract.

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

Return true if the specified lhs 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().

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

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.

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

Return true if the specified lhs and rhs 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.

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

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

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

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

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

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

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

Return true if the specified nullable object and std::optional do not have the same value.

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

Return true if the specified 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.

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

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

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

Return 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.

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

Return true if the specified lhs 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.

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

Return true if the specified lhs 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.

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

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

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

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

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

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

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

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

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

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

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

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

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

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.

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

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.

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