com.malliina.concurrent.Futures.scala Maven / Gradle / Ivy

Go to download

Show more of this group Show more artifacts with this name
Show all versions of utilbase_3 Show documentation

utilBase

There is a newer version: 3.7.6

package com.malliina.concurrent

import com.malliina.util.Utils

import scala.concurrent._
import scala.concurrent.duration.Duration

trait Futures {
  def before[T, TO](other: Future[TO])(f: Future[T])(implicit ec: ExecutionContext): Future[T] =
    promisedFuture[T](p => {
      f.onComplete(result => if (!p.isCompleted) p.tryComplete(result))
      other.onComplete(_ => {
        if (!p.isCompleted)
          p.tryFailure(
            new TimeoutException(s"Unable to complete task within the given time limit.")
          )
      })
    })

  /** Constructs a future that is completed according to `keepPromise`. This pattern
    * can be used to convert callback-based APIs to Future-based ones. For example,
    * parameter `keepPromise` can call some callback-based API, and the callback
    * implementation can complete the supplied promise.
    *
    * @param keepPromise code that completes the promise
    * @tparam T type of value to complete promise with
    * @return the future completion value
    */
  def promisedFuture[T](keepPromise: Promise[T] => Unit): Future[T] = {
    val p = Promise[T]()
    keepPromise(p)
    p.future
  }
}

object Futures extends Futures