=doc #3689 Don't rewrite arrows in doc and samples
This commit is contained in:
Patrik Nordwall
parent
37f8f2831b
commit
5a019c0a7a
61 changed files with 531 additions and 517 deletions
|
|
@ -26,8 +26,8 @@ import scala.concurrent.Await
|
|||
class MyActor extends Actor {
|
||||
val log = Logging(context.system, this)
|
||||
def receive = {
|
||||
case "test" ⇒ log.info("received test")
|
||||
case _ ⇒ log.info("received unknown message")
|
||||
case "test" => log.info("received test")
|
||||
case _ => log.info("received unknown message")
|
||||
}
|
||||
}
|
||||
//#my-actor
|
||||
|
|
@ -40,14 +40,14 @@ class FirstActor extends Actor {
|
|||
val child = context.actorOf(Props[MyActor], name = "myChild")
|
||||
//#plus-some-behavior
|
||||
def receive = {
|
||||
case x ⇒ sender ! x
|
||||
case x => sender ! x
|
||||
}
|
||||
//#plus-some-behavior
|
||||
}
|
||||
//#context-actorOf
|
||||
|
||||
class ActorWithArgs(arg: String) extends Actor {
|
||||
def receive = { case _ ⇒ () }
|
||||
def receive = { case _ => () }
|
||||
}
|
||||
|
||||
class DemoActorWrapper extends Actor {
|
||||
|
|
@ -64,7 +64,7 @@ class DemoActorWrapper extends Actor {
|
|||
|
||||
class DemoActor(magicNumber: Int) extends Actor {
|
||||
def receive = {
|
||||
case x: Int ⇒ sender ! (x + magicNumber)
|
||||
case x: Int => sender ! (x + magicNumber)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -79,10 +79,10 @@ class DemoActorWrapper extends Actor {
|
|||
class AnonymousActor extends Actor {
|
||||
//#anonymous-actor
|
||||
def receive = {
|
||||
case m: DoIt ⇒
|
||||
case m: DoIt =>
|
||||
context.actorOf(Props(new Actor {
|
||||
def receive = {
|
||||
case DoIt(msg) ⇒
|
||||
case DoIt(msg) =>
|
||||
val replyMsg = doSomeDangerousWork(msg)
|
||||
sender ! replyMsg
|
||||
context.stop(self)
|
||||
|
|
@ -112,13 +112,13 @@ class Hook extends Actor {
|
|||
|
||||
class ReplyException extends Actor {
|
||||
def receive = {
|
||||
case _ ⇒
|
||||
case _ =>
|
||||
//#reply-exception
|
||||
try {
|
||||
val result = operation()
|
||||
sender ! result
|
||||
} catch {
|
||||
case e: Exception ⇒
|
||||
case e: Exception =>
|
||||
sender ! akka.actor.Status.Failure(e)
|
||||
throw e
|
||||
}
|
||||
|
|
@ -136,10 +136,10 @@ class Swapper extends Actor {
|
|||
val log = Logging(system, this)
|
||||
|
||||
def receive = {
|
||||
case Swap ⇒
|
||||
case Swap =>
|
||||
log.info("Hi")
|
||||
become({
|
||||
case Swap ⇒
|
||||
case Swap =>
|
||||
log.info("Ho")
|
||||
unbecome() // resets the latest 'become' (just for fun)
|
||||
}, discardOld = false) // push on top instead of replace
|
||||
|
|
@ -166,7 +166,7 @@ abstract class GenericActor extends Actor {
|
|||
|
||||
// generic message handler
|
||||
def genericMessageHandler: Receive = {
|
||||
case event ⇒ printf("generic: %s\n", event)
|
||||
case event => printf("generic: %s\n", event)
|
||||
}
|
||||
|
||||
def receive = specificMessageHandler orElse genericMessageHandler
|
||||
|
|
@ -174,7 +174,7 @@ abstract class GenericActor extends Actor {
|
|||
|
||||
class SpecificActor extends GenericActor {
|
||||
def specificMessageHandler = {
|
||||
case event: MyMsg ⇒ printf("specific: %s\n", event.subject)
|
||||
case event: MyMsg => printf("specific: %s\n", event.subject)
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -190,7 +190,7 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
import context._
|
||||
val myActor = actorOf(Props[MyActor], name = "myactor")
|
||||
def receive = {
|
||||
case x ⇒ myActor ! x
|
||||
case x => myActor ! x
|
||||
}
|
||||
}
|
||||
//#import-context
|
||||
|
|
@ -207,17 +207,17 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
|
||||
// TODO: convert docs to AkkaSpec(Map(...))
|
||||
val filter = EventFilter.custom {
|
||||
case e: Logging.Info ⇒ true
|
||||
case _ ⇒ false
|
||||
case e: Logging.Info => true
|
||||
case _ => false
|
||||
}
|
||||
system.eventStream.publish(TestEvent.Mute(filter))
|
||||
system.eventStream.subscribe(testActor, classOf[Logging.Info])
|
||||
|
||||
myActor ! "test"
|
||||
expectMsgPF(1 second) { case Logging.Info(_, _, "received test") ⇒ true }
|
||||
expectMsgPF(1 second) { case Logging.Info(_, _, "received test") => true }
|
||||
|
||||
myActor ! "unknown"
|
||||
expectMsgPF(1 second) { case Logging.Info(_, _, "received unknown message") ⇒ true }
|
||||
expectMsgPF(1 second) { case Logging.Info(_, _, "received unknown message") => true }
|
||||
|
||||
system.eventStream.unsubscribe(testActor)
|
||||
system.eventStream.publish(TestEvent.UnMute(filter))
|
||||
|
|
@ -245,7 +245,7 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
//#creating-props-deprecated
|
||||
// DEPRECATED: old case class signature
|
||||
val props4 = Props(
|
||||
creator = { () ⇒ new MyActor },
|
||||
creator = { () => new MyActor },
|
||||
dispatcher = "my-dispatcher")
|
||||
|
||||
// DEPRECATED due to duplicate functionality with Props.apply()
|
||||
|
|
@ -273,8 +273,8 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
"creating actor with IndirectActorProducer" in {
|
||||
class Echo(name: String) extends Actor {
|
||||
def receive = {
|
||||
case n: Int ⇒ sender ! name
|
||||
case message ⇒
|
||||
case n: Int => sender ! name
|
||||
case message =>
|
||||
val target = testActor
|
||||
//#forward
|
||||
target forward message
|
||||
|
|
@ -348,10 +348,10 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
// To set an initial delay
|
||||
context.setReceiveTimeout(30 milliseconds)
|
||||
def receive = {
|
||||
case "Hello" ⇒
|
||||
case "Hello" =>
|
||||
// To set in a response to a message
|
||||
context.setReceiveTimeout(100 milliseconds)
|
||||
case ReceiveTimeout ⇒
|
||||
case ReceiveTimeout =>
|
||||
// To turn it off
|
||||
context.setReceiveTimeout(Duration.Undefined)
|
||||
throw new RuntimeException("Receive timed out")
|
||||
|
|
@ -364,18 +364,18 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
class HotSwapActor extends Actor {
|
||||
import context._
|
||||
def angry: Receive = {
|
||||
case "foo" ⇒ sender ! "I am already angry?"
|
||||
case "bar" ⇒ become(happy)
|
||||
case "foo" => sender ! "I am already angry?"
|
||||
case "bar" => become(happy)
|
||||
}
|
||||
|
||||
def happy: Receive = {
|
||||
case "bar" ⇒ sender ! "I am already happy :-)"
|
||||
case "foo" ⇒ become(angry)
|
||||
case "bar" => sender ! "I am already happy :-)"
|
||||
case "foo" => become(angry)
|
||||
}
|
||||
|
||||
def receive = {
|
||||
case "foo" ⇒ become(angry)
|
||||
case "bar" ⇒ become(happy)
|
||||
case "foo" => become(angry)
|
||||
case "bar" => become(happy)
|
||||
}
|
||||
}
|
||||
//#hot-swap-actor
|
||||
|
|
@ -389,16 +389,16 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
import akka.actor.Stash
|
||||
class ActorWithProtocol extends Actor with Stash {
|
||||
def receive = {
|
||||
case "open" ⇒
|
||||
case "open" =>
|
||||
unstashAll()
|
||||
context.become({
|
||||
case "write" ⇒ // do writing...
|
||||
case "close" ⇒
|
||||
case "write" => // do writing...
|
||||
case "close" =>
|
||||
unstashAll()
|
||||
context.unbecome()
|
||||
case msg ⇒ stash()
|
||||
case msg => stash()
|
||||
}, discardOld = false) // stack on top instead of replacing
|
||||
case msg ⇒ stash()
|
||||
case msg => stash()
|
||||
}
|
||||
}
|
||||
//#stash
|
||||
|
|
@ -415,9 +415,9 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
var lastSender = system.deadLetters
|
||||
|
||||
def receive = {
|
||||
case "kill" ⇒
|
||||
case "kill" =>
|
||||
context.stop(child); lastSender = sender
|
||||
case Terminated(`child`) ⇒ lastSender ! "finished"
|
||||
case Terminated(`child`) => lastSender ! "finished"
|
||||
}
|
||||
}
|
||||
//#watch
|
||||
|
|
@ -457,15 +457,15 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
context.actorSelection("/user/another") ! Identify(identifyId)
|
||||
|
||||
def receive = {
|
||||
case ActorIdentity(`identifyId`, Some(ref)) ⇒
|
||||
case ActorIdentity(`identifyId`, Some(ref)) =>
|
||||
context.watch(ref)
|
||||
context.become(active(ref))
|
||||
case ActorIdentity(`identifyId`, None) ⇒ context.stop(self)
|
||||
case ActorIdentity(`identifyId`, None) => context.stop(self)
|
||||
|
||||
}
|
||||
|
||||
def active(another: ActorRef): Actor.Receive = {
|
||||
case Terminated(`another`) ⇒ context.stop(self)
|
||||
case Terminated(`another`) => context.stop(self)
|
||||
}
|
||||
}
|
||||
//#identify
|
||||
|
|
@ -490,7 +490,7 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
// the actor has been stopped
|
||||
} catch {
|
||||
// the actor wasn't stopped within 5 seconds
|
||||
case e: akka.pattern.AskTimeoutException ⇒
|
||||
case e: akka.pattern.AskTimeoutException =>
|
||||
}
|
||||
//#gracefulStop
|
||||
}
|
||||
|
|
@ -507,9 +507,9 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
|
||||
val f: Future[Result] =
|
||||
for {
|
||||
x ← ask(actorA, Request).mapTo[Int] // call pattern directly
|
||||
s ← (actorB ask Request).mapTo[String] // call by implicit conversion
|
||||
d ← (actorC ? Request).mapTo[Double] // call by symbolic name
|
||||
x <- ask(actorA, Request).mapTo[Int] // call pattern directly
|
||||
s <- (actorB ask Request).mapTo[String] // call by implicit conversion
|
||||
d <- (actorC ? Request).mapTo[Double] // call by symbolic name
|
||||
} yield Result(x, s, d)
|
||||
|
||||
f pipeTo actorD // .. or ..
|
||||
|
|
@ -519,12 +519,12 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
|
||||
class Replier extends Actor {
|
||||
def receive = {
|
||||
case ref: ActorRef ⇒
|
||||
case ref: ActorRef =>
|
||||
//#reply-with-sender
|
||||
sender.tell("reply", context.parent) // replies will go back to parent
|
||||
sender.!("reply")(context.parent) // alternative syntax (beware of the parens!)
|
||||
//#reply-with-sender
|
||||
case x ⇒
|
||||
case x =>
|
||||
//#reply-without-sender
|
||||
sender ! x // replies will go to this actor
|
||||
//#reply-without-sender
|
||||
|
|
@ -547,8 +547,8 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
"using ActorDSL outside of akka.actor package" in {
|
||||
import akka.actor.ActorDSL._
|
||||
actor(new Act {
|
||||
superviseWith(OneForOneStrategy() { case _ ⇒ Stop; Restart; Resume; Escalate })
|
||||
superviseWith(AllForOneStrategy() { case _ ⇒ Stop; Restart; Resume; Escalate })
|
||||
superviseWith(OneForOneStrategy() { case _ => Stop; Restart; Resume; Escalate })
|
||||
superviseWith(AllForOneStrategy() { case _ => Stop; Restart; Resume; Escalate })
|
||||
})
|
||||
}
|
||||
|
||||
|
|
@ -561,9 +561,9 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
|
||||
private var pfsOption: Option[Vector[PF]] = Some(Vector.empty)
|
||||
|
||||
private def mapPfs[C](f: Vector[PF] ⇒ (Option[Vector[PF]], C)): C = {
|
||||
private def mapPfs[C](f: Vector[PF] => (Option[Vector[PF]], C)): C = {
|
||||
pfsOption.fold(throw new IllegalStateException("Already built"))(f) match {
|
||||
case (newPfsOption, result) ⇒ {
|
||||
case (newPfsOption, result) => {
|
||||
pfsOption = newPfsOption
|
||||
result
|
||||
}
|
||||
|
|
@ -571,10 +571,10 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
}
|
||||
|
||||
def +=(pf: PF): Unit =
|
||||
mapPfs { case pfs ⇒ (Some(pfs :+ pf), ()) }
|
||||
mapPfs { case pfs => (Some(pfs :+ pf), ()) }
|
||||
|
||||
def result(): PF =
|
||||
mapPfs { case pfs ⇒ (None, pfs.foldLeft[PF](Map.empty) { _ orElse _ }) }
|
||||
mapPfs { case pfs => (None, pfs.foldLeft[PF](Map.empty) { _ orElse _ }) }
|
||||
}
|
||||
|
||||
trait ComposableActor extends Actor {
|
||||
|
|
@ -584,13 +584,13 @@ class ActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
|
||||
trait TheirComposableActor extends ComposableActor {
|
||||
receiveBuilder += {
|
||||
case "foo" ⇒ sender ! "foo received"
|
||||
case "foo" => sender ! "foo received"
|
||||
}
|
||||
}
|
||||
|
||||
class MyComposableActor extends TheirComposableActor {
|
||||
receiveBuilder += {
|
||||
case "bar" ⇒ sender ! "bar received"
|
||||
case "bar" => sender ! "bar received"
|
||||
}
|
||||
}
|
||||
//#receive-orElse2
|
||||
|
|
|
|||
|
|
@ -5,7 +5,7 @@ package docs.actor
|
|||
|
||||
import language.postfixOps
|
||||
|
||||
import akka.testkit.{ AkkaSpec ⇒ MyFavoriteTestFrameWorkPlusAkkaTestKit }
|
||||
import akka.testkit.{ AkkaSpec => MyFavoriteTestFrameWorkPlusAkkaTestKit }
|
||||
import akka.util.ByteString
|
||||
|
||||
//#test-code
|
||||
|
|
@ -46,23 +46,23 @@ class FSMDocSpec extends MyFavoriteTestFrameWorkPlusAkkaTestKit {
|
|||
|
||||
//#when-syntax
|
||||
when(Idle) {
|
||||
case Event(SetTarget(ref), Uninitialized) ⇒
|
||||
case Event(SetTarget(ref), Uninitialized) =>
|
||||
stay using Todo(ref, Vector.empty)
|
||||
}
|
||||
//#when-syntax
|
||||
|
||||
//#transition-elided
|
||||
onTransition {
|
||||
case Active -> Idle ⇒
|
||||
case Active -> Idle =>
|
||||
stateData match {
|
||||
case Todo(ref, queue) ⇒ ref ! Batch(queue)
|
||||
case Todo(ref, queue) => ref ! Batch(queue)
|
||||
}
|
||||
}
|
||||
//#transition-elided
|
||||
//#when-syntax
|
||||
|
||||
when(Active, stateTimeout = 1 second) {
|
||||
case Event(Flush | StateTimeout, t: Todo) ⇒
|
||||
case Event(Flush | StateTimeout, t: Todo) =>
|
||||
goto(Idle) using t.copy(queue = Vector.empty)
|
||||
}
|
||||
//#when-syntax
|
||||
|
|
@ -70,10 +70,10 @@ class FSMDocSpec extends MyFavoriteTestFrameWorkPlusAkkaTestKit {
|
|||
//#unhandled-elided
|
||||
whenUnhandled {
|
||||
// common code for both states
|
||||
case Event(Queue(obj), t @ Todo(_, v)) ⇒
|
||||
case Event(Queue(obj), t @ Todo(_, v)) =>
|
||||
goto(Active) using t.copy(queue = v :+ obj)
|
||||
|
||||
case Event(e, s) ⇒
|
||||
case Event(e, s) =>
|
||||
log.warning("received unhandled request {} in state {}/{}", e, stateName, s)
|
||||
stay
|
||||
}
|
||||
|
|
@ -99,16 +99,16 @@ class FSMDocSpec extends MyFavoriteTestFrameWorkPlusAkkaTestKit {
|
|||
|
||||
//#modifier-syntax
|
||||
when(SomeState) {
|
||||
case Event(msg, _) ⇒
|
||||
case Event(msg, _) =>
|
||||
goto(Processing) using (newData) forMax (5 seconds) replying (WillDo)
|
||||
}
|
||||
//#modifier-syntax
|
||||
|
||||
//#transition-syntax
|
||||
onTransition {
|
||||
case Idle -> Active ⇒ setTimer("timeout", Tick, 1 second, true)
|
||||
case Active -> _ ⇒ cancelTimer("timeout")
|
||||
case x -> Idle ⇒ log.info("entering Idle from " + x)
|
||||
case Idle -> Active => setTimer("timeout", Tick, 1 second, true)
|
||||
case Active -> _ => cancelTimer("timeout")
|
||||
case x -> Idle => log.info("entering Idle from " + x)
|
||||
}
|
||||
//#transition-syntax
|
||||
|
||||
|
|
@ -122,7 +122,7 @@ class FSMDocSpec extends MyFavoriteTestFrameWorkPlusAkkaTestKit {
|
|||
|
||||
//#stop-syntax
|
||||
when(Error) {
|
||||
case Event("stop", _) ⇒
|
||||
case Event("stop", _) =>
|
||||
// do cleanup ...
|
||||
stop()
|
||||
}
|
||||
|
|
@ -130,38 +130,38 @@ class FSMDocSpec extends MyFavoriteTestFrameWorkPlusAkkaTestKit {
|
|||
|
||||
//#transform-syntax
|
||||
when(SomeState)(transform {
|
||||
case Event(bytes: ByteString, read) ⇒ stay using (read + bytes.length)
|
||||
case Event(bytes: ByteString, read) => stay using (read + bytes.length)
|
||||
} using {
|
||||
case s @ FSM.State(state, read, timeout, stopReason, replies) if read > 1000 ⇒
|
||||
case s @ FSM.State(state, read, timeout, stopReason, replies) if read > 1000 =>
|
||||
goto(Processing)
|
||||
})
|
||||
//#transform-syntax
|
||||
|
||||
//#alt-transform-syntax
|
||||
val processingTrigger: PartialFunction[State, State] = {
|
||||
case s @ FSM.State(state, read, timeout, stopReason, replies) if read > 1000 ⇒
|
||||
case s @ FSM.State(state, read, timeout, stopReason, replies) if read > 1000 =>
|
||||
goto(Processing)
|
||||
}
|
||||
|
||||
when(SomeState)(transform {
|
||||
case Event(bytes: ByteString, read) ⇒ stay using (read + bytes.length)
|
||||
case Event(bytes: ByteString, read) => stay using (read + bytes.length)
|
||||
} using processingTrigger)
|
||||
//#alt-transform-syntax
|
||||
|
||||
//#termination-syntax
|
||||
onTermination {
|
||||
case StopEvent(FSM.Normal, state, data) ⇒ // ...
|
||||
case StopEvent(FSM.Shutdown, state, data) ⇒ // ...
|
||||
case StopEvent(FSM.Failure(cause), state, data) ⇒ // ...
|
||||
case StopEvent(FSM.Normal, state, data) => // ...
|
||||
case StopEvent(FSM.Shutdown, state, data) => // ...
|
||||
case StopEvent(FSM.Failure(cause), state, data) => // ...
|
||||
}
|
||||
//#termination-syntax
|
||||
|
||||
//#unhandled-syntax
|
||||
whenUnhandled {
|
||||
case Event(x: X, data) ⇒
|
||||
case Event(x: X, data) =>
|
||||
log.info("Received unhandled event: " + x)
|
||||
stay
|
||||
case Event(msg, _) ⇒
|
||||
case Event(msg, _) =>
|
||||
log.warning("Received unknown event: " + msg)
|
||||
goto(Error)
|
||||
}
|
||||
|
|
@ -175,7 +175,7 @@ class FSMDocSpec extends MyFavoriteTestFrameWorkPlusAkkaTestKit {
|
|||
//#body-elided
|
||||
override def logDepth = 12
|
||||
onTermination {
|
||||
case StopEvent(FSM.Failure(_), state, data) ⇒
|
||||
case StopEvent(FSM.Failure(_), state, data) =>
|
||||
val lastEvents = getLog.mkString("\n\t")
|
||||
log.warning("Failure in state " + state + " with data " + data + "\n" +
|
||||
"Events leading up to this point:\n\t" + lastEvents)
|
||||
|
|
|
|||
|
|
@ -49,14 +49,14 @@ class Listener extends Actor with ActorLogging {
|
|||
context.setReceiveTimeout(15 seconds)
|
||||
|
||||
def receive = {
|
||||
case Progress(percent) ⇒
|
||||
case Progress(percent) =>
|
||||
log.info("Current progress: {} %", percent)
|
||||
if (percent >= 100.0) {
|
||||
log.info("That's all, shutting down")
|
||||
context.system.shutdown()
|
||||
}
|
||||
|
||||
case ReceiveTimeout ⇒
|
||||
case ReceiveTimeout =>
|
||||
// No progress within 15 seconds, ServiceUnavailable
|
||||
log.error("Shutting down due to unavailable service")
|
||||
context.system.shutdown()
|
||||
|
|
@ -83,7 +83,7 @@ class Worker extends Actor with ActorLogging {
|
|||
|
||||
// Stop the CounterService child if it throws ServiceUnavailable
|
||||
override val supervisorStrategy = OneForOneStrategy() {
|
||||
case _: CounterService.ServiceUnavailable ⇒ Stop
|
||||
case _: CounterService.ServiceUnavailable => Stop
|
||||
}
|
||||
|
||||
// The sender of the initial Start message will continuously be notified
|
||||
|
|
@ -94,18 +94,18 @@ class Worker extends Actor with ActorLogging {
|
|||
import context.dispatcher // Use this Actors' Dispatcher as ExecutionContext
|
||||
|
||||
def receive = LoggingReceive {
|
||||
case Start if progressListener.isEmpty ⇒
|
||||
case Start if progressListener.isEmpty =>
|
||||
progressListener = Some(sender)
|
||||
context.system.scheduler.schedule(Duration.Zero, 1 second, self, Do)
|
||||
|
||||
case Do ⇒
|
||||
case Do =>
|
||||
counterService ! Increment(1)
|
||||
counterService ! Increment(1)
|
||||
counterService ! Increment(1)
|
||||
|
||||
// Send current progress to the initial sender
|
||||
counterService ? GetCurrentCount map {
|
||||
case CurrentCount(_, count) ⇒ Progress(100.0 * count / totalCount)
|
||||
case CurrentCount(_, count) => Progress(100.0 * count / totalCount)
|
||||
} pipeTo progressListener.get
|
||||
}
|
||||
}
|
||||
|
|
@ -135,7 +135,7 @@ class CounterService extends Actor {
|
|||
// After 3 restarts within 5 seconds it will be stopped.
|
||||
override val supervisorStrategy = OneForOneStrategy(maxNrOfRetries = 3,
|
||||
withinTimeRange = 5 seconds) {
|
||||
case _: Storage.StorageException ⇒ Restart
|
||||
case _: Storage.StorageException => Restart
|
||||
}
|
||||
|
||||
val key = self.path.name
|
||||
|
|
@ -166,21 +166,21 @@ class CounterService extends Actor {
|
|||
|
||||
def receive = LoggingReceive {
|
||||
|
||||
case Entry(k, v) if k == key && counter == None ⇒
|
||||
case Entry(k, v) if k == key && counter == None =>
|
||||
// Reply from Storage of the initial value, now we can create the Counter
|
||||
val c = context.actorOf(Props(classOf[Counter], key, v))
|
||||
counter = Some(c)
|
||||
// Tell the counter to use current storage
|
||||
c ! UseStorage(storage)
|
||||
// and send the buffered backlog to the counter
|
||||
for ((replyTo, msg) ← backlog) c.tell(msg, sender = replyTo)
|
||||
for ((replyTo, msg) <- backlog) c.tell(msg, sender = replyTo)
|
||||
backlog = IndexedSeq.empty
|
||||
|
||||
case msg @ Increment(n) ⇒ forwardOrPlaceInBacklog(msg)
|
||||
case msg @ Increment(n) => forwardOrPlaceInBacklog(msg)
|
||||
|
||||
case msg @ GetCurrentCount ⇒ forwardOrPlaceInBacklog(msg)
|
||||
case msg @ GetCurrentCount => forwardOrPlaceInBacklog(msg)
|
||||
|
||||
case Terminated(actorRef) if Some(actorRef) == storage ⇒
|
||||
case Terminated(actorRef) if Some(actorRef) == storage =>
|
||||
// After 3 restarts the storage child is stopped.
|
||||
// We receive Terminated because we watch the child, see initStorage.
|
||||
storage = None
|
||||
|
|
@ -189,7 +189,7 @@ class CounterService extends Actor {
|
|||
// Try to re-establish storage after while
|
||||
context.system.scheduler.scheduleOnce(10 seconds, self, Reconnect)
|
||||
|
||||
case Reconnect ⇒
|
||||
case Reconnect =>
|
||||
// Re-establish storage after the scheduled delay
|
||||
initStorage()
|
||||
}
|
||||
|
|
@ -199,8 +199,8 @@ class CounterService extends Actor {
|
|||
// the counter. Before that we place the messages in a backlog, to be sent
|
||||
// to the counter when it is initialized.
|
||||
counter match {
|
||||
case Some(c) ⇒ c forward msg
|
||||
case None ⇒
|
||||
case Some(c) => c forward msg
|
||||
case None =>
|
||||
if (backlog.size >= MaxBacklog)
|
||||
throw new ServiceUnavailable(
|
||||
"CounterService not available, lack of initial value")
|
||||
|
|
@ -230,15 +230,15 @@ class Counter(key: String, initialValue: Long) extends Actor {
|
|||
var storage: Option[ActorRef] = None
|
||||
|
||||
def receive = LoggingReceive {
|
||||
case UseStorage(s) ⇒
|
||||
case UseStorage(s) =>
|
||||
storage = s
|
||||
storeCount()
|
||||
|
||||
case Increment(n) ⇒
|
||||
case Increment(n) =>
|
||||
count += n
|
||||
storeCount()
|
||||
|
||||
case GetCurrentCount ⇒
|
||||
case GetCurrentCount =>
|
||||
sender ! CurrentCount(key, count)
|
||||
|
||||
}
|
||||
|
|
@ -271,8 +271,8 @@ class Storage extends Actor {
|
|||
val db = DummyDB
|
||||
|
||||
def receive = LoggingReceive {
|
||||
case Store(Entry(key, count)) ⇒ db.save(key, count)
|
||||
case Get(key) ⇒ sender ! Entry(key, db.load(key).getOrElse(0L))
|
||||
case Store(Entry(key, count)) => db.save(key, count)
|
||||
case Get(key) => sender ! Entry(key, db.load(key).getOrElse(0L))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -26,15 +26,15 @@ object FaultHandlingDocSpec {
|
|||
|
||||
override val supervisorStrategy =
|
||||
OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
|
||||
case _: ArithmeticException ⇒ Resume
|
||||
case _: NullPointerException ⇒ Restart
|
||||
case _: IllegalArgumentException ⇒ Stop
|
||||
case _: Exception ⇒ Escalate
|
||||
case _: ArithmeticException => Resume
|
||||
case _: NullPointerException => Restart
|
||||
case _: IllegalArgumentException => Stop
|
||||
case _: Exception => Escalate
|
||||
}
|
||||
//#strategy
|
||||
|
||||
def receive = {
|
||||
case p: Props ⇒ sender ! context.actorOf(p)
|
||||
case p: Props => sender ! context.actorOf(p)
|
||||
}
|
||||
}
|
||||
//#supervisor
|
||||
|
|
@ -48,15 +48,15 @@ object FaultHandlingDocSpec {
|
|||
|
||||
override val supervisorStrategy =
|
||||
OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
|
||||
case _: ArithmeticException ⇒ Resume
|
||||
case _: NullPointerException ⇒ Restart
|
||||
case _: IllegalArgumentException ⇒ Stop
|
||||
case _: Exception ⇒ Escalate
|
||||
case _: ArithmeticException => Resume
|
||||
case _: NullPointerException => Restart
|
||||
case _: IllegalArgumentException => Stop
|
||||
case _: Exception => Escalate
|
||||
}
|
||||
//#strategy2
|
||||
|
||||
def receive = {
|
||||
case p: Props ⇒ sender ! context.actorOf(p)
|
||||
case p: Props => sender ! context.actorOf(p)
|
||||
}
|
||||
// override default to kill all children during restart
|
||||
override def preRestart(cause: Throwable, msg: Option[Any]) {}
|
||||
|
|
@ -71,9 +71,9 @@ object FaultHandlingDocSpec {
|
|||
|
||||
override val supervisorStrategy =
|
||||
OneForOneStrategy(maxNrOfRetries = 10, withinTimeRange = 1 minute) {
|
||||
case _: ArithmeticException ⇒ Resume
|
||||
case t ⇒
|
||||
super.supervisorStrategy.decider.applyOrElse(t, (_: Any) ⇒ Escalate)
|
||||
case _: ArithmeticException => Resume
|
||||
case t =>
|
||||
super.supervisorStrategy.decider.applyOrElse(t, (_: Any) => Escalate)
|
||||
}
|
||||
//#default-strategy-fallback
|
||||
|
||||
|
|
@ -85,9 +85,9 @@ object FaultHandlingDocSpec {
|
|||
class Child extends Actor {
|
||||
var state = 0
|
||||
def receive = {
|
||||
case ex: Exception ⇒ throw ex
|
||||
case x: Int ⇒ state = x
|
||||
case "get" ⇒ sender ! state
|
||||
case ex: Exception => throw ex
|
||||
case x: Int => state = x
|
||||
case "get" => sender ! state
|
||||
}
|
||||
}
|
||||
//#child
|
||||
|
|
@ -133,7 +133,7 @@ class FaultHandlingDocSpec extends AkkaSpec with ImplicitSender {
|
|||
//#stop
|
||||
watch(child) // have testActor watch “child”
|
||||
child ! new IllegalArgumentException // break it
|
||||
expectMsgPF() { case Terminated(`child`) ⇒ () }
|
||||
expectMsgPF() { case Terminated(`child`) => () }
|
||||
//#stop
|
||||
}
|
||||
EventFilter[Exception]("CRASH", occurrences = 2) intercept {
|
||||
|
|
@ -147,7 +147,7 @@ class FaultHandlingDocSpec extends AkkaSpec with ImplicitSender {
|
|||
|
||||
child2 ! new Exception("CRASH") // escalate failure
|
||||
expectMsgPF() {
|
||||
case t @ Terminated(`child2`) if t.existenceConfirmed ⇒ ()
|
||||
case t @ Terminated(`child2`) if t.existenceConfirmed => ()
|
||||
}
|
||||
//#escalate-kill
|
||||
//#escalate-restart
|
||||
|
|
|
|||
|
|
@ -10,7 +10,7 @@ object InitializationDocSpec {
|
|||
|
||||
class PreStartInitExample extends Actor {
|
||||
override def receive = {
|
||||
case _ ⇒ // Ignore
|
||||
case _ => // Ignore
|
||||
}
|
||||
|
||||
//#preStartInit
|
||||
|
|
@ -37,14 +37,14 @@ object InitializationDocSpec {
|
|||
var initializeMe: Option[String] = None
|
||||
|
||||
override def receive = {
|
||||
case "init" ⇒
|
||||
case "init" =>
|
||||
initializeMe = Some("Up and running")
|
||||
context.become(initialized, discardOld = true)
|
||||
|
||||
}
|
||||
|
||||
def initialized: Receive = {
|
||||
case "U OK?" ⇒ initializeMe foreach { sender ! _ }
|
||||
case "U OK?" => initializeMe foreach { sender ! _ }
|
||||
}
|
||||
//#messageInit
|
||||
|
||||
|
|
|
|||
|
|
@ -43,7 +43,7 @@ class SchedulerDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
val Tick = "tick"
|
||||
class TickActor extends Actor {
|
||||
def receive = {
|
||||
case Tick ⇒ //Do something
|
||||
case Tick => //Do something
|
||||
}
|
||||
}
|
||||
val tickActor = system.actorOf(Props(classOf[TickActor], this))
|
||||
|
|
|
|||
|
|
@ -12,7 +12,7 @@ import org.scalatest.matchers.MustMatchers
|
|||
import akka.testkit._
|
||||
|
||||
//Mr funny man avoids printing to stdout AND keeping docs alright
|
||||
import java.lang.String.{ valueOf ⇒ println }
|
||||
import java.lang.String.{ valueOf => println }
|
||||
import akka.actor.ActorRef
|
||||
|
||||
//#typed-actor-iface
|
||||
|
|
@ -91,7 +91,7 @@ class TypedActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
|
||||
//#typed-actor-extension-tools
|
||||
} catch {
|
||||
case e: Exception ⇒ //dun care
|
||||
case e: Exception => //dun care
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -160,7 +160,7 @@ class TypedActorDocSpec extends AkkaSpec(Map("akka.loglevel" -> "INFO")) {
|
|||
//Use "childSquarer" as a Squarer
|
||||
//#typed-actor-hierarchy
|
||||
} catch {
|
||||
case e: Exception ⇒ //ignore
|
||||
case e: Exception => //ignore
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -34,16 +34,16 @@ class UnnestedReceives extends Actor {
|
|||
}
|
||||
|
||||
def receive = {
|
||||
case 'Replay ⇒ //Our first message should be a 'Replay message, all others are invalid
|
||||
case 'Replay => //Our first message should be a 'Replay message, all others are invalid
|
||||
allOldMessages() foreach process //Process all old messages/events
|
||||
become { //Switch behavior to look for the GoAhead signal
|
||||
case 'GoAhead ⇒ //When we get the GoAhead signal we process all our buffered messages/events
|
||||
case 'GoAhead => //When we get the GoAhead signal we process all our buffered messages/events
|
||||
queue foreach process
|
||||
queue.clear
|
||||
become { //Then we change behaviour to process incoming messages/events as they arrive
|
||||
case msg ⇒ process(msg)
|
||||
case msg => process(msg)
|
||||
}
|
||||
case msg ⇒ //While we haven't gotten the GoAhead signal, buffer all incoming messages
|
||||
case msg => //While we haven't gotten the GoAhead signal, buffer all incoming messages
|
||||
queue += msg //Here you have full control, you can handle overflow etc
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -17,7 +17,7 @@ import akka.actor.{ Actor, ExtendedActorSystem }
|
|||
|
||||
class MyActor extends Actor {
|
||||
def receive = {
|
||||
case x ⇒
|
||||
case x =>
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -61,8 +61,8 @@ class MyMailboxType(systemSettings: ActorSystem.Settings, config: Config)
|
|||
override def create(owner: Option[ActorRef],
|
||||
system: Option[ActorSystem]): MessageQueue =
|
||||
(owner zip system) headOption match {
|
||||
case Some((o, s: ExtendedActorSystem)) ⇒ new MyMessageQueue(o, s)
|
||||
case _ ⇒
|
||||
case Some((o, s: ExtendedActorSystem)) => new MyMessageQueue(o, s)
|
||||
case _ =>
|
||||
throw new IllegalArgumentException("requires an owner " +
|
||||
"(i.e. does not work with BalancingDispatcher)")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -58,7 +58,7 @@ class AgentDocSpec extends AkkaSpec {
|
|||
agent send (_ * 2)
|
||||
//#send
|
||||
|
||||
def longRunningOrBlockingFunction = (i: Int) ⇒ i * 1 // Just for the example code
|
||||
def longRunningOrBlockingFunction = (i: Int) => i * 1 // Just for the example code
|
||||
def someExecutionContext() = scala.concurrent.ExecutionContext.Implicits.global // Just for the example code
|
||||
//#send-off
|
||||
// the ExecutionContext you want to run the function on
|
||||
|
|
@ -81,7 +81,7 @@ class AgentDocSpec extends AkkaSpec {
|
|||
val f3: Future[Int] = agent alter (_ * 2)
|
||||
//#alter
|
||||
|
||||
def longRunningOrBlockingFunction = (i: Int) ⇒ i * 1 // Just for the example code
|
||||
def longRunningOrBlockingFunction = (i: Int) => i * 1 // Just for the example code
|
||||
def someExecutionContext() = ExecutionContext.global // Just for the example code
|
||||
|
||||
//#alter-off
|
||||
|
|
@ -102,7 +102,7 @@ class AgentDocSpec extends AkkaSpec {
|
|||
import scala.concurrent.stm._
|
||||
|
||||
def transfer(from: Agent[Int], to: Agent[Int], amount: Int): Boolean = {
|
||||
atomic { txn ⇒
|
||||
atomic { txn =>
|
||||
if (from.get < amount) false
|
||||
else {
|
||||
from send (_ - amount)
|
||||
|
|
@ -133,19 +133,19 @@ class AgentDocSpec extends AkkaSpec {
|
|||
val agent2 = Agent(5)
|
||||
|
||||
// uses foreach
|
||||
for (value ← agent1)
|
||||
for (value <- agent1)
|
||||
println(value)
|
||||
|
||||
// uses map
|
||||
val agent3 = for (value ← agent1) yield value + 1
|
||||
val agent3 = for (value <- agent1) yield value + 1
|
||||
|
||||
// or using map directly
|
||||
val agent4 = agent1 map (_ + 1)
|
||||
|
||||
// uses flatMap
|
||||
val agent5 = for {
|
||||
value1 ← agent1
|
||||
value2 ← agent2
|
||||
value1 <- agent1
|
||||
value2 <- agent2
|
||||
} yield value1 + value2
|
||||
//#monadic-example
|
||||
|
||||
|
|
|
|||
|
|
@ -15,7 +15,7 @@ object Consumers {
|
|||
def endpointUri = "file:data/input/actor"
|
||||
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒ println("received %s" format msg.bodyAs[String])
|
||||
case msg: CamelMessage => println("received %s" format msg.bodyAs[String])
|
||||
}
|
||||
}
|
||||
//#Consumer1
|
||||
|
|
@ -28,7 +28,7 @@ object Consumers {
|
|||
def endpointUri = "jetty:http://localhost:8877/camel/default"
|
||||
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒ sender ! ("Hello %s" format msg.bodyAs[String])
|
||||
case msg: CamelMessage => sender ! ("Hello %s" format msg.bodyAs[String])
|
||||
}
|
||||
}
|
||||
//#Consumer2
|
||||
|
|
@ -45,7 +45,7 @@ object Consumers {
|
|||
def endpointUri = "jms:queue:test"
|
||||
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒
|
||||
case msg: CamelMessage =>
|
||||
sender ! Ack
|
||||
// on success
|
||||
// ..
|
||||
|
|
@ -65,7 +65,7 @@ object Consumers {
|
|||
def endpointUri = "jetty:http://localhost:8877/camel/default"
|
||||
override def replyTimeout = 500 millis
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒ sender ! ("Hello %s" format msg.bodyAs[String])
|
||||
case msg: CamelMessage => sender ! ("Hello %s" format msg.bodyAs[String])
|
||||
}
|
||||
}
|
||||
//#Consumer4
|
||||
|
|
|
|||
|
|
@ -18,9 +18,9 @@ object CustomRoute {
|
|||
import akka.camel._
|
||||
class Responder extends Actor {
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒
|
||||
case msg: CamelMessage =>
|
||||
sender ! (msg.mapBody {
|
||||
body: String ⇒ "received %s" format body
|
||||
body: String => "received %s" format body
|
||||
})
|
||||
}
|
||||
}
|
||||
|
|
@ -47,9 +47,9 @@ object CustomRoute {
|
|||
|
||||
class ErrorThrowingConsumer(override val endpointUri: String) extends Consumer {
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒ throw new Exception("error: %s" format msg.body)
|
||||
case msg: CamelMessage => throw new Exception("error: %s" format msg.body)
|
||||
}
|
||||
override def onRouteDefinition = (rd) ⇒ rd.onException(classOf[Exception]).
|
||||
override def onRouteDefinition = (rd) => rd.onException(classOf[Exception]).
|
||||
handled(true).transform(Builder.exceptionMessage).end
|
||||
|
||||
final override def preRestart(reason: Throwable, message: Option[Any]) {
|
||||
|
|
|
|||
|
|
@ -15,8 +15,8 @@ object Introduction {
|
|||
def endpointUri = "mina2:tcp://localhost:6200?textline=true"
|
||||
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒ { /* ... */ }
|
||||
case _ ⇒ { /* ... */ }
|
||||
case msg: CamelMessage => { /* ... */ }
|
||||
case _ => { /* ... */ }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -35,8 +35,8 @@ object Introduction {
|
|||
def endpointUri = "jetty:http://localhost:8877/example"
|
||||
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒ { /* ... */ }
|
||||
case _ ⇒ { /* ... */ }
|
||||
case msg: CamelMessage => { /* ... */ }
|
||||
case _ => { /* ... */ }
|
||||
}
|
||||
}
|
||||
//#Consumer
|
||||
|
|
@ -85,8 +85,8 @@ object Introduction {
|
|||
def endpointUri = "mina2:tcp://localhost:6200?textline=true"
|
||||
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒ { /* ... */ }
|
||||
case _ ⇒ { /* ... */ }
|
||||
case msg: CamelMessage => { /* ... */ }
|
||||
case _ => { /* ... */ }
|
||||
}
|
||||
}
|
||||
val system = ActorSystem("some-system")
|
||||
|
|
|
|||
|
|
@ -33,7 +33,7 @@ object Producers {
|
|||
|
||||
class ResponseReceiver extends Actor {
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒
|
||||
case msg: CamelMessage =>
|
||||
// do something with the forwarded response
|
||||
}
|
||||
}
|
||||
|
|
@ -61,11 +61,11 @@ object Producers {
|
|||
def endpointUri = uri
|
||||
|
||||
def upperCase(msg: CamelMessage) = msg.mapBody {
|
||||
body: String ⇒ body.toUpperCase
|
||||
body: String => body.toUpperCase
|
||||
}
|
||||
|
||||
override def transformOutgoingMessage(msg: Any) = msg match {
|
||||
case msg: CamelMessage ⇒ upperCase(msg)
|
||||
case msg: CamelMessage => upperCase(msg)
|
||||
}
|
||||
}
|
||||
//#TransformOutgoingMessage
|
||||
|
|
@ -106,7 +106,7 @@ object Producers {
|
|||
import akka.actor.Actor
|
||||
class MyActor extends Actor {
|
||||
def receive = {
|
||||
case msg ⇒
|
||||
case msg =>
|
||||
val template = CamelExtension(context.system).template
|
||||
template.sendBody("direct:news", msg)
|
||||
}
|
||||
|
|
@ -118,7 +118,7 @@ object Producers {
|
|||
import akka.actor.Actor
|
||||
class MyActor extends Actor {
|
||||
def receive = {
|
||||
case msg ⇒
|
||||
case msg =>
|
||||
val template = CamelExtension(context.system).template
|
||||
sender ! template.requestBody("direct:news", msg)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -9,7 +9,7 @@ object PublishSubscribe {
|
|||
def endpointUri = uri
|
||||
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒ println("%s received: %s" format (name, msg.body))
|
||||
case msg: CamelMessage => println("%s received: %s" format (name, msg.body))
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -25,7 +25,7 @@ object PublishSubscribe {
|
|||
def endpointUri = uri
|
||||
|
||||
def receive = {
|
||||
case msg: CamelMessage ⇒ {
|
||||
case msg: CamelMessage => {
|
||||
publisher ! msg.bodyAs[String]
|
||||
sender ! ("message published")
|
||||
}
|
||||
|
|
|
|||
|
|
@ -32,7 +32,7 @@ object ChannelDocSpec {
|
|||
class Child extends Actor
|
||||
with Channels[(Stats, Nothing) :+: TNil, (Request, Reply) :+: TNil] {
|
||||
|
||||
channel[Request] { (x, snd) ⇒
|
||||
channel[Request] { (x, snd) =>
|
||||
parentChannel <-!- Stats(x)
|
||||
snd <-!- CommandSuccess
|
||||
}
|
||||
|
|
@ -43,9 +43,9 @@ object ChannelDocSpec {
|
|||
|
||||
val child = createChild(new Child)
|
||||
|
||||
channel[GetChild.type] { (_, snd) ⇒ ChildRef(child) -!-> snd }
|
||||
channel[GetChild.type] { (_, snd) => ChildRef(child) -!-> snd }
|
||||
|
||||
channel[Stats] { (x, _) ⇒
|
||||
channel[Stats] { (x, _) =>
|
||||
// collect some stats
|
||||
}
|
||||
}
|
||||
|
|
@ -89,10 +89,10 @@ class ChannelDocSpec extends AkkaSpec {
|
|||
"demonstrate channels creation" ignore {
|
||||
//#declaring-channels
|
||||
class AC extends Actor with Channels[TNil, (Request, Reply) :+: TNil] {
|
||||
channel[Request] { (req, snd) ⇒
|
||||
channel[Request] { (req, snd) =>
|
||||
req match {
|
||||
case Command("ping") ⇒ snd <-!- CommandSuccess
|
||||
case _ ⇒
|
||||
case Command("ping") => snd <-!- CommandSuccess
|
||||
case _ =>
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -100,8 +100,8 @@ class ChannelDocSpec extends AkkaSpec {
|
|||
|
||||
//#declaring-subchannels
|
||||
class ACSub extends Actor with Channels[TNil, (Request, Reply) :+: TNil] {
|
||||
channel[Command] { (cmd, snd) ⇒ snd <-!- CommandSuccess }
|
||||
channel[Request] { (req, snd) ⇒
|
||||
channel[Command] { (cmd, snd) => snd <-!- CommandSuccess }
|
||||
channel[Request] { (req, snd) =>
|
||||
if (ThreadLocalRandom.current.nextBoolean) snd <-!- CommandSuccess
|
||||
else snd <-!- CommandFailure("no luck")
|
||||
}
|
||||
|
|
@ -159,17 +159,17 @@ class ChannelDocSpec extends AkkaSpec {
|
|||
//#become
|
||||
channel[Request] {
|
||||
|
||||
case (Command("close"), snd) ⇒
|
||||
channel[T1] { (t, s) ⇒ t -?-> target -!-> s }
|
||||
case (Command("close"), snd) =>
|
||||
channel[T1] { (t, s) => t -?-> target -!-> s }
|
||||
snd <-!- CommandSuccess
|
||||
|
||||
case (Command("open"), snd) ⇒
|
||||
channel[T1] { (_, _) ⇒ }
|
||||
case (Command("open"), snd) =>
|
||||
channel[T1] { (_, _) => }
|
||||
snd <-!- CommandSuccess
|
||||
}
|
||||
|
||||
//#become
|
||||
channel[T1] { (t, snd) ⇒ t -?-> target -!-> snd }
|
||||
channel[T1] { (t, snd) => t -?-> target -!-> snd }
|
||||
}
|
||||
//#forwarding
|
||||
|
||||
|
|
|
|||
|
|
@ -64,7 +64,7 @@ class DataflowDocSpec extends WordSpec with MustMatchers {
|
|||
//#for-vs-flow
|
||||
val f1, f2 = Future { 1 }
|
||||
|
||||
val usingFor = for { v1 ← f1; v2 ← f2 } yield v1 + v2
|
||||
val usingFor = for { v1 <- f1; v2 <- f2 } yield v1 + v2
|
||||
val usingFlow = flow { f1() + f2() }
|
||||
|
||||
usingFor onComplete println
|
||||
|
|
|
|||
|
|
@ -200,22 +200,22 @@ object DispatcherDocSpec {
|
|||
// Create a new PriorityGenerator, lower prio means more important
|
||||
PriorityGenerator {
|
||||
// 'highpriority messages should be treated first if possible
|
||||
case 'highpriority ⇒ 0
|
||||
case 'highpriority => 0
|
||||
|
||||
// 'lowpriority messages should be treated last if possible
|
||||
case 'lowpriority ⇒ 2
|
||||
case 'lowpriority => 2
|
||||
|
||||
// PoisonPill when no other left
|
||||
case PoisonPill ⇒ 3
|
||||
case PoisonPill => 3
|
||||
|
||||
// We default to 1, which is in between high and low
|
||||
case otherwise ⇒ 1
|
||||
case otherwise => 1
|
||||
})
|
||||
//#prio-mailbox
|
||||
|
||||
class MyActor extends Actor {
|
||||
def receive = {
|
||||
case x ⇒
|
||||
case x =>
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -232,7 +232,7 @@ object DispatcherDocSpec {
|
|||
with RequiresMessageQueue[MyUnboundedMessageQueueSemantics] {
|
||||
//#require-mailbox-on-actor
|
||||
def receive = {
|
||||
case _ ⇒
|
||||
case _ =>
|
||||
}
|
||||
//#require-mailbox-on-actor
|
||||
// ...
|
||||
|
|
@ -319,7 +319,7 @@ class DispatcherDocSpec extends AkkaSpec(DispatcherDocSpec.config) {
|
|||
self ! PoisonPill
|
||||
|
||||
def receive = {
|
||||
case x ⇒ log.info(x.toString)
|
||||
case x => log.info(x.toString)
|
||||
}
|
||||
}
|
||||
val a = system.actorOf(Props(classOf[Logger], this).withDispatcher(
|
||||
|
|
@ -338,7 +338,7 @@ class DispatcherDocSpec extends AkkaSpec(DispatcherDocSpec.config) {
|
|||
//#prio-dispatcher
|
||||
|
||||
watch(a)
|
||||
expectMsgPF() { case Terminated(`a`) ⇒ () }
|
||||
expectMsgPF() { case Terminated(`a`) => () }
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -22,8 +22,8 @@ object LoggingDocSpec {
|
|||
reason.getMessage, message.getOrElse(""))
|
||||
}
|
||||
def receive = {
|
||||
case "test" ⇒ log.info("Received test")
|
||||
case x ⇒ log.warning("Received unknown message: {}", x)
|
||||
case "test" => log.info("Received test")
|
||||
case x => log.warning("Received unknown message: {}", x)
|
||||
}
|
||||
}
|
||||
//#my-actor
|
||||
|
|
@ -34,7 +34,7 @@ object LoggingDocSpec {
|
|||
val log = Logging(this)
|
||||
def receive = {
|
||||
|
||||
case _ ⇒ {
|
||||
case _ => {
|
||||
//#mdc
|
||||
val mdc = Map("requestId" -> 1234, "visitorId" -> 5678)
|
||||
log.mdc(mdc)
|
||||
|
|
@ -60,14 +60,14 @@ object LoggingDocSpec {
|
|||
reqId += 1
|
||||
val always = Map("requestId" -> reqId)
|
||||
val perMessage = currentMessage match {
|
||||
case r: Req ⇒ Map("visitorId" -> r.visitorId)
|
||||
case _ ⇒ Map()
|
||||
case r: Req => Map("visitorId" -> r.visitorId)
|
||||
case _ => Map()
|
||||
}
|
||||
always ++ perMessage
|
||||
}
|
||||
|
||||
def receive: Receive = {
|
||||
case r: Req ⇒ {
|
||||
case r: Req => {
|
||||
log.info(s"Starting new request: ${r.work}")
|
||||
}
|
||||
}
|
||||
|
|
@ -85,11 +85,11 @@ object LoggingDocSpec {
|
|||
|
||||
class MyEventListener extends Actor {
|
||||
def receive = {
|
||||
case InitializeLogger(_) ⇒ sender ! LoggerInitialized
|
||||
case Error(cause, logSource, logClass, message) ⇒ // ...
|
||||
case Warning(logSource, logClass, message) ⇒ // ...
|
||||
case Info(logSource, logClass, message) ⇒ // ...
|
||||
case Debug(logSource, logClass, message) ⇒ // ...
|
||||
case InitializeLogger(_) => sender ! LoggerInitialized
|
||||
case Error(cause, logSource, logClass, message) => // ...
|
||||
case Warning(logSource, logClass, message) => // ...
|
||||
case Info(logSource, logClass, message) => // ...
|
||||
case Debug(logSource, logClass, message) => // ...
|
||||
}
|
||||
}
|
||||
//#my-event-listener
|
||||
|
|
@ -140,7 +140,7 @@ class LoggingDocSpec extends AkkaSpec {
|
|||
|
||||
class Listener extends Actor {
|
||||
def receive = {
|
||||
case d: DeadLetter ⇒ println(d)
|
||||
case d: DeadLetter => println(d)
|
||||
}
|
||||
}
|
||||
val listener = system.actorOf(Props(classOf[Listener], this))
|
||||
|
|
|
|||
|
|
@ -60,7 +60,7 @@ object ExtensionDocSpec {
|
|||
|
||||
class MyActor extends Actor {
|
||||
def receive = {
|
||||
case someMessage ⇒
|
||||
case someMessage =>
|
||||
CountExtension(context.system).increment()
|
||||
}
|
||||
}
|
||||
|
|
@ -68,12 +68,12 @@ object ExtensionDocSpec {
|
|||
|
||||
//#extension-usage-actor-trait
|
||||
|
||||
trait Counting { self: Actor ⇒
|
||||
trait Counting { self: Actor =>
|
||||
def increment() = CountExtension(context.system).increment()
|
||||
}
|
||||
class MyCounterActor extends Actor with Counting {
|
||||
def receive = {
|
||||
case someMessage ⇒ increment()
|
||||
case someMessage => increment()
|
||||
}
|
||||
}
|
||||
//#extension-usage-actor-trait
|
||||
|
|
|
|||
|
|
@ -65,7 +65,7 @@ object SettingsExtensionDocSpec {
|
|||
|
||||
//#extension-usage-actor
|
||||
def receive = {
|
||||
case someMessage ⇒
|
||||
case someMessage =>
|
||||
}
|
||||
|
||||
def connect(dbUri: String, circuitBreakerTimeout: Duration) = {
|
||||
|
|
|
|||
|
|
@ -18,9 +18,9 @@ object FutureDocSpec {
|
|||
|
||||
class MyActor extends Actor {
|
||||
def receive = {
|
||||
case x: String ⇒ sender ! x.toUpperCase
|
||||
case x: Int if x < 0 ⇒ sender ! Status.Failure(new ArithmeticException("Negative values not supported"))
|
||||
case x: Int ⇒ sender ! x
|
||||
case x: String => sender ! x.toUpperCase
|
||||
case x: Int if x < 0 => sender ! Status.Failure(new ArithmeticException("Negative values not supported"))
|
||||
case x: Int => sender ! x
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -29,7 +29,7 @@ object FutureDocSpec {
|
|||
class OddActor extends Actor {
|
||||
var n = 1
|
||||
def receive = {
|
||||
case GetNext ⇒
|
||||
case GetNext =>
|
||||
sender ! n
|
||||
n += 2
|
||||
}
|
||||
|
|
@ -40,7 +40,7 @@ class FutureDocSpec extends AkkaSpec {
|
|||
import FutureDocSpec._
|
||||
import system.dispatcher
|
||||
|
||||
val println: PartialFunction[Any, Unit] = { case _ ⇒ }
|
||||
val println: PartialFunction[Any, Unit] = { case _ => }
|
||||
|
||||
"demonstrate usage custom ExecutionContext" in {
|
||||
val yourExecutorServiceGoesHere = java.util.concurrent.Executors.newSingleThreadExecutor()
|
||||
|
|
@ -112,7 +112,7 @@ class FutureDocSpec extends AkkaSpec {
|
|||
val f1 = Future {
|
||||
"Hello" + "World"
|
||||
}
|
||||
val f2 = f1 map { x ⇒
|
||||
val f2 = f1 map { x =>
|
||||
x.length
|
||||
}
|
||||
f2 foreach println
|
||||
|
|
@ -128,8 +128,8 @@ class FutureDocSpec extends AkkaSpec {
|
|||
"Hello" + "World"
|
||||
}
|
||||
val f2 = Future.successful(3)
|
||||
val f3 = f1 map { x ⇒
|
||||
f2 map { y ⇒
|
||||
val f3 = f1 map { x =>
|
||||
f2 map { y =>
|
||||
x.length * y
|
||||
}
|
||||
}
|
||||
|
|
@ -144,8 +144,8 @@ class FutureDocSpec extends AkkaSpec {
|
|||
"Hello" + "World"
|
||||
}
|
||||
val f2 = Future.successful(3)
|
||||
val f3 = f1 flatMap { x ⇒
|
||||
f2 map { y ⇒
|
||||
val f3 = f1 flatMap { x =>
|
||||
f2 map { y =>
|
||||
x.length * y
|
||||
}
|
||||
}
|
||||
|
|
@ -164,7 +164,7 @@ class FutureDocSpec extends AkkaSpec {
|
|||
|
||||
val failedFilter = future1.filter(_ % 2 == 1).recover {
|
||||
// When filter fails, it will have a java.util.NoSuchElementException
|
||||
case m: NoSuchElementException ⇒ 0
|
||||
case m: NoSuchElementException => 0
|
||||
}
|
||||
|
||||
failedFilter foreach println
|
||||
|
|
@ -178,9 +178,9 @@ class FutureDocSpec extends AkkaSpec {
|
|||
"demonstrate usage of for comprehension" in {
|
||||
//#for-comprehension
|
||||
val f = for {
|
||||
a ← Future(10 / 2) // 10 / 2 = 5
|
||||
b ← Future(a + 1) // 5 + 1 = 6
|
||||
c ← Future(a - 1) // 5 - 1 = 4
|
||||
a <- Future(10 / 2) // 10 / 2 = 5
|
||||
b <- Future(a + 1) // 5 + 1 = 6
|
||||
c <- Future(a - 1) // 5 - 1 = 4
|
||||
if c > 3 // Future.filter
|
||||
} yield b * c // 6 * 4 = 24
|
||||
|
||||
|
|
@ -232,9 +232,9 @@ class FutureDocSpec extends AkkaSpec {
|
|||
val f2 = ask(actor2, msg2)
|
||||
|
||||
val f3 = for {
|
||||
a ← f1.mapTo[Int]
|
||||
b ← f2.mapTo[Int]
|
||||
c ← ask(actor3, (a + b)).mapTo[Int]
|
||||
a <- f1.mapTo[Int]
|
||||
b <- f2.mapTo[Int]
|
||||
c <- ask(actor3, (a + b)).mapTo[Int]
|
||||
} yield c
|
||||
|
||||
f3 foreach println
|
||||
|
|
@ -262,7 +262,7 @@ class FutureDocSpec extends AkkaSpec {
|
|||
|
||||
"demonstrate usage of sequence" in {
|
||||
//#sequence
|
||||
val futureList = Future.sequence((1 to 100).toList.map(x ⇒ Future(x * 2 - 1)))
|
||||
val futureList = Future.sequence((1 to 100).toList.map(x => Future(x * 2 - 1)))
|
||||
val oddSum = futureList.map(_.sum)
|
||||
oddSum foreach println
|
||||
//#sequence
|
||||
|
|
@ -271,7 +271,7 @@ class FutureDocSpec extends AkkaSpec {
|
|||
|
||||
"demonstrate usage of traverse" in {
|
||||
//#traverse
|
||||
val futureList = Future.traverse((1 to 100).toList)(x ⇒ Future(x * 2 - 1))
|
||||
val futureList = Future.traverse((1 to 100).toList)(x => Future(x * 2 - 1))
|
||||
val oddSum = futureList.map(_.sum)
|
||||
oddSum foreach println
|
||||
//#traverse
|
||||
|
|
@ -281,7 +281,7 @@ class FutureDocSpec extends AkkaSpec {
|
|||
"demonstrate usage of fold" in {
|
||||
//#fold
|
||||
// Create a sequence of Futures
|
||||
val futures = for (i ← 1 to 1000) yield Future(i * 2)
|
||||
val futures = for (i <- 1 to 1000) yield Future(i * 2)
|
||||
val futureSum = Future.fold(futures)(0)(_ + _)
|
||||
futureSum foreach println
|
||||
//#fold
|
||||
|
|
@ -291,7 +291,7 @@ class FutureDocSpec extends AkkaSpec {
|
|||
"demonstrate usage of reduce" in {
|
||||
//#reduce
|
||||
// Create a sequence of Futures
|
||||
val futures = for (i ← 1 to 1000) yield Future(i * 2)
|
||||
val futures = for (i <- 1 to 1000) yield Future(i * 2)
|
||||
val futureSum = Future.reduce(futures)(_ + _)
|
||||
futureSum foreach println
|
||||
//#reduce
|
||||
|
|
@ -304,7 +304,7 @@ class FutureDocSpec extends AkkaSpec {
|
|||
val msg1 = -1
|
||||
//#recover
|
||||
val future = akka.pattern.ask(actor, msg1) recover {
|
||||
case e: ArithmeticException ⇒ 0
|
||||
case e: ArithmeticException => 0
|
||||
}
|
||||
future foreach println
|
||||
//#recover
|
||||
|
|
@ -317,8 +317,8 @@ class FutureDocSpec extends AkkaSpec {
|
|||
val msg1 = -1
|
||||
//#try-recover
|
||||
val future = akka.pattern.ask(actor, msg1) recoverWith {
|
||||
case e: ArithmeticException ⇒ Future.successful(0)
|
||||
case foo: IllegalArgumentException ⇒
|
||||
case e: ArithmeticException => Future.successful(0)
|
||||
case foo: IllegalArgumentException =>
|
||||
Future.failed[Int](new IllegalStateException("All br0ken!"))
|
||||
}
|
||||
future foreach println
|
||||
|
|
@ -330,7 +330,7 @@ class FutureDocSpec extends AkkaSpec {
|
|||
val future1 = Future { "foo" }
|
||||
val future2 = Future { "bar" }
|
||||
//#zip
|
||||
val future3 = future1 zip future2 map { case (a, b) ⇒ a + " " + b }
|
||||
val future3 = future1 zip future2 map { case (a, b) => a + " " + b }
|
||||
future3 foreach println
|
||||
//#zip
|
||||
Await.result(future3, 3 seconds) must be("foo bar")
|
||||
|
|
@ -343,9 +343,9 @@ class FutureDocSpec extends AkkaSpec {
|
|||
def watchSomeTV(): Unit = ()
|
||||
//#and-then
|
||||
val result = Future { loadPage(url) } andThen {
|
||||
case Failure(exception) ⇒ log(exception)
|
||||
case Failure(exception) => log(exception)
|
||||
} andThen {
|
||||
case _ ⇒ watchSomeTV()
|
||||
case _ => watchSomeTV()
|
||||
}
|
||||
result foreach println
|
||||
//#and-then
|
||||
|
|
@ -368,8 +368,8 @@ class FutureDocSpec extends AkkaSpec {
|
|||
val future = Future { "foo" }
|
||||
//#onSuccess
|
||||
future onSuccess {
|
||||
case "bar" ⇒ println("Got my bar alright!")
|
||||
case x: String ⇒ println("Got some random string: " + x)
|
||||
case "bar" => println("Got my bar alright!")
|
||||
case x: String => println("Got some random string: " + x)
|
||||
}
|
||||
//#onSuccess
|
||||
Await.result(future, 3 seconds) must be("foo")
|
||||
|
|
@ -378,9 +378,9 @@ class FutureDocSpec extends AkkaSpec {
|
|||
val future = Future.failed[String](new IllegalStateException("OHNOES"))
|
||||
//#onFailure
|
||||
future onFailure {
|
||||
case ise: IllegalStateException if ise.getMessage == "OHNOES" ⇒
|
||||
case ise: IllegalStateException if ise.getMessage == "OHNOES" =>
|
||||
//OHNOES! We are in deep trouble, do something!
|
||||
case e: Exception ⇒
|
||||
case e: Exception =>
|
||||
//Do something else
|
||||
}
|
||||
//#onFailure
|
||||
|
|
@ -391,8 +391,8 @@ class FutureDocSpec extends AkkaSpec {
|
|||
def doSomethingOnFailure(t: Throwable) = ()
|
||||
//#onComplete
|
||||
future onComplete {
|
||||
case Success(result) ⇒ doSomethingOnSuccess(result)
|
||||
case Failure(failure) ⇒ doSomethingOnFailure(failure)
|
||||
case Success(result) => doSomethingOnSuccess(result)
|
||||
case Failure(failure) => doSomethingOnFailure(failure)
|
||||
}
|
||||
//#onComplete
|
||||
Await.result(future, 3 seconds) must be("foo")
|
||||
|
|
@ -436,7 +436,7 @@ class FutureDocSpec extends AkkaSpec {
|
|||
val f = Future("hello")
|
||||
def receive = {
|
||||
//#receive-omitted
|
||||
case _ ⇒
|
||||
case _ =>
|
||||
//#receive-omitted
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,15 +53,15 @@ class EchoManager(handlerClass: Class[_]) extends Actor with ActorLogging {
|
|||
override def postRestart(thr: Throwable): Unit = context stop self
|
||||
|
||||
def receive = {
|
||||
case Bound(localAddress) ⇒
|
||||
case Bound(localAddress) =>
|
||||
log.info("listening on port {}", localAddress.getPort)
|
||||
|
||||
case CommandFailed(Bind(_, local, _, _)) ⇒
|
||||
case CommandFailed(Bind(_, local, _, _)) =>
|
||||
log.warning(s"cannot bind to [$local]")
|
||||
context stop self
|
||||
|
||||
//#echo-manager
|
||||
case Connected(remote, local) ⇒
|
||||
case Connected(remote, local) =>
|
||||
log.info("received connection from {}", remote)
|
||||
val handler = context.actorOf(Props(handlerClass, sender, remote))
|
||||
sender ! Register(handler, keepOpenOnPeerClosed = true)
|
||||
|
|
@ -91,18 +91,18 @@ class EchoHandler(connection: ActorRef, remote: InetSocketAddress)
|
|||
|
||||
//#writing
|
||||
def writing: Receive = {
|
||||
case Received(data) ⇒
|
||||
case Received(data) =>
|
||||
connection ! Write(data, Ack(currentOffset))
|
||||
buffer(data)
|
||||
|
||||
case Ack(ack) ⇒
|
||||
case Ack(ack) =>
|
||||
acknowledge(ack)
|
||||
|
||||
case CommandFailed(Write(_, Ack(ack))) ⇒
|
||||
case CommandFailed(Write(_, Ack(ack))) =>
|
||||
connection ! ResumeWriting
|
||||
context become buffering(ack)
|
||||
|
||||
case PeerClosed ⇒
|
||||
case PeerClosed =>
|
||||
if (storage.isEmpty) context stop self
|
||||
else context become closing
|
||||
}
|
||||
|
|
@ -114,11 +114,11 @@ class EchoHandler(connection: ActorRef, remote: InetSocketAddress)
|
|||
var peerClosed = false
|
||||
|
||||
{
|
||||
case Received(data) ⇒ buffer(data)
|
||||
case WritingResumed ⇒ writeFirst()
|
||||
case PeerClosed ⇒ peerClosed = true
|
||||
case Ack(ack) if ack < nack ⇒ acknowledge(ack)
|
||||
case Ack(ack) ⇒
|
||||
case Received(data) => buffer(data)
|
||||
case WritingResumed => writeFirst()
|
||||
case PeerClosed => peerClosed = true
|
||||
case Ack(ack) if ack < nack => acknowledge(ack)
|
||||
case Ack(ack) =>
|
||||
acknowledge(ack)
|
||||
if (storage.nonEmpty) {
|
||||
if (toAck > 0) {
|
||||
|
|
@ -138,19 +138,19 @@ class EchoHandler(connection: ActorRef, remote: InetSocketAddress)
|
|||
|
||||
//#closing
|
||||
def closing: Receive = {
|
||||
case CommandFailed(_: Write) ⇒
|
||||
case CommandFailed(_: Write) =>
|
||||
connection ! ResumeWriting
|
||||
context.become({
|
||||
|
||||
case WritingResumed ⇒
|
||||
case WritingResumed =>
|
||||
writeAll()
|
||||
context.unbecome()
|
||||
|
||||
case ack: Int ⇒ acknowledge(ack)
|
||||
case ack: Int => acknowledge(ack)
|
||||
|
||||
}, discardOld = false)
|
||||
|
||||
case Ack(ack) ⇒
|
||||
case Ack(ack) =>
|
||||
acknowledge(ack)
|
||||
if (storage.isEmpty) context stop self
|
||||
}
|
||||
|
|
@ -213,7 +213,7 @@ class EchoHandler(connection: ActorRef, remote: InetSocketAddress)
|
|||
}
|
||||
|
||||
private def writeAll(): Unit = {
|
||||
for ((data, i) ← storage.zipWithIndex) {
|
||||
for ((data, i) <- storage.zipWithIndex) {
|
||||
connection ! Write(data, Ack(storageOffset + i))
|
||||
}
|
||||
}
|
||||
|
|
@ -234,17 +234,17 @@ class SimpleEchoHandler(connection: ActorRef, remote: InetSocketAddress)
|
|||
case object Ack extends Event
|
||||
|
||||
def receive = {
|
||||
case Received(data) ⇒
|
||||
case Received(data) =>
|
||||
buffer(data)
|
||||
connection ! Write(data, Ack)
|
||||
|
||||
context.become({
|
||||
case Received(data) ⇒ buffer(data)
|
||||
case Ack ⇒ acknowledge()
|
||||
case PeerClosed ⇒ closing = true
|
||||
case Received(data) => buffer(data)
|
||||
case Ack => acknowledge()
|
||||
case PeerClosed => closing = true
|
||||
}, discardOld = false)
|
||||
|
||||
case PeerClosed ⇒ context stop self
|
||||
case PeerClosed => context stop self
|
||||
}
|
||||
|
||||
//#storage-omitted
|
||||
|
|
|
|||
|
|
@ -34,14 +34,14 @@ class Server extends Actor {
|
|||
IO(Tcp) ! Bind(self, new InetSocketAddress("localhost", 0))
|
||||
|
||||
def receive = {
|
||||
case b @ Bound(localAddress) ⇒
|
||||
case b @ Bound(localAddress) =>
|
||||
//#do-some-logging-or-setup
|
||||
context.parent ! b
|
||||
//#do-some-logging-or-setup
|
||||
|
||||
case CommandFailed(_: Bind) ⇒ context stop self
|
||||
case CommandFailed(_: Bind) => context stop self
|
||||
|
||||
case c @ Connected(remote, local) ⇒
|
||||
case c @ Connected(remote, local) =>
|
||||
//#server
|
||||
context.parent ! c
|
||||
//#server
|
||||
|
|
@ -57,8 +57,8 @@ class Server extends Actor {
|
|||
class SimplisticHandler extends Actor {
|
||||
import Tcp._
|
||||
def receive = {
|
||||
case Received(data) ⇒ sender ! Write(data)
|
||||
case PeerClosed ⇒ context stop self
|
||||
case Received(data) => sender ! Write(data)
|
||||
case PeerClosed => context stop self
|
||||
}
|
||||
}
|
||||
//#simplistic-handler
|
||||
|
|
@ -77,20 +77,20 @@ class Client(remote: InetSocketAddress, listener: ActorRef) extends Actor {
|
|||
IO(Tcp) ! Connect(remote)
|
||||
|
||||
def receive = {
|
||||
case CommandFailed(_: Connect) ⇒
|
||||
case CommandFailed(_: Connect) =>
|
||||
listener ! "failed"
|
||||
context stop self
|
||||
|
||||
case c @ Connected(remote, local) ⇒
|
||||
case c @ Connected(remote, local) =>
|
||||
listener ! c
|
||||
val connection = sender
|
||||
connection ! Register(self)
|
||||
context become {
|
||||
case data: ByteString ⇒ connection ! Write(data)
|
||||
case CommandFailed(w: Write) ⇒ // O/S buffer was full
|
||||
case Received(data) ⇒ listener ! data
|
||||
case "close" ⇒ connection ! Close
|
||||
case _: ConnectionClosed ⇒ context stop self
|
||||
case data: ByteString => connection ! Write(data)
|
||||
case CommandFailed(w: Write) => // O/S buffer was full
|
||||
case Received(data) => listener ! data
|
||||
case "close" => connection ! Close
|
||||
case _: ConnectionClosed => context stop self
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -101,7 +101,7 @@ class IODocSpec extends AkkaSpec {
|
|||
class Parent extends Actor {
|
||||
context.actorOf(Props[Server], "server")
|
||||
def receive = {
|
||||
case msg ⇒ testActor forward msg
|
||||
case msg => testActor forward msg
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -45,12 +45,12 @@ class PipelinesDocSpec extends AkkaSpec {
|
|||
builder ++= bs
|
||||
}
|
||||
|
||||
override val commandPipeline = { msg: Message ⇒
|
||||
override val commandPipeline = { msg: Message =>
|
||||
val bs = ByteString.newBuilder
|
||||
|
||||
// first store the persons
|
||||
bs putInt msg.persons.size
|
||||
msg.persons foreach { p ⇒
|
||||
msg.persons foreach { p =>
|
||||
putString(bs, p.first)
|
||||
putString(bs, p.last)
|
||||
}
|
||||
|
|
@ -72,12 +72,12 @@ class PipelinesDocSpec extends AkkaSpec {
|
|||
ByteString(bytes).utf8String
|
||||
}
|
||||
|
||||
override val eventPipeline = { bs: ByteString ⇒
|
||||
override val eventPipeline = { bs: ByteString =>
|
||||
val iter = bs.iterator
|
||||
|
||||
val personLength = iter.getInt
|
||||
val persons =
|
||||
(1 to personLength) map (_ ⇒ Person(getString(iter), getString(iter)))
|
||||
(1 to personLength) map (_ => Person(getString(iter), getString(iter)))
|
||||
|
||||
val curveLength = iter.getInt
|
||||
val curve = new Array[Double](curveLength)
|
||||
|
|
@ -94,10 +94,10 @@ class PipelinesDocSpec extends AkkaSpec {
|
|||
var lastTick = Duration.Zero
|
||||
|
||||
override val managementPort: Mgmt = {
|
||||
case TickGenerator.Tick(timestamp) ⇒
|
||||
case TickGenerator.Tick(timestamp) =>
|
||||
//#omitted
|
||||
testActor ! TickGenerator.Tick(timestamp)
|
||||
import java.lang.String.{ valueOf ⇒ println }
|
||||
import java.lang.String.{ valueOf => println }
|
||||
//#omitted
|
||||
println(s"time since last tick: ${timestamp - lastTick}")
|
||||
lastTick = timestamp
|
||||
|
|
@ -207,20 +207,20 @@ class PipelinesDocSpec extends AkkaSpec {
|
|||
new LengthFieldFrame(10000) //
|
||||
)(
|
||||
// failure in the pipeline will fail this actor
|
||||
cmd ⇒ cmds ! cmd.get,
|
||||
evt ⇒ evts ! evt.get)
|
||||
cmd => cmds ! cmd.get,
|
||||
evt => evts ! evt.get)
|
||||
|
||||
def receive = {
|
||||
case m: Message ⇒ pipeline.injectCommand(m)
|
||||
case b: ByteString ⇒ pipeline.injectEvent(b)
|
||||
case t: TickGenerator.Trigger ⇒ pipeline.managementCommand(t)
|
||||
case m: Message => pipeline.injectCommand(m)
|
||||
case b: ByteString => pipeline.injectEvent(b)
|
||||
case t: TickGenerator.Trigger => pipeline.managementCommand(t)
|
||||
}
|
||||
}
|
||||
//#actor
|
||||
|
||||
class P(cmds: ActorRef, evts: ActorRef) extends Processor(cmds, evts) {
|
||||
override def receive = ({
|
||||
case "fail!" ⇒ throw new RuntimeException("FAIL!")
|
||||
case "fail!" => throw new RuntimeException("FAIL!")
|
||||
}: Receive) orElse super.receive
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -21,7 +21,7 @@ object ScalaUdpDocSpec {
|
|||
IO(Udp) ! Udp.SimpleSender
|
||||
|
||||
def receive = {
|
||||
case Udp.SimpleSenderReady ⇒
|
||||
case Udp.SimpleSenderReady =>
|
||||
context.become(ready(sender))
|
||||
//#sender
|
||||
sender ! Udp.Send(ByteString("hello"), remote)
|
||||
|
|
@ -29,7 +29,7 @@ object ScalaUdpDocSpec {
|
|||
}
|
||||
|
||||
def ready(send: ActorRef): Receive = {
|
||||
case msg: String ⇒
|
||||
case msg: String =>
|
||||
send ! Udp.Send(ByteString(msg), remote)
|
||||
//#sender
|
||||
if (msg == "world") send ! PoisonPill
|
||||
|
|
@ -44,7 +44,7 @@ object ScalaUdpDocSpec {
|
|||
IO(Udp) ! Udp.Bind(self, new InetSocketAddress("localhost", 0))
|
||||
|
||||
def receive = {
|
||||
case Udp.Bound(local) ⇒
|
||||
case Udp.Bound(local) =>
|
||||
//#listener
|
||||
nextActor forward local
|
||||
//#listener
|
||||
|
|
@ -52,15 +52,15 @@ object ScalaUdpDocSpec {
|
|||
}
|
||||
|
||||
def ready(socket: ActorRef): Receive = {
|
||||
case Udp.Received(data, remote) ⇒
|
||||
case Udp.Received(data, remote) =>
|
||||
val processed = // parse data etc., e.g. using PipelineStage
|
||||
//#listener
|
||||
data.utf8String
|
||||
//#listener
|
||||
socket ! Udp.Send(data, remote) // example server echoes back
|
||||
nextActor ! processed
|
||||
case Udp.Unbind ⇒ socket ! Udp.Unbind
|
||||
case Udp.Unbound ⇒ context.stop(self)
|
||||
case Udp.Unbind => socket ! Udp.Unbind
|
||||
case Udp.Unbound => context.stop(self)
|
||||
}
|
||||
}
|
||||
//#listener
|
||||
|
|
@ -71,7 +71,7 @@ object ScalaUdpDocSpec {
|
|||
IO(UdpConnected) ! UdpConnected.Connect(self, remote)
|
||||
|
||||
def receive = {
|
||||
case UdpConnected.Connected ⇒
|
||||
case UdpConnected.Connected =>
|
||||
context.become(ready(sender))
|
||||
//#connected
|
||||
sender ! UdpConnected.Send(ByteString("hello"))
|
||||
|
|
@ -79,16 +79,16 @@ object ScalaUdpDocSpec {
|
|||
}
|
||||
|
||||
def ready(connection: ActorRef): Receive = {
|
||||
case UdpConnected.Received(data) ⇒
|
||||
case UdpConnected.Received(data) =>
|
||||
// process data, send it on, etc.
|
||||
//#connected
|
||||
if (data.utf8String == "hello")
|
||||
connection ! UdpConnected.Send(ByteString("world"))
|
||||
//#connected
|
||||
case msg: String ⇒
|
||||
case msg: String =>
|
||||
connection ! UdpConnected.Send(ByteString(msg))
|
||||
case d @ UdpConnected.Disconnect ⇒ connection ! d
|
||||
case UdpConnected.Disconnected ⇒ context.stop(self)
|
||||
case d @ UdpConnected.Disconnect => connection ! d
|
||||
case UdpConnected.Disconnected => context.stop(self)
|
||||
}
|
||||
}
|
||||
//#connected
|
||||
|
|
|
|||
|
|
@ -26,11 +26,11 @@ object SchedulerPatternSpec {
|
|||
override def postStop() = tick.cancel()
|
||||
|
||||
def receive = {
|
||||
case "tick" ⇒
|
||||
case "tick" =>
|
||||
// do something useful here
|
||||
//#schedule-constructor
|
||||
target ! "tick"
|
||||
case "restart" ⇒
|
||||
case "restart" =>
|
||||
throw new ArithmeticException
|
||||
//#schedule-constructor
|
||||
}
|
||||
|
|
@ -53,13 +53,13 @@ object SchedulerPatternSpec {
|
|||
override def postRestart(reason: Throwable) = {}
|
||||
|
||||
def receive = {
|
||||
case "tick" ⇒
|
||||
case "tick" =>
|
||||
// send another periodic tick after the specified delay
|
||||
system.scheduler.scheduleOnce(1000 millis, self, "tick")
|
||||
// do something useful here
|
||||
//#schedule-receive
|
||||
target ! "tick"
|
||||
case "restart" ⇒
|
||||
case "restart" =>
|
||||
throw new ArithmeticException
|
||||
//#schedule-receive
|
||||
}
|
||||
|
|
|
|||
|
|
@ -21,11 +21,11 @@ trait PersistenceDocSpec {
|
|||
|
||||
class MyProcessor extends Processor {
|
||||
def receive = {
|
||||
case Persistent(payload, sequenceNr) ⇒
|
||||
case Persistent(payload, sequenceNr) =>
|
||||
// message successfully written to journal
|
||||
case PersistenceFailure(payload, sequenceNr, cause) ⇒
|
||||
case PersistenceFailure(payload, sequenceNr, cause) =>
|
||||
// message failed to be written to journal
|
||||
case other ⇒
|
||||
case other =>
|
||||
// message not written to journal
|
||||
}
|
||||
}
|
||||
|
|
@ -67,8 +67,8 @@ trait PersistenceDocSpec {
|
|||
//#deletion
|
||||
override def preRestart(reason: Throwable, message: Option[Any]) {
|
||||
message match {
|
||||
case Some(p: Persistent) ⇒ deleteMessage(p.sequenceNr)
|
||||
case _ ⇒
|
||||
case Some(p: Persistent) => deleteMessage(p.sequenceNr)
|
||||
case _ =>
|
||||
}
|
||||
super.preRestart(reason, message)
|
||||
}
|
||||
|
|
@ -94,7 +94,7 @@ trait PersistenceDocSpec {
|
|||
override def processorId = "my-stable-processor-id"
|
||||
//#processor-id-override
|
||||
def receive = {
|
||||
case _ ⇒
|
||||
case _ =>
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -109,14 +109,14 @@ trait PersistenceDocSpec {
|
|||
val channel = context.actorOf(Channel.props(), name = "myChannel")
|
||||
|
||||
def receive = {
|
||||
case p @ Persistent(payload, _) ⇒
|
||||
case p @ Persistent(payload, _) =>
|
||||
channel ! Deliver(p.withPayload(s"processed ${payload}"), destination)
|
||||
}
|
||||
}
|
||||
|
||||
class MyDestination extends Actor {
|
||||
def receive = {
|
||||
case p @ ConfirmablePersistent(payload, sequenceNr, redeliveries) ⇒
|
||||
case p @ ConfirmablePersistent(payload, sequenceNr, redeliveries) =>
|
||||
// ...
|
||||
p.confirm()
|
||||
}
|
||||
|
|
@ -139,7 +139,7 @@ trait PersistenceDocSpec {
|
|||
//#channel-custom-settings
|
||||
|
||||
def receive = {
|
||||
case p @ Persistent(payload, _) ⇒
|
||||
case p @ Persistent(payload, _) =>
|
||||
//#channel-example-reply
|
||||
channel ! Deliver(p.withPayload(s"processed ${payload}"), sender)
|
||||
//#channel-example-reply
|
||||
|
|
@ -155,7 +155,7 @@ trait PersistenceDocSpec {
|
|||
class MyProcessor3 extends Processor {
|
||||
def receive = {
|
||||
//#payload-pattern-matching
|
||||
case Persistent(payload, _) ⇒
|
||||
case Persistent(payload, _) =>
|
||||
//#payload-pattern-matching
|
||||
}
|
||||
}
|
||||
|
|
@ -163,7 +163,7 @@ trait PersistenceDocSpec {
|
|||
class MyProcessor4 extends Processor {
|
||||
def receive = {
|
||||
//#sequence-nr-pattern-matching
|
||||
case Persistent(_, sequenceNr) ⇒
|
||||
case Persistent(_, sequenceNr) =>
|
||||
//#sequence-nr-pattern-matching
|
||||
}
|
||||
}
|
||||
|
|
@ -178,12 +178,12 @@ trait PersistenceDocSpec {
|
|||
startWith("closed", 0)
|
||||
|
||||
when("closed") {
|
||||
case Event(Persistent("open", _), counter) ⇒
|
||||
case Event(Persistent("open", _), counter) =>
|
||||
goto("open") using (counter + 1) replying (counter)
|
||||
}
|
||||
|
||||
when("open") {
|
||||
case Event(Persistent("close", _), counter) ⇒
|
||||
case Event(Persistent("close", _), counter) =>
|
||||
goto("closed") using (counter + 1) replying (counter)
|
||||
}
|
||||
}
|
||||
|
|
@ -196,9 +196,9 @@ trait PersistenceDocSpec {
|
|||
var state: Any = _
|
||||
|
||||
def receive = {
|
||||
case "snap" ⇒ saveSnapshot(state)
|
||||
case SaveSnapshotSuccess(metadata) ⇒ // ...
|
||||
case SaveSnapshotFailure(metadata, reason) ⇒ // ...
|
||||
case "snap" => saveSnapshot(state)
|
||||
case SaveSnapshotSuccess(metadata) => // ...
|
||||
case SaveSnapshotFailure(metadata, reason) => // ...
|
||||
}
|
||||
}
|
||||
//#save-snapshot
|
||||
|
|
@ -210,8 +210,8 @@ trait PersistenceDocSpec {
|
|||
var state: Any = _
|
||||
|
||||
def receive = {
|
||||
case SnapshotOffer(metadata, offeredSnapshot) ⇒ state = offeredSnapshot
|
||||
case Persistent(payload, sequenceNr) ⇒ // ...
|
||||
case SnapshotOffer(metadata, offeredSnapshot) => state = offeredSnapshot
|
||||
case Persistent(payload, sequenceNr) => // ...
|
||||
}
|
||||
}
|
||||
//#snapshot-offer
|
||||
|
|
@ -232,8 +232,8 @@ trait PersistenceDocSpec {
|
|||
//#batch-write
|
||||
class MyProcessor extends Processor {
|
||||
def receive = {
|
||||
case Persistent("a", _) ⇒ // ...
|
||||
case Persistent("b", _) ⇒ // ...
|
||||
case Persistent("a", _) => // ...
|
||||
case Persistent("b", _) => // ...
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -278,11 +278,11 @@ trait PersistenceDocSpec {
|
|||
}
|
||||
|
||||
def receiveReplay: Receive = {
|
||||
case event: String ⇒ handleEvent(event)
|
||||
case event: String => handleEvent(event)
|
||||
}
|
||||
|
||||
def receiveCommand: Receive = {
|
||||
case "cmd" ⇒ {
|
||||
case "cmd" => {
|
||||
// ...
|
||||
persist("evt")(handleEvent)
|
||||
}
|
||||
|
|
|
|||
|
|
@ -98,7 +98,7 @@ object SharedLeveldbPluginDocSpec {
|
|||
}
|
||||
|
||||
def receive = {
|
||||
case ActorIdentity(1, Some(store)) ⇒
|
||||
case ActorIdentity(1, Some(store)) =>
|
||||
SharedLeveldbJournal.setStore(store, context.system)
|
||||
}
|
||||
}
|
||||
|
|
@ -122,7 +122,7 @@ class MyJournal extends AsyncWriteJournal {
|
|||
def writeAsync(persistentBatch: Seq[PersistentRepr]): Future[Unit] = ???
|
||||
def deleteAsync(processorId: String, fromSequenceNr: Long, toSequenceNr: Long, permanent: Boolean): Future[Unit] = ???
|
||||
def confirmAsync(processorId: String, sequenceNr: Long, channelId: String): Future[Unit] = ???
|
||||
def replayAsync(processorId: String, fromSequenceNr: Long, toSequenceNr: Long)(replayCallback: (PersistentRepr) ⇒ Unit): Future[Long] = ???
|
||||
def replayAsync(processorId: String, fromSequenceNr: Long, toSequenceNr: Long)(replayCallback: (PersistentRepr) => Unit): Future[Long] = ???
|
||||
}
|
||||
|
||||
class MySnapshotStore extends SnapshotStore {
|
||||
|
|
|
|||
|
|
@ -13,7 +13,7 @@ import akka.remote.RemoteScope
|
|||
object RemoteDeploymentDocSpec {
|
||||
|
||||
class SampleActor extends Actor {
|
||||
def receive = { case _ ⇒ sender ! self }
|
||||
def receive = { case _ => sender ! self }
|
||||
}
|
||||
|
||||
}
|
||||
|
|
|
|||
|
|
@ -18,9 +18,9 @@ object ConsistentHashingRouterDocSpec {
|
|||
var cache = Map.empty[String, String]
|
||||
|
||||
def receive = {
|
||||
case Entry(key, value) ⇒ cache += (key -> value)
|
||||
case Get(key) ⇒ sender ! cache.get(key)
|
||||
case Evict(key) ⇒ cache -= key
|
||||
case Entry(key, value) => cache += (key -> value)
|
||||
case Get(key) => sender ! cache.get(key)
|
||||
case Evict(key) => cache -= key
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -50,7 +50,7 @@ class ConsistentHashingRouterDocSpec extends AkkaSpec with ImplicitSender {
|
|||
import akka.routing.ConsistentHashingRouter.ConsistentHashableEnvelope
|
||||
|
||||
def hashMapping: ConsistentHashMapping = {
|
||||
case Evict(key) ⇒ key
|
||||
case Evict(key) => key
|
||||
}
|
||||
|
||||
val cache: ActorRef =
|
||||
|
|
|
|||
|
|
@ -50,7 +50,7 @@ akka.actor.deployment {
|
|||
class RedundancyRoutingLogic(nbrCopies: Int) extends RoutingLogic {
|
||||
val roundRobin = RoundRobinRoutingLogic()
|
||||
def select(message: Any, routees: immutable.IndexedSeq[Routee]): Routee = {
|
||||
val targets = (1 to nbrCopies).map(_ ⇒ roundRobin.select(message, routees))
|
||||
val targets = (1 to nbrCopies).map(_ => roundRobin.select(message, routees))
|
||||
SeveralRoutees(targets)
|
||||
}
|
||||
}
|
||||
|
|
@ -58,7 +58,7 @@ akka.actor.deployment {
|
|||
|
||||
class Storage extends Actor {
|
||||
def receive = {
|
||||
case x ⇒ sender ! x
|
||||
case x => sender ! x
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -99,7 +99,7 @@ class CustomRouterDocSpec extends AkkaSpec(CustomRouterDocSpec.config) with Impl
|
|||
//#unit-test-logic
|
||||
val logic = new RedundancyRoutingLogic(nbrCopies = 3)
|
||||
|
||||
val routees = for (n ← 1 to 7) yield TestRoutee(n)
|
||||
val routees = for (n <- 1 to 7) yield TestRoutee(n)
|
||||
|
||||
val r1 = logic.select("msg", routees)
|
||||
r1.asInstanceOf[SeveralRoutees].routees must be(
|
||||
|
|
@ -118,16 +118,16 @@ class CustomRouterDocSpec extends AkkaSpec(CustomRouterDocSpec.config) with Impl
|
|||
|
||||
"demonstrate usage of custom router" in {
|
||||
//#usage-1
|
||||
for (n ← 1 to 10) system.actorOf(Props[Storage], "s" + n)
|
||||
for (n <- 1 to 10) system.actorOf(Props[Storage], "s" + n)
|
||||
|
||||
val paths = for (n ← 1 to 10) yield ("/user/s" + n)
|
||||
val paths = for (n <- 1 to 10) yield ("/user/s" + n)
|
||||
val redundancy1: ActorRef =
|
||||
system.actorOf(RedundancyGroup(paths, nbrCopies = 3).props(),
|
||||
name = "redundancy1")
|
||||
redundancy1 ! "important"
|
||||
//#usage-1
|
||||
|
||||
for (_ ← 1 to 3) expectMsg("important")
|
||||
for (_ <- 1 to 3) expectMsg("important")
|
||||
|
||||
//#usage-2
|
||||
val redundancy2: ActorRef = system.actorOf(FromConfig.props(),
|
||||
|
|
@ -135,7 +135,7 @@ class CustomRouterDocSpec extends AkkaSpec(CustomRouterDocSpec.config) with Impl
|
|||
redundancy2 ! "very important"
|
||||
//#usage-2
|
||||
|
||||
for (_ ← 1 to 5) expectMsg("very important")
|
||||
for (_ <- 1 to 5) expectMsg("very important")
|
||||
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -173,9 +173,9 @@ router-dispatcher {}
|
|||
}
|
||||
|
||||
def receive = {
|
||||
case w: Work ⇒
|
||||
case w: Work =>
|
||||
router.route(w, sender)
|
||||
case Terminated(a) ⇒
|
||||
case Terminated(a) =>
|
||||
router = router.removeRoutee(a)
|
||||
val r = context.actorOf(Props[Worker])
|
||||
context watch r
|
||||
|
|
@ -186,7 +186,7 @@ router-dispatcher {}
|
|||
|
||||
class Worker extends Actor {
|
||||
def receive = {
|
||||
case _ ⇒
|
||||
case _ =>
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -199,7 +199,7 @@ router-dispatcher {}
|
|||
//#create-worker-actors
|
||||
|
||||
def receive = {
|
||||
case _ ⇒
|
||||
case _ =>
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -335,14 +335,14 @@ router-dispatcher {}
|
|||
//#resize-pool-2
|
||||
|
||||
def receive = {
|
||||
case _ ⇒
|
||||
case _ =>
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
class Echo extends Actor {
|
||||
def receive = {
|
||||
case m ⇒ sender ! m
|
||||
case m => sender ! m
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -16,7 +16,7 @@ import akka.testkit.ImplicitSender
|
|||
object MySpec {
|
||||
class EchoActor extends Actor {
|
||||
def receive = {
|
||||
case x ⇒ sender ! x
|
||||
case x => sender ! x
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -79,7 +79,7 @@ class TestKitUsageSpec
|
|||
filterRef ! 1
|
||||
|
||||
receiveWhile(500 millis) {
|
||||
case msg: String ⇒ messages = msg +: messages
|
||||
case msg: String => messages = msg +: messages
|
||||
}
|
||||
}
|
||||
messages.length should be(3)
|
||||
|
|
@ -90,12 +90,12 @@ class TestKitUsageSpec
|
|||
"receive an interesting message at some point " in {
|
||||
within(500 millis) {
|
||||
ignoreMsg {
|
||||
case msg: String ⇒ msg != "something"
|
||||
case msg: String => msg != "something"
|
||||
}
|
||||
seqRef ! "something"
|
||||
expectMsg("something")
|
||||
ignoreMsg {
|
||||
case msg: String ⇒ msg == "1"
|
||||
case msg: String => msg == "1"
|
||||
}
|
||||
expectNoMsg
|
||||
ignoreNoMsg
|
||||
|
|
@ -117,7 +117,7 @@ object TestKitUsageSpec {
|
|||
*/
|
||||
class EchoActor extends Actor {
|
||||
def receive = {
|
||||
case msg ⇒ sender ! msg
|
||||
case msg => sender ! msg
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -126,7 +126,7 @@ object TestKitUsageSpec {
|
|||
*/
|
||||
class ForwardingActor(next: ActorRef) extends Actor {
|
||||
def receive = {
|
||||
case msg ⇒ next ! msg
|
||||
case msg => next ! msg
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -135,8 +135,8 @@ object TestKitUsageSpec {
|
|||
*/
|
||||
class FilteringActor(next: ActorRef) extends Actor {
|
||||
def receive = {
|
||||
case msg: String ⇒ next ! msg
|
||||
case _ ⇒ None
|
||||
case msg: String => next ! msg
|
||||
case _ => None
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -149,7 +149,7 @@ object TestKitUsageSpec {
|
|||
class SequencingActor(next: ActorRef, head: immutable.Seq[String],
|
||||
tail: immutable.Seq[String]) extends Actor {
|
||||
def receive = {
|
||||
case msg ⇒ {
|
||||
case msg => {
|
||||
head foreach { next ! _ }
|
||||
next ! msg
|
||||
tail foreach { next ! _ }
|
||||
|
|
|
|||
|
|
@ -22,18 +22,18 @@ object TestkitDocSpec {
|
|||
|
||||
class MyActor extends Actor {
|
||||
def receive = {
|
||||
case Say42 ⇒ sender ! 42
|
||||
case "some work" ⇒ sender ! "some result"
|
||||
case Say42 => sender ! 42
|
||||
case "some work" => sender ! "some result"
|
||||
}
|
||||
}
|
||||
|
||||
class TestFsmActor extends Actor with FSM[Int, String] {
|
||||
startWith(1, "")
|
||||
when(1) {
|
||||
case Event("go", _) ⇒ goto(2) using "go"
|
||||
case Event("go", _) => goto(2) using "go"
|
||||
}
|
||||
when(2) {
|
||||
case Event("back", _) ⇒ goto(1) using "back"
|
||||
case Event("back", _) => goto(1) using "back"
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -42,10 +42,10 @@ object TestkitDocSpec {
|
|||
var dest1: ActorRef = _
|
||||
var dest2: ActorRef = _
|
||||
def receive = {
|
||||
case (d1: ActorRef, d2: ActorRef) ⇒
|
||||
case (d1: ActorRef, d2: ActorRef) =>
|
||||
dest1 = d1
|
||||
dest2 = d2
|
||||
case x ⇒
|
||||
case x =>
|
||||
dest1 ! x
|
||||
dest2 ! x
|
||||
}
|
||||
|
|
@ -58,13 +58,13 @@ object TestkitDocSpec {
|
|||
//#test-probe-forward-actors
|
||||
class Source(target: ActorRef) extends Actor {
|
||||
def receive = {
|
||||
case "start" ⇒ target ! "work"
|
||||
case "start" => target ! "work"
|
||||
}
|
||||
}
|
||||
|
||||
class Destination extends Actor {
|
||||
def receive = {
|
||||
case x ⇒ // Do something..
|
||||
case x => // Do something..
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -74,7 +74,7 @@ object TestkitDocSpec {
|
|||
//#logging-receive
|
||||
import akka.event.LoggingReceive
|
||||
def receive = LoggingReceive {
|
||||
case msg ⇒ // Do something...
|
||||
case msg => // Do something...
|
||||
}
|
||||
//#logging-receive
|
||||
}
|
||||
|
|
@ -151,7 +151,7 @@ class TestkitDocSpec extends AkkaSpec with DefaultTimeout with ImplicitSender {
|
|||
|
||||
val actorRef = TestActorRef(new Actor {
|
||||
def receive = {
|
||||
case "hello" ⇒ throw new IllegalArgumentException("boom")
|
||||
case "hello" => throw new IllegalArgumentException("boom")
|
||||
}
|
||||
})
|
||||
intercept[IllegalArgumentException] { actorRef.receive("hello") }
|
||||
|
|
@ -199,7 +199,7 @@ class TestkitDocSpec extends AkkaSpec with DefaultTimeout with ImplicitSender {
|
|||
val probe = new TestProbe(system) {
|
||||
def expectUpdate(x: Int) = {
|
||||
expectMsgPF() {
|
||||
case Update(id, _) if id == x ⇒ true
|
||||
case Update(id, _) if id == x => true
|
||||
}
|
||||
sender ! "ACK"
|
||||
}
|
||||
|
|
@ -280,7 +280,7 @@ class TestkitDocSpec extends AkkaSpec with DefaultTimeout with ImplicitSender {
|
|||
//#put-your-test-code-here
|
||||
val probe = TestProbe()
|
||||
probe.send(testActor, "hello")
|
||||
try expectMsg("hello") catch { case NonFatal(e) ⇒ system.shutdown(); throw e }
|
||||
try expectMsg("hello") catch { case NonFatal(e) => system.shutdown(); throw e }
|
||||
//#put-your-test-code-here
|
||||
|
||||
shutdown(system)
|
||||
|
|
|
|||
|
|
@ -26,13 +26,13 @@ object CoordinatedExample {
|
|||
val count = Ref(0)
|
||||
|
||||
def receive = {
|
||||
case coordinated @ Coordinated(Increment(friend)) ⇒ {
|
||||
case coordinated @ Coordinated(Increment(friend)) => {
|
||||
friend foreach (_ ! coordinated(Increment()))
|
||||
coordinated atomic { implicit t ⇒
|
||||
coordinated atomic { implicit t =>
|
||||
count transform (_ + 1)
|
||||
}
|
||||
}
|
||||
case GetCount ⇒ sender ! count.single.get
|
||||
case GetCount => sender ! count.single.get
|
||||
}
|
||||
}
|
||||
//#coordinated-example
|
||||
|
|
@ -44,9 +44,9 @@ object CoordinatedApi {
|
|||
class Coordinator extends Actor {
|
||||
//#receive-coordinated
|
||||
def receive = {
|
||||
case coordinated @ Coordinated(Message) ⇒ {
|
||||
case coordinated @ Coordinated(Message) => {
|
||||
//#coordinated-atomic
|
||||
coordinated atomic { implicit t ⇒
|
||||
coordinated atomic { implicit t =>
|
||||
// do something in the coordinated transaction ...
|
||||
}
|
||||
//#coordinated-atomic
|
||||
|
|
@ -66,8 +66,8 @@ object CounterExample {
|
|||
class Counter extends Transactor {
|
||||
val count = Ref(0)
|
||||
|
||||
def atomically = implicit txn ⇒ {
|
||||
case Increment ⇒ count transform (_ + 1)
|
||||
def atomically = implicit txn => {
|
||||
case Increment => count transform (_ + 1)
|
||||
}
|
||||
}
|
||||
//#counter-example
|
||||
|
|
@ -85,11 +85,11 @@ object FriendlyCounterExample {
|
|||
val count = Ref(0)
|
||||
|
||||
override def coordinate = {
|
||||
case Increment ⇒ include(friend)
|
||||
case Increment => include(friend)
|
||||
}
|
||||
|
||||
def atomically = implicit txn ⇒ {
|
||||
case Increment ⇒ count transform (_ + 1)
|
||||
def atomically = implicit txn => {
|
||||
case Increment => count transform (_ + 1)
|
||||
}
|
||||
}
|
||||
//#friendly-counter-example
|
||||
|
|
@ -97,8 +97,8 @@ object FriendlyCounterExample {
|
|||
class Friend extends Transactor {
|
||||
val count = Ref(0)
|
||||
|
||||
def atomically = implicit txn ⇒ {
|
||||
case Increment ⇒ count transform (_ + 1)
|
||||
def atomically = implicit txn => {
|
||||
case Increment => count transform (_ + 1)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
@ -115,22 +115,22 @@ object TransactorCoordinate {
|
|||
class TestCoordinateInclude(actor1: ActorRef, actor2: ActorRef, actor3: ActorRef) extends Transactor {
|
||||
//#coordinate-include
|
||||
override def coordinate = {
|
||||
case Message ⇒ include(actor1, actor2, actor3)
|
||||
case Message => include(actor1, actor2, actor3)
|
||||
}
|
||||
//#coordinate-include
|
||||
|
||||
def atomically = txn ⇒ doNothing
|
||||
def atomically = txn => doNothing
|
||||
}
|
||||
|
||||
class TestCoordinateSendTo(someActor: ActorRef, actor1: ActorRef, actor2: ActorRef) extends Transactor {
|
||||
//#coordinate-sendto
|
||||
override def coordinate = {
|
||||
case SomeMessage ⇒ sendTo(someActor -> SomeOtherMessage)
|
||||
case OtherMessage ⇒ sendTo(actor1 -> Message1, actor2 -> Message2)
|
||||
case SomeMessage => sendTo(someActor -> SomeOtherMessage)
|
||||
case OtherMessage => sendTo(actor1 -> Message1, actor2 -> Message2)
|
||||
}
|
||||
//#coordinate-sendto
|
||||
|
||||
def atomically = txn ⇒ doNothing
|
||||
def atomically = txn => doNothing
|
||||
}
|
||||
}
|
||||
|
||||
|
|
|
|||
|
|
@ -45,7 +45,7 @@ object ZeromqDocSpec {
|
|||
}
|
||||
|
||||
def receive: Receive = {
|
||||
case Tick ⇒
|
||||
case Tick =>
|
||||
val currentHeap = memory.getHeapMemoryUsage
|
||||
val timestamp = System.currentTimeMillis
|
||||
|
||||
|
|
@ -73,13 +73,13 @@ object ZeromqDocSpec {
|
|||
|
||||
def receive = {
|
||||
// the first frame is the topic, second is the message
|
||||
case m: ZMQMessage if m.frames(0).utf8String == "health.heap" ⇒
|
||||
case m: ZMQMessage if m.frames(0).utf8String == "health.heap" =>
|
||||
val Heap(timestamp, used, max) = ser.deserialize(m.frames(1).toArray,
|
||||
classOf[Heap]).get
|
||||
log.info("Used heap {} bytes, at {}", used,
|
||||
timestampFormat.format(new Date(timestamp)))
|
||||
|
||||
case m: ZMQMessage if m.frames(0).utf8String == "health.load" ⇒
|
||||
case m: ZMQMessage if m.frames(0).utf8String == "health.load" =>
|
||||
val Load(timestamp, loadAverage) = ser.deserialize(m.frames(1).toArray,
|
||||
classOf[Load]).get
|
||||
log.info("Load average {}, at {}", loadAverage,
|
||||
|
|
@ -98,7 +98,7 @@ object ZeromqDocSpec {
|
|||
|
||||
def receive = {
|
||||
// the first frame is the topic, second is the message
|
||||
case m: ZMQMessage if m.frames(0).utf8String == "health.heap" ⇒
|
||||
case m: ZMQMessage if m.frames(0).utf8String == "health.heap" =>
|
||||
val Heap(timestamp, used, max) =
|
||||
ser.deserialize(m.frames(1).toArray, classOf[Heap]).get
|
||||
if ((used.toDouble / max) > 0.9) count += 1
|
||||
|
|
@ -130,9 +130,9 @@ class ZeromqDocSpec extends AkkaSpec("akka.loglevel=INFO") {
|
|||
|
||||
class Listener extends Actor {
|
||||
def receive: Receive = {
|
||||
case Connecting ⇒ //...
|
||||
case m: ZMQMessage ⇒ //...
|
||||
case _ ⇒ //...
|
||||
case Connecting => //...
|
||||
case m: ZMQMessage => //...
|
||||
case _ => //...
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -195,11 +195,11 @@ class ZeromqDocSpec extends AkkaSpec("akka.loglevel=INFO") {
|
|||
|
||||
def checkZeroMQInstallation() = try {
|
||||
ZeroMQExtension(system).version match {
|
||||
case ZeroMQVersion(2, x, _) if x >= 1 ⇒ Unit
|
||||
case ZeroMQVersion(y, _, _) if y >= 3 ⇒ Unit
|
||||
case version ⇒ pending
|
||||
case ZeroMQVersion(2, x, _) if x >= 1 => Unit
|
||||
case ZeroMQVersion(y, _, _) if y >= 3 => Unit
|
||||
case version => pending
|
||||
}
|
||||
} catch {
|
||||
case e: LinkageError ⇒ pending
|
||||
case e: LinkageError => pending
|
||||
}
|
||||
}
|
||||
|
|
|
|||
Loading…
Add table
Add a link
Reference in a new issue