From 1f024f1c9ee9544010537d796f0e0aacb34e6a55 Mon Sep 17 00:00:00 2001
From: Viktor Klang <viktor.klang@gmail.com>
Date: Fri, 20 May 2011 22:25:46 +0200
Subject: [PATCH] Harmonizing constructors and Dispatcher-factories, closing
 ticket #807

---
 .../scala/akka/dispatch/Dispatchers.scala     | 36 ++++++++++++-------
 .../akka/dispatch/ThreadBasedDispatcher.scala | 29 ++++++++-------
 project/build/AkkaProject.scala               |  2 +-
 3 files changed, 42 insertions(+), 25 deletions(-)

diff --git a/akka-actor/src/main/scala/akka/dispatch/Dispatchers.scala b/akka-actor/src/main/scala/akka/dispatch/Dispatchers.scala
index 07daf658d3..5de9e91d51 100644
--- a/akka-actor/src/main/scala/akka/dispatch/Dispatchers.scala
+++ b/akka-actor/src/main/scala/akka/dispatch/Dispatchers.scala
@@ -68,16 +68,10 @@ object Dispatchers {
    * <p/>
    * E.g. each actor consumes its own thread.
    */
-  def newThreadBasedDispatcher(actor: ActorRef) = new ThreadBasedDispatcher(actor)
-
-  /**
-   * Creates an thread based dispatcher serving a single actor through the same single thread.
-   * Uses the default timeout
-   * If capacity is negative, it's Integer.MAX_VALUE
-   * <p/>
-   * E.g. each actor consumes its own thread.
-   */
-  def newThreadBasedDispatcher(actor: ActorRef, mailboxCapacity: Int) = new ThreadBasedDispatcher(actor, mailboxCapacity)
+  def newThreadBasedDispatcher(actor: ActorRef) = actor match {
+    case null ⇒ new ThreadBasedDispatcher()
+    case some ⇒ new ThreadBasedDispatcher(some)
+  }
 
   /**
    * Creates an thread based dispatcher serving a single actor through the same single thread.
@@ -85,8 +79,26 @@ object Dispatchers {
    * <p/>
    * E.g. each actor consumes its own thread.
    */
-  def newThreadBasedDispatcher(actor: ActorRef, mailboxCapacity: Int, pushTimeOut: Duration) =
-    new ThreadBasedDispatcher(actor, mailboxCapacity, pushTimeOut)
+  def newThreadBasedDispatcher(actor: ActorRef, mailboxType: MailboxType) = actor match {
+    case null ⇒ new ThreadBasedDispatcher(mailboxType)
+    case some ⇒ new ThreadBasedDispatcher(some, mailboxType)
+  }
+
+  /**
+   * Creates an thread based dispatcher serving a single actor through the same single thread.
+   * <p/>
+   * E.g. each actor consumes its own thread.
+   */
+  def newThreadBasedDispatcher(name: String, mailboxType: MailboxType) =
+    new ThreadBasedDispatcher(name, mailboxType)
+
+  /**
+   * Creates an thread based dispatcher serving a single actor through the same single thread.
+   * <p/>
+   * E.g. each actor consumes its own thread.
+   */
+  def newThreadBasedDispatcher(name: String) =
+    new ThreadBasedDispatcher(name)
 
   /**
    * Creates a executor-based event-driven dispatcher serving multiple (millions) of actors through a thread pool.
diff --git a/akka-actor/src/main/scala/akka/dispatch/ThreadBasedDispatcher.scala b/akka-actor/src/main/scala/akka/dispatch/ThreadBasedDispatcher.scala
index c365329834..101a2ae2c5 100644
--- a/akka-actor/src/main/scala/akka/dispatch/ThreadBasedDispatcher.scala
+++ b/akka-actor/src/main/scala/akka/dispatch/ThreadBasedDispatcher.scala
@@ -4,31 +4,36 @@
 
 package akka.dispatch
 
-import akka.actor.{ ActorRef }
 import akka.util.Duration
 
 import java.util.concurrent.atomic.AtomicReference
+import akka.actor.{ Actor, ActorRef }
 
 /**
  * Dedicates a unique thread for each actor passed in as reference. Served through its messageQueue.
  *
  * @author <a href="http://jonasboner.com">Jonas Bon&#233;r</a>
  */
-class ThreadBasedDispatcher(_actor: ActorRef, _mailboxType: MailboxType)
+class ThreadBasedDispatcher(_actor: ActorRef, _name: String, _mailboxType: MailboxType)
   extends ExecutorBasedEventDrivenDispatcher(
-    _actor.uuid.toString, Dispatchers.THROUGHPUT, -1, _mailboxType, ThreadBasedDispatcher.oneThread) {
+    _name, Dispatchers.THROUGHPUT, -1, _mailboxType, ThreadBasedDispatcher.oneThread) {
+
+  def this(_name: String, _mailboxType: MailboxType) = this(null, _name, _mailboxType)
+
+  def this(_actor: ActorRef, _name: String) = this(_actor, _name, Dispatchers.MAILBOX_TYPE)
+
+  def this(_name: String) = this(null, _name, Dispatchers.MAILBOX_TYPE)
+
+  def this(_mailboxType: MailboxType) = this(null, "anon", _mailboxType)
+
+  def this(_actor: ActorRef, _mailboxType: MailboxType) = this(_actor, _actor.uuid.toString, _mailboxType)
+
+  def this(_actor: ActorRef) = this(_actor, _actor.uuid.toString, Dispatchers.MAILBOX_TYPE)
+
+  def this() = this(Dispatchers.MAILBOX_TYPE)
 
   private[akka] val owner = new AtomicReference[ActorRef](_actor)
 
-  def this(actor: ActorRef) =
-    this(actor, UnboundedMailbox()) // For Java API
-
-  def this(actor: ActorRef, capacity: Int) =
-    this(actor, BoundedMailbox(capacity)) //For Java API
-
-  def this(actor: ActorRef, capacity: Int, pushTimeOut: Duration) = //For Java API
-    this(actor, BoundedMailbox(capacity, pushTimeOut))
-
   override def register(actorRef: ActorRef) = {
     val actor = owner.get()
     if ((actor ne null) && actorRef != actor) throw new IllegalArgumentException("Cannot register to anyone but " + actor)
diff --git a/project/build/AkkaProject.scala b/project/build/AkkaProject.scala
index 53e79bb5e9..35c487d70c 100644
--- a/project/build/AkkaProject.scala
+++ b/project/build/AkkaProject.scala
@@ -19,7 +19,7 @@ class AkkaParentProject(info: ProjectInfo) extends ParentProject(info) with Exec
   val scalaCompileSettings =
     Seq("-deprecation",
         //"-Xmigration",
-        "-optimise",
+        //"-optimise",
         "-encoding", "utf8")
 
   val javaCompileSettings = Seq("-Xlint:unchecked")