Moved all actorOf-methods from Actor to ActorRegistry and deprecated the forwarders in Actor

akka-actor/src/main/scala/akka/actor/Actor.scala

@@ -128,7 +128,7 @@ object Actor extends Logging {
    *   val actor = actorOf[MyActor].start
    * </pre>
    */
-  def actorOf[T <: Actor : Manifest]: ActorRef = actorOf(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]])
+  @deprecated def actorOf[T <: Actor : Manifest]: ActorRef = ActorRegistry.actorOf[T]
 
   /**
    * Creates an ActorRef out of the Actor of the specified Class.
@@ -144,15 +144,7 @@ object Actor extends Logging {
    *   val actor = actorOf(classOf[MyActor]).start
    * </pre>
    */
-  def actorOf(clazz: Class[_ <: Actor]): ActorRef = new LocalActorRef(() => {
-    import ReflectiveAccess.{ createInstance, noParams, noArgs }
-    createInstance[Actor](clazz.asInstanceOf[Class[_]], noParams, noArgs).getOrElse(
-      throw new ActorInitializationException(
-        "Could not instantiate Actor" +
-        "\nMake sure Actor is NOT defined inside a class/trait," +
-        "\nif so put it outside the class/trait, f.e. in a companion object," +
-        "\nOR try to change: 'actorOf[MyActor]' to 'actorOf(new MyActor)'."))
-  }, None)
+  @deprecated def actorOf(clazz: Class[_ <: Actor]): ActorRef = ActorRegistry.actorOf(clazz)
 
   /**
    * Creates an ActorRef out of the Actor. Allows you to pass in a factory function
@@ -172,7 +164,7 @@ object Actor extends Logging {
    *   val actor = actorOf(new MyActor).start
    * </pre>
    */
-  def actorOf(factory: => Actor): ActorRef = new LocalActorRef(() => factory, None)
+  @deprecated def actorOf(factory: => Actor): ActorRef = ActorRegistry.actorOf(factory)
 
   /**
    * Use to spawn out a block of code in an event-driven actor. Will shut actor down when
@@ -189,16 +181,8 @@ object Actor extends Logging {
    * }
    * </pre>
    */
-  def spawn(body: => Unit)(implicit dispatcher: MessageDispatcher = Dispatchers.defaultGlobalDispatcher): Unit = {
-    case object Spawn
-    actorOf(new Actor() {
-      self.dispatcher = dispatcher
-      def receive = {
-        case Spawn => try { body } finally { self.stop }
-      }
-    }).start ! Spawn
-  }
-
+  @deprecated def spawn(body: => Unit)(implicit dispatcher: MessageDispatcher = Dispatchers.defaultGlobalDispatcher): Unit =
+    ActorRegistry.spawn(body)
 
   /**
    * Implicitly converts the given Option[Any] to a AnyOptionAsTypedOption which offers the method <code>as[T]</code>

akka-actor/src/main/scala/akka/actor/ActorRegistry.scala

@@ -239,6 +239,92 @@ object ActorRegistry extends ListenerManagement {
   def homeAddress(): InetSocketAddress = if (isRemotingEnabled) remote.address else Remote.configDefaultAddress
 
 
+   /**
+   *  Creates an ActorRef out of the Actor with type T.
+   * <pre>
+   *   import Actor._
+   *   val actor = actorOf[MyActor]
+   *   actor.start
+   *   actor ! message
+   *   actor.stop
+   * </pre>
+   * You can create and start the actor in one statement like this:
+   * <pre>
+   *   val actor = actorOf[MyActor].start
+   * </pre>
+   */
+  def actorOf[T <: Actor : Manifest]: ActorRef = actorOf(manifest[T].erasure.asInstanceOf[Class[_ <: Actor]])
+
+  /**
+   * Creates an ActorRef out of the Actor of the specified Class.
+   * <pre>
+   *   import Actor._
+   *   val actor = actorOf(classOf[MyActor])
+   *   actor.start
+   *   actor ! message
+   *   actor.stop
+   * </pre>
+   * You can create and start the actor in one statement like this:
+   * <pre>
+   *   val actor = actorOf(classOf[MyActor]).start
+   * </pre>
+   */
+  def actorOf(clazz: Class[_ <: Actor]): ActorRef = new LocalActorRef(() => {
+    import ReflectiveAccess.{ createInstance, noParams, noArgs }
+    createInstance[Actor](clazz.asInstanceOf[Class[_]], noParams, noArgs).getOrElse(
+      throw new ActorInitializationException(
+        "Could not instantiate Actor" +
+        "\nMake sure Actor is NOT defined inside a class/trait," +
+        "\nif so put it outside the class/trait, f.e. in a companion object," +
+        "\nOR try to change: 'actorOf[MyActor]' to 'actorOf(new MyActor)'."))
+  }, None)
+
+  /**
+   * Creates an ActorRef out of the Actor. Allows you to pass in a factory function
+   * that creates the Actor. Please note that this function can be invoked multiple
+   * times if for example the Actor is supervised and needs to be restarted.
+   * <p/>
+   * This function should <b>NOT</b> be used for remote actors.
+   * <pre>
+   *   import Actor._
+   *   val actor = actorOf(new MyActor)
+   *   actor.start
+   *   actor ! message
+   *   actor.stop
+   * </pre>
+   * You can create and start the actor in one statement like this:
+   * <pre>
+   *   val actor = actorOf(new MyActor).start
+   * </pre>
+   */
+  def actorOf(factory: => Actor): ActorRef = new LocalActorRef(() => factory, None)
+
+  /**
+   * Use to spawn out a block of code in an event-driven actor. Will shut actor down when
+   * the block has been executed.
+   * <p/>
+   * NOTE: If used from within an Actor then has to be qualified with 'ActorRegistry.spawn' since
+   * there is a method 'spawn[ActorType]' in the Actor trait already.
+   * Example:
+   * <pre>
+   * import ActorRegistry.{spawn}
+   *
+   * spawn  {
+   *   ... // do stuff
+   * }
+   * </pre>
+   */
+  def spawn(body: => Unit)(implicit dispatcher: MessageDispatcher = Dispatchers.defaultGlobalDispatcher): Unit = {
+    case object Spawn
+    actorOf(new Actor() {
+      self.dispatcher = dispatcher
+      def receive = {
+        case Spawn => try { body } finally { self.stop }
+      }
+    }).start ! Spawn
+  }
+
+
   /**
    *  Registers an actor in the ActorRegistry.
    */