Processor

Type Members

type Receive = PartialFunction[Any, Unit]

Definition Classes
Actor
case class UnstashAndWork(evt: Event, state: State) extends Product with Serializable
case class UnstashAndWorkBatch(es: Seq[Event], state: State) extends Product with Serializable

Abstract Value Members

abstract def handleCommand(state: State): Receive

Attributes
protected
abstract def handleInitCommand: Receive

Attributes
protected
abstract def handleQuery(state: State): Receive

Attributes
protected
abstract def persistenceId: String

Definition Classes
PersistenceIdentity
abstract def receiveRecover: Receive

Definition Classes
Eventsourced
abstract def updatedState(evt: Event, state: State): State

Attributes
protected

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
def aroundPostRestart(reason: Throwable): Unit

Attributes
protected[akka]
Definition Classes
Eventsourced → Actor
def aroundPostStop(): Unit

Attributes
protected[akka]
Definition Classes
Eventsourced → Actor
def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit

Attributes
protected[akka]
Definition Classes
Eventsourced → Actor
def aroundPreStart(): Unit

Attributes
protected[akka]
Definition Classes
Eventsourced → Actor
def aroundReceive(receive: Receive, message: Any): Unit

Attributes
protected[akka]
Definition Classes
Eventsourced → Actor
final def asInstanceOf[T0]: T0

Definition Classes
Any
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
implicit val context: ActorContext

Definition Classes
Actor
def deferAsync[A](event: A)(handler: (A) ⇒ Unit): Unit

Definition Classes
Eventsourced
final def deferStashingReply[R](e: Event, state: State)(f: (Event) ⇒ Future[R]): Unit
def deleteMessages(toSequenceNr: Long): Unit

Definition Classes
Eventsourced
def deleteSnapshot(sequenceNr: Long): Unit

Definition Classes
Snapshotter
def deleteSnapshots(criteria: SnapshotSelectionCriteria): Unit

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

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

Definition Classes
AnyRef → Any
def finalize(): Unit

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( classOf[java.lang.Throwable] )
final def futureWaitingBehavior(replyTo: ActorRef): Receive

Attributes
protected
Definition Classes
ActorFutures
final def getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
final def initializing: Receive

Attributes
protected
final def isInstanceOf[T0]: Boolean

Definition Classes
Any
def journalPluginId: String

Definition Classes
PersistenceIdentity
def lastSequenceNr: Long

Definition Classes
Eventsourced
def loadSnapshot(persistenceId: String, criteria: SnapshotSelectionCriteria, toSequenceNr: Long): Unit

Definition Classes
Snapshotter
def log: LoggingAdapter

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

Definition Classes
AnyRef
val notFoundError: EntityNotFound

Attributes
protected
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def now(): DateTime
def onPersistFailure(cause: Throwable, event: Any, seqNr: Long): Unit

Attributes
protected
Definition Classes
Eventsourced
def onPersistRejected(cause: Throwable, event: Any, seqNr: Long): Unit

Attributes
protected
Definition Classes
Eventsourced
def onRecoveryFailure(cause: Throwable, event: Option[Any]): Unit

Attributes
protected
Definition Classes
Eventsourced
final def onSuccess[T](f: Future[T], replyTo: ActorRef)(cb: (T) ⇒ Unit)(implicit arg0: ClassTag[T]): Unit

Attributes
protected
Definition Classes
ActorFutures
final def onSuccess[T](f: Future[T])(cb: (T) ⇒ Unit)(implicit arg0: ClassTag[T]): Unit

Attributes
protected
Definition Classes
ActorFutures
def persist[A](event: A)(handler: (A) ⇒ Unit): Unit

Definition Classes
Eventsourced
def persistAll[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

Definition Classes
Eventsourced
def persistAllAsync[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

Definition Classes
Eventsourced
def persistAsync[A](event: A)(handler: (A) ⇒ Unit): Unit

Definition Classes
Eventsourced
final def persistReply[R](e: Event, state: State, replyTo: ActorRef)(f: (Event) ⇒ Future[R]): Unit
final def persistReply[R](e: Event, state: State)(f: (Event) ⇒ Future[R]): Unit
final def persistStashing[R](es: Seq[Event], state: State)(f: (Event) ⇒ Unit): Unit
final def persistStashing[R](e: Event, state: State)(f: (Event) ⇒ Future[R]): Unit
final def persistStashingReply[R](es: Seq[Event], state: State)(f: (Seq[Event]) ⇒ Future[R]): Unit
final def persistStashingReply[R](e: Event, state: State, replyTo: ActorRef)(f: (Event) ⇒ Future[R]): Unit
final def persistStashingReply[R](e: Event, state: State)(f: (Event) ⇒ Future[R]): Unit
def postRestart(reason: Throwable): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def postStop(): Unit

Definition Classes
UnrestrictedStash → Actor
def preRestart(reason: Throwable, message: Option[Any]): Unit

Definition Classes
Processor → UnrestrictedStash → Actor
def preStart(): Unit

Definition Classes
Actor
Annotations
@throws( classOf[java.lang.Exception] )
def receive: Receive

Definition Classes
PersistentActor → Actor
final def receiveCommand: Receive

Definition Classes
Processor → Eventsourced
def recovery: Recovery

Definition Classes
PersistenceRecovery
def recoveryFinished: Boolean

Definition Classes
Eventsourced
def recoveryRunning: Boolean

Definition Classes
Eventsourced
def saveSnapshot(snapshot: Any): Unit

Definition Classes
Snapshotter
implicit final val self: ActorRef

Definition Classes
Actor
final def sender(): ActorRef

Definition Classes
Actor
def snapshotPluginId: String

Definition Classes
PersistenceIdentity
def snapshotSequenceNr: Long

Definition Classes
Eventsourced → Snapshotter
def snapshotterId: String

Definition Classes
Eventsourced → Snapshotter
def stash(): Unit

Definition Classes
StashSupport
final def stashing(state: State): Receive

Attributes
protected
final def stashingBehavior: Receive

Attributes
protected
def supervisorStrategy: SupervisorStrategy

Definition Classes
Actor
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def toString(): String

Definition Classes
AnyRef → Any
def unhandled(message: Any): Unit

Definition Classes
Eventsourced → Actor
def unstashAll(): Unit

Definition Classes
Eventsourced → StashSupport
final def unstashAndWork(evt: Event, state: State): Unit

Attributes
protected
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( ... )
def workWith(e: Event, s: State): State

Attributes
protected
def workWith(es: Seq[Event], state: State): State

Attributes
protected
final def working(state: State): Receive

Attributes
protected

Deprecated Value Members

def persist[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

Definition Classes
Eventsourced
Annotations
@deprecated
Deprecated
(Since version 2.4) use persistAll instead
def persistAsync[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

Definition Classes
Eventsourced
Annotations
@deprecated
Deprecated
(Since version 2.4) use persistAllAsync instead

Related Doc: package office

trait Processor[State, Event <: AnyRef] extends PersistentActor with ActorFutures

Type Members

type Receive = PartialFunction[Any, Unit]

case class UnstashAndWork(evt: Event, state: State) extends Product with Serializable

case class UnstashAndWorkBatch(es: Seq[Event], state: State) extends Product with Serializable

Abstract Value Members

abstract def handleCommand(state: State): Receive

abstract def handleInitCommand: Receive

abstract def handleQuery(state: State): Receive

abstract def persistenceId: String

abstract def receiveRecover: Receive

abstract def updatedState(evt: Event, state: State): State

Concrete Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

def aroundPostRestart(reason: Throwable): Unit

def aroundPostStop(): Unit

def aroundPreRestart(reason: Throwable, message: Option[Any]): Unit

def aroundPreStart(): Unit

def aroundReceive(receive: Receive, message: Any): Unit

final def asInstanceOf[T0]: T0

def clone(): AnyRef

implicit val context: ActorContext

def deferAsync[A](event: A)(handler: (A) ⇒ Unit): Unit

final def deferStashingReply[R](e: Event, state: State)(f: (Event) ⇒ Future[R]): Unit

def deleteMessages(toSequenceNr: Long): Unit

def deleteSnapshot(sequenceNr: Long): Unit

def deleteSnapshots(criteria: SnapshotSelectionCriteria): Unit

final def eq(arg0: AnyRef): Boolean

def equals(arg0: Any): Boolean

def finalize(): Unit

final def futureWaitingBehavior(replyTo: ActorRef): Receive

final def getClass(): Class[_]

def hashCode(): Int

final def initializing: Receive

final def isInstanceOf[T0]: Boolean

def journalPluginId: String

def lastSequenceNr: Long

def loadSnapshot(persistenceId: String, criteria: SnapshotSelectionCriteria, toSequenceNr: Long): Unit

def log: LoggingAdapter

final def ne(arg0: AnyRef): Boolean

val notFoundError: EntityNotFound

final def notify(): Unit

final def notifyAll(): Unit

def now(): DateTime

def onPersistFailure(cause: Throwable, event: Any, seqNr: Long): Unit

def onPersistRejected(cause: Throwable, event: Any, seqNr: Long): Unit

def onRecoveryFailure(cause: Throwable, event: Option[Any]): Unit

final def onSuccess[T](f: Future[T], replyTo: ActorRef)(cb: (T) ⇒ Unit)(implicit arg0: ClassTag[T]): Unit

final def onSuccess[T](f: Future[T])(cb: (T) ⇒ Unit)(implicit arg0: ClassTag[T]): Unit

def persist[A](event: A)(handler: (A) ⇒ Unit): Unit

def persistAll[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

def persistAllAsync[A](events: Seq[A])(handler: (A) ⇒ Unit): Unit

def persistAsync[A](event: A)(handler: (A) ⇒ Unit): Unit

final def persistReply[R](e: Event, state: State, replyTo: ActorRef)(f: (Event) ⇒ Future[R]): Unit

final def persistReply[R](e: Event, state: State)(f: (Event) ⇒ Future[R]): Unit

final def persistStashing[R](es: Seq[Event], state: State)(f: (Event) ⇒ Unit): Unit

final def persistStashing[R](e: Event, state: State)(f: (Event) ⇒ Future[R]): Unit

final def persistStashingReply[R](es: Seq[Event], state: State)(f: (Seq[Event]) ⇒ Future[R]): Unit

final def persistStashingReply[R](e: Event, state: State, replyTo: ActorRef)(f: (Event) ⇒ Future[R]): Unit

final def persistStashingReply[R](e: Event, state: State)(f: (Event) ⇒ Future[R]): Unit

def postRestart(reason: Throwable): Unit

def postStop(): Unit

def preRestart(reason: Throwable, message: Option[Any]): Unit

def preStart(): Unit

def receive: Receive

final def receiveCommand: Receive

def recovery: Recovery

def recoveryFinished: Boolean

def recoveryRunning: Boolean

def saveSnapshot(snapshot: Any): Unit

implicit final val self: ActorRef

final def sender(): ActorRef

def snapshotPluginId: String

def snapshotSequenceNr: Long

def snapshotterId: String

def stash(): Unit