scala.actors
trait Actor

[source: `scala/actors/Actor.scala`]

`` `trait` Actor
  `extends` OutputChannel[Any]

  This class provides (together with `Channel`) an implementation of event-based actors.

  The main ideas of our approach are explained in the two papers

  - Event-Based Programming without Inversion of Control,
    Philipp Haller and Martin Odersky, Proc. JMLC 2006, and
  - Actors that Unify Threads and Events,
    Philipp Haller and Martin Odersky, Proc. COORDINATION 2007.

Version
  0.9.9
Author
  Philipp Haller

Direct Known Subclasses:
  ActorProxy, Proxy

Value Summary
`var` | exitReason : AnyRef
`var` | exiting : Boolean
`var` | isDetached : Boolean
`var` | kill : () => Unit
`var` | links : List[Actor]
`var` | shouldExit : Boolean
`var` | trapExit : Boolean

Method Summary
`def` | ! (msg : Any) : Unit Sends `msg` to this actor (asynchronous).
`def` | !! (msg : Any) : Future[Any] Sends `msg` to this actor and immediately returns a future representing the reply value.
`def` | !! [A](msg : Any, f : PartialFunction[Any, A]) : Future[A] Sends `msg` to this actor and immediately returns a future representing the reply value. The reply is post-processed using the partial function `f`. This also allows to recover a more precise type for the reply value.
`def` | !? (msec : Long, msg : Any) : Option[Any] Sends `msg` to this actor and awaits reply (synchronous) within `msec` milliseconds.
`def` | !? (msg : Any) : Any Sends `msg` to this actor and awaits reply (synchronous).
`def` | ? : Any Receives the next message from this actor's mailbox.
`abstract def` | act : Unit The behavior of an actor is specified by implementing this abstract method. Note that the preferred way to create actors is through the `actor` method defined in object `Actor`.
`def` | exit (reason : AnyRef) : Nothing Terminates execution of `self` with the following effect on linked actors: For each linked actor `a` with `trapExit` set to `true`, send message `Exit(self, reason)` to `a`. For each linked actor `a` with `trapExit` set to `false` (default), call `a.exit(reason)` if `reason != 'normal`.
`def` | exit (from : Actor, reason : AnyRef) : Unit
`def` | exit : Nothing Terminates with exit reason `'normal`.
`def` | exitLinked (reason : AnyRef) : Unit
`def` | exitLinked : Unit
`def` | forward (msg : Any) : Unit Forwards `msg` to this actor (asynchronous).
`def` | freshReplyChannel : Channel[Any]
`def` | link (body : => Unit) : Actor Links `self` to actor defined by `body`.
`def` | link (to : Actor) : Actor Links `self` to actor `to`.
`def` | linkTo (to : Actor) : Unit
`def` | react (f : PartialFunction[Any, Unit]) : Nothing Receives a message from this actor's mailbox. This method never returns. Therefore, the rest of the computation has to be contained in the actions of the partial function.
`def` | reactWithin (msec : Long)(f : PartialFunction[Any, Unit]) : Nothing Receives a message from this actor's mailbox within a certain time span. This method never returns. Therefore, the rest of the computation has to be contained in the actions of the partial function.
`def` | receive [R](f : PartialFunction[Any, R]) : R Receives a message from this actor's mailbox.
`def` | receiveWithin [R](msec : Long)(f : PartialFunction[Any, R]) : R Receives a message from this actor's mailbox within a certain time span.
`def` | receiver : Actor Returns the `Actor` that is receiving from this `OutputChannel`.
`def` | reply (msg : Any) : Unit Replies with `msg` to the sender.
`def` | replyChannel : Channel[Any]
`def` | send (msg : Any, replyTo : OutputChannel[Any]) : Unit Sends `msg` to this actor (asynchronous) supplying explicit reply destination.
`def` | sender : OutputChannel[Any]
`def` | start : Actor Starts this actor.
`def` | unlink (from : Actor) : Unit Unlinks `self` from actor `from`.
`def` | unlinkFrom (from : Actor) : Unit

Methods inherited from AnyRef
getClass, hashCode, equals, clone, toString, notify, notifyAll, wait, wait, wait, finalize, ==, !=, eq, ne, synchronized

Methods inherited from Any
==, !=, isInstanceOf, asInstanceOf

Value Details

`` `var` isDetached : Boolean

`` `var` kill : () => Unit

`` `var` links : List[Actor]

`` `var` trapExit : Boolean

`` `var` exitReason : AnyRef

`` `var` exiting : Boolean

`` `var` shouldExit : Boolean

Method Details

`` `def` send(msg : Any, replyTo : OutputChannel[Any]) : Unit

  Sends `msg` to this actor (asynchronous) supplying explicit reply destination.

Parameters
  `msg -` the message to send
  `replyTo -` the reply destination

`` `def` receive[R](f : PartialFunction[Any, R]) : R

  Receives a message from this actor's mailbox.

Parameters
  `f -` a partial function with message patterns and actions
Returns
  result of processing the received value

`` `def` receiveWithin[R](msec : Long)(f : PartialFunction[Any, R]) : R

  Receives a message from this actor's mailbox within a certain time span.

Parameters
  `msec -` the time span before timeout
  `f -` a partial function with message patterns and actions
Returns
  result of processing the received value

`` `def` react(f : PartialFunction[Any, Unit]) : Nothing

  Receives a message from this actor's mailbox.

  This method never returns. Therefore, the rest of the computation has to be contained in the actions of the partial function.

Parameters
  `f -` a partial function with message patterns and actions

`` `def` reactWithin(msec : Long)(f : PartialFunction[Any, Unit]) : Nothing

  Receives a message from this actor's mailbox within a certain time span.

  This method never returns. Therefore, the rest of the computation has to be contained in the actions of the partial function.

Parameters
  `msec -` the time span before timeout
  `f -` a partial function with message patterns and actions

`abstract` `def` act : Unit

  The behavior of an actor is specified by implementing this abstract method. Note that the preferred way to create actors is through the `actor` method defined in object `Actor`.

`` `def` !(msg : Any) : Unit

  Sends `msg` to this actor (asynchronous).

Overrides
  OutputChannel.!

`` `def` forward(msg : Any) : Unit

  Forwards `msg` to this actor (asynchronous).

Overrides
  OutputChannel.forward

`` `def` !?(msg : Any) : Any

  Sends `msg` to this actor and awaits reply (synchronous).

Parameters
  `msg -` the message to be sent
Returns
  the reply

`` `def` !?(msec : Long, msg : Any) : Option[Any]

  Sends `msg` to this actor and awaits reply (synchronous) within `msec` milliseconds.

Parameters
  `msec -` the time span before timeout
  `msg -` the message to be sent
Returns
  `None` in case of timeout, otherwise `Some(x)` where `x` is the reply

`` `def` !!(msg : Any) : Future[Any]

  Sends `msg` to this actor and immediately returns a future representing the reply value.

`` `def` !![A](msg : Any, f : PartialFunction[Any, A]) : Future[A]

  Sends `msg` to this actor and immediately returns a future representing the reply value. The reply is post-processed using the partial function `f`. This also allows to recover a more precise type for the reply value.

`` `def` reply(msg : Any) : Unit

  Replies with `msg` to the sender.

`` `def` replyChannel : Channel[Any]

`` `def` freshReplyChannel : Channel[Any]

`` `def` ? : Any

  Receives the next message from this actor's mailbox.

`` `def` sender : OutputChannel[Any]

`` `def` receiver : Actor

  Returns the `Actor` that is receiving from this `OutputChannel`.

Overrides
  OutputChannel.receiver

`` `def` start : Actor

  Starts this actor.

`` `def` link(to : Actor) : Actor

  Links `self` to actor `to`.

Parameters
  `to -` ...
Returns
  ...

`` `def` link(body : => Unit) : Actor

  Links `self` to actor defined by `body`.

`` `def` linkTo(to : Actor) : Unit

`` `def` unlink(from : Actor) : Unit

  Unlinks `self` from actor `from`.

`` `def` unlinkFrom(from : Actor) : Unit

`` `def` exit(reason : AnyRef) : Nothing

  Terminates execution of `self` with the following effect on linked actors:

  For each linked actor `a` with `trapExit` set to `true`, send message `Exit(self, reason)` to `a`.

  For each linked actor `a` with `trapExit` set to `false` (default), call `a.exit(reason)` if `reason != 'normal`.

`` `def` exit : Nothing

  Terminates with exit reason `'normal`.

`` `def` exitLinked : Unit

`` `def` exitLinked(reason : AnyRef) : Unit

`` `def` exit(from : Actor, reason : AnyRef) : Unit