BloombergLP::bdlb::operator!=

Inequality operators

Synopses

Declared in <bdlb_bigendian.h>

Return true if the underlying iterators of lhs and rhs are unequal.

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

Return whether the nullable reference is not null.

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

Return whether rhs is not null.

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

Return whether lhs and rhs do not have the same value.

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

Return whether lhs and rhs do not have the same value.

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

See the overload above for contract.

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

Return whether lhs is not null.

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

Return whether rhs is not null.

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

Return whether lhs and rhs do not have the same value.

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.

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

Return true if the specified lhs and rhs do not have the same value.

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

Return true if the specified lhs and rhs do not have the same value.

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

Return true if the specified lhs and rhs do not have the same value.

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

Return true if the specified lhs and rhs do not have the same value.

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

Return true if the specified lhs and rhs do not have the same value.

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

Return true if the specified lhs and rhs do not have the same value.

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

Return true if the specified lhs and rhs do not have the same value.

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

Return true if lhs and rhs do not refer to the same token position.

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

Return whether the operands do not have the same value.

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

Return whether the specified lhs and rhs do not have the same value.

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 whether the specified lhs and rhs do not have the same value.

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 true if the specified lhs and rhs objects do not have the same value.

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 whether the operands do not have the same value.

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

Return whether lhs and rhs do not have the same 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& nullopt) noexcept;

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

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

Return whether the operands do not have the same 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 rhs have different values.

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

Return whether lhs and rhs do not have the same value.

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

Return whether lhs and rhs do not have the same value.

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

Return Value

true if the underlying iterators are unequal, and false otherwise
true if the specified lhs is not null, and false otherwise
true if the specified rhs is not null, and false otherwise
true if the specified lhs and rhs nullable objects do not have the same value, and false otherwise
true if the specified lhs and rhs objects do not have the same value, and false otherwise
true if lhs and rhs do not have the same value, and false otherwise
true if lhs and rhs do not have the same value, and false otherwise
true if lhs and rhs do not have the same value, and false otherwise
true if lhs and rhs do not have the same value, and false otherwise
true if the operands do not have the same value, and false otherwise
true if the specified nullable objects do not have the same value
true if the specified nullable object and std::optional do not have the same value
true if lhs is not null, and false otherwise
true if rhs is not null, and false otherwise
true if lhs and rhs have different values, and false otherwise

Parameters

Name

Description

lhs

left‐hand operand

rhs

right‐hand operand

nullopt

disengaged‐optional tag; value is unused

Created with MrDocs