bsl::operator<=>

Synopses

Declared in <bslstl_deque.h>

Return the lexicographic three-way comparison of lhs and rhs.

template<
    class KEY,
    class COMPARATOR,
    class ALLOCATOR>
BloombergLP::bslalg::SynthThreeWayUtil::Result<KEY>
operator<=>(
    multiset<KEY, COMPARATOR, ALLOCATOR> const& lhs,
    multiset<KEY, COMPARATOR, ALLOCATOR> const& rhs);

» more...

Perform a lexicographic three-way comparison of lhs and rhs.

template<
    class VALUE,
    class ALLOCATOR>
BloombergLP::bslalg::SynthThreeWayUtil::Result<VALUE>
operator<=>(
    list<VALUE, ALLOCATOR> const& lhs,
    list<VALUE, ALLOCATOR> const& rhs);

» more...

Return the three-way comparison result of lhs and rhs.

template<
    class VALUE,
    three_way_comparable CONTAINER>
compare_three_way_result_t<CONTAINER>
operator<=>(
    queue<VALUE, CONTAINER> const& lhs,
    queue<VALUE, CONTAINER> const& rhs);

» more...

Return the three-way comparison of the specified queues; see the non-member operator<=> in the bsl namespace.

compare_three_way_result_t<CONTAINER2>
operator<=>(
    queue<VALUE2, CONTAINER2> const& lhs,
    queue<VALUE2, CONTAINER2> const& rhs);

» more...

Return the three-way comparison result of lhs and rhs.

template<class... t_ALTS>
requires (std::three_way_comparable<t_ALTS> && ...)
constexpr
std::common_comparison_category_t<std::compare_three_way_result_t<t_ALTS>...>
operator<=>(
    variant<t_ALTS...> const& lhs,
    variant<t_ALTS...> const& rhs);

» more...

Return the three-way comparison result of the specified lhs and rhs stacks by comparing their underlying containers.

template<
    class VALUE,
    three_way_comparable CONTAINER>
compare_three_way_result_t<CONTAINER>
operator<=>(
    stack<VALUE, CONTAINER> const& lhs,
    stack<VALUE, CONTAINER> const& rhs);

» more...

Return the three-way comparison of the specified stacks; see the non-member operator<=> in the bsl namespace.

compare_three_way_result_t<CONT>
operator<=>(
    stack<VAL, CONT> const& lhs,
    stack<VAL, CONT> const& rhs);

» more...

Perform a lexicographic three-way comparison of lhs and rhs.

template<
    class VALUE_TYPE,
    class ALLOCATOR>
BloombergLP::bslalg::SynthThreeWayUtil::Result<VALUE_TYPE>
operator<=>(
    deque<VALUE_TYPE, ALLOCATOR> const& lhs,
    deque<VALUE_TYPE, ALLOCATOR> const& rhs);

» more...

Perform a three-way comparison of the operands.

template<
    class t_LHS,
    three_way_comparable_with<t_LHS> t_RHS>
constexpr
compare_three_way_result_t<t_LHS, t_RHS>
operator<=>(
    bsl::optional<t_LHS> const& lhs,
    std::optional<t_RHS> const& rhs);

» more...

Perform a three-way comparison of the operands.

template<class t_TYPE>
constexpr
std::strong_ordering
operator<=>(
    bsl::optional<t_TYPE> const& value,
    bsl::nullopt_t nullopt) noexcept;

» more...

Perform a three-way comparison of the operands.

template<
    class t_LHS,
    class t_RHS>
requires (!BloombergLP::bslstl::Optional_DerivedFromOptional<t_RHS>) &&
         three_way_comparable_with<t_LHS, t_RHS>
constexpr
compare_three_way_result_t<t_LHS, t_RHS>
operator<=>(
    bsl::optional<t_LHS> const& lhs,
    t_RHS const& rhs);

» more...

Perform a three-way comparison of the operands.

template<
    class t_LHS,
    three_way_comparable_with<t_LHS> t_RHS>
constexpr
compare_three_way_result_t<t_LHS, t_RHS>
operator<=>(
    bsl::optional<t_LHS> const& lhs,
    bsl::optional<t_RHS> const& rhs);

» more...

Compare the specified lhs and rhs pairs lexicographically.

template<
    class T1,
    class T2>
constexpr
std::common_comparison_category_t<BloombergLP::bslalg::SynthThreeWayUtil::Result<T1>, BloombergLP::bslalg::SynthThreeWayUtil::Result<T2>>
operator<=>(
    pair<T1, T2> const& lhs,
    pair<T1, T2> const& rhs);

» more...

Perform a lexicographic three-way comparison of lhs and rhs.

template<
    class KEY,
    class COMPARATOR,
    class ALLOCATOR>
BloombergLP::bslalg::SynthThreeWayUtil::Result<KEY>
operator<=>(
    set<KEY, COMPARATOR, ALLOCATOR> const& lhs,
    set<KEY, COMPARATOR, ALLOCATOR> const& rhs);

» more...

Perform a lexicographic three-way comparison of lhs and rhs.

template<
    class KEY,
    class VALUE,
    class COMPARATOR,
    class ALLOCATOR>
BloombergLP::bslalg::SynthThreeWayUtil::Result<bsl::pair<KEY const, VALUE>>
operator<=>(
    multimap<KEY, VALUE, COMPARATOR, ALLOCATOR> const& lhs,
    multimap<KEY, VALUE, COMPARATOR, ALLOCATOR> const& rhs);

» more...

Perform a lexicographic three-way comparison of lhs and rhs.

template<
    class KEY,
    class VALUE,
    class COMPARATOR,
    class ALLOCATOR>
BloombergLP::bslalg::SynthThreeWayUtil::Result<bsl::pair<KEY const, VALUE>>
operator<=>(
    map<KEY, VALUE, COMPARATOR, ALLOCATOR> const& lhs,
    map<KEY, VALUE, COMPARATOR, ALLOCATOR> const& rhs);

» more...

Perform a three-way comparison of the specified ptr and null pointer by using the comparison operators of TYPE *; return the result of that comparison.

template<class TYPE>
std::strong_ordering
operator<=>(
    shared_ptr<TYPE> const& ptr,
    nullptr_t nullPointerLiteral) noexcept;

» more...

Compare lhs and rhs three-way by their stored pointers.

template<
    class LHS_TYPE,
    class RHS_TYPE>
std::strong_ordering
operator<=>(
    shared_ptr<LHS_TYPE> const& lhs,
    shared_ptr<RHS_TYPE> const& rhs) noexcept;

» more...

Perform a lexicographic three-way comparison of two strings.

template<
    class CHAR_TYPE,
    class CHAR_TRAITS,
    class ALLOC1,
    class ALLOC2>
bsl::String_ComparisonCategoryType<CHAR_TRAITS>
operator<=>(
    bsl::basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOC1> const& lhs,
    std::basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOC2> const& rhs) noexcept;

» more...

Perform a lexicographic three-way comparison of two strings.

template<
    class CHAR_TYPE,
    class CHAR_TRAITS,
    class ALLOC>
bsl::String_ComparisonCategoryType<CHAR_TRAITS>
operator<=>(
    basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOC> const& lhs,
    CHAR_TYPE const* rhs);

» more...

Perform a lexicographic three-way comparison of two strings.

template<
    class CHAR_TYPE,
    class CHAR_TRAITS,
    class ALLOC>
bsl::String_ComparisonCategoryType<CHAR_TRAITS>
operator<=>(
    basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOC> const& lhs,
    basic_string<CHAR_TYPE, CHAR_TRAITS, ALLOC> const& rhs) noexcept;

» more...

Perform a three-way comparison of the specified lhs and rhs vectors and return the result of that comparison.

BloombergLP::bslalg::SynthThreeWayUtil::Result<Impl>
operator<=>(
    vector const& lhs,
    vector const& rhs);

» more...

Perform a three-way comparison of the operands.

template<
    class VALUE_TYPE,
    class ALLOCATOR>
BloombergLP::bslalg::SynthThreeWayUtil::Result<VALUE_TYPE>
operator<=>(
    vector<VALUE_TYPE, ALLOCATOR> const& lhs,
    vector<VALUE_TYPE, ALLOCATOR> const& rhs);

» more...