Объект scala.concurrent.Future.never

Проверяет два объекта на неравенство.

Эквивалентно x.hashCode за исключением boxed числовых типов и null. Для чисел, он возвращает хэш-значение, которое согласуется с равенством значений: если два экземпляра типа значения сравниваются как true, то ## будет производить одно и то же хэш-значение для каждого из них. Для null возвращает хэш-код, где null.hashCode вызывает NullPointerException.

Выражение x == that эквивалентно if (x eq null) that eq null else x.equals(that).

Применяет функцию с побочными эффектами к результату этого future и возвращает новый future с результатом этого future.

Этот метод позволяет обеспечить выполнение обратных вызовов в указанном порядке.

Обратите внимание, что если один из связанных andThen обратных вызовов вызывает исключение, это исключение не распространяется на последующие andThen обратные вызовы. Вместо этого последующие andThen обратные вызовы получают исходное значение этого future.

Следующий пример выводит 5:

val f = Future { 5 }
f andThen {
  case r => sys.error("runtime exception")
} andThen {
  case Failure(t) => println(t)
  case Success(v) => println(v)
}

Поскольку этот метод выполняется асинхронно и не возвращает значение, любые нефатальные исключения, которые будут выброшены, будут сообщены ExecutionContext.

Преобразует принимаемый объект в тип T0.

Обратите внимание, что успех приведения типов во время выполнения зависит от семантики стирания типов Scala. Поэтому выражение 1.asInstanceOf[String] вызовет ClassCastException во время выполнения, а выражение List(1).asInstanceOf[List[String]] — нет. В последнем примере, поскольку аргумент типа стирается во время компиляции, невозможно проверить, являются ли содержимые списка запрашиваемого типа.

Создает копию принимаемого объекта.

Реализация метода clone по умолчанию зависит от платформы.

Создает новый future, отображая значение текущего future, если данная частичная функция определена для этого значения.

Если текущий future содержит значение, для которого определена частичная функция, новый future также будет содержать это значение. В противном случае результирующий future завершится ошибкой с NoSuchElementException.

Если текущий future завершается ошибкой, то результирующий future также завершается ошибкой.

Пример:

val f = Future { -5 }
val g = f collect {
  case x if x < 0 => -x
}
val h = f collect {
  case x if x > 0 => x * 2
}
g foreach println // Eventually prints 5
Await.result(h, Duration.Zero) // throw a NoSuchElementException

Проверяет, является ли аргумент (that) ссылкой на объект-получатель (this).

Метод eq реализует отношение эквивалентности на не-null экземплярах AnyRef, и обладает тремя дополнительными свойствами:

Он согласован: для любых не-null экземпляров x и y типа AnyRef, многократные вызовы x.eq(y) последовательно возвращают true или последовательно возвращают false. Для любого не-null экземпляра x типа AnyRef, x.eq(null) и null.eq(x) возвращают false. null.eq(null) возвращает true.

При переопределении методов equals или hashCode важно обеспечить, что их поведение согласуется с равенством ссылок. Таким образом, если два объекта являются ссылками друг на друга (o1 eq o2), они должны быть равны друг другу (o1 == o2) и должны иметь одинаковое значение хэша (o1.hashCode == o2.hashCode).

Метод равенства для типов ссылок. По умолчанию делегирует вызов к eq.

Смотрите также equals в scala.Any.

Возвращаемое значение Future будет успешно завершено с Throwable исходного Future в случае, если исходное Future завершилось неудачно.

Если исходное Future успешно завершено, возвращаемое Future завершается неудачно с NoSuchElementException.

Этот фьючер может содержать объект типа исключение, что означает неудачное завершение фьючера. Фьючеры, полученные через комбинаторы, содержат те же исключения, что и фьючер, из которого они получены. Нижеследующие объекты исключения не содержатся во фьючере:

Error - ошибки не содержатся во фьючерах InterruptedException - не содержатся во фьючерахвсе scala.util.control.ControlThrowable кроме NonLocalReturnControl - не содержатся во фьючерах

Вместо этого фьючер завершается с ExecutionException, причиной которого является одно из вышеперечисленных исключений. Если фьючер завершается неудачно с scala.runtime.NonLocalReturnControl, он завершается с значением из этого объекта исключения.

Создает новый фьючер, который содержит результат этого фьючера, если он завершился успешно, или, если нет, результат фьючера that если that завершился успешно. Если оба фьючера завершились неудачно, результирующий фьючер содержит объект исключения первого фьючера.

Использование этого метода не приведет к недетерминированному поведению конкуретных программ.

Пример:

val f = Future { sys.error("failed") }
val g = Future { 5 }
val h = f fallbackTo g
h foreach println // Eventually prints 5

Создает новый фьючер, отфильтровав значение текущего фьючера с помощью предиката.

Если текущий фьючер содержит значение, удовлетворяющее предикату, новый фьючер также будет содержать это значение. В противном случае результирующий фьючер завершится неудачно с NoSuchElementException.

Если текущий фьючер завершается неудачно, то результирующий фьючер также завершается неудачно.

Пример:

val f = Future { 5 }
val g = f filter { _ % 2 == 1 }
val h = f filter { _ % 2 == 0 }
g foreach println // Eventually prints 5
Await.result(h, Duration.Zero) // throw a NoSuchElementException

Вызывается сборщиком мусора для объекта-получателя, когда больше нет ссылок на объект.

Подробности о том, когда и если вызывается метод finalize, а также взаимодействие между finalize и нелокальными возвратами и исключениями, зависят от платформы.

Создает новый фьючер, применяя функцию к успешному результату этого фьючера и возвращая результат функции как новый фьючер. Если этот фьючер завершается с исключением, то новый фьючер также будет содержать это исключение.

Пример:

val f = Future { 5 }
val g = Future { 3 }
val h = for {
  x: Int <- f // returns Future(5)
  y: Int <- g // returns Future(3)
} yield x + y

Переводится в:

f flatMap { (x: Int) => g map { (y: Int) => x + y } }

Создаёт новую будущую задачу с одним уровнем вложенности, уплощенной. Этот метод эквивалентен flatMap(identity).

Асинхронно обрабатывает значение в будущем, как только оно станет доступным.

ВНИМАНИЕ: Не будет вызываться, если эта будущая задача никогда не завершится или если она завершится с ошибкой.

Поскольку этот метод выполняется асинхронно и не возвращает значение, любые некритические исключения будут сообщены ExecutionContext.

Возвращает представление класса времени выполнения объекта.

Метод hashCode для ссылочных типов. См. hashCode в scala.Any.

Возвращает, завершилась ли будущая задача значением или исключением.

Примечание: использование этого метода приводит к недетерминированным программам потока данных.

Проверяет, является ли динамический тип объекта-получателя T0.

Обратите внимание, что результат теста зависит от семантики стирания Scala. Поэтому выражение 1.isInstanceOf[String] вернёт false, а выражение List(1).isInstanceOf[List[String]] вернёт true. В последнем примере, поскольку аргумент типа стирается во время компиляции, проверить, являются ли содержимое списка указанного типа, невозможно.

Создаёт новую будущую задачу, применяя функцию к успешному результату этой будущей задачи. Если эта будущая задача завершится с исключением, то и новая будущая задача также будет содержать это исключение.

Пример:

val f = Future { "The future" }
val g = f map { x: String => x + " is now!" }

Обратите внимание, что for-понимание, включающее Future может расширяться, включая вызов map и/или flatMap и withFilter. См. scala.concurrent.Future#flatMap для примера такого понимания.

Создаёт новую будущую задачу, которая завершится результатом этой Future, если он соответствует стёртому типу S, или ClassCastException в противном случае.

Эквивалентно !(this eq that).

Разбуждает один поток, ожидающий монитора объекта-приёмника.

Разбуждает все потоки, ожидающие монитора объекта-приёмника.

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

Если будущее уже завершено, это будет применено немедленно или запланировано асинхронно.

Обратите внимание, что возвращаемое значение f будет проигнорировано.

Поскольку этот метод выполняется асинхронно и не возвращает значения, любые некритические исключения будут сообщены ExecutionContext.

Могут быть зарегистрированы несколько обратных вызовов; нет гарантии, что они будут выполнены в определённом порядке.

Предоставленный обратный вызов всегда выполняется в предоставленном неявном ExecutionContext, хотя нет гарантии, что метод execute() на ExecutionContext будет вызываться один раз на каждый обратный вызов или что execute() будет вызван в текущем потоке. То есть реализация может запускать несколько обратных вызовов в пакетном режиме в рамках одного execute() и может запускать execute() немедленно или асинхронно. Завершение будущего должно *предшествовать* вызову обратного вызова.

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

Это будущее может содержать объект исключения, что означает, что будущее потерпело неудачу. Будущие, полученные через комбинаторы, имеют то же исключение, что и будущее, из которого они были получены. Следующие объекты исключений не содержатся в будущем:

Error - ошибки не содержатся в будущих InterruptedException - не содержится в будущихвсе scala.util.control.ControlThrowable кроме NonLocalReturnControl - не содержится в будущих

Вместо этого будущее завершается с ExecutionException с одним из вышеперечисленных исключений в качестве причины. Если будущее завершается с scala.runtime.NonLocalReturnControl, оно завершается со значением из этого исключения.

Если будущее уже завершено с ошибкой, это будет применено немедленно или запланировано асинхронно.

Не будет вызываться в случае, если будущее завершено со значением.

Обратите внимание, что возвращаемое значение pf будет проигнорировано.

Поскольку этот метод выполняется асинхронно и не возвращает значения, любые некритические исключения будут сообщены ExecutionContext.

Могут быть зарегистрированы несколько обратных вызовов; нет гарантии, что они будут выполнены в определённом порядке.

Предоставленный обратный вызов всегда выполняется в предоставленном неявном ExecutionContext, хотя нет гарантии, что метод execute() на ExecutionContext будет вызываться один раз на каждый обратный вызов или что execute() будет вызван в текущем потоке. То есть реализация может запускать несколько обратных вызовов в пакетном режиме в рамках одного execute() и может запускать execute() немедленно или асинхронно. Завершение будущего должно *предшествовать* вызову обратного вызова.

При успешном завершении этого будущего (т.е. со значением), примените предоставленную частичную функцию к значению, если частичная функция определена для этого значения.

Если будущее уже завершено со значением, это будет применено немедленно или запланировано асинхронно.

Обратите внимание, что возвращаемое значение pf будет проигнорировано.

Поскольку этот метод выполняется асинхронно и не возвращает значения, любые некритические исключения будут сообщены ExecutionContext.

Могут быть зарегистрированы несколько обратных вызовов; нет гарантии, что они будут выполнены в определённом порядке.

Предоставленный обратный вызов всегда выполняется в предоставленном неявном ExecutionContext, хотя нет гарантии, что метод execute() на ExecutionContext будет вызываться один раз на каждый обратный вызов или что execute() будет вызван в текущем потоке. То есть реализация может запускать несколько обратных вызовов в пакетном режиме в рамках одного execute() и может запускать execute() немедленно или асинхронно. Завершение будущего должно *предшествовать* вызову обратного вызова.

Дождитесь состояния "completed" этого Awaitable.

Этот метод не следует вызывать напрямую; используйте Await.ready вместо него.

Создает новый фьючер, который будет обрабатывать любые сопоставимые исключения, которые может содержать этот фьючер. Если совпадений нет или этот фьючер содержит действительный результат, то новый фьючер будет содержать то же самое.

Пример:

Future (6 / 0) recover { case e: ArithmeticException => 0 } // result: 0
Future (6 / 0) recover { case e: NotFoundException   => 0 } // result: exception
Future (6 / 2) recover { case e: ArithmeticException => 0 } // result: 3

Создаёт новый фьючер, который будет обрабатывать любые сопоставимые исключения, которые может содержать этот фьючер, назначив ему значение другого фьючера.

Если совпадений нет или этот фьючер содержит действительный результат, то новый фьючер будет содержать тот же результат.

Пример:

val f = Future { Int.MaxValue }
Future (6 / 0) recoverWith { case e: ArithmeticException => f } // result: Int.MaxValue

Ожидает и возвращает результат (типа T) этого Awaitable.

Этот метод не следует вызывать напрямую; используйте Await.result вместо него.

Создаёт строковое представление этого объекта. По умолчанию представление зависит от платформы. На платформе Java это объединение имени класса, "@" и хэш-кода объекта в шестнадцатеричном формате.

Создаёт новый Future, применяя указанную функцию к результату этого Future. Если при применении функции 'f' возникает какое-либо исключение, которое не является фатальным, то это исключение будет передано в результирующий future.

Создаёт новый future, применяя функцию 's' к успешному результату этого future или функцию 'f' к результату с ошибкой. Если при применении 's' или 'f' возникает какое-либо нефатальное исключение, это исключение будет передано в результирующий future.

Создаёт новый Future, применяя указанную функцию, которая создаёт Future, к результату этого Future. Если при применении функции 'f' возникает какое-либо нефатальное исключение, то это исключение будет передано в результирующий future.

Текущее значение этого Future.

Примечание: использование этого метода приводит к недетерминированным программам.

Если future не завершён, возвращаемое значение будет None. Если future завершён, значение будет Some(Success(t)), если оно содержало действительный результат, или Some(Failure(error)), если оно содержало исключение.

Используется для for-comprehensions.

Объединяет значения this и that фьючерсов и создаёт новый фьючерс, содержащий кортеж их результатов.

Если фьючерс this завершается ошибкой, результирующий фьючерс завершается с исключением, сохранённым в this. В противном случае, если фьючерс that завершается ошибкой, результирующий фьючерс завершается с исключением, сохранённым в that.

Объединяет значения this и that фьючерсов с помощью функции f, и создаёт новый фьючерс, содержащий результат.

Если фьючерс this завершается ошибкой, результирующий фьючерс завершается с исключением, сохранённым в this. В противном случае, если фьючерс that завершается ошибкой, результирующий фьючерс завершается с исключением, сохранённым в that. Если применение f вызывает исключение, результирующий фьючерс завершается с этим исключением, если оно не является фатальным.