3rd round of clean ups (see r25285, r25292)

git-svn-id: http://lampsvn.epfl.ch/svn-repos/scala/scala/trunk@25293 5e8d7ff9-d8ef-0310-90f0-a4852d11357a

Author: michelou

src/actors/scala/actors/Actor.scala

@@ -12,8 +12,7 @@ package scala.actors
 import java.lang.Thread
 
 /**
- * Provides a dynamic actor proxy for normal
- * Java threads.
+ * Provides a dynamic actor proxy for normal Java threads.
  *
  * @author Philipp Haller
  */
@@ -22,7 +21,7 @@ private[actors] class ActorProxy(t: Thread, override final val scheduler: ISched
   def act() {}
 
   /**
-   * Terminates with exit reason <code>'normal</code>.
+   * Terminates with exit reason `'normal`.
    */
   override def exit(): Nothing = {
     shouldExit = false

src/actors/scala/actors/ActorProxy.scala

@@ -21,41 +21,38 @@ trait CanReply[-T, +R] {
   type Future[+P] <: () => P
 
   /**
-   * Sends <code>msg</code> to this $actor and
-   * awaits reply (synchronous).
+   * Sends `msg` to this $actor and awaits reply (synchronous).
    *
    * @param  msg the message to be sent
    * @return     the reply
    */
   def !?(msg: T): R
 
   /**
-   * Sends <code>msg</code> to this $actor and
-   * awaits reply (synchronous) within <code>msec</code>
-   * milliseconds.
+   * Sends `msg` to this $actor and awaits reply (synchronous) within
+   * `msec` milliseconds.
    *
    * @param  msec the time span before timeout
    * @param  msg  the message to be sent
-   * @return      <code>None</code> in case of timeout, otherwise
-   *              <code>Some(x)</code> where <code>x</code> is the reply
+   * @return      `None` in case of timeout, otherwise
+   *              `Some(x)` where `x` is the reply
    */
   def !?(msec: Long, msg: T): Option[R]
 
   /**
-   * Sends <code>msg</code> to this $actor and
-   * immediately returns a future representing the reply value.
+   * Sends `msg` to this $actor and immediately returns a future representing
+   * the reply value.
    *
    * @param  msg the message to be sent
    * @return     the future
    */
   def !!(msg: T): Future[R]
 
   /**
-   * Sends <code>msg</code> to this $actor and
-   * immediately returns a future representing the reply value.
-   * The reply is post-processed using the partial function
-   * <code>handler</code>. This also allows to recover a more
-   * precise type for the reply value.
+   * Sends `msg` to this $actor and immediately returns a future representing
+   * the reply value. The reply is post-processed using the partial function
+   * `handler`. This also allows to recover a more precise type for the reply
+   * value.
    *
    * @param      msg the message to be sent
    * @param  handler the function to be applied to the response

src/actors/scala/actors/CanReply.scala

@@ -6,15 +6,13 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
 import scala.concurrent.SyncVar
 
 /**
- *  Used to pattern match on values that were sent
- *  to some channel <code>Chan<sub>n</sub></code> by the current
- *  actor <code>self</code>.
+ * Used to pattern match on values that were sent to some channel `Chan,,n,,`
+ * by the current actor `self`.
  * 
  *  @example {{{
  *  receive {
@@ -28,9 +26,8 @@ import scala.concurrent.SyncVar
 case class ! [a](ch: Channel[a], msg: a)
 
 /**
- * Provides a means for typed communication among
- * actors. Only the actor creating an instance of a
- * <code>Channel</code> may receive from it.
+ * Provides a means for typed communication among actors. Only the
+ * actor creating an instance of a `Channel` may receive from it.
  *
  * @author Philipp Haller
  *

src/actors/scala/actors/Channel.scala

@@ -10,13 +10,14 @@ package scala.actors
 
 import scheduler.DaemonScheduler
 
-/** 
+/**
  * Base trait for actors with daemon semantics.
- * Unlike a regular <code>Actor</code>, an active <code>DaemonActor</code> will 
- * not prevent an application terminating, much like a daemon thread. 
  *
- * @author Erik Engbrecht 
- */ 
-trait DaemonActor extends Actor { 
+ * Unlike a regular `Actor`, an active `DaemonActor` will not
+ * prevent an application terminating, much like a daemon thread. 
+ *
+ * @author Erik Engbrecht
+ */
+trait DaemonActor extends Actor {
   override def scheduler: IScheduler = DaemonScheduler
 }

src/actors/scala/actors/DaemonActor.scala

@@ -10,12 +10,10 @@
 package scala.actors
 
 /**
- * A common interface
- * for all schedulers used to execute actor tasks.
+ * A common interface for all schedulers used to execute actor tasks.
  *
- * Subclasses of <code>Actor</code> that override its
- * <code>scheduler</code> member must provide
- * an <code>IScheduler</code> implementation.
+ * Subclasses of `Actor` that override its `scheduler` member must provide
+ * an `IScheduler` implementation.
  *
  * @author Philipp Haller
  */
@@ -27,7 +25,7 @@ trait IScheduler {
    */
   def execute(fun: => Unit): Unit
 
-  /** Submits a <code>Runnable</code> for execution.
+  /** Submits a `Runnable` for execution.
    *
    *  @param  task  the task to be executed
    */

src/actors/scala/actors/IScheduler.scala

@@ -6,12 +6,10 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
 /**
- * This class is used by our efficient message queue
- * implementation.
+ * This class is used by our efficient message queue implementation.
  *
  * @author Philipp Haller
  */
@@ -28,10 +26,9 @@ private[actors] class MQueueElement[Msg >: Null](val msg: Msg, val session: Outp
 }
 
 /**
- * The class <code>MessageQueue</code> provides an efficient
- * implementation of a message queue specialized for this actor
- * library. Classes in this package are supposed to be the only
- * clients of this class.
+ * The class `MessageQueue` provides an efficient implementation of a message
+ * queue specialized for this actor library. Classes in this package are
+ * supposed to be the only clients of this class.
  *
  * @author Philipp Haller
  */
@@ -107,7 +104,7 @@ private[actors] class MQueue[Msg >: Null](protected val label: String) {
     acc
   }
 
-  /** Returns the n-th message that satisfies the predicate <code>p</code>
+  /** Returns the n-th message that satisfies the predicate `p`
    *  without removing it.
    */
   def get(n: Int)(p: Msg => Boolean): Option[Msg] = {
@@ -129,8 +126,8 @@ private[actors] class MQueue[Msg >: Null](protected val label: String) {
   def remove(n: Int)(p: (Msg, OutputChannel[Any]) => Boolean): Option[(Msg, OutputChannel[Any])] =
     removeInternal(n)(p) map (x => (x.msg, x.session))
 
-  /** Extracts the first message that satisfies the predicate <code>p</code>
-   *  or <code>null</code> if <code>p</code> fails for all of them.
+  /** Extracts the first message that satisfies the predicate `p`
+   *  or `'''null'''` if `p` fails for all of them.
    */
   def extractFirst(p: (Msg, OutputChannel[Any]) => Boolean): MQueueElement[Msg] =
     removeInternal(0)(p) orNull

src/actors/scala/actors/MessageQueue.scala

@@ -6,7 +6,6 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
 /**
@@ -19,14 +18,14 @@ package scala.actors
 trait OutputChannel[-Msg] {
 
   /**
-   * Sends <code>msg</code> to this $actor (asynchronous).
+   * Sends `msg` to this $actor (asynchronous).
    *
    * @param  msg      the message to send
    */
   def !(msg: Msg): Unit
 
   /**
-   * Sends <code>msg</code> to this $actor (asynchronous) supplying
+   * Sends `msg` to this $actor (asynchronous) supplying
    * explicit reply destination.
    *
    * @param  msg      the message to send
@@ -35,14 +34,14 @@ trait OutputChannel[-Msg] {
   def send(msg: Msg, replyTo: OutputChannel[Any]): Unit
 
   /**
-   * Forwards <code>msg</code> to this $actor (asynchronous).
+   * Forwards `msg` to this $actor (asynchronous).
    *
    * @param  msg      the message to forward
    */
   def forward(msg: Msg): Unit
 
   /**
-   * Returns the <code>Actor</code> that is receiving from this $actor.
+   * Returns the `Actor` that is receiving from this $actor.
    */
   def receiver: Actor
 }

src/actors/scala/actors/OutputChannel.scala

@@ -26,8 +26,8 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Sends a message to this <code>ReactChannel</code>
-   * (asynchronous) supplying explicit reply destination.
+   * Sends a message to this `ReactChannel` (asynchronous) supplying
+   * explicit reply destination.
    *
    * @param  msg     the message to send
    * @param  replyTo the reply destination
@@ -37,17 +37,17 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Forwards <code>msg</code> to <code>this</code> keeping the
-   * last sender as sender instead of <code>self</code>.
+   * Forwards `msg` to `'''this'''` keeping the last sender as sender
+   * instead of `self`.
    */
   def forward(msg: Msg) {
     receiver forward SendToReactor(this, msg)
   }
 
   /**
-   * Receives a message from this <code>ReactChannel</code>.
-   * <p>
-   * This method never returns. Therefore, the rest of the computation
+   * Receives a message from this `ReactChannel`.
+   * 
+   * This method ''never'' returns. Therefore, the rest of the computation
    * has to be contained in the actions of the partial function.
    *
    * @param  f    a partial function with message patterns and actions
@@ -61,10 +61,9 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Receives a message from this <code>ReactChannel</code> within
-   * a certain time span.
-   * <p>
-   * This method never returns. Therefore, the rest of the computation
+   * Receives a message from this `ReactChannel` 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.
    *
    * @param  msec the time span before timeout
@@ -81,7 +80,7 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Receives a message from this <code>ReactChannel</code>.
+   * Receives a message from this `ReactChannel`.
    *
    * @param  f    a partial function with message patterns and actions
    * @return      result of processing the received value
@@ -96,8 +95,7 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Receives a message from this <code>ReactChannel</code> within a certain
-   * time span.
+   * Receives a message from this `ReactChannel` within a certain time span.
    *
    * @param  msec the time span before timeout
    * @param  f    a partial function with message patterns and actions
@@ -114,7 +112,7 @@ private[actors] class ReactChannel[Msg](receiver: ReplyReactor) extends InputCha
   }
 
   /**
-   * Receives the next message from this <code>ReactChannel</code>.
+   * Receives the next message from this `ReactChannel`.
    */
   def ? : Msg = receive {
     case x => x

src/actors/scala/actors/ReactChannel.scala

@@ -6,16 +6,16 @@
 **                          |/                                          **
 \*                                                                      */
 
-
 package scala.actors
 
 import java.util.{Timer, TimerTask}
 
 /** 
- * Extends the [[scala.actors.Reactor]]
- *    trait with methods to reply to the sender of a message.
- *    Sending a message to a <code>ReplyReactor</code> implicitly
- *    passes a reference to the sender together with the message.
+ * Extends the [[scala.actors.Reactor]] trait with methods to reply to the
+ * sender of a message.
+ *
+ * Sending a message to a `ReplyReactor` implicitly passes a reference to
+ * the sender together with the message.
  *
  *  @author Philipp Haller
  *
@@ -43,7 +43,7 @@ trait ReplyReactor extends Reactor[Any] with ReactorCanReply {
   protected[actors] def sender: OutputChannel[Any] = senders.head
 
   /**
-   * Replies with <code>msg</code> to the sender.
+   * Replies with `msg` to the sender.
    */
   protected[actors] def reply(msg: Any) {
     sender ! msg