folly::operator!=

Inequality operators

Synopses

Declared in <folly/CancellationToken.h>

Return whether two tokens do not share the same underlying cancellation state.

bool
operator!=(
    CancellationToken const& a,
    CancellationToken const& b) noexcept;

» more...

Tests whether a shared pointer is non‐empty.

template<
    typename T,
    typename RefCount>
bool
operator!=(
    ReadMostlySharedPtr<T, RefCount> const& ptr,
    std::nullptr_t null);

» more...

Tests whether a main pointer is non‐empty.

template<
    typename T,
    typename RefCount>
bool
operator!=(
    std::nullptr_t null,
    ReadMostlyMainPtr<T, RefCount> const& ptr);

» more...

Tests whether a main pointer is non‐empty.

template<
    typename T,
    typename RefCount>
bool
operator!=(
    ReadMostlyMainPtr<T, RefCount> const& ptr,
    std::nullptr_t null);

» more...

Tests whether a pointer manages an object.

template<typename RightAliasType>
bool
operator!=(
    std::nullptr_t null,
    DelayedDestructionBase::IntrusivePtr<RightAliasType> const& right);

» more...

Tests whether a pointer manages an object.

template<typename LeftAliasType>
bool
operator!=(
    DelayedDestructionBase::IntrusivePtr<LeftAliasType> const& left,
    std::nullptr_t null);

» more...

Compares two pointers for different managed objects.

template<
    typename LeftAliasType,
    typename RightAliasType>
bool
operator!=(
    DelayedDestructionBase::IntrusivePtr<LeftAliasType> const& left,
    DelayedDestructionBase::IntrusivePtr<RightAliasType> const& right);

» more...

Tests whether a guard protects an object.

bool
operator!=(
    std::nullptr_t null,
    DelayedDestructionBase::DestructorGuard const& right);

» more...

Tests whether a guard protects an object.

bool
operator!=(
    DelayedDestructionBase::DestructorGuard const& left,
    std::nullptr_t null);

» more...

Compares two guards for different guarded objects.

bool
operator!=(
    DelayedDestructionBase::DestructorGuard const& left,
    DelayedDestructionBase::DestructorGuard const& right);

» more...

Return whether two sources do not share the same underlying cancellation state.

bool
operator!=(
    CancellationSource const& a,
    CancellationSource const& b) noexcept;

» more...

Tests whether a shared pointer is non‐empty.

template<
    typename T,
    typename RefCount>
bool
operator!=(
    std::nullptr_t null,
    ReadMostlySharedPtr<T, RefCount> const& ptr);

» more...

Returns whether two sets differ in their elements.

template<
    typename K,
    typename H,
    typename E,
    typename A>
bool
operator!=(
    F14FastSet<K, H, E, A> const& lhs,
    F14FastSet<K, H, E, A> const& rhs);

» more...

Returns whether two sets differ in their elements.

template<
    typename K,
    typename H,
    typename E,
    typename A>
bool
operator!=(
    F14VectorSet<K, H, E, A> const& lhs,
    F14VectorSet<K, H, E, A> const& rhs);

» more...

Returns whether two sets differ in their elements.

template<
    typename K,
    typename H,
    typename E,
    typename A>
bool
operator!=(
    F14NodeSet<K, H, E, A> const& lhs,
    F14NodeSet<K, H, E, A> const& rhs);

» more...

Returns whether two sets differ in their elements.

template<
    typename K,
    typename H,
    typename E,
    typename A>
bool
operator!=(
    F14ValueSet<K, H, E, A> const& lhs,
    F14ValueSet<K, H, E, A> const& rhs);

» more...

Deep inequality comparison.

bool
operator!=(
    dynamic const& a,
    dynamic const& b);

» more...

Compare two pointers for inequality.

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

» more...

Compare two metrics for inequality.

bool
operator!=(
    UserMetric const& x,
    UserMetric const& y);

» more...

Compare two keys for byte‐wise inequality.

auto
operator!=(
    self const& a,
    self const& b) noexcept;

» more...

Compares two maps for inequality.

template<
    typename K,
    typename M,
    typename H,
    typename E,
    typename A>
bool
operator!=(
    F14FastMap<K, M, H, E, A> const& lhs,
    F14FastMap<K, M, H, E, A> const& rhs);

» more...

Compares two maps for inequality.

template<
    typename K,
    typename M,
    typename H,
    typename E,
    typename A>
bool
operator!=(
    F14VectorMap<K, M, H, E, A> const& lhs,
    F14VectorMap<K, M, H, E, A> const& rhs);

» more...

Returns whether two iterators refer to different bit positions.

bool
operator!=(
    self const& a,
    self const& b) noexcept;

» more...

Tests two Poly objects for inequality.

template<
    class I1,
    class I2>
requires detail::Comparable<I1, I2>::value
bool
operator!=(
    Poly<I1> const& _this,
    Poly<I2> const& that);

» more...

Compares two allocators for inequality.

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

» more...

Tests whether a pointer is non‐empty.

bool
operator!=(
    holder const& holder,
    std::nullptr_t unused) noexcept;

» more...

Tests whether a pointer is non‐empty.

bool
operator!=(
    std::nullptr_t unused,
    holder const& holder) noexcept;

» more...

Compares two allocators for inequality.

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

» more...

Compares two SysAllocator instances for inequality.

bool
operator!=(
    Self const& a,
    Self const& b) noexcept;

» more...

Inequality comparison forwarding to the underlying pointer.

template<
    typename PtrT,
    typename T,
    typename RhsNullHandlerT>
bool
operator!=(
    T const& lhs,
    not_null<PtrT, RhsNullHandlerT> const& rhs);

[» more...]

Inequality comparison forwarding to the underlying pointer.

template<
    typename PtrT,
    typename T,
    typename LhsNullHandlerT>
bool
operator!=(
    not_null<PtrT, LhsNullHandlerT> const& lhs,
    T const& rhs);

[» more...]

Compares two tapes for inequality.

bool
operator!=(
    tape const& x,
    tape const& y);

» more...

Returns whether two spans differ in data or size.

bool
operator!=(
    bit_span const& a,
    bit_span const& b) noexcept;

» more...

Compares two maps for inequality.

template<
    typename K,
    typename M,
    typename H,
    typename E,
    typename A>
bool
operator!=(
    F14NodeMap<K, M, H, E, A> const& lhs,
    F14NodeMap<K, M, H, E, A> const& rhs);

» more...

Compares two allocators for inequality.

template<
    typename A,
    typename B>
bool
operator!=(
    reentrant_allocator<A> const& a,
    reentrant_allocator<B> const& b) noexcept;

» more...

Compares two allocators for inequality.

bool
operator!=(
    reentrant_allocator<A> const& a,
    reentrant_allocator<B> const& b) noexcept;

» more...

Compares two values for inequality.

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

» more...

Compares the value against an int for inequality.

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

» more...

Compares the value against a string for inequality.

bool
operator!=(
    SocketOptionValue const& lhs,
    std::string const& rhs);

» more...

Compares two operations for inequality.

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

» more...

Return true if two address are not equal

bool
operator!=(
    IPAddress const& addr1,
    IPAddress const& addr2);

» more...

Return true if addr1 != addr2.

bool
operator!=(
    IPAddressV4 const& addr1,
    IPAddressV4 const& addr2);

» more...

Return true if the two addresses are not equal.

bool
operator!=(
    IPAddressV6 const& addr1,
    IPAddressV6 const& addr2);

» more...

Compares a std::basic_string and an fbstring for inequality.

template<
    typename E,
    class T,
    class A,
    class S,
    class A2>
bool
operator!=(
    std::basic_string<E, T, A2> const& lhs,
    basic_fbstring<E, T, A, S> const& rhs);

» more...

Compares two BasicFixedString objects for inequality.

template<
    class Char,
    std::size_t A,
    std::size_t B>
constexpr
bool
operator!=(
    BasicFixedString<Char, A> const& a,
    BasicFixedString<Char, B> const& b);

» more...

Compares a BasicFixedString against a null‐terminated string or a character range for inequality.

constexpr
bool
operator!=(
    Char const* a,
    BasicFixedString const& b) noexcept;

» more...

Inequality operator

constexpr
bool
operator!=(
    BasicFixedString const& a,
    Char const* b) noexcept;

» more...

Inequality operator

constexpr
bool
operator!=(
    Range<Char const*> a,
    BasicFixedString const& b) noexcept;

» more...

Inequality operator

constexpr
bool
operator!=(
    BasicFixedString const& a,
    Range<Char const*> b) noexcept;

» more...

Test whether two partial_ordering values represent different results.

bool
operator!=(
    partial_ordering a,
    partial_ordering b) noexcept;

» more...

Returns true if the iterators refer to different positions.

constexpr
bool
operator!=(
    index_iterator const& x,
    index_iterator const& y);

» more...

Compares two NetworkSockets for inequality.

constexpr
bool
operator!=(
    NetworkSocket const& a,
    NetworkSocket const& b) noexcept;

» more...

operator!= through conversion for Range<const char*>

template<
    class T,
    class U>
bool
operator!=(
    T const& lhs,
    U const& rhs)
requires detail::ComparableAsStringPiece<T, U>::value;

» more...

Compare two ranges for inequality.

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

» more...

Compares two allocators for inequality.

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

» more...

Compares an fbstring and a std::basic_string for inequality.

template<
    typename E,
    class T,
    class A,
    class S,
    class A2>
bool
operator!=(
    basic_fbstring<E, T, A, S> const& lhs,
    std::basic_string<E, T, A2> const& rhs);

» more...

Compares a string and a null‐terminated array for inequality.

template<
    typename E,
    class T,
    class A,
    class S>
bool
operator!=(
    basic_fbstring<E, T, A, S> const& lhs,
    basic_fbstring<E, T, A, S>::value_type const* rhs);

» more...

Inequality comparison against nullptr is deleted.

template<
    typename E,
    class T,
    class A,
    class S>
bool
operator!=(
    basic_fbstring<E, T, A, S> const& lhs,
    std::nullptr_t rhs) = delete;

» more...

Compares a null‐terminated array and a string for inequality.

template<
    typename E,
    class T,
    class A,
    class S>
bool
operator!=(
    basic_fbstring<E, T, A, S>::value_type const* lhs,
    basic_fbstring<E, T, A, S> const& rhs);

» more...

Inequality comparison against nullptr is deleted.

template<
    typename E,
    class T,
    class A,
    class S>
bool
operator!=(
    std::nullptr_t lhs,
    basic_fbstring<E, T, A, S> const& rhs) = delete;

» more...

Compares two strings for inequality.

template<
    typename E,
    class T,
    class A,
    class S>
bool
operator!=(
    basic_fbstring<E, T, A, S> const& lhs,
    basic_fbstring<E, T, A, S> const& rhs);

» more...

Checks two views for inequality.

bool
operator!=(
    self lhs,
    self rhs) noexcept;

» more...

Returns true if the FunctionRef is non‐empty.

constexpr
bool
operator!=(
    FunctionRef<ReturnType(Args...)> ref,
    std::nullptr_t nullPtr) noexcept;

» more...

Returns true if the FunctionRef is non‐empty.

constexpr
bool
operator!=(
    std::nullptr_t nullPtr,
    FunctionRef<ReturnType(Args...)> ref) noexcept;

» more...

Returns true if the function is non‐empty.

template<typename FunctionType>
bool
operator!=(
    std::nullptr_t nullPtr,
    Function<FunctionType> const& fn);

» more...

Returns whether a hashed key compares unequal to a heterogeneous key.

bool
operator!=(
    F14HashedKey const& a,
    K const& b);

» more...

Compares two maps for inequality.

template<
    typename K,
    typename M,
    typename H,
    typename E,
    typename A>
bool
operator!=(
    F14ValueMap<K, M, H, E, A> const& lhs,
    F14ValueMap<K, M, H, E, A> const& rhs);

» more...

Compares two adaptors for inequality.

bool
operator!=(
    Self const& a,
    Self const& b) noexcept;

» more...

Compares two allocators for inequality.

bool
operator!=(
    Self const& a,
    Self const& b) noexcept;

» more...

Compares two policies for inequality.

bool
operator!=(
    Self const& a,
    Self const& b) noexcept;

» more...

Compares two policies for inequality.

bool
operator!=(
    Self const& a,
    Self const& b) noexcept;

» more...

Compares two SysAllocator instances for inequality.

bool
operator!=(
    Self const& a,
    Self const& b) noexcept;

» more...

Returns whether two hash tokens hold different processed hashes.

constexpr
bool
operator!=(
    F14HashToken const& a,
    F14HashToken const& b) noexcept;

» more...

Returns whether two hashed keys compare unequal.

bool
operator!=(
    F14HashedKey const& a,
    F14HashedKey const& b);

» more...

Returns whether a hashed key compares unequal to a key.

bool
operator!=(
    F14HashedKey const& a,
    TKeyType const& b);

» more...

Returns whether a key compares unequal to a hashed key.

bool
operator!=(
    TKeyType const& a,
    F14HashedKey const& b);

» more...

Returns true if the function is non‐empty.

template<typename FunctionType>
bool
operator!=(
    Function<FunctionType> const& fn,
    std::nullptr_t nullPtr);

» more...

Returns whether a heterogeneous key compares unequal to a hashed key.

bool
operator!=(
    K const& a,
    F14HashedKey const& b);

» more...

Compare two iterators for inequality.

bool
operator!=(
    down const lhs,
    down const rhs) noexcept;

» more...

Compares two Optionals for inequality.

template<
    class U,
    class V>
constexpr
bool
operator!=(
    Optional<U> const& a,
    Optional<V> const& b);

» more...

Compares a value with an Optional for inequality.

template<
    class U,
    class V>
constexpr
bool
operator!=(
    U const& a,
    Optional<V> const& b);

» more...

Compares an Optional with a value for inequality.

template<
    class U,
    class V>
constexpr
bool
operator!=(
    Optional<U> const& a,
    V const& b);

» more...

Deleted: comparing a bare value with an Expected is not allowed.

template<
    class Value,
    class Error>
bool
operator!=(
    Value const& other,
    Expected<Value, Error> const& exp) = delete;

» more...

Deleted: comparing an Expected with a bare value is not allowed.

template<
    class Value,
    class Error>
bool
operator!=(
    Expected<Value, Error> const& exp,
    Value const& other) = delete;

» more...

Compares two Expected values for inequality.

template<
    class Value,
    class Error,
    bool FollyRequires1909 = false>
bool
operator!=(
    Expected<Value, Error> const& lhs,
    Expected<Value, Error> const& rhs);

» more...

Compares two Unexpected values for inequality.

template<
    class Error,
    bool FollyRequires154 = false>
bool
operator!=(
    Unexpected<Error> const& lhs,
    Unexpected<Error> const& rhs);

» more...

Return Value

true if the tokens differ, false otherwise.
true if the pointer references an object.
true if the pointer manages an object.
true if the pointer manages a non‐null object.
true if the pointers manage different objects.
true if the guard protects a non‐null object.
true if the guards protect different objects.
true if the sources differ, false otherwise.
True if the sets differ in their elements.
True if the two dynamics are not deeply equal.
True if the pointers differ in their tokens.
True if the metrics differ.
True if the keys differ in any byte
True if the maps do not contain the same elements.
True if the iterators are not equal.
true if the objects are not equal.
false, as all instances are interchangeable.
true if holder is non‐empty, false otherwise.
Always false, since all instances are interchangeable.
true if the tapes are not equal.
True if a and b are not equal.
true if the allocators do not share state.
True when the values differ.
True when the value does not hold an int equal to rhs.
True when the value does not hold a string equal to rhs.
True if the operations differ.
true if the two addresses are not equal.
true if addr1 and addr2 differ
True if the two addresses are not equal.
true if the contents differ.
True if the strings hold different character sequences.
True if the two operands hold different character sequences.
true if the two hold different values.
True if x and y are not equal.
true if the sockets wrap different handles.
True if the two operands differ as StringPiece.
True if the ranges differ.
Always false, since the allocator is stateless.
Never returns; this overload is deleted.
true if the strings differ.
True if the views differ.
True if ref references a callable.
True if fn holds a callable.
True if the hashed key compares unequal to the key.
true if the adaptors refer to different Inner instances.
true if the allocators use different alignment policies.
true if the policies hold different alignments.
True if the tokens hold different processed hashes.
True if the two hashed keys compare unequal.
True if the key compares unequal to the hashed key.
true if the iterators refer to different positions.
true if the two Optionals are not equal.
true if b is empty or its value differs from a.
true if a is empty or its value differs from b.
true if the two Expected values are not equal.
true if the stored errors are not equal.

Template Parameters

Name

Description

The pointee type.

RefCount

The reference‐count implementation.

RightAliasType

The pointer's managed type.

LeftAliasType

The pointer's managed type.

Parameters

Name

Description

The first token to compare.

The second token to compare.

ptr

The shared pointer to test.

null

The null pointer constant to compare against.

right

The pointer to test.

left

The pointer to test.

lhs

The first set to compare.

rhs

The second set to compare.

The left‐hand metric.

The right‐hand metric.

_this

The left‐hand operand.

that

The right‐hand operand.

holder

The pointer to test.

unused

A null pointer constant.

addr1

The first address to compare.

addr2

The second address to compare.

ref

The reference to test.

nullPtr

A null pointer constant.

The function to test.

other

The value operand.

exp

The Expected operand.

Created with MrDocs