* Gives Inlets and Outlets a `carbonCopy` method and switches to allocate them via `apply`
* Removes 4 Array allocations per FanIn and uses a bitmasked array instead
* Makes the FlattenStrategy.concat instance a singleton
- ActorProcessor terminated eagerly when ConcatAll had just taken up a
new input stream but not yet received onSubscribe for it
- The ActorProcessor eagerly shuts itself down upon onError and that
cannot be changed without completely reworking the Pump, so I opted
for just tracking the outstanding substreamSubscribers that have not
yet seen OnSubscribe and making them cancel properly when that arrives
(possibly later).
* found one bug of too early actor stop and thereby missing cancel of upstream,
in fan-in tests ""work with one immediately failed and one nonempty publisher"
These are synchronous implementations, because we need to be Java 6
compatible while developing on 2.3.x. However asynchronous
implementations using AsynchronousFileChannel will come soon for JDK7
users.
+ ActorPublisher/Subscriber now manage stopping of the actor
+ added documentation on configuring dispatcher for File IO
+ properly handle if source file does not exist
+ file sink / source come with default io dispatcher
> verified no actors are leaking
> exceptions are caught and onErrored properly
+ moved files to akka.stream.io
+ Added OutputStreamSink and InputStreamSource
* Remove optional attributes parameter in favor of withAttributes
* Overload explosion when trying to add attributes to ZipWith.
* Aligned with Flow and Source.
* Remove name parameter (no overloads), naming is performed using `.withAttributes` or the new
convenience `.named`. Those adds the OperationAttribute.Name and also change the name of the
shape Inlet and Outlet.
* Remove Source/Sink parameter list for 0 parameter methods,
this allows usage of `Sink.head` instead of `Sink.head()`
Changed rules:
* 1.9 Always onSubscribe prior to any other signals
* 1.9 NullPointerException if subscriber is null
* 3.17 Long overflow, effectively unbounded instead of onError
Fixed some more things:
* fixed some FIXME
* Long drop and take
* memory leaks in tck tests, use BeforeClass to create ActorSystem
use AfterClass to shutdown ActorSystem
* more tck tests
* don't emit OnComplete when substream is cancelled
* work around for memory leak in PrefixAndTail
* add supervion for stages and built in ops run by interpreter
* add supervision for mapAsync and mapAsyncUnordered
* add supervision to groupBy and splitWhen
* reference doc for scala and java
* FlowMaterializer is now the actor independent interface
* ActorFlowMaterializer is the actor based interface
* MaterializerSettings renamed to ActorFlowMaterializerSettings
* impl.ActorBasedFlowMaterializer renamed to impl.ActorFlowMaterializerImpl
* Optimizations included in ActorFlowMaterializerSettings
* Note that http is using FlowMaterializer in api, but I suspect that it
will currently only run with a ActorFlowMaterializer
* StreamTcp and Http extensions now return Flows and Sources that can be materialized later
* Flow can now be completed with another flow to be turned into a runnable flow
- Switches from using size-of-1/2 Vectors to using Lists
- Fixes an issue where processorForNode wouldn't use the dispatcher form the settings
- Adds a dedicated Collect fusion op
- Adds various simplifications to ActorBasedFlowMaterializer
- Adds FIXMEs where appropriate
- Switches `grouped` to use a VectorBuilder
- Adds support for `scan`
- ActorBasedFlowMaterializer now uses Iterator instead of head+tail decomp on Seqs
- Identity and Completed Transformers are now cached
- Adds dedicated AstNodes for all combinators
- Adds a hook-in point for fusion in `ActorBasedFlowMaterializer`
- Adds support for `Operate` an AstNode with a function that create a fusing.Op
- Adds experimental and slow optimizer as a PoC
- Adds verification that Ast.Fused does not exist in optimizer input
* Fold Tap/Drain into Source/Sink
* Create Source/Sink helpers to create all Sources/Sinks
* Make concrete Source/Sink implementations private[scaladsl2]
* runWith(drainWithKey) and runWith(tapWithKey) returning the
materialized drain/tap
* remove toPublisher, toSubscriber, and friends, in favor of using
runWith
* MaterializedMap is the return type for both flow and graph
* Source[T] return type for Source.apply methods
* Cleaned up type signatures
* Changed names of Source/Sink/ProcessorFlow to Tap/Drain/Pipe
* Introduced new Source/Sink/Flow
* Made all Pipe types package private
* Changed the TypeGraph DSL to work on Flow/Sink/Source
