Package akka.actor.dungeon

Interface DeathWatch

public interface DeathWatch

INTERNAL API

Method Summary

Modifier and Type	Method	Description
void	addressTerminated(Address address)
void	addWatcher(ActorRef watchee, ActorRef watcher)
void	checkWatchingSame(akka.actor.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)
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(akka.actor.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)
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(akka.actor.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.

maintainAddressTerminatedSubscription$default$1

<T> ActorRef maintainAddressTerminatedSubscription$default$1()

receivedTerminated

void receivedTerminated(Terminated t)

remWatcher

void remWatcher(ActorRef watchee,
                ActorRef watcher)

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(akka.actor.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.

watchedBy_$eq

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

watching_$eq

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