+doc #19429 initial merge of docs-dev and docs

akka-docs/rst/java/code/docs/stream/MigrationsJava.java

@@ -0,0 +1,259 @@
+/**
+ * Copyright (C) 2015 Typesafe Inc. <http://www.typesafe.com>
+ */
+package docs.stream;
+
+import akka.actor.ActorSystem;
+import akka.actor.Cancellable;
+import akka.http.javadsl.model.Uri;
+import akka.dispatch.Futures;
+import akka.japi.function.Creator;
+import akka.japi.Pair;
+import akka.japi.function.Function;
+import akka.stream.*;
+import akka.stream.javadsl.*;
+import akka.stream.testkit.TestPublisher;
+import akka.stream.testkit.TestSubscriber;
+import akka.util.ByteString;
+import scala.Option;
+import scala.concurrent.Future;
+import scala.concurrent.duration.FiniteDuration;
+import scala.concurrent.Promise;
+import scala.runtime.BoxedUnit;
+
+import org.reactivestreams.Publisher;
+import org.reactivestreams.Subscriber;
+
+import java.io.File;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.concurrent.TimeUnit;
+import java.nio.charset.Charset;
+
+public class MigrationsJava {
+
+  // This is compile-only code, no need for actually running anything.
+  public static ActorMaterializer mat = null;
+  public static ActorSystem sys = null;
+
+  public static class SomeInputStream extends InputStream {
+    public SomeInputStream() {
+    }
+
+    @Override
+    public int read() throws IOException {
+      return 0;
+    }
+  }
+
+  public static class SomeOutputStream extends OutputStream {
+    @Override
+    public void write(int b) throws IOException {
+      return;
+    }
+  }
+
+  public static void main(String[] args) {
+
+    Outlet<Integer> outlet = null;
+
+    Outlet<Integer> outlet1 = null;
+    Outlet<Integer> outlet2 = null;
+
+    Inlet<Integer> inlet = null;
+
+    Inlet<Integer> inlet1 = null;
+    Inlet<Integer> inlet2 = null;
+
+    Flow<Integer, Integer, BoxedUnit> flow = Flow.of(Integer.class);
+    Flow<Integer, Integer, BoxedUnit> flow1 = Flow.of(Integer.class);
+    Flow<Integer, Integer, BoxedUnit> flow2 = Flow.of(Integer.class);
+
+    Promise<Option<Integer>> promise = null;
+
+
+    {
+      Graph<SourceShape<Integer>, BoxedUnit> graphSource = null;
+      Graph<SinkShape<Integer>, BoxedUnit> graphSink = null;
+      Graph<FlowShape<Integer, Integer>, BoxedUnit> graphFlow = null;
+
+      //#flow-wrap
+      Source<Integer, BoxedUnit> source = Source.fromGraph(graphSource);
+      Sink<Integer, BoxedUnit> sink = Sink.fromGraph(graphSink);
+      Flow<Integer, Integer, BoxedUnit> aflow = Flow.fromGraph(graphFlow);
+      Flow.fromSinkAndSource(Sink.<Integer>head(), Source.single(0));
+      Flow.fromSinkAndSourceMat(Sink.<Integer>head(), Source.single(0), Keep.left());
+      //#flow-wrap
+
+      Graph<BidiShape<Integer, Integer, Integer, Integer>, BoxedUnit> bidiGraph = null;
+
+      //#bidi-wrap
+      BidiFlow<Integer, Integer, Integer, Integer, BoxedUnit> bidiFlow =
+        BidiFlow.fromGraph(bidiGraph);
+      BidiFlow.fromFlows(flow1, flow2);
+      BidiFlow.fromFlowsMat(flow1, flow2, Keep.both());
+      //#bidi-wrap
+
+    }
+
+    {
+      //#graph-create
+      GraphDSL.create(builder -> {
+        //...
+        return ClosedShape.getInstance();
+      });
+
+      GraphDSL.create(builder -> {
+        //...
+        return new FlowShape<>(inlet, outlet);
+      });
+      //#graph-create
+    }
+
+    {
+      //#graph-create-2
+      GraphDSL.create(builder -> {
+        //...
+        return SourceShape.of(outlet);
+      });
+
+      GraphDSL.create(builder -> {
+        //...
+        return SinkShape.of(inlet);
+      });
+
+      GraphDSL.create(builder -> {
+        //...
+        return FlowShape.of(inlet, outlet);
+      });
+
+      GraphDSL.create(builder -> {
+        //...
+        return BidiShape.of(inlet1, outlet1, inlet2, outlet2);
+      });
+      //#graph-create-2
+    }
+
+    {
+      //#graph-builder
+      GraphDSL.create(builder -> {
+        builder.from(outlet).toInlet(inlet);
+        builder.from(outlet).via(builder.add(flow)).toInlet(inlet);
+        builder.from(builder.add(Source.single(0))).to(builder.add(Sink.head()));
+        //...
+        return ClosedShape.getInstance();
+      });
+      //#graph-builder
+    }
+
+    //#source-creators
+    Source<Integer, Promise<Option<Integer>>> src = Source.<Integer>maybe();
+    // Complete the promise with an empty option to emulate the old lazyEmpty
+    promise.trySuccess(scala.Option.empty());
+
+    final Source<String, Cancellable> ticks = Source.tick(
+      FiniteDuration.create(0, TimeUnit.MILLISECONDS),
+      FiniteDuration.create(200, TimeUnit.MILLISECONDS),
+      "tick");
+
+    final Source<Integer, BoxedUnit> pubSource =
+      Source.fromPublisher(TestPublisher.<Integer>manualProbe(true, sys));
+
+    final Source<Integer, BoxedUnit> futSource =
+      Source.fromFuture(Futures.successful(42));
+
+    final Source<Integer, Subscriber<Integer>> subSource =
+      Source.<Integer>asSubscriber();
+    //#source-creators
+
+    //#sink-creators
+    final Sink<Integer, BoxedUnit> subSink =
+      Sink.fromSubscriber(TestSubscriber.<Integer>manualProbe(sys));
+    //#sink-creators
+
+    //#sink-as-publisher
+    final Sink<Integer, Publisher<Integer>> pubSink =
+      Sink.<Integer>asPublisher(false);
+
+    final Sink<Integer, Publisher<Integer>> pubSinkFanout =
+      Sink.<Integer>asPublisher(true);
+    //#sink-as-publisher
+
+    //#empty-flow
+    Flow<Integer, Integer, BoxedUnit> emptyFlow = Flow.<Integer>create();
+    // or
+    Flow<Integer, Integer, BoxedUnit> emptyFlow2 = Flow.of(Integer.class);
+    //#empty-flow
+
+    //#flatMapConcat
+    Flow.<Source<Integer, BoxedUnit>>create().
+      <Integer, BoxedUnit>flatMapConcat(i -> i);
+    //#flatMapConcat
+
+    //#group-flatten
+    Flow.of(Integer.class)
+      .groupBy(2, in -> in % 2) // the first parameter sets max number of substreams
+      .map(subIn -> + 3)
+      .concatSubstreams();
+    //#group-flatten
+
+    final int maxDistinctWords = 1000;
+    //#group-fold
+    Flow.of(String.class)
+      .groupBy(maxDistinctWords, i -> i)
+      .fold(Pair.create("", 0), (pair, word) -> Pair.create(word, pair.second() + 1))
+      .mergeSubstreams();
+    //#group-fold
+
+    Uri uri = null;
+    //#raw-query
+    final akka.japi.Option<String> theRawQueryString = uri.rawQueryString();
+    //#raw-query
+
+    //#query-param
+    final akka.japi.Option<String> aQueryParam = uri.query().get("a");
+    //#query-param
+
+    //#file-source-sink
+    final Source<ByteString, Future<Long>> fileSrc =
+      FileIO.fromFile(new File("."));
+
+    final Source<ByteString, Future<Long>> otherFileSrc =
+      FileIO.fromFile(new File("."), 1024);
+
+    final Sink<ByteString, Future<Long>> fileSink =
+      FileIO.toFile(new File("."));
+    //#file-source-sink
+
+    //#input-output-stream-source-sink
+    final Source<ByteString, Future<java.lang.Long>> inputStreamSrc =
+      StreamConverters.fromInputStream((Creator<InputStream>) () -> new SomeInputStream());
+
+    final Source<ByteString, Future<java.lang.Long>> otherInputStreamSrc =
+      StreamConverters.fromInputStream((Creator<InputStream>) () -> new SomeInputStream(), 1024);
+
+    final Sink<ByteString, Future<java.lang.Long>> outputStreamSink =
+      StreamConverters.fromOutputStream((Creator<OutputStream>) () -> new SomeOutputStream());
+    //#input-output-stream-source-sink
+
+
+    //#output-input-stream-source-sink
+    final FiniteDuration timeout = FiniteDuration.Zero();
+
+    final Source<ByteString, OutputStream> outputStreamSrc =
+      StreamConverters.asOutputStream();
+
+    final Source<ByteString, OutputStream> otherOutputStreamSrc =
+      StreamConverters.asOutputStream(timeout);
+
+    final Sink<ByteString, InputStream> someInputStreamSink =
+      StreamConverters.asInputStream();
+
+    final Sink<ByteString, InputStream> someOtherInputStreamSink =
+      StreamConverters.asInputStream(timeout);
+    //#output-input-stream-source-sink
+
+  }
+
+}