PotActionRetriable

Abstract Value Members

abstract def next(newValue: Pot[A], newRetryPolicy: RetryPolicy): P
abstract def potResult: Pot[A]

Definition Classes
PotAction
abstract def retryPolicy: RetryPolicy

Definition Classes
AsyncActionRetriable

Concrete Value Members

final def !=(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def ##(): Int

Definition Classes
AnyRef → Any
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
implicit object PActionType extends ActionType[P]

Definition Classes
AsyncAction
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
def effect[B](f: ⇒ Future[B])(success: (B) ⇒ A, failure: (Throwable) ⇒ Throwable = identity)(implicit ec: ExecutionContext): EffectSingle[P]

Wraps a by-name future result into an effect using success and failure transformations.
Wraps a by-name future result into an effect using success and failure transformations.
f
Future to wrap, passes using by-name (lazy evaluation)
success
Transformation function for success case
failure
Transformation function for failure case
returns
An Effect for running the provided Future

Definition Classes
AsyncAction
def effectWithRetry[B](f: ⇒ Future[B])(success: (B) ⇒ A, failure: (Throwable) ⇒ Throwable = identity)(implicit ec: ExecutionContext): (RetryPolicy) ⇒ EffectSingle[P]

Wraps a by-name future result into an effect creator function, using success and failure transformations.
Wraps a by-name future result into an effect creator function, using success and failure transformations.
f
Future to wrap, passes using by-name (lazy evaluation)
success
Transformation function for success case
failure
Transformation function for failure case
returns
An Effect for running the provided Future

Definition Classes
AsyncActionRetriable
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def equals(arg0: Any): Boolean

Definition Classes
AnyRef → Any
def failed(ex: Throwable, nextRetryPolicy: RetryPolicy = retryPolicy): P

Moves this action to a failed state with the provided exception.
Moves this action to a failed state with the provided exception.
ex
Exception describing the reason for failure
nextRetryPolicy
Updated retry policy

Definition Classes
AsyncActionRetriable
def failed(ex: Throwable): P

Moves this action to a failed state with the provided exception.
Moves this action to a failed state with the provided exception.
ex
Reason for the failure.

Definition Classes
AsyncAction
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def handle[M](pf: PartialFunction[PotState, ActionResult[M]]): ActionResult[M]

Handles the action using the supplied partial function matching current state.
Handles the action using the supplied partial function matching current state.

Definition Classes
AsyncAction
def handleWith[M, T](handler: ActionHandler[M, T], effectRetry: (RetryPolicy) ⇒ Effect)(f: (PotActionRetriable.this.type, ActionHandler[M, T], (RetryPolicy) ⇒ Effect) ⇒ ActionResult[M]): ActionResult[M]

Handles the action using an external handler function.
Handles the action using an external handler function. The function is provided with instance of this AsyncAction, the ActionHandler this action currently resides in and the provided update Effect creator function. The reason why retry policy is provided to the effect creator is that in case of failure, the updated retry policy can be passed on to the next effect instantiation.
handler
The current action handler instance.
effectRetry
Function taking current RetryPolicy and returning an effect that performs the requested async operation.
f
External handler function
returns
An action result

Definition Classes
AsyncActionRetriable
def handleWith[M, T](handler: ActionHandler[M, T], effect: Effect)(f: (PotActionRetriable.this.type, ActionHandler[M, T], Effect) ⇒ ActionResult[M]): ActionResult[M]

Handles the action using an external handler function.
Handles the action using an external handler function. The function is provided with instance of this AsyncAction, the ActionHandler this action currently resides in and the provided update Effect.
handler
The current action handler instance.
effect
Effect that performs the requested async operation.
f
External handler function
returns
An action result

Definition Classes
AsyncAction
def hashCode(): Int

Definition Classes
AnyRef → Any
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
final def ne(arg0: AnyRef): Boolean

Definition Classes
AnyRef
def next(newState: PotState, newValue: Try[A], newRetryPolicy: RetryPolicy): P

Definition Classes
PotActionRetriable → AsyncActionRetriable
def next(newValue: Pot[A]): P

Definition Classes
PotActionRetriable → PotAction
def next(newState: PotState, newValue: Try[A]): P

Moves the action to the next state.
Moves the action to the next state.
newState
New state for the action
newValue
New value for the action
returns
A new instance of this action with updated state and value

Definition Classes
AsyncActionRetriable → AsyncAction
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def pending: P

Moves this action to pending state.
Moves this action to pending state.

Definition Classes
AsyncAction
def ready(a: A): P

Moves this action to ready state with a result value.
Moves this action to ready state with a result value.
a
Result for the action.

Definition Classes
AsyncAction
def result: Try[A]

Definition Classes
PotAction → AsyncAction
def state: PotState

Definition Classes
PotAction → AsyncAction
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
final def wait(): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long, arg1: Int): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )
final def wait(arg0: Long): Unit

Definition Classes
AnyRef
Annotations
@throws( ... )

Related Docs: object PotActionRetriable | package data

trait PotActionRetriable[A, P <: PotActionRetriable[A, P]] extends PotAction[A, P] with AsyncActionRetriable[A, P]

Abstract Value Members

abstract def next(newValue: Pot[A], newRetryPolicy: RetryPolicy): P

abstract def potResult: Pot[A]

abstract def retryPolicy: RetryPolicy

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

implicit object PActionType extends ActionType[P]

final def asInstanceOf[T0]: T0

def clone(): AnyRef

def effect[B](f: ⇒ Future[B])(success: (B) ⇒ A, failure: (Throwable) ⇒ Throwable = identity)(implicit ec: ExecutionContext): EffectSingle[P]

def effectWithRetry[B](f: ⇒ Future[B])(success: (B) ⇒ A, failure: (Throwable) ⇒ Throwable = identity)(implicit ec: ExecutionContext): (RetryPolicy) ⇒ EffectSingle[P]

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def failed(ex: Throwable, nextRetryPolicy: RetryPolicy = retryPolicy): P

def failed(ex: Throwable): P

def finalize(): Unit

final def getClass(): Class[_]

def handle[M](pf: PartialFunction[PotState, ActionResult[M]]): ActionResult[M]

def handleWith[M, T](handler: ActionHandler[M, T], effectRetry: (RetryPolicy) ⇒ Effect)(f: (PotActionRetriable.this.type, ActionHandler[M, T], (RetryPolicy) ⇒ Effect) ⇒ ActionResult[M]): ActionResult[M]

def handleWith[M, T](handler: ActionHandler[M, T], effect: Effect)(f: (PotActionRetriable.this.type, ActionHandler[M, T], Effect) ⇒ ActionResult[M]): ActionResult[M]

def hashCode(): Int

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

def next(newState: PotState, newValue: Try[A], newRetryPolicy: RetryPolicy): P

def next(newValue: Pot[A]): P

def next(newState: PotState, newValue: Try[A]): P

final def notify(): Unit

final def notifyAll(): Unit

def pending: P

def ready(a: A): P

def result: Try[A]

def state: PotState

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

def toString(): String

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Inherited from AsyncActionRetriable[A, P]

Inherited from PotAction[A, P]

Inherited from AsyncAction[A, P]

Inherited from Action

Inherited from AnyRef

Inherited from Any

Ungrouped