Package akka.actor.dungeon

Interface DeathWatch

All Known Implementing Classes:

ActorCell, ResizablePoolCell, RoutedActorCell

public interface DeathWatch

This map holds a None for actors for which we send a Terminated notification on termination, Some(message) for actors for which we send a custom termination message.

Method Summary

Modifier and Type	Method	Description
void	addressTerminated(Address address)
void	addWatcher(ActorRef watchee, ActorRef watcher)
void	checkWatchingSame(InternalActorRef ref, scala.Option<java.lang.Object> newMessage)	Call only if it was checked before that `watching contains ref`
boolean	isWatching(ActorRef ref)
<T> T	maintainAddressTerminatedSubscription(ActorRef change, scala.Function0<T> block)	Starts subscription to AddressTerminated if not already subscribing and the block adds a non-local ref to watching or watchedBy.
<T> ActorRef	maintainAddressTerminatedSubscription$default$1()
void	receivedTerminated(Terminated t)
<T> scala.collection.immutable.Map<ActorRef,T>	removeFromMap(ActorRef subject, scala.collection.immutable.Map<ActorRef,T> map)
void	remWatcher(ActorRef watchee, ActorRef watcher)
void	subscribeAddressTerminated()
void	tellWatchersWeDied()
void	terminatedQueued_$eq(scala.collection.immutable.Map<ActorRef,scala.Option<java.lang.Object>> x$1)
void	terminatedQueuedFor(ActorRef subject, scala.Option<java.lang.Object> customMessage)
void	unsubscribeAddressTerminated()
ActorRef	unwatch(ActorRef subject)
void	unwatchWatchedActors(Actor actor)
void	updateWatching(InternalActorRef ref, scala.Option<java.lang.Object> newMessage)
ActorRef	watch(ActorRef subject)
void	watchedActorTerminated(ActorRef actor, boolean existenceConfirmed, boolean addressTerminated)	When this actor is watching the subject of Terminated message it will be propagated to user's receive.
void	watchedBy_$eq(scala.collection.immutable.Set<ActorRef> x$1)
void	watching_$eq(scala.collection.immutable.Map<ActorRef,scala.Option<java.lang.Object>> x$1)
boolean	watchingContains(ActorRef subject)
scala.Option<scala.Option<java.lang.Object>>	watchingGet(ActorRef subject)
ActorRef	watchWith(ActorRef subject, java.lang.Object msg)

Method Detail

addWatcher

void addWatcher(ActorRef watchee,
                ActorRef watcher)

addressTerminated

void addressTerminated(Address address)

checkWatchingSame

void checkWatchingSame(InternalActorRef ref,
                       scala.Option<java.lang.Object> newMessage)

Call only if it was checked before that `watching contains ref`

isWatching

boolean isWatching(ActorRef ref)

maintainAddressTerminatedSubscription

<T> T maintainAddressTerminatedSubscription(ActorRef change,
                                            scala.Function0<T> block)

Starts subscription to AddressTerminated if not already subscribing and the block adds a non-local ref to watching or watchedBy. Ends subscription to AddressTerminated if subscribing and the block removes the last non-local ref from watching and watchedBy.

Parameters:

change - (undocumented)

block - (undocumented)

Returns:

(undocumented)

maintainAddressTerminatedSubscription$default$1

<T> ActorRef maintainAddressTerminatedSubscription$default$1()

receivedTerminated

void receivedTerminated(Terminated t)

remWatcher

void remWatcher(ActorRef watchee,
                ActorRef watcher)

removeFromMap

<T> scala.collection.immutable.Map<ActorRef,T> removeFromMap(ActorRef subject,
                                                                   scala.collection.immutable.Map<ActorRef,T> map)

subscribeAddressTerminated

void subscribeAddressTerminated()

tellWatchersWeDied

void tellWatchersWeDied()

terminatedQueuedFor

void terminatedQueuedFor(ActorRef subject,
                         scala.Option<java.lang.Object> customMessage)

terminatedQueued_$eq

void terminatedQueued_$eq(scala.collection.immutable.Map<ActorRef,scala.Option<java.lang.Object>> x$1)

unsubscribeAddressTerminated

void unsubscribeAddressTerminated()

unwatch

ActorRef unwatch(ActorRef subject)

unwatchWatchedActors

void unwatchWatchedActors(Actor actor)

updateWatching

void updateWatching(InternalActorRef ref,
                    scala.Option<java.lang.Object> newMessage)

watch

ActorRef watch(ActorRef subject)

watchWith

ActorRef watchWith(ActorRef subject,
                   java.lang.Object msg)

watchedActorTerminated

void watchedActorTerminated(ActorRef actor,
                            boolean existenceConfirmed,
                            boolean addressTerminated)

When this actor is watching the subject of Terminated message it will be propagated to user's receive.

Parameters:

actor - (undocumented)

existenceConfirmed - (undocumented)

addressTerminated - (undocumented)

watchedBy_$eq

void watchedBy_$eq(scala.collection.immutable.Set<ActorRef> x$1)

watchingContains

boolean watchingContains(ActorRef subject)

watchingGet

scala.Option<scala.Option<java.lang.Object>> watchingGet(ActorRef subject)

watching_$eq

void watching_$eq(scala.collection.immutable.Map<ActorRef,scala.Option<java.lang.Object>> x$1)