Trait scala.math.CachedReverse

sealed trait CachedReverse[T] extends Ordering[T]

Порядок, кэширующий значение своего обратного порядка.

Наследуемые классы

Исходный код

class OrderingOps(lhs: T)

Этот внутренний класс определяет операторы сравнения, доступные для T.

Он не может расширять AnyVal, так как это не класс верхнего уровня или член статически доступного объекта.

Конкретные методы

Исходный код

final override def isReverseOf(other: Ordering[_]): Boolean

Исходный код

final override def reverse: Ordering[T]

Наследуемые методы

Исходный код

def compare(x: T, y: T): Int

Возвращает целое число, знак которого указывает, как x сравнивается с y.

Знак результата имеет следующее значение:

- отрицательный, если x < y - положительный, если x > y - нулевой, если x == y

Исходный код

override def equiv(x: T, y: T): Boolean

Возвращает true, если x == y в порядке.

Исходный код

override def gt(x: T, y: T): Boolean

Возвращает true, если x > y в порядке.

Исходный код

override def gteq(x: T, y: T): Boolean

Возвращает true, если x >= y в порядке.

Исходный код

override def lt(x: T, y: T): Boolean

Возвращает true, если x < y в порядке.

Исходный код

override def lteq(x: T, y: T): Boolean

Возвращает true, если x <= y в порядке.

Исходный код

def max[U <: T](x: U, y: U): U

Возвращает x, если x >= y, иначе y.

Исходный код

def min[U <: T](x: U, y: U): U

Возвращает x, если x <= y, иначе y.

Исходный код

def on[U](f: U => T): Ordering[U]

Принимая f, функцию из U в T, создаёт Ordering[U], чья функция сравнения эквивалентна:

def compare(x:U, y:U) = Ordering[T].compare(f(x), f(y))

Исходный код

def orElse(other: Ordering[T]): Ordering[T]

Создаёт Ordering[T], чья функция сравнения возвращает результат функции сравнения этого Ordering, если она не равна нулю, иначе результат функции сравнения other.

case class Pair(a: Int, b: Int)
val pairOrdering = Ordering.by[Pair, Int](_.a)
                          .orElse(Ordering.by[Pair, Int](_.b))

Исходный код

def orElseBy[S](f: T => S)(implicit ord: Ordering[S]): Ordering[T]

Принимая f, функцию из T в S, создаёт Ordering[T], чья функция сравнения возвращает результат функции сравнения этого Ordering, если она не равна нулю, иначе результат, эквивалентный:

Ordering[S].compare(f(x), f(y))

Эта функция эквивалентна передаче результата Ordering.by(f) в orElse.

case class Pair(a: Int, b: Int)
val pairOrdering = Ordering.by[Pair, Int](_.a)
                          .orElseBy[Int](_.b)

def reversed(): Comparator[T]

def thenComparing[U <: Comparable[_ >: U <: <FromJavaObject>]](x$0: Function[_ >: T <: <FromJavaObject>, _ <: U]): Comparator[T]

def thenComparing[U <: <FromJavaObject>](x$0: Function[_ >: T <: <FromJavaObject>, _ <: U], x$1: Comparator[_ >: U <: <FromJavaObject>]): Comparator[T]

def thenComparing(x$0: Comparator[_ >: T <: <FromJavaObject>]): Comparator[T]

def thenComparingDouble(x$0: ToDoubleFunction[_ >: T <: <FromJavaObject>]): Comparator[T]

def thenComparingInt(x$0: ToIntFunction[_ >: T <: <FromJavaObject>]): Comparator[T]

def thenComparingLong(x$0: ToLongFunction[_ >: T <: <FromJavaObject>]): Comparator[T]

Source

def tryCompare(x: T, y: T): Option[Int]

Возвращает, определено ли сравнение между x и y, и если да, то результат compare(x, y).

Inherited implicits

Source

implicit def mkOrderingOps(lhs: T): OrderingOps

Этот неявный метод дополняет T операторами сравнения, определёнными в scala.math.Ordering.Ops.