Type alias because traits cannot have companion objects.
Type alias because traits cannot have companion objects.
A Receive block that runs after the coordinated transaction.
Default coordination - no other transactors.
Changes the Actor's behavior to become the new 'Receive' (PartialFunction[Any, Unit]) handler.
Changes the Actor's behavior to become the new 'Receive' (PartialFunction[Any, Unit]) handler. Puts the behavior on top of the hotswap stack. If "discardOld" is true, an unbecome will be issued prior to pushing the new behavior to the stack
A Receive block that runs before the coordinated transaction is entered.
Override this method to coordinate with other transactors.
Override this method to coordinate with other transactors. The other transactors are added to the coordinated transaction barrier and sent a Coordinated message. The message to send can be specified or otherwise the same message as received is sent. Use the 'include' and 'sendTo' methods to easily create the set of transactors to be involved.
Default catch-all for the different Receive methods.
User overridable callback.
User overridable callback.
Is called on the crashed Actor to give it the option of producing the Actor's reincarnation. If it returns None, which is the default, the initially provided actor factory is used.
Warning: Propagating state from a crashed actor carries the risk of proliferating the cause of the error. Consider let-it-crash first.
Include other actors in this coordinated transaction and send them the same message as received.
Include other actors in this coordinated transaction and send them the same message as received. Use as the result in 'coordinated'.
Is the actor able to handle the message passed in as arguments?
Is the actor able to handle the message passed in as arguments?
Empty set of transactors to send to.
Bypass transactionality and behave like a normal actor.
Option[ActorRef] representation of the 'self' ActorRef reference.
Option[ActorRef] representation of the 'self' ActorRef reference.
Mainly for internal use, functions as the implicit sender references when invoking one of the message send functions ('!', '!!' and '!!!').
User overridable callback.
User overridable callback.
Is called right AFTER restart on the newly created Actor to allow reinitialization after an Actor crash.
User overridable callback.
User overridable callback.
Is called when 'actor.stop()' is invoked.
User overridable callback.
User overridable callback.
Is called on a crashed Actor right BEFORE it is restarted to allow clean up of resources before Actor is terminated. Override either the variant with or without the currentMessage argument.
User overridable callback.
User overridable callback.
Is called when an Actor is started by invoking 'actor.start()'.
Implement a general pattern for using coordinated transactions.
Implement a general pattern for using coordinated transactions.
The 'self' field holds the ActorRef for this actor.
The 'self' field holds the ActorRef for this actor.
Can be used to send messages to itself:
self ! messageHere you also find most of the Actor API.
For example fields like:
self.dispatcher = ... self.trapExit = ... self.faultHandler = ... self.lifeCycle = ... self.sender
Here you also find methods like:
self.reply(..) self.link(..) self.unlink(..) self.start(..) self.stop(..)
Include other actors in this coordinated transaction and specify the message to send by providing ActorRef -> Message pairs.
Include other actors in this coordinated transaction and specify the message to send by providing ActorRef -> Message pairs. Use as the result in 'coordinated'.
Some[ActorRef] representation of the 'self' ActorRef reference.
Some[ActorRef] representation of the 'self' ActorRef reference.
Mainly for internal use, functions as the implicit sender references when invoking the 'forward' function.
Create default transaction factory.
Create default transaction factory. Override to provide custom configuration.
Reverts the Actor behavior to the previous one in the hotswap stack.
Reverts the Actor behavior to the previous one in the hotswap stack.
User overridable callback.
User overridable callback.
Is called when a message isn't handled by the current behavior of the actor by default it throws an UnhandledMessageException
User overridable callback.
User overridable callback.
Is called on a crashed Actor right BEFORE it is restarted to allow clean up of resources before Actor is terminated. Override either the variant with or without the currentMessage argument.
This method is deprecated: use the variant which receives the current message instead. This method will be removed in version 2.0.
use two-argument version, this one will be removed in 2.0
An actor with built-in support for coordinated transactions.
Transactors implement the general pattern for using akka.stm.Coordinated where first any coordination messages are sent to other transactors, then the coordinated transaction is entered. Transactors can also accept explicitly sent
Coordinatedmessages.Simple transactors will just implement the
atomicallymethod which is similar to the actorreceivemethod but runs within a coordinated transaction.Example of a simple transactor that will join a coordinated transaction:
class Counter extends Transactor { val count = Ref(0) def atomically = { case Increment => count alter (_ + 1) } }To coordinate with other transactors override the
coordinatemethod. Thecoordinatemethod maps a message to a set of akka.actor.Transactor.SendTo objects, pairs ofActorRefand a message. You can use theincludeandsendTomethods to easily coordinate with other transactors. Theincludemethod will send on the same message that was received to other transactors. ThesendTomethod allows you to specify both the actor to send to, and message to send.Example of coordinating an increment:
class FriendlyCounter(friend: ActorRef) extends Transactor { val count = Ref(0) override def coordinate = { case Increment => include(friend) } def atomically = { case Increment => count alter (_ + 1) } }Using
includeto include more than one transactor:override def coordinate = { case Message => include(actor1, actor2, actor3) }Using
sendToto coordinate transactions but send on a different message than the one that was received:override def coordinate = { case Message => sendTo(someActor -> SomeOtherMessage) case SomeMessage => sendTo(actor1 -> Message1, actor2 -> Message2) }To execute directly before or after the coordinated transaction, override the
beforeandaftermethods. These methods also expect partial functions like the receive method. They do not execute within the transaction.To completely bypass coordinated transactions override the
normallymethod. Any message matched bynormallywill not be matched by the other methods, and will not be involved in coordinated transactions. In this method you can implement normal actor behavior, or use the normal STM atomic for local transactions.akka.stm.Coordinated for more information about the underlying mechanism