+act #3770 Added Java 8 friendly APIs for Actor and FSM

akka-samples/akka-sample-java8/src/main/java/sample/java8/buncher/Buncher.java

@@ -0,0 +1,155 @@
+package sample.java8.buncher;
+
+//#simple-imports
+import akka.actor.AbstractFSM;
+import akka.actor.ActorRef;
+import akka.japi.pf.UnitMatch;
+import java.util.Arrays;
+import java.util.LinkedList;
+import java.util.List;
+import scala.concurrent.duration.Duration;
+//#simple-imports
+
+import static sample.java8.buncher.Buncher.State;
+import static sample.java8.buncher.Buncher.Data;
+import static sample.java8.buncher.Buncher.State.*;
+import static sample.java8.buncher.Buncher.Uninitialized.*;
+import static sample.java8.buncher.Events.*;
+
+//#simple-fsm
+public class Buncher extends AbstractFSM<State, Data> {
+
+  {
+    //#fsm-body
+    startWith(Idle, Uninitialized);
+
+    //#when-syntax
+    when(Idle,
+      matchEvent(SetTarget.class, Uninitialized.class,
+        (setTarget, uninitialized) -> stay().using(new Todo(setTarget.getRef(), new LinkedList<>()))));
+    //#when-syntax
+
+    //#transition-elided
+    onTransition(
+      matchState(Active, Idle, () -> {
+        // reuse this matcher
+        final UnitMatch<Data> m = UnitMatch.create(
+          matchData(Todo.class,
+            todo -> todo.getTarget().tell(new Batch(todo.getQueue()), self())));
+        m.match(stateData());
+      }).
+      state(Idle, Active, () -> {/* Do something here */}));
+    //#transition-elided
+
+    when(Active, Duration.create(1, "second"),
+      matchEvent(Arrays.asList(Flush.class, StateTimeout()), Todo.class,
+        todo -> goTo(Idle).using(todo.copy(new LinkedList<>()))));
+
+    //#unhandled-elided
+    whenUnhandled(
+      matchEvent(Queue.class, Todo.class,
+        (queue, todo) -> goTo(Active).using(todo.addElement(queue.getObj()))).
+        anyEvent((event, state) -> {
+          log().warning("received unhandled request {} in state {}/{}", event, stateName(), state);
+          return stay();
+        }));
+    //#unhandled-elided
+
+    //#termination-elided
+    //#termination-syntax
+    onTermination(
+      matchStop(Normal(),
+        (state, data) -> {/* Do something here */}).
+      stop(Shutdown(),
+        (state, data) -> {/* Do something here */}).
+      stop(Failure(),
+        (reason, state, data) -> {/* Do something here */}));
+    //#termination-syntax
+    //#termination-elided
+    //#fsm-body
+
+    initialize();
+  }
+  //#simple-fsm
+
+  static
+  //#simple-state
+  // states
+  enum State {
+    Idle, Active
+  }
+
+  //#simple-state
+  static
+  //#simple-state
+  // state data
+  interface Data {
+  }
+
+  //#simple-state
+  static
+  //#simple-state
+  enum Uninitialized implements Data {
+    Uninitialized
+  }
+
+  //#simple-state
+  static
+  //#simple-state
+  final class Todo implements Data {
+    private final ActorRef target;
+    private final List<Object> queue;
+
+    public Todo(ActorRef target, List<Object> queue) {
+      this.target = target;
+      this.queue = queue;
+    }
+
+    public ActorRef getTarget() {
+      return target;
+    }
+
+    public List<Object> getQueue() {
+      return queue;
+    }
+    //#boilerplate
+
+    @Override
+    public String toString() {
+      return "Todo{" +
+        "target=" + target +
+        ", queue=" + queue +
+        '}';
+    }
+
+    public Todo addElement(Object element) {
+      List<Object> nQueue = new LinkedList<>(queue);
+      nQueue.add(element);
+      return new Todo(this.target, nQueue);
+    }
+
+    public Todo copy(List<Object> queue) {
+      return new Todo(this.target, queue);
+    }
+
+    public Todo copy(ActorRef target) {
+      return new Todo(target, this.queue);
+    }
+    //#boilerplate
+  }
+  //#simple-state
+  //#simple-fsm
+}
+//#simple-fsm
+
+//#NullFunction
+//#unhandled-syntax
+//#modifier-syntax
+//#transition-syntax
+//#stop-syntax
+// TODO add code example here
+//#stop-syntax
+//#transition-syntax
+//#modifier-syntax
+//#unhandled-syntax
+//#NullFunction

akka-samples/akka-sample-java8/src/main/java/sample/java8/buncher/Events.java

@@ -0,0 +1,104 @@
+package sample.java8.buncher;
+
+import akka.actor.ActorRef;
+import java.util.List;
+
+public class Events {
+
+  static
+  //#simple-events
+  public final class SetTarget {
+    private final ActorRef ref;
+
+    public SetTarget(ActorRef ref) {
+      this.ref = ref;
+    }
+
+    public ActorRef getRef() {
+      return ref;
+    }
+    //#boilerplate
+
+    @Override
+    public String toString() {
+      return "SetTarget{" +
+        "ref=" + ref +
+        '}';
+    }
+    //#boilerplate
+  }
+
+  //#simple-events
+  static
+  //#simple-events
+  public final class Queue {
+    private final Object obj;
+
+    public Queue(Object obj) {
+      this.obj = obj;
+    }
+
+    public Object getObj() {
+      return obj;
+    }
+    //#boilerplate
+
+    @Override
+    public String toString() {
+      return "Queue{" +
+        "obj=" + obj +
+        '}';
+    }
+    //#boilerplate
+  }
+
+  //#simple-events
+  static
+  //#simple-events
+  public final class Batch {
+    private final List<Object> list;
+
+    public Batch(List<Object> list) {
+      this.list = list;
+    }
+
+    public List<Object> getList() {
+      return list;
+    }
+    //#boilerplate
+
+    @Override
+    public boolean equals(Object o) {
+      if (this == o) return true;
+      if (o == null || getClass() != o.getClass()) return false;
+
+      Batch batch = (Batch) o;
+
+      return list.equals(batch.list);
+    }
+
+    @Override
+    public int hashCode() {
+      return list.hashCode();
+    }
+
+    @Override
+    public String toString() {
+      final StringBuilder builder = new StringBuilder();
+      builder.append( "Batch{list=");
+      list.stream().forEachOrdered(e -> { builder.append(e); builder.append(","); });
+      int len = builder.length();
+      builder.replace(len, len, "}");
+      return builder.toString();
+    }
+    //#boilerplate
+  }
+
+  //#simple-events
+  static
+  //#simple-events
+  public enum Flush {
+    Flush
+  }
+  //#simple-events
+}