Move all doc examples out of the akka-package to avoid use of private APIs. See #2092

akka-docs/scala/code/docs/routing/RouterDocSpec.scala

@@ -0,0 +1,29 @@
+/**
+ * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+package docs.routing
+
+import RouterDocSpec.MyActor
+import akka.actor.{ Props, Actor }
+import akka.testkit.AkkaSpec
+import akka.routing.RoundRobinRouter
+
+object RouterDocSpec {
+  class MyActor extends Actor {
+    def receive = {
+      case _ ⇒
+    }
+  }
+}
+
+class RouterDocSpec extends AkkaSpec {
+
+  import RouterDocSpec._
+
+  //#dispatchers
+  val router = system.actorOf(Props[MyActor]
+    .withRouter(RoundRobinRouter(5, routerDispatcher = "router")) // “head” will run on "router" dispatcher
+    .withDispatcher("workers")) // MyActor workers will run on "workers" dispatcher
+  //#dispatchers
+
+}

akka-docs/scala/code/docs/routing/RouterTypeExample.scala

@@ -0,0 +1,92 @@
+/**
+ * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+package docs.routing
+
+import akka.routing.{ ScatterGatherFirstCompletedRouter, BroadcastRouter, RandomRouter, RoundRobinRouter }
+import annotation.tailrec
+import akka.actor.{ Props, Actor }
+import akka.util.duration._
+import akka.util.Timeout
+import akka.dispatch.Await
+import akka.pattern.ask
+import akka.routing.SmallestMailboxRouter
+
+case class FibonacciNumber(nbr: Int)
+
+//#printlnActor
+class PrintlnActor extends Actor {
+  def receive = {
+    case msg ⇒
+      println("Received message '%s' in actor %s".format(msg, self.path.name))
+  }
+}
+
+//#printlnActor
+
+//#fibonacciActor
+class FibonacciActor extends Actor {
+  def receive = {
+    case FibonacciNumber(nbr) ⇒ sender tell fibonacci(nbr)
+  }
+
+  private def fibonacci(n: Int): Int = {
+    @tailrec
+    def fib(n: Int, b: Int, a: Int): Int = n match {
+      case 0 ⇒ a
+      case _ ⇒ fib(n - 1, a + b, b)
+    }
+
+    fib(n, 1, 0)
+  }
+}
+
+//#fibonacciActor
+
+//#parentActor
+class ParentActor extends Actor {
+  def receive = {
+    case "rrr" ⇒
+      //#roundRobinRouter
+      val roundRobinRouter =
+        context.actorOf(Props[PrintlnActor].withRouter(RoundRobinRouter(5)), "router")
+      1 to 10 foreach {
+        i ⇒ roundRobinRouter ! i
+      }
+    //#roundRobinRouter
+    case "rr" ⇒
+      //#randomRouter
+      val randomRouter =
+        context.actorOf(Props[PrintlnActor].withRouter(RandomRouter(5)), "router")
+      1 to 10 foreach {
+        i ⇒ randomRouter ! i
+      }
+    //#randomRouter
+    case "smr" ⇒
+      //#smallestMailboxRouter
+      val smallestMailboxRouter =
+        context.actorOf(Props[PrintlnActor].withRouter(SmallestMailboxRouter(5)), "router")
+      1 to 10 foreach {
+        i ⇒ smallestMailboxRouter ! i
+      }
+    //#smallestMailboxRouter
+    case "br" ⇒
+      //#broadcastRouter
+      val broadcastRouter =
+        context.actorOf(Props[PrintlnActor].withRouter(BroadcastRouter(5)), "router")
+      broadcastRouter ! "this is a broadcast message"
+    //#broadcastRouter
+    case "sgfcr" ⇒
+      //#scatterGatherFirstCompletedRouter
+      val scatterGatherFirstCompletedRouter = context.actorOf(
+        Props[FibonacciActor].withRouter(ScatterGatherFirstCompletedRouter(
+          nrOfInstances = 5, within = 2 seconds)), "router")
+      implicit val timeout = Timeout(5 seconds)
+      val futureResult = scatterGatherFirstCompletedRouter ? FibonacciNumber(10)
+      val result = Await.result(futureResult, timeout.duration)
+      //#scatterGatherFirstCompletedRouter
+      println("The result of calculating Fibonacci for 10 is %d".format(result))
+  }
+}
+
+//#parentActor

akka-docs/scala/code/docs/routing/RouterViaConfigExample.scala

@@ -0,0 +1,52 @@
+/**
+ * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+package docs.routing
+
+import akka.actor.{ Actor, Props, ActorSystem }
+import com.typesafe.config.ConfigFactory
+import akka.routing.FromConfig
+
+case class Message(nbr: Int)
+
+class ExampleActor extends Actor {
+  def receive = {
+    case Message(nbr) ⇒ println("Received %s in router %s".format(nbr, self.path.name))
+  }
+}
+
+object RouterWithConfigExample extends App {
+  val config = ConfigFactory.parseString("""
+    //#config
+    akka.actor.deployment {
+      /router {
+        router = round-robin
+        nr-of-instances = 5
+      }
+    }
+    //#config
+    //#config-resize
+    akka.actor.deployment {
+      /router2 {
+        router = round-robin
+        resizer {
+          lower-bound = 2
+          upper-bound = 15
+        }
+      }
+    }
+    //#config-resize
+      """)
+  val system = ActorSystem("Example", config)
+  //#configurableRouting
+  val router = system.actorOf(Props[ExampleActor].withRouter(FromConfig()),
+    "router")
+  //#configurableRouting
+  1 to 10 foreach { i ⇒ router ! Message(i) }
+
+  //#configurableRoutingWithResizer
+  val router2 = system.actorOf(Props[ExampleActor].withRouter(FromConfig()),
+    "router2")
+  //#configurableRoutingWithResizer
+  1 to 10 foreach { i ⇒ router2 ! Message(i) }
+}

akka-docs/scala/code/docs/routing/RouterViaProgramExample.scala

@@ -0,0 +1,53 @@
+/**
+ * Copyright (C) 2009-2012 Typesafe Inc. <http://www.typesafe.com>
+ */
+package docs.routing
+
+import akka.routing.RoundRobinRouter
+import akka.actor.{ ActorRef, Props, Actor, ActorSystem }
+import akka.routing.DefaultResizer
+import akka.routing.RemoteRouterConfig
+
+case class Message1(nbr: Int)
+
+class ExampleActor1 extends Actor {
+  def receive = {
+    case Message1(nbr) ⇒ println("Received %s in router %s".format(nbr, self.path.name))
+  }
+}
+
+object RoutingProgrammaticallyExample extends App {
+  val system = ActorSystem("RPE")
+  //#programmaticRoutingNrOfInstances
+  val router1 = system.actorOf(Props[ExampleActor1].withRouter(
+    RoundRobinRouter(nrOfInstances = 5)))
+  //#programmaticRoutingNrOfInstances
+  1 to 6 foreach { i ⇒ router1 ! Message1(i) }
+
+  //#programmaticRoutingRoutees
+  val actor1 = system.actorOf(Props[ExampleActor1])
+  val actor2 = system.actorOf(Props[ExampleActor1])
+  val actor3 = system.actorOf(Props[ExampleActor1])
+  val routees = Vector[ActorRef](actor1, actor2, actor3)
+  val router2 = system.actorOf(Props[ExampleActor1].withRouter(
+    RoundRobinRouter(routees = routees)))
+  //#programmaticRoutingRoutees
+  1 to 6 foreach { i ⇒ router2 ! Message1(i) }
+
+  //#programmaticRoutingWithResizer
+  val resizer = DefaultResizer(lowerBound = 2, upperBound = 15)
+  val router3 = system.actorOf(Props[ExampleActor1].withRouter(
+    RoundRobinRouter(resizer = Some(resizer))))
+  //#programmaticRoutingWithResizer
+  1 to 6 foreach { i ⇒ router3 ! Message1(i) }
+
+  //#remoteRoutees
+  import akka.actor.{ Address, AddressFromURIString }
+  val addresses = Seq(
+    Address("akka", "remotesys", "otherhost", 1234),
+    AddressFromURIString("akka://othersys@anotherhost:1234"))
+  val routerRemote = system.actorOf(Props[ExampleActor1].withRouter(
+    RemoteRouterConfig(RoundRobinRouter(5), addresses)))
+  //#remoteRoutees
+
+}