RichListenableFuture

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def clone(): AnyRef

final def eq(arg0: AnyRef): Boolean

def filter(q: (T) ⇒ Boolean): ListenableFuture[T]

def finalize(): Unit

def flatMap[A](f: (T) ⇒ ListenableFuture[A]): ListenableFuture[A]

def foreach[U](f: (T) ⇒ Unit): Unit

val future: ListenableFuture[T]

final def getClass(): Class[_]

final def isInstanceOf[T0]: Boolean

def map[A](f: (T) ⇒ A): ListenableFuture[A]

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def recover[U >: T](pf: PartialFunction[Throwable, U])(implicit executor: ExecutorService = MoreExecutors.sameThreadExecutor()): ListenableFuture[U]

Creates a new future that will handle any matching throwable that this future might contain.

def recoverWith[U >: T](pf: PartialFunction[Throwable, ListenableFuture[U]])(implicit executor: ExecutorService = MoreExecutors.sameThreadExecutor()): ListenableFuture[U]

Creates a new future that will handle any matching throwable that this future might contain by assigning it a value of another future.

final def synchronized[T0](arg0: ⇒ T0): T0

def transform[U](s: (T) ⇒ U, f: (Throwable) ⇒ Throwable)(implicit executor: ExecutorService = MoreExecutors.sameThreadExecutor()): ListenableFuture[U]

Creates a new future by applying the 's' function to the successful result of this future, or the 'f' function to the failed result.

final def wait(): Unit

final def wait(arg0: Long, arg1: Int): Unit

final def wait(arg0: Long): Unit

def withDefault(fallbackValue: T, errorCallback: (Throwable) ⇒ Unit = ex: Throwable => error(ex)): ListenableFuture[T]

Helper method to guard against RPC failures and the like.

def withFilter(q: (T) ⇒ Boolean): ListenableFuture[T]

def withOptionFallback(errorCallback: (Throwable) ⇒ Unit = ex: Throwable => error(ex)): ListenableFuture[Option[T]]

Helper method to guard against RPC failures and the like, converts a 'regular' Future to a Future of Option.

class Foo extends Loggable {
  f.withOptionFallback(error(_))
}

def withTryFallback: ListenableFuture[Try[T]]

Helper method to guard against RPC failures and the like, converts a 'regular' Future to a Future of Try with Failure representing cases where an exception was caught and Success[T] representing desired results.

def withEitherFallback: ListenableFuture[Either[Throwable, T]]

Helper method to guard against RPC failures and the like, converts a 'regular' Future to a Future of Either with Left[Throwable] representing cases where an exception was caught and Right[T] representing desired results.