!str #18692 javadsl.FlowGraph.Builder.add()

* also make factories more consistent by only offering
  FlowGraph.create()
* also remove secondary (edge-based) FlowGraph.Builder DSL
* also improve naming for conversions from Graph to
  Source/Flow/BidiFlow/Sink

akka-docs-dev/rst/java/stream-composition.rst

@@ -126,8 +126,8 @@ As a first example, let's look at a more complex layout:
 
 The diagram shows a :class:`RunnableGraph` (remember, if there are no unwired ports, the graph is closed, and therefore
 can be materialized) that encapsulates a non-trivial stream processing network. It contains fan-in, fan-out stages,
-directed and non-directed cycles. The ``closed()`` method of the :class:`FlowGraph` factory object allows the creation of a
-general closed graph. For example the network on the diagram can be realized like this:
+directed and non-directed cycles. The ``runnable()`` method of the :class:`FlowGraph` factory object allows the creation of a
+general, closed, and runnable graph. For example the network on the diagram can be realized like this:
 
 .. includecode:: ../../../akka-samples/akka-docs-java-lambda/src/test/java/docs/stream/CompositionDocTest.java#complex-graph
 
@@ -140,7 +140,7 @@ It is possible to refer to the ports, so another version might look like this:
 
 Similar to the case in the first section, so far we have not considered modularity. We created a complex graph, but
 the layout is flat, not modularized. We will modify our example, and create a reusable component with the graph DSL.
-The way to do it is to use the ``partial()`` method on :class:`FlowGraph` factory. If we remove the sources and sinks
+The way to do it is to use the ``create()`` method on :class:`FlowGraph` factory. If we remove the sources and sinks
 from the previous example, what remains is a partial graph:
 
 |
@@ -283,7 +283,7 @@ Attributes
 ----------
 
 We have seen that we can use ``named()`` to introduce a nesting level in the fluid DSL (and also explicit nesting by using
-``partial()`` from :class:`FlowGraph`). Apart from having the effect of adding a nesting level, ``named()`` is actually
+``create()`` from :class:`FlowGraph`). Apart from having the effect of adding a nesting level, ``named()`` is actually
 a shorthand for calling ``withAttributes(Attributes.name("someName"))``. Attributes provide a way to fine-tune certain
 aspects of the materialized running entity. For example buffer sizes can be controlled via attributes (see
 :ref:`stream-buffers-scala`). When it comes to hierarchic composition, attributes are inherited by nested modules,

akka-docs-dev/rst/java/stream-graphs.rst

@@ -85,8 +85,8 @@ Constructing and combining Partial Flow Graphs
 Sometimes it is not possible (or needed) to construct the entire computation graph in one place, but instead construct
 all of its different phases in different places and in the end connect them all into a complete graph and run it.
 
-This can be achieved using ``FlowGraph.factory().partial()`` instead of
-``FlowGraph.factory().closed()``, which will return a ``Graph`` instead of a
+This can be achieved using ``FlowGraph.create()`` instead of
+``FlowGraph.runnable()``, which will return a ``Graph`` instead of a
 ``RunnableGraph``.  The reason of representing it as a different type is that a
 :class:`RunnableGraph` requires all ports to be connected, and if they are not
 it will throw an exception at construction time, which helps to avoid simple

akka-docs-dev/rst/java/stream-quickstart.rst

@@ -119,7 +119,7 @@ detail in :ref:`constructing-sources-sinks-flows-from-partial-graphs-java`. Flow
 .. includecode:: ../../../akka-samples/akka-docs-java-lambda/src/test/java/docs/stream/TwitterStreamQuickstartDocTest.java#flow-graph-broadcast
 
 As you can see, we use graph builder ``b`` to construct the graph using ``UniformFanOutShape`` and ``Flow``s. Once we have the
-FlowGraph as a result of ``closed()`` method *it is immutable, thread-safe, and freely shareable*. A graph can be ``run()`` directly -
+FlowGraph as a result of ``runnable()`` method *it is immutable, thread-safe, and freely shareable*. A graph can be ``run()`` directly -
 assuming all ports (sinks/sources) within a flow have been connected properly. It is possible also to construct several :class:`PartialFlowGraph`s and
 and then combine them into one fully connected graph. This will be covered in detail in :ref:`partial-flow-graph-java`.