BloombergLP::bsltf::operator!=

Inequality operators

Synopses

Declared in <bsltf_allocbitwisemoveabletesttype.h>

Return true if the specified iterators do not refer to the same element, and false otherwise.

bool
operator!=(
    TestValuesArrayIterator<OTHER_VALUE> const& lhs,
    TestValuesArrayIterator<OTHER_VALUE> const& rhs);

» more...

Return whether two objects do not have the same value.

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

» more...

Return whether two objects do not have the same value.

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

» more...

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

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

» more...

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

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

» more...

Return true if the specified iterators do not refer to the same underlying position, and false otherwise.

bool
operator!=(
    InputIterator<TYPE2> const& lhs,
    InputIterator<TYPE2> const& rhs);

» more...

Return true if the specified lhs and rhs do not refer to the same TYPE object and false othersise.

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

» more...

Return whether two allocator adaptors do not compare equal.

template<
    class TYPE1,
    class TYPE2>
bool
operator!=(
    StdAllocatorAdaptor<TYPE1> const& lhs,
    StdAllocatorAdaptor<TYPE2> const& rhs);

» more...

Return true if the specified iterator and sentinel do not refer to the same element, and false otherwise.

bool
operator!=(
    TestValuesArrayIterator<OTHER_VALUE> const& lhs,
    TestValuesArraySentinel<OTHER_VALUE> const& rhs);

» more...

Return whether two objects do not have the same value.

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

» more...

Return true if the specified sentinel and iterator do not refer to the same element, and false otherwise.

bool
operator!=(
    TestValuesArraySentinel<OTHER_VALUE> const& lhs,
    TestValuesArrayIterator<OTHER_VALUE> const& rhs);

» more...

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

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

» more...

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

template<class VALUE>
bool
operator!=(
    TestValuesArrayIterator<VALUE> const& lhs,
    TestValuesArraySentinel<VALUE> const& rhs);

» more...

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

template<class VALUE>
bool
operator!=(
    TestValuesArraySentinel<VALUE> const& lhs,
    TestValuesArrayIterator<VALUE> const& rhs);

» more...

Return whether two objects do not have the same value.

bsltf::EvilBooleanType
operator!=(
    EvilBooleanType const& lhs,
    EvilBooleanType const& rhs);

» more...

Return whether two allocators wrap different underlying allocators.

template<
    class TYPE1,
    class TYPE2,
    bool PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION,
    bool PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT,
    bool PROPAGATE_ON_CONTAINER_SWAP,
    bool PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT,
    bool IS_ALWAYS_EQUAL>
bool
operator!=(
    StdStatefulAllocator<TYPE1, PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, PROPAGATE_ON_CONTAINER_SWAP, PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, IS_ALWAYS_EQUAL> const& lhs,
    StdStatefulAllocator<TYPE2, PROPAGATE_ON_CONTAINER_COPY_CONSTRUCTION, PROPAGATE_ON_CONTAINER_COPY_ASSIGNMENT, PROPAGATE_ON_CONTAINER_SWAP, PROPAGATE_ON_CONTAINER_MOVE_ASSIGNMENT, IS_ALWAYS_EQUAL> const& rhs);

» more...

Return false because StdTestAllocator does not hold a state.

template<
    class TYPE1,
    class TYPE2>
bool
operator!=(
    StdTestAllocator<TYPE1> const& lhs,
    StdTestAllocator<TYPE2> const& rhs);

» more...

Return whether two objects do not have the same value.

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

» more...

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

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

» more...

Return whether two objects do not have the same value.

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

» more...

Return whether two objects do not have the same value.

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

» more...

Return whether two objects do not have the same value.

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

» more...

Return whether the two objects do not have the same value.

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

» more...

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

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

» more...

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

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

» more...

Return whether two EmplacableTestType objects differ in value.

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

» more...

Return whether two CopyMoveTracker objects have different values.

constexpr
bool
operator!=(
    CopyMoveTracker const& lhs,
    OTHER const& rhs)
requires bsl::is_same<CopyMoveTracker, OTHER>::value;

» more...

Return whether two objects do not have the same value.

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

» more...

Return whether two objects do not have the same value.

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

» more...

Return whether two objects do not have the same value.

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

» more...

Return whether two AllocEmplacableTestType objects differ in value.

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

» more...

Same as the preceding overload with operand order reversed.

bool
operator!=(
    int a,
    CopyMoveState::Enum b);

» more...

Return true if the integral values of the specified a and b do not compare equal; otherwise return false.

bool
operator!=(
    CopyMoveState::Enum a,
    int b);

» more...

Return Value

true if the iterators do not refer to the same element
true if lhs and rhs differ, else false
true if the iterators refer to different positions
true if the iterators refer to different objects
true if lhs and rhs do not compare equal, else false
true if they do not refer to the same element
an EvilBooleanType converting to true if the operands differ
true if lhs and rhs wrap different allocators, else false
false because StdTestAllocator does not hold a state
true if lhs and rhs do not have the same value, and false otherwise
false
true if a and b do not compare equal, else false

Parameters

Name

Description

lhs

left‐hand iterator

rhs

right‐hand iterator

left‐hand operand

right‐hand operand

Created with MrDocs