AggregateActor

Instance Constructors

new AggregateActor(identifier: I, interpreter: AsyncInterpreter[A, C, E], aggregateType: String)

Type Members

sealed trait ActorState extends AnyRef

state of Aggregate Root
type Aggregate = A

Definition Classes
AggregateActor → AggregateAliases
type Command = C

Definition Classes
AggregateActor → AggregateAliases
type Event = E

Definition Classes
AggregateActor → AggregateAliases
type Events = Seq[Event]

Definition Classes
AggregateAliases
type Id = I

Definition Classes
AggregateActor → AggregateAliases
type Receive = PartialFunction[Any, Unit]

Definition Classes
Actor

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
object Available extends ActorState with Product with Serializable
object BadId

Definition Classes
AggregateMessageExtractors
object Busy extends ActorState with Product with Serializable
object GoodId

Definition Classes
AggregateMessageExtractors
object IdAndCommand

Definition Classes
AggregateMessageExtractors
object TypedCommand

Definition Classes
AggregateMessageExtractors
object TypedEvent

Definition Classes
AggregateMessageExtractors
def afterEventPersisted(evt: Event): Unit

This method should be used as a callback handler for persist() method.
This method should be used as a callback handler for persist() method. It will: - apply the event on the aggregate effectively changing its state - check if a snapshot needs to be saved.
evt
DomainEvent that has been persisted

Attributes
protected
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 changeState(state: ActorState): Unit
def clone(): AnyRef

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

Definition Classes
Actor
def defaultReceive: Receive

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

Definition Classes
PersistentActor
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 getClass(): Class[_]

Definition Classes
AnyRef → Any
def hashCode(): Int

Definition Classes
AnyRef → Any
def internalStashOverflowStrategy: StashOverflowStrategy

Definition Classes
PersistenceStash
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
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onEvent(evt: Any): Unit

Attributes
protected
def onFailure(failedCmd: FailedCommand): Unit
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
def persist[A](event: A)(handler: (A) ⇒ Unit): Unit

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

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

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

Definition Classes
PersistentActor
val persistenceId: String

Definition Classes
AggregateActor → PersistenceIdentity
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
UnrestrictedStash → Actor
def preStart(): Unit

Definition Classes
AggregateActor → Actor
def receive: Receive

Definition Classes
PersistentActor → Actor
def receiveCommand: Receive

Definition Classes
AggregateActor → Eventsourced
val receiveRecover: Receive

Recovery handler that receives persisted events during recovery.
Recovery handler that receives persisted events during recovery. If a state snapshot has been captured and saved, this handler will receive a SnapshotOffer message followed by events that are younger than the offered snapshot.
This handler must not have side-effects other than changing persistent actor state i.e. it should not perform actions that may fail, such as interacting with external services, for example.

Definition Classes
AggregateActor → Eventsourced
def recovery: Recovery

Definition Classes
AggregateActor → 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
def sendState(replyTo: ActorRef): Unit

send a message containing the aggregate's state back to the requester
send a message containing the aggregate's state back to the requester
replyTo
actor to send message to

Attributes
protected
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
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 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 AggregateActor | package akka

class AggregateActor[A, C, E, I <: AggregateId] extends AggregateAliases with AggregateMessageExtractors with PersistentActor with ActorLogging

Instance Constructors

new AggregateActor(identifier: I, interpreter: AsyncInterpreter[A, C, E], aggregateType: String)

Type Members

sealed trait ActorState extends AnyRef

type Aggregate = A

type Command = C

type Event = E

type Events = Seq[Event]

type Id = I

type Receive = PartialFunction[Any, Unit]

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

final def ==(arg0: Any): Boolean

object Available extends ActorState with Product with Serializable

object BadId

object Busy extends ActorState with Product with Serializable

object GoodId

object IdAndCommand

object TypedCommand

object TypedEvent

def afterEventPersisted(evt: Event): Unit

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 changeState(state: ActorState): Unit

def clone(): AnyRef

implicit val context: ActorContext

def defaultReceive: Receive

def deferAsync[A](event: A)(handler: (A) ⇒ Unit): 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 getClass(): Class[_]

def hashCode(): Int

def internalStashOverflowStrategy: StashOverflowStrategy

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

final def notify(): Unit

final def notifyAll(): Unit

def onEvent(evt: Any): Unit

def onFailure(failedCmd: FailedCommand): Unit

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

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

val persistenceId: String

def postRestart(reason: Throwable): Unit

def postStop(): Unit

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

def preStart(): Unit

def receive: Receive

def receiveCommand: Receive

val receiveRecover: Receive

def recovery: Recovery

def recoveryFinished: Boolean

def recoveryRunning: Boolean

def saveSnapshot(snapshot: Any): Unit

implicit final val self: ActorRef

def sendState(replyTo: ActorRef): Unit

final def sender(): ActorRef

def snapshotPluginId: String

def snapshotSequenceNr: Long

def snapshotterId: String