fr33m0nk.akka.stream — net.clojars.fr33m0nk/clj-alpakka-kafka 0.1.2

create-flow clj

(create-flow)

draining-substream-cancel-strategy clj

flow-from-function clj

(flow-from-function f)

flow-from-graph clj

(flow-from-graph graph)

flow-from-materializer clj

(flow-from-materializer f)

flow-from-sink-and-source clj

(flow-from-sink-and-source sink source)

IStreamOperations clj protocol

reduce clj

(reduce source-or-flow reducer-fn)

Start with first element and then apply the current and next value to the given function, when upstream complete the current value is emitted downstream. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/reduce.html

concat-lazy clj

(concat-lazy source-or-flow stream)

After completion of the original upstream the elements of the given source will be emitted. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/concatLazy.html

take clj

(take source-or-flow n)

Pass n incoming elements downstream and then complete https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/take.html

map clj

(map source-or-flow mapping-fn)

Transform each element in the stream by calling a mapping function with it and passing the returned value downstream https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/map.html

run-with clj

(run-with source-or-flow source sink materializer-or-actor-system)

mapcat clj

(mapcat source-or-flow mapping-fn)

Transform each element into zero or more elements that are individually passed downstream https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/mapConcat.html

to clj

(to source-or-flow sink)

to-mat clj

(to-mat source-or-flow sink combiner-fn)

map-async clj

(map-async source-or-flow parallelism mapping-fn)

(map-async source-or-flow parallelism mapping-fn then-fn)

Pass incoming elements to a function that return a CompletionStage result https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/mapAsync.html

take-while clj

(take-while source-or-flow pred?)

(take-while source-or-flow pred? inclusive?)

Pass elements downstream as long as a predicate function returns true and then complete. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/takeWhile.html

grouped clj

(grouped source-or-flow size)

Accumulate incoming events until the specified number of elements have been accumulated and then pass the collection of elements downstream. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/grouped.html

map-materialized-value clj

(map-materialized-value source-or-flow mapping-fn)

run clj

(run source-or-flow actor-system)

flatmap-merge clj

(flatmap-merge source-or-flow breadth mapping-fn)

Transform each input element into a Source whose elements are then flattened into the output stream through merging. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/flatMapMerge.html

split-when clj

(split-when source-or-flow pred?)

(split-when source-or-flow substream-cancel-strategy pred?)

Split off elements into a new substream whenever a predicate function return true. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/splitWhen.html

via-mat clj

(via-mat source-or-flow flow combiner-fn)

concat-all-lazy clj

(concat-all-lazy source-or-flow streams)

After completion of the original upstream the elements of the given sources will be emitted sequentially https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/concatAllLazy.html

group-by clj

(group-by source-or-flow max-substreams grouping-fn)

(group-by source-or-flow
          max-substreams
          grouping-fn
          allow-closed-substream-recreation?)

Demultiplex the incoming stream into separate output streams. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/groupBy.html

concat clj

(concat source-or-flow stream)

After completion of the original upstream the elements of the given source will be emitted. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/concat.html

via clj

(via source-or-flow flow)

sliding clj

(sliding source-or-flow count step-size)

Provide a sliding window over the incoming stream and pass the windows as groups of elements downstream. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/sliding.html

drop clj

(drop source-or-flow n)

Drop n elements and then pass any subsequent element downstream. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/drop.html

fold clj

(fold source-or-flow zero-value fold-fn)

Start with current value zero and then apply the current and next value to the given function. When upstream completes, the current value is emitted downstream. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/fold.html

merge clj

(merge source-or-flow stream)

(merge source-or-flow stream eager-complete?)

Merge multiple sources. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/merge.html

map-async-unordered clj

(map-async-unordered source-or-flow parallelism mapping-fn)

(map-async-unordered source-or-flow parallelism mapping-fn then-fn)

Like mapAsync but CompletionStage results are passed downstream as they arrive regardless of the order of the elements that triggered them https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/mapAsyncUnordered.html

merge-all clj

(merge-all source-or-flow streams eager-complete?)

Merge multiple sources. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/mergeAll.html

filter clj

(filter source-or-flow pred?)

Filter the incoming elements using a predicate. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/filter.html

split-after clj

(split-after source-or-flow pred?)

(split-after source-or-flow substream-cancel-strategy pred?)

End the current substream whenever a predicate returns true, starting a new substream for the next element. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/splitAfter.html

flatmap-concat clj

(flatmap-concat source-or-flow mapping-fn)

Transform each input element into a Source whose elements are then flattened into the output stream through concatenation https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/flatMapConcat.html

fold-async clj

(fold-async source-or-flow zero-value fold-fn)

(fold-async source-or-flow zero-value fold-fn then-fn)

Just like fold but receives a function that results in a CompletionStage to the next value. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/foldAsync.html

drop-while clj

(drop-while source-or-flow pred?)

Drop elements as long as a predicate function return true for the element https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/dropWhile.html

map-async-partitioned clj

(map-async-partitioned source-or-flow
                       parallelism
                       per-partition-count
                       partitioner-fn
                       bi-mapper-fn)

Pass incoming elements to a function that extracts a partitioning key from the element, then to a function that returns a CompletionStage result, bounding the number of incomplete CompletionStages per partitioning key. https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/mapAsyncPartitioned.html

filter-falsy clj

(filter-falsy source-or-flow pred?)

Filter the incoming elements using a predicate https://doc.akka.io/docs/akka/current/stream/operators/Source-or-Flow/filterNot.html

ISubStreamOperations clj protocol

also-to-all clj

(also-to-all sub-source-or-flow streams)

concat-substreams clj

(concat-substreams sub-source-or-flow)

merge-substreams clj

(merge-substreams sub-source-or-flow)

merge-substreams-with-parallelism clj

(merge-substreams-with-parallelism sub-source-or-flow parallelism)

propagate-substream-cancel-strategy clj

source-from-graph clj

(source-from-graph graph)

source-from-materializer clj

(source-from-materializer f)