Actions

Instance Constructors

new Actions(cmdHandlerInvokers: CommandHandlerToInvoker[ProtocolAliases.Protocol.ProtocolCommand, ProtocolAliases.Protocol.ProtocolEvent] = PartialFunction.empty, rejectCmdInvokers: CommandHandlerToInvoker[ProtocolAliases.Protocol.ProtocolCommand, ProtocolAliases.Protocol.ProtocolEvent] = PartialFunction.empty, eventHandlers: EventHandler[ProtocolAliases.Protocol.ProtocolEvent, A] = PartialFunction.empty)

Type Members

type Aggregate = A

The Aggregate type.
The Aggregate type. This is the only (abstract) type member to be defined.
All other type members are aliases defined by type projection of inner types from Aggregate type itself.

Definition Classes
Actions → AggregateAliases
type Command = ProtocolAliases.Protocol.ProtocolCommand

Alias for Aggregate's ProtocolCommand
Alias for Aggregate's ProtocolCommand

Definition Classes
ProtocolAliases
type Event = ProtocolAliases.Protocol.ProtocolEvent

Alias for Aggregate's ProtocolEvent
Alias for Aggregate's ProtocolEvent

Definition Classes
ProtocolAliases
type Events = Seq[Event]

Alias for an immutable Seq of Aggregate's ProtocolEvent
Alias for an immutable Seq of Aggregate's ProtocolEvent

Definition Classes
ProtocolAliases
case class FutureManyEventsBinder(behavior: Actions[A]) extends ManyEventsBinder[Future] with Product with Serializable
type Id = A.Id

Alias for Aggregate#Id
Alias for Aggregate#Id

Definition Classes
AggregateAliases
case class IdentityManyEventsBinder(behavior: Actions[A]) extends ManyEventsBinder[Identity] with Product with Serializable
trait ManyEventsBinder[F[_]] extends AnyRef
type Protocol = A.Protocol

Alias for Aggregate#Protocol
Alias for Aggregate#Protocol

Definition Classes
AggregateAliases → ProtocolAliases
case class TryManyEventsBinder(behavior: Actions[A]) extends ManyEventsBinder[Try] with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

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

Definition Classes
AnyRef → Any
def ++(that: Actions[A]): Actions[A]

Concatenate this Actions with that Actions
final def ==(arg0: Any): Boolean

Definition Classes
AnyRef → Any
final def asInstanceOf[T0]: T0

Definition Classes
Any
def canHandleEvent(event: Event): Boolean

Check if the passed Event can be handled by this Actions instance
Check if the passed Event can be handled by this Actions instance
INTERNAL API This method is used to prevent that Events that can't be handle are stored.
def canHandleEvents(events: Events): Boolean

Check if the passed Events can be handled by this Actions instance
Check if the passed Events can be handled by this Actions instance
INTERNAL API This method is used to prevent that Events that can't be handle are stored.
def clone(): AnyRef

Attributes
protected[java.lang]
Definition Classes
AnyRef
Annotations
@throws( ... )
val cmdHandlerInvokers: CommandHandlerToInvoker[ProtocolAliases.Protocol.ProtocolCommand, ProtocolAliases.Protocol.ProtocolEvent]
final def eq(arg0: AnyRef): Boolean

Definition Classes
AnyRef
val eventHandlers: EventHandler[ProtocolAliases.Protocol.ProtocolEvent, A]
def fallbackInvoker(msg: String): CommandHandlerInvoker[Command, Event]

Build a TryCommandHandlerInvoker that will always return an Failure Used internally to handle unknown commands
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 handleCommand: ManyEventsBinder[Identity]
def handleCommand[C <: Command, E <: Event](cmdHandler: (C) ⇒ Identity[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]

Declares a Command Handler that produces one single Event
def handleCommandAsync: ManyEventsBinder[Future]
def handleCommandAsync[C <: Command, E <: Event](cmdHandler: (C) ⇒ Future[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]
def handleEvent[E <: Event](eventHandler: (E) ⇒ A)(implicit arg0: ClassTag[E]): Actions[Aggregate]

Declares an event handler
Declares an event handler
eventHandler
- the event handler function
returns
an Actions for A
final def isInstanceOf[T0]: Boolean

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

Definition Classes
AnyRef
final def notify(): Unit

Definition Classes
AnyRef
final def notifyAll(): Unit

Definition Classes
AnyRef
def onCommand(cmd: Command): CommandHandlerInvoker[Command, Event]

Returns a CommandHandlerInvoker for the passed Command.
Returns a CommandHandlerInvoker for the passed Command. Invokers are delayed execution of Command Handlers and abstract over the Functor that will be returned when handling the command.
Internally, this method calls the declared Command Handlers.
def onEvent(evt: Event): Aggregate

Applies the passed Event producing a new instance of Aggregate.
Applies the passed Event producing a new instance of Aggregate. Internally, this method calls the declared Event Handlers.
def reject(cmdHandler: PartialFunction[ProtocolAliases.Protocol.ProtocolCommand, Throwable]): Actions[Aggregate]

Declares a guard clause that reject commands that fulfill a given condition.
Declares a guard clause that reject commands that fulfill a given condition.
A guard clause is a Command Handler as it handles a incoming command, but instead of producing Event, it returns a Throwable to signalize an error condition.
Guard clauses command handlers have predecence over handlers producting Events.
cmdHandler
- a PartialFunction from Command to Throwable.
returns
- return a Actions.
val rejectCmdInvokers: CommandHandlerToInvoker[ProtocolAliases.Protocol.ProtocolCommand, ProtocolAliases.Protocol.ProtocolEvent]
def rejectCommand(cmdHandler: PartialFunction[Command, Throwable]): Actions[Aggregate]

Alias for reject
final def synchronized[T0](arg0: ⇒ T0): T0

Definition Classes
AnyRef
def tryToHandleCommand: ManyEventsBinder[Try]
def tryToHandleCommand[C <: Command, E <: Event](cmdHandler: (C) ⇒ Try[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]
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( ... )

Deprecated Value Members

def asyncHandler: ManyEventsBinder[Future]

Annotations
@deprecated
Deprecated
(Since version 0.3.1) Use handleCommandAsync instead
def asyncHandler[C <: Command, E <: Event](cmdHandler: (C) ⇒ Future[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]

Annotations
@deprecated
Deprecated
(Since version 0.3.1) Use handleCommandAsync instead
def handler: ManyEventsBinder[Identity]

Annotations
@deprecated
Deprecated
(Since version 0.3.1) Use handleCommand instead
def handler[C <: Command, E <: Event](cmdHandler: (C) ⇒ Identity[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]

Annotations
@deprecated
Deprecated
(Since version 0.3.1) Use handleCommand instead
def listener[E <: Event](eventHandler: (E) ⇒ A)(implicit arg0: ClassTag[E]): Actions[Aggregate]

Annotations
@deprecated
Deprecated
(Since version 0.3.1) Use handleEvent instead
def tryHandler: ManyEventsBinder[Try]

Annotations
@deprecated
Deprecated
(Since version 0.3.1) Use tryToHandleCommand instead
def tryHandler[C <: Command, E <: Event](cmdHandler: (C) ⇒ Try[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]

Annotations
@deprecated
Deprecated
(Since version 0.3.1) Use tryToHandleCommand instead

Related Docs: object Actions | package behavior

Instance Constructors

Type Members

type Aggregate = A

type Command = ProtocolAliases.Protocol.ProtocolCommand

type Event = ProtocolAliases.Protocol.ProtocolEvent

type Events = Seq[Event]

case class FutureManyEventsBinder(behavior: Actions[A]) extends ManyEventsBinder[Future] with Product with Serializable

type Id = A.Id

case class IdentityManyEventsBinder(behavior: Actions[A]) extends ManyEventsBinder[Identity] with Product with Serializable

trait ManyEventsBinder[F[_]] extends AnyRef

type Protocol = A.Protocol

case class TryManyEventsBinder(behavior: Actions[A]) extends ManyEventsBinder[Try] with Product with Serializable

Value Members

final def !=(arg0: Any): Boolean

final def ##(): Int

def ++(that: Actions[A]): Actions[A]

final def ==(arg0: Any): Boolean

final def asInstanceOf[T0]: T0

def canHandleEvent(event: Event): Boolean

def canHandleEvents(events: Events): Boolean

def clone(): AnyRef

val cmdHandlerInvokers: CommandHandlerToInvoker[ProtocolAliases.Protocol.ProtocolCommand, ProtocolAliases.Protocol.ProtocolEvent]

final def eq(arg0: AnyRef): Boolean

val eventHandlers: EventHandler[ProtocolAliases.Protocol.ProtocolEvent, A]

def fallbackInvoker(msg: String): CommandHandlerInvoker[Command, Event]

def finalize(): Unit

final def getClass(): Class[_]

def handleCommand: ManyEventsBinder[Identity]

def handleCommand[C <: Command, E <: Event](cmdHandler: (C) ⇒ Identity[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]

def handleCommandAsync: ManyEventsBinder[Future]

def handleCommandAsync[C <: Command, E <: Event](cmdHandler: (C) ⇒ Future[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]

def handleEvent[E <: Event](eventHandler: (E) ⇒ A)(implicit arg0: ClassTag[E]): Actions[Aggregate]

final def isInstanceOf[T0]: Boolean

final def ne(arg0: AnyRef): Boolean

final def notify(): Unit

final def notifyAll(): Unit

def onCommand(cmd: Command): CommandHandlerInvoker[Command, Event]

def onEvent(evt: Event): Aggregate

def reject(cmdHandler: PartialFunction[ProtocolAliases.Protocol.ProtocolCommand, Throwable]): Actions[Aggregate]

val rejectCmdInvokers: CommandHandlerToInvoker[ProtocolAliases.Protocol.ProtocolCommand, ProtocolAliases.Protocol.ProtocolEvent]

def rejectCommand(cmdHandler: PartialFunction[Command, Throwable]): Actions[Aggregate]

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

def tryToHandleCommand: ManyEventsBinder[Try]

def tryToHandleCommand[C <: Command, E <: Event](cmdHandler: (C) ⇒ Try[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]

final def wait(): Unit

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

final def wait(arg0: Long): Unit

Deprecated Value Members

def asyncHandler: ManyEventsBinder[Future]

def asyncHandler[C <: Command, E <: Event](cmdHandler: (C) ⇒ Future[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]

def handler: ManyEventsBinder[Identity]

def handler[C <: Command, E <: Event](cmdHandler: (C) ⇒ Identity[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]

def listener[E <: Event](eventHandler: (E) ⇒ A)(implicit arg0: ClassTag[E]): Actions[Aggregate]

def tryHandler: ManyEventsBinder[Try]

def tryHandler[C <: Command, E <: Event](cmdHandler: (C) ⇒ Try[E])(implicit arg0: ClassTag[C]): Actions[Aggregate]

Inherited from Serializable

Inherited from Serializable

Inherited from Product

Inherited from Equals

Inherited from AggregateAliases

Inherited from ProtocolAliases

Inherited from AnyRef

Inherited from Any

Ungrouped