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

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

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

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

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

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

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

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

val f = Future { 5 }
f andThen {
  case r => throw new RuntimeException("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 зависит от платформы.

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

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

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

Пример:

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.

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

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

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

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

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

Пример:

val f = Future { throw new RuntimeException("failed") }
val g = Future { 5 }
val h = f fallbackTo g
h foreach println // Eventually prints 5

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

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

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

Пример:

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 comprehension, включающее Future, может быть расширено, чтобы включать вызов map и или flatMap и withFilter. См. scala.concurrent.Future#flatMap для примера такого выражения.

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

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

Разбуждает единственную нить, которая ожидает монитор объекта-получателя.

Разбуждает все нити, которые ожидают монитор объекта-получателя.

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

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

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

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

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

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

Ожидание состояния "завершён" этого 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 это конкатенация имени класса, «@» и хэш-кода объекта в шестнадцатеричном формате.

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

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

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

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

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

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

Используется для for-выражений.

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

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

Сжатие значений this и that будущих значений с помощью функции f, и создание нового будущего, содержащего результат.

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