Greater‐than operators

Synopses

Declared in <absl/base/log_severity.h>

Tests whether the value of an inlined vector is greater than the value of another inlined vector using a lexicographical comparison algorithm.

template<
    typename T,
    size_t N,
    typename A>
bool
operator>(
    absl::InlinedVector<T, N, A> const& a,
    absl::InlinedVector<T, N, A> const& b);

Greater‐than operator

bool
operator>(
    btree_multiset const& x,
    btree_multiset const& y);

Greater‐than operator

bool
operator>(
    btree_set const& x,
    btree_set const& y);

Greater‐than operator

bool
operator>(
    btree_multimap const& x,
    btree_multimap const& y);

Greater‐than operator

bool
operator>(
    btree_map const& x,
    btree_map const& y);

Orders two iterators by position.

bool
operator>(
    Iter const& a,
    Iter const& b);

Orders string data after a Cord.

bool
operator>(
    std::string_view x,
    Cord const& y);

Orders a Cord after string data.

bool
operator>(
    Cord const& x,
    std::string_view y);

Orders one Cord after another.

bool
operator>(
    Cord const& x,
    Cord const& y);

Returns whether lhs orders lexicographically after rhs.

bool
operator>(
    FixedArray const& lhs,
    FixedArray const& rhs);

Compares an absl::LogSeverityAtLeast threshold against an absl::LogSeverity value (in either operand order).

Determines whether lhs is greater than rhs.

constexpr
bool
operator>(
    uint128 lhs,
    uint128 rhs);

Returns whether one time is later than another.

constexpr
bool
operator>(
    Time lhs,
    Time rhs);

Returns whether one duration is greater than another.

constexpr
bool
operator>(
    Duration lhs,
    Duration rhs);

Compares a span and a container lexicographically.

template<
    typename T,
    typename U,
    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<T const>>>
constexpr
bool
operator>(
    Span<T> a,
    U const& b);

Compares a container and a span lexicographically.

template<
    typename T,
    typename U,
    typename = span_internal::EnableIfConvertibleTo<U, absl::Span<T const>>>
constexpr
bool
operator>(
    U const& a,
    Span<T> b);

Compares two spans lexicographically.

template<typename T>
constexpr
bool
operator>(
    Span<T> a,
    Span<T const> b);

Compares two spans lexicographically.

template<typename T>
constexpr
bool
operator>(
    Span<T const> a,
    Span<T> b);

Compares two spans lexicographically.

template<typename T>
constexpr
bool
operator>(
    Span<T> a,
    Span<T> b);

Compares an absl::LogSeverityAtMost threshold against an absl::LogSeverity value (in either operand order).

Return Value

  • true if a is greater than b, false otherwise.

  • true if a follows b.

  • true if x is lexicographically greater than y.

  • true if lhs is lexicographically greater than rhs.

  • true if the comparison holds, false otherwise.

  • true if lhs is greater than rhs; false otherwise.

  • true if lhs is later than rhs.

  • true if lhs is greater than rhs.

  • true if a is lexicographically greater than b.

Parameters

Name

Description

a

The first inlined vector.

b

The second inlined vector.

x

The left‐hand string data.

y

The right‐hand Cord.

lhs

The left‐hand fixed array.

rhs

The right‐hand fixed array.

Created with MrDocs