RetryContext

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

val baseWaitMillis: Int

def beforeRetry[U](handler: (RetryContext) ⇒ U): RetryContext

val beforeRetryAction: (RetryContext) ⇒ Any

def canContinue: Boolean

def clone(): AnyRef

val context: Option[Any]

final def eq(arg0: AnyRef): Boolean

val errorClassifier: (Throwable) ⇒ ResultClass

final def getClass(): Class[_]

def init(context: Option[Any] = None): RetryContext

final def isInstanceOf[T0]: Boolean

val lastError: Throwable

val maxRetry: Int

final def ne(arg0: AnyRef): Boolean

def nextRetry(retryReason: Throwable): RetryContext

Update the retry context, including retry count, last error, next wait time, etc.

val nextWaitMillis: Int

final def notify(): Unit

final def notifyAll(): Unit

val resultClassifier: (Any) ⇒ ResultClass

val retryCount: Int

def retryOn[U](errorClassifier: PartialFunction[Throwable, Failed]): RetryContext

Add a partial function that accepts exceptions that need to be retried.

val retryWaitStrategy: RetryPolicy

def run[A](body: ⇒ A): A

def runInternal[A](context: Option[Any])(body: ⇒ A): A

def runWithContext[A](context: Any)(body: ⇒ A): A

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

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

final def wait(arg0: Long): Unit

final def wait(): Unit

def withBackOff(initialIntervalMillis: Int = 100, maxIntervalMillis: Int = 15000, multiplier: Double = 1.5): RetryContext

def withErrorClassifier[U](errorClassifier: (Throwable) ⇒ U): RetryContext

Set a detailed error handler upon Exception.

def withExtraWaitMillis(extraWaitMillis: Int): RetryContext

def withJitter(initialIntervalMillis: Int = 100, maxIntervalMillis: Int = 15000, multiplier: Double = 1.5): RetryContext

def withMaxRetry(newMaxRetry: Int): RetryContext

def withResultClassifier[U](newResultClassifier: (U) ⇒ ResultClass): RetryContext

def withRetryWaitStrategy(newRetryWaitStrategy: RetryPolicy): RetryContext

def finalize(): Unit