folly::operator==

Equality operators

Synopses

Declared in <folly/CancellationToken.h>

Return true if two addresses are equal.

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

» more...

Tests whether two huge page sizes have the same size in bytes.

bool
operator==(
    HugePageSize const& a,
    HugePageSize const& b);

» more...

Compares two keys by level and option name.

bool
operator==(
    SocketOptionKey const& lhs,
    SocketOptionKey const& rhs);

» more...

Compares two values for equality.

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

» more...

Compares the value against an int.

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

» more...

Compares the value against a string.

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

» more...

Compares two result<void> values for equality.

bool
operator==(
    result<> const& a,
    result<> const& b);

» more...

Compares two result values for equality.

bool
operator==(
    result const& a,
    result const& b)
requires requires(const ref_wrapped_t& v) { v == v; };

» more...

Compares two error_or_stopped values for equality.

bool
operator==(
    error_or_stopped const& lhs,
    error_or_stopped const& rhs);

» more...

Compares against nullptr.

constexpr
bool
operator==(
    std::nullptr_t null,
    rich_ptr_to_underlying_error const& p);

» more...

Compares against a raw Ex*.

constexpr
bool
operator==(
    Ex const* raw_p,
    rich_ptr_to_underlying_error const& p);

» more...

Compares two rich‐error pointers.

constexpr
bool
operator==(
    rich_ptr_to_underlying_error const& lhs,
    rich_ptr_to_underlying_error const& rhs);

» more...

Compares two operations for equality.

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

» more...

Compares two locations for equality.

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

» more...

Compares two positions for equality.

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

» more...

Compares two allocators for equality.

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

» more...

Return true if two addresses are equal.

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

» more...

Return true if the two addresses are equal.

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

» more...

Compares two wrappers for equality by their owned values.

template<
    typename U,
    typename AA>
constexpr
bool
operator==(
    indirect const& lhs,
    indirect<U, AA> const& rhs) noexcept(noexcept(bool(*lhs == *rhs)));

» more...

Compares a wrapper with a value for equality.

template<typename U>
requires (!std::is_same_v<std::remove_cvref_t<U>, indirect>)
constexpr
bool
operator==(
    indirect const& lhs,
    U const& rhs) noexcept(noexcept(bool(*lhs == rhs)));

» more...

Tests whether a shared pointer is empty.

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

» more...

Tests whether a shared pointer is empty.

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

» more...

Tests whether a main pointer is empty.

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

» more...

Tests whether a main pointer is empty.

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

» more...

Tests whether a pointer manages no object.

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

» more...

Tests whether a pointer manages no object.

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

» more...

Compares two pointers for equal 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 no object.

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

» more...

Tests whether a guard protects no object.

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

» more...

Compares two guards for equal guarded objects.

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

» more...

Equality‐compare a strong against a value of the underlying type.

template<typename U>
requires std::same_as<std::remove_cvref_t<U>, T>
constexpr
bool
operator==(
    strong const& st,
    U&& underlying);

» more...

Equality operator

bool
operator==(
    item_iterator const& lhs,
    item_iterator const& rhs);

» more...

Equality operator

bool
operator==(
    value_iterator const& lhs,
    value_iterator const& rhs);

» more...

Equality operator

bool
operator==(
    const_item_iterator const& lhs,
    const_item_iterator const& rhs);

» more...

Equality operator

bool
operator==(
    const_value_iterator const& lhs,
    const_value_iterator const& rhs);

» more...

Equality operator

bool
operator==(
    const_key_iterator const& lhs,
    const_key_iterator const& rhs);

» more...

Equality operator

bool
operator==(
    Iterator const& lhs,
    Iterator const& rhs);

» more...

Equality operator

bool
operator==(
    Iterator const& lhs,
    Iterator const& rhs);

» more...

Equality operator

bool
operator==(
    Iterator const& lhs,
    Iterator const& rhs);

» more...

Equality operator

template<__tuple_like_no_tuple _UTuple>
constexpr
bool
operator==(
    emplace_args const& __x,
    _UTuple const& __y);

» more...

Equality operator

bool
operator==(
    D const& lhs,
    D const& rhs);

» more...

Equality operator

bool
operator==(
    D const& lhs,
    D const& rhs);

» more...

Equality operator

bool
operator==(
    D const& lhs,
    D const& rhs);

» more...

Equality operator

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

» more...

Equality‐compare two strong values; available iff T is comparable.

bool
operator==(
    strong const& lhs,
    strong const& rhs) = default;

» more...

Returns whether two sets contain the same 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...

Equality‐compare a wrapper against a value of another type.

template<
    typename Pointer,
    typename Other>
constexpr
decltype(get_underlying(a) == b, false)
operator==(
    propagate_const<Pointer> const& a,
    Other const& b);

» more...

Equality‐compare two wrappers by their underlying pointers.

template<typename Pointer>
constexpr
bool
operator==(
    propagate_const<Pointer> const& a,
    propagate_const<Pointer> const& b);

» more...

Equality‐compare a wrapper against nullptr.

template<typename Pointer>
constexpr
bool
operator==(
    propagate_const<Pointer> const& a,
    std::nullptr_t np);

» more...

Compares two allocators for equality.

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

» more...

Tests whether a pointer is empty.

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

» more...

Tests whether a pointer is empty.

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

» more...

Compares two allocators for equality.

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

» more...

Compares two SysAllocator instances for equality.

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

» more...

Equality 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...]

Equality 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 equality.

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

» more...

Returns whether two spans refer to the same data and size.

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

» more...

Returns whether two iterators refer to the same bit position.

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

» more...

Compares two allocators for equality.

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

» more...

Compares two NetworkSockets for equality.

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

» 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 equality.

template<
    class Value,
    class Error>
bool
operator==(
    Expected<Value, Error> const& lhs,
    Expected<Value, Error> const& rhs)
requires IsEqualityComparable<Value>::value;

» more...

Relational Operators

template<
    class Val,
    class Err>
bool
operator==(
    Expected<Val, Err> const& lhs,
    Expected<Val, Err> const& rhs)
requires IsEqualityComparable<Val>::value;

» more...

Compares two Unexpected values for equality.

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

» more...

Compares two allocators for equality.

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

» more...

** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** Symmetric relational operators

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

» more...

** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** ** Asymmetric relational operators

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

» more...

Equality operator

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

» more...

Equality operator

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

» more...

Equality operator

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

» more...

Test whether two partial_ordering values represent the same result.

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

» more...

Compares two engines for equality of state.

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

» more...

Returns true if both iterators refer to the same position.

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

» more...

Compares an Optional with a value for equality.

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

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

Templated comparison operators

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

» more...

Compares two wrappers for pointing to the same exception object.

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

» more...

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

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 an fbstring and a std::basic_string for equality.

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

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

Equality 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 equality.

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

Equality 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 equality.

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

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

» more...

Returns true if the FunctionRef is empty.

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

» more...

Returns true if the FunctionRef is empty.

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

» more...

Returns true if the function is empty.

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

» more...

Compares two allocators for equality.

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

» more...

Returns whether two sets contain the same 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 contain the same 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 contain the same 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...

Return whether two tokens share the same underlying cancellation state.

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

» more...

Return whether two sources share the same underlying cancellation state.

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

» more...

Deep equality comparison. This will compare all the way down an object or array, and is potentially expensive.

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

» more...

Compare two pointers for equality.

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

» more...

Compare two metrics for equality.

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

» more...

Compare two keys for byte‐wise equality.

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

» more...

Compares two maps for equality.

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

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

Compares two maps for equality.

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 maps for equality.

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

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

» more...

Returns true if the function is empty.

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

» more...

Compares two policies for equality.

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

» more...

Compares two policies for equality.

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

» more...

Compares two SysAllocator instances for equality.

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

» more...

Returns whether two hash tokens hold the same processed hash.

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

» more...

Returns whether two hashed keys compare equal.

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

» more...

Returns whether a hashed key compares equal to a key.

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

» more...

Returns whether a key compares equal to a hashed key.

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

» more...

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

template<typename K>
bool
operator==(
    F14HashedKey const& a,
    K const& b);

» more...

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

template<typename K>
bool
operator==(
    K const& a,
    F14HashedKey const& b);

» more...

Compare two iterators for equality.

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

» more...

Tests whether an Optional is empty.

template<class V>
constexpr
bool
operator==(
    None none,
    Optional<V> const& a) noexcept;

» more...

Tests whether an Optional is empty.

template<class V>
constexpr
bool
operator==(
    Optional<V> const& a,
    None none) noexcept;

» more...

Compares two Optionals for equality.

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

» more...

Compares a value with an Optional for equality.

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

» more...

Return Value

true if the two addresses are equal.
True if a and b have the same size.
true if both keys have the same level and option name.
True when both hold the same alternative and value.
True when the value holds an int equal to rhs.
True when the value holds a string equal to rhs.
true if both have a value, or both hold the same error‐or‐stopped state.
true if both hold equal values, or both hold the same error‐or‐stopped state.
true if both hold the same error‐or‐stopped representation.
true if p is null.
true if both refer to the same error.
True if the operations are equal.
True if both locations are equal.
True if both positions are equal.
true if the allocators share state.
true if addr1 and addr2 are equal
True if the two addresses are equal.
true if the wrappers are equal.
true if the owned value equals rhs.
true if the pointer is empty.
true if the pointer manages no object.
true if both pointers manage the same object.
true if the guard protects no object.
true if both guards protect the same object.
true if the wrapped value equals underlying.
true if the wrapped values are equal.
True if both sets contain the same elements.
true if the underlying pointer equals b.
true if the underlying pointers are equal.
true if the underlying pointer is null.
true, as all instances are interchangeable.
true if holder is empty, false otherwise.
Always true, since all instances are interchangeable.
true if the tapes are equal.
True if a and b are equal.
True if the iterators are equal.
true if both sockets wrap the same handle.
Never returns; this overload is deleted.
true if both hold errors or both hold equal values.
true if the stored errors compare equal.
Always true, since the allocator is stateless.
True if both strings hold the same character sequence.
True if the two operands hold the same character sequence.
true if both hold the same value.
True if both engines have the same state.
True if x and y are equal.
true if a has a value equal to b.
True if the two operands compare equal as StringPiece.
True if both ranges have equal elements.
true if the wrappers point to the same exception object
true if the contents are equal.
true if the strings have equal contents.
True if both views hold the same characters.
True if ref is empty.
True if fn is empty.
true if both use the same alignment policy.
true if both tokens share the same state, false otherwise.
true if both sources share the same state, false otherwise.
True if the two dynamics are deeply equal.
True if both pointers have identical tokens.
True if both value and type are equal.
True if the keys have identical bytes
True if both maps contain the same elements.
true if both refer to the same Inner.
true if both hold the same alignment.
True if both tokens hold the same processed hash.
True if the two hashed keys compare equal.
True if the hashed key compares equal to the key.
True if the key compares equal to the hashed key.
true if both iterators refer to the same position.
true if a has no value.
true if both are empty or both hold equal values.
true if b has a value equal to a.

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

addr1

The first address to compare.

addr2

The second address to compare.

The left‐hand huge page size.

The right‐hand huge page size.

lhs

The left‐hand key to compare.

rhs

The right‐hand key to compare.

null

A nullptr literal.

The rich‐error pointer.

raw_p

The raw pointer to compare.

ptr

The shared pointer to test.

right

The pointer to test.

left

The pointer to test.

The strong value.

underlying

A value of the underlying type T.

The null pointer literal to compare against.

holder

The pointer to test.

unused

A null pointer constant.

The left‐hand tape.

The right‐hand tape.

other

The value operand.

exp

The Expected operand.

ref

The reference to test.

nullPtr

A null pointer constant.

The function to test.

none

The None tag.

Created with MrDocs