raboof/pekko
1
0
Fork 0
Code Issues Pull requests Projects Releases 6 Packages Wiki Activity Actions 10

add statefulMapConcat to overview and fix links

Browse source
This commit is contained in:
Roland Kuhn 2016-02-15 13:03:47 +01:00
parent a83f08d4ab
commit d1b35e441e
13 changed files with 529 additions and 462 deletions
Download patch file Download diff file Expand all files Collapse all files

441
akka-docs/rst/java/stream/stages-overview.rst
View file

File diff suppressed because it is too large Load diff

6
akka-docs/rst/java/stream/stream-cookbook.rst
View file

@ -16,7 +16,7 @@ This part also serves as supplementary material for the main body of documentati
open while reading the manual and look for examples demonstrating various streaming concepts
as they appear in the main body of documentation.
If you need a quick reference of the available processing stages used in the recipes see :ref:`stages-overview`.
If you need a quick reference of the available processing stages used in the recipes see :ref:`stages-overview_java`.
Working with Flows
==================
@ -63,11 +63,11 @@ The function ``limit`` or ``take`` should always be used in conjunction in order
For example, this is best avoided:
.. includecode:: ../../../akka-samples/akka-docs-java-lambda/src/test/java/docs/stream/cookbook/RecipeSeq.java#draining-to-list-unsafe
.. includecode:: ../code/docs/stream/javadsl/cookbook/RecipeSeq.java#draining-to-list-unsafe
Rather, use ``limit`` or ``take`` to ensure that the resulting ``List`` will contain only up to ``MAX_ALLOWED_SIZE`` elements:
.. includecode:: ../../../akka-samples/akka-docs-java-lambda/src/test/java/docs/stream/cookbook/RecipeSeq.java#draining-to-list-safe
.. includecode:: ../code/docs/stream/javadsl/cookbook/RecipeSeq.java#draining-to-list-safe
Calculating the digest of a ByteString stream
---------------------------------------------

2
akka-docs/rst/java/stream/stream-flows-and-basics.rst
View file

@ -38,7 +38,7 @@ Processing Stage
The common name for all building blocks that build up a Graph.
Examples of a processing stage would be operations like ``map()``, ``filter()``, stages added by ``transform()`` like
:class:`PushStage`, :class:`PushPullStage`, :class:`StatefulStage` and graph junctions like ``Merge`` or ``Broadcast``.
For the full list of built-in processing stages see :ref:`stages-overview`
For the full list of built-in processing stages see :ref:`stages-overview_java`
When we talk about *asynchronous, non-blocking backpressure* we mean that the processing stages available in Akka
Streams will not use blocking calls but asynchronous message passing to exchange messages between each other, and they

2
akka-docs/rst/java/stream/stream-graphs.rst
View file

@ -24,7 +24,7 @@ Graphs are built from simple Flows which serve as the linear connections within
which serve as fan-in and fan-out points for Flows. Thanks to the junctions having meaningful types based on their behaviour
and making them explicit elements these elements should be rather straightforward to use.
Akka Streams currently provide these junctions (for a detailed list see :ref:`stages-overview`):
Akka Streams currently provide these junctions (for a detailed list see :ref:`stages-overview_java`):
* **Fan-out**

2
akka-docs/rst/java/stream/stream-introduction.rst
View file

@ -79,7 +79,7 @@ and for best results we recommend the following approach:
* The bottom-up learners may feel more at home rummaging through the
:ref:`stream-cookbook-java`.
* For a complete overview of the built-in processing stages you can look at the
table in :ref:`stages-overview`
table in :ref:`stages-overview_java`
* The other sections can be read sequentially or as needed during the previous
steps, each digging deeper into specific topics.