* Remove unused parameter to example class AckingReceiver
* Update description of Source.actorRef to match the current API design (since 2.6.0)
* Improve the description of what happens after the Actor receives a completion request
* More accurate wording.
* Operator docs: examples for asSource/FlowWithContext
* javafmtAll
* Try to capture the essence better
* Update index
* Include the test use in the snippets
* Adding example for collection operator
* Modifying example
* Add parenthesises to side effect only method
Co-authored-by: Johan Andrén <johan@markatta.com>
* To avoid head of line blocking from serialization and transfer of large messages
this can be enabled.
* ProducerController setting to chunk messages
* split up large messages in chunks in ProducerController
and assemble again in ConsumerController
* serialization moved to these actors instead of in the Artery stream
* other messages (for other actors) can interleave with the chunks
* serializer for ChunkedMessage in SequencedMessage and MessageSent
* cleanup partially stored chunked messages
* reference docs
* mima filters
* additional test for sending the Request after half window size
* enforce that chunk-large-messages=off for sharding and work-pulling
Fixes#28769
Use case for this is if you have a sequence of elements that has been
partitioned across multiple streams, and you want to merge them back
together in order. It will typically be used in combination with
`zipWithIndex` to define the index for the sequence, followed by a
`Partition`, followed by the processing of different substreams with
different flows (each flow emitting exactly one output for each input),
and then merging with this stage, using the index from `zipWithIndex`.
A more concrete use case is if you're consuming messages from a message
broker, and you have a flow that you wish to apply to some messages, but
not others, you can partition the message stream according to which
should be processed by the flow and which should bypass it, and then
bring the elements back together acknowledgement. If an ordinary merge
was used rather than this, the messages that bypass the processing flow
would likely overtake the messages going through the processing flow,
and the result would be out of order offset acknowledgement which would
lead to dropping messages on failure.
I've included a minimal version of the above example in the documentation.
