public interface ReactiveStream<T> extends LazyStream<T>, org.reactivestreams.Publisher<T>, com.aol.cyclops.sequence.reactivestreams.ReactiveStreamsTerminalOperations<T>
LazyStream.Empty<T>, LazyStream.LazyCons<T>javaslang.collection.Stream.Cons<T>serialVersionUID| Modifier and Type | Method and Description |
|---|---|
default ReactiveStream<T> |
append(T... elements) |
default ReactiveStream<T> |
append(T element) |
default ReactiveStream<T> |
appendAll(java.lang.Iterable<? extends T> elements) |
default <R> com.aol.simple.react.stream.traits.LazyFutureStream<R> |
asyncMap(com.aol.simple.react.stream.lazy.LazyReact react,
java.util.function.Function<? super T,? extends R> fn)
fan out operators
|
default <R> com.aol.simple.react.stream.traits.LazyFutureStream<R> |
asyncRetry(com.aol.simple.react.stream.lazy.LazyReact react,
java.util.function.Function<? super T,? extends R> fn) |
default <U> ReactiveStream<U> |
cast(java.lang.Class<U> type) |
default ReactiveStream<T> |
clear() |
default ReactiveStream<javaslang.collection.Stream<T>> |
combinations() |
default ReactiveStream<javaslang.collection.Stream<T>> |
combinations(int k) |
static <T> ReactiveStream<T> |
cons(java.util.function.Supplier<T> head,
java.util.function.Supplier<? extends LazyStream<? extends T>> tailSupplier)
Constructs a ReactiveStream of a head element and a tail supplier.
|
default ReactiveStream<javaslang.Tuple2<T,T>> |
crossProduct() |
default ReactiveStream<javaslang.collection.Stream<T>> |
crossProduct(int power) |
default <U> ReactiveStream<javaslang.Tuple2<T,U>> |
crossProduct(java.lang.Iterable<? extends U> that) |
default ReactiveStream<T> |
cycle()
Create a new Stream that infiniteable cycles the provided Stream
|
default ReactiveStream<T> |
cycle(int times) |
default ReactiveStream<T> |
cycleUntil(LazyStream<T> stream,
java.util.function.Predicate<? super T> predicate)
Repeat in a Stream until specified predicate holds
|
default ReactiveStream<T> |
cycleWhile(java.util.function.Predicate<? super T> predicate)
Repeat in a Stream while specified predicate holds
|
default ReactiveStream<T> |
debounce(long time,
java.util.concurrent.TimeUnit t)
time based operations
|
default ReactiveStream<T> |
distinct() |
default ReactiveStream<T> |
distinctBy(java.util.Comparator<? super T> comparator) |
default <U> ReactiveStream<T> |
distinctBy(java.util.function.Function<? super T,? extends U> keyExtractor) |
default ReactiveStream<T> |
drop(long n) |
default ReactiveStream<T> |
drop(long time,
java.util.concurrent.TimeUnit unit) |
default ReactiveStream<T> |
dropRight(long n) |
default ReactiveStream<T> |
dropWhile(java.util.function.Predicate<? super T> predicate) |
default ReactiveStream<javaslang.Tuple2<T,java.lang.Long>> |
elapsed()
ReactiveStream.of(1,2,3,4,5)
.elapsed()
.forEach(System.out::println);
|
static <T> ReactiveStream<T> |
empty()
Returns the single instance of Nil.
|
default ReactiveStream<T> |
filter(java.util.function.Predicate<? super T> predicate) |
default ReactiveStream<T> |
fixedDelay(long time,
java.util.concurrent.TimeUnit unit) |
default <U> ReactiveStream<U> |
flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends U>> mapper) |
default <U> ReactiveStream<U> |
flatten() |
default T |
foldRight(com.aol.cyclops.sequence.Monoid<T> reducer) |
default <U> U |
foldRight2(U zero,
java.util.function.BiFunction<? super U,? super T,? extends U> f) |
<R1,R> ReactiveStream<R> |
forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the
supplied stream
|
<R1,R> ReactiveStream<R> |
forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
Perform a two level nested internal iteration over this Stream and the
supplied stream
|
<R1,R2,R> ReactiveStream<R> |
forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.lang.Iterable<R2>>> stream2,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the
supplied streams
|
<R1,R2,R> ReactiveStream<R> |
forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1,
java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.lang.Iterable<R2>>> stream2,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction,
java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
Perform a three level nested internal iteration over this Stream and the
supplied streams
|
static ReactiveStream<java.lang.Integer> |
from(int value)
Returns an infinitely long Stream of int values starting from
from. |
static ReactiveStream<java.lang.Long> |
from(long value)
Returns an infinitely long Stream of long values starting from
from. |
static <T> ReactiveStream<T> |
fromAnyM(com.aol.cyclops.monad.AnyM<T> stream) |
static <T> ReactiveStream<T> |
fromAsyncQueue(com.aol.simple.react.async.Queue<T> q) |
static <T> ReactiveStream<T> |
fromIterable(java.lang.Iterable<T> stream) |
static <T> ReactiveStream<T> |
fromIterator(java.util.Iterator<T> it) |
static <T> ReactiveStream<T> |
fromJDK(java.util.stream.BaseStream<T,? extends java.util.stream.BaseStream<T,?>> stream) |
static <T> ReactiveStream<T> |
fromStream(javaslang.collection.Stream<T> stream) |
static <T> ReactiveStream<T> |
fromStreamable(com.aol.cyclops.sequence.streamable.Streamable<T> stream) |
default com.aol.cyclops.sequence.future.FutureOperations<T> |
futureOperations(java.util.concurrent.Executor ex)
async execution
|
static <T> ReactiveStream<T> |
generate(java.util.function.Supplier<T> gen) |
default <C> javaslang.collection.Map<C,? extends ReactiveStream<T>> |
groupByReactive(java.util.function.Function<? super T,? extends C> classifier) |
default JavaslangHotStream<T> |
hotStream(java.util.concurrent.Executor ex) |
default ReactiveStream<T> |
init() |
default javaslang.control.Option<? extends ReactiveStream<T>> |
initOptionReactive() |
default ReactiveStream<T> |
insert(int index,
T element) |
default ReactiveStream<T> |
insertAll(int index,
java.lang.Iterable<? extends T> elements) |
default ReactiveStream<T> |
intersperse(T element) |
static <T> ReactiveStream<T> |
iterate(T seed,
java.util.function.Function<? super T,? extends T> gen) |
default javaslang.collection.Iterator<T> |
iterator()
An iterator by means of head() and tail().
|
default ReactiveStream<T> |
jitter(long jitterInNanos) |
default <U> ReactiveStream<U> |
map(java.util.function.Function<? super T,? extends U> mapper) |
default <R> R |
mapReduce(java.util.function.Function<? super T,? extends R> mapper,
com.aol.cyclops.sequence.Monoid<R> reducer)
Attempt to map this Monad to the same type as the supplied Monoid, using
supplied function Then use Monoid to reduce values
|
default <R> R |
mapReduce(com.aol.cyclops.sequence.Monoid<R> reducer)
Attempt to map this Monad to the same type as the supplied Monoid (using
mapToType on the monoid interface) Then use Monoid to reduce values
|
static <T> ReactiveStream<T> |
of(T... values)
Returns a singleton
Stream, i.e. |
default <U> ReactiveStream<U> |
ofType(java.lang.Class<U> type) |
default ReactiveStream<T> |
onEmpty(T value) |
default ReactiveStream<T> |
onEmptyGet(java.util.function.Supplier<T> supplier) |
default ReactiveStream<T> |
onEmptySwitch(java.util.function.Supplier<LazyStream<T>> switchTo)
If this SequenceM is empty replace it with a another Stream
|
default <X extends java.lang.Throwable> |
onEmptyThrow(java.util.function.Supplier<X> supplier) |
default ReactiveStream<T> |
onePer(long time,
java.util.concurrent.TimeUnit t) |
default ReactiveStream<T> |
padTo(int length,
T element) |
default javaslang.Tuple2<? extends ReactiveStream<T>,? extends ReactiveStream<T>> |
partitionReactive(java.util.function.Predicate<? super T> predicate) |
default ReactiveStream<T> |
patch(int from,
java.lang.Iterable<? extends T> that,
int replaced) |
default JavaslangHotStream<T> |
pausedHotStream(java.util.concurrent.Executor ex) |
default ReactiveStream<T> |
peek(java.util.function.Consumer<? super T> action) |
default ReactiveStream<javaslang.collection.Stream<T>> |
permutations() |
default ReactiveStream<T> |
prepend(T... elements) |
default ReactiveStream<T> |
prepend(T element) |
default ReactiveStream<T> |
prependAll(java.lang.Iterable<? extends T> elements) |
static ReactiveStream<java.lang.Integer> |
range(int start,
int end)
Creates a Stream of int numbers starting from
from, extending to toExclusive - 1. |
static ReactiveStream<java.lang.Long> |
range(long start,
long end)
Creates a Stream of long numbers starting from
from, extending to toExclusive - 1. |
default <EX extends java.lang.Throwable> |
recover(java.lang.Class<EX> type,
java.util.function.Function<EX,? extends T> fn) |
default ReactiveStream<T> |
recover(java.util.function.Function<java.lang.Throwable,? extends T> fn) |
default javaslang.collection.List<T> |
reduce(LazyStream<com.aol.cyclops.sequence.Monoid<T>> reducers)
Simultanously reduce a stream with multiple reducers
|
default T |
reduce(com.aol.cyclops.sequence.Monoid<T> reducer) |
default ReactiveStream<T> |
remove(T element) |
default ReactiveStream<T> |
removeAll(java.lang.Iterable<? extends T> elements) |
default ReactiveStream<T> |
removeAll(T element) |
default ReactiveStream<T> |
removeAt(int index) |
default ReactiveStream<T> |
removeBetween(int start,
int end) |
default ReactiveStream<T> |
removeFirst(java.util.function.Predicate<T> predicate) |
default ReactiveStream<T> |
removeLast(java.util.function.Predicate<T> predicate) |
default ReactiveStream<T> |
replace(T currentElement,
T newElement) |
default ReactiveStream<T> |
replaceAll(T currentElement,
T newElement) |
default ReactiveStream<T> |
retainAll(java.lang.Iterable<? extends T> elements) |
default <R> ReactiveStream<R> |
retry(java.util.function.Function<? super T,? extends R> fn) |
default ReactiveStream<T> |
reverse() |
default ReactiveStream<T> |
scanLeft(com.aol.cyclops.sequence.Monoid<T> monoid)
Scan left using supplied Monoid
|
default <U> ReactiveStream<U> |
scanLeft(U identity,
java.util.function.BiFunction<? super U,? super T,? extends U> combiner) |
default ReactiveStream<T> |
scanRight(com.aol.cyclops.sequence.Monoid<T> monoid) |
default <U> LazyStream<U> |
scanRight(U identity,
java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
scanLeft & scanRight
|
default JavaslangHotStream<T> |
schedule(java.lang.String cron,
java.util.concurrent.ScheduledExecutorService ex)
Execute this Stream on a schedule
|
default JavaslangHotStream<T> |
scheduleFixedDelay(long delay,
java.util.concurrent.ScheduledExecutorService ex)
Execute this Stream on a schedule
|
default JavaslangHotStream<T> |
scheduleFixedRate(long rate,
java.util.concurrent.ScheduledExecutorService ex)
Execute this Stream on a schedule
|
default T |
single()
//1
SequenceM.of(1).single();
//UnsupportedOperationException
SequenceM.of().single();
//UnsupportedOperationException
SequenceM.of(1,2,3).single();
|
default T |
single(java.util.function.Predicate<? super T> predicate) |
default javaslang.control.Option<T> |
singleOption()
//Some[1]
ReactiveStream.of(1).singleOption();
//None
ReactiveStream.of().singleOpion();
//None
ReactiveStream.of(1,2,3).singleOption();
|
default ReactiveStream<T> |
slice(long beginIndex,
long endIndex) |
default ReactiveStream<ReactiveStream<T>> |
slidingWindow(int windowSize) |
default ReactiveStream<ReactiveStream<T>> |
slidingWindow(int windowSize,
int increment)
batching & windowing
|
default ReactiveStream<T> |
sort() |
default ReactiveStream<T> |
sort(java.util.Comparator<? super T> comparator) |
default <U> ReactiveStream<T> |
sortBy(java.util.Comparator<? super U> comparator,
java.util.function.Function<? super T,? extends U> mapper) |
default <U extends java.lang.Comparable<? super U>> |
sortBy(java.util.function.Function<? super T,? extends U> mapper) |
default javaslang.Tuple2<? extends ReactiveStream<T>,? extends ReactiveStream<T>> |
spanReactive(java.util.function.Predicate<? super T> predicate) |
default javaslang.Tuple2<? extends ReactiveStream<T>,? extends ReactiveStream<T>> |
splitAtInclusiveReactive(java.util.function.Predicate<? super T> predicate) |
default javaslang.Tuple2<? extends ReactiveStream<T>,? extends ReactiveStream<T>> |
splitAtReactive(int n) |
default javaslang.Tuple2<? extends ReactiveStream<T>,? extends ReactiveStream<T>> |
splitAtReactive(java.util.function.Predicate<? super T> predicate) |
default void |
subscribe(org.reactivestreams.Subscriber<? super T> s)
subscribe
|
default void |
subscribeAsync(java.util.concurrent.Executor ex,
org.reactivestreams.Subscriber<? super T> s) |
static <T> JavaslangReactiveStreamsSubscriber<T> |
subscriber() |
default ReactiveStream<T> |
subSequence(int beginIndex) |
default ReactiveStream<T> |
subSequence(int beginIndex,
int endIndex) |
default ReactiveStream<T> |
subStream(int start,
int end)
Return a Stream with elements before the provided start index removed, and elements after the provided
end index removed
|
default ReactiveStream<T> |
tail() |
default javaslang.control.Option<? extends ReactiveStream<T>> |
tailOptionReactive() |
default ReactiveStream<T> |
take(long n) |
default ReactiveStream<T> |
take(long time,
java.util.concurrent.TimeUnit unit)
take & drop
|
default ReactiveStream<T> |
takeRight(long n) |
default ReactiveStream<T> |
takeUntil(java.util.function.Predicate<? super T> predicate) |
default ReactiveStream<T> |
takeWhile(java.util.function.Predicate<? super T> predicate) |
default ReactiveStream<javaslang.Tuple2<T,java.lang.Long>> |
timestamp()
ReactiveStream.of(1,2,3,4,5)
.timestamp()
.forEach(System.out::println)
|
default <R> ReactiveStream<R> |
trampoline(java.util.function.Function<? super T,? extends com.aol.cyclops.trampoline.Trampoline<? extends R>> mapper) |
default <U> ReactiveStream<U> |
unit(java.lang.Iterable<? extends U> iterable) |
default <T1,T2,T3> javaslang.Tuple3<? extends ReactiveStream<T1>,? extends ReactiveStream<T2>,? extends ReactiveStream<T3>> |
unzip3Reactive(java.util.function.Function<? super T,javaslang.Tuple3<? extends T1,? extends T2,? extends T3>> unzipper) |
default <T1,T2> javaslang.Tuple2<? extends ReactiveStream<T1>,? extends ReactiveStream<T2>> |
unzipReactive(java.util.function.Function<? super T,javaslang.Tuple2<? extends T1,? extends T2>> unzipper) |
default ReactiveStream<T> |
update(int index,
T element) |
default ReactiveStream<ReactiveStream<T>> |
windowBySize(int size) |
default ReactiveStream<ReactiveStream<T>> |
windowBySizeAndTime(int size,
long time,
java.util.concurrent.TimeUnit t) |
default ReactiveStream<ReactiveStream<T>> |
windowByTime(long time,
java.util.concurrent.TimeUnit t) |
default ReactiveStream<ReactiveStream<T>> |
windowStatefullyWhile(java.util.function.BiPredicate<com.aol.cyclops.sequence.streamable.Streamable<? super T>,? super T> predicate) |
default ReactiveStream<ReactiveStream<T>> |
windowUntil(java.util.function.Predicate<? super T> predicate) |
default ReactiveStream<ReactiveStream<T>> |
windowWhile(java.util.function.Predicate<? super T> predicate) |
default boolean |
xMatch(int num,
java.util.function.Predicate<? super T> c)
Check that there are specified number of matches of predicate in the Stream
|
default ReactiveStream<T> |
xPer(int x,
long time,
java.util.concurrent.TimeUnit t) |
default <U> ReactiveStream<javaslang.Tuple2<T,U>> |
zip(java.lang.Iterable<U> that) |
default <U> ReactiveStream<javaslang.Tuple2<T,U>> |
zipAll(java.lang.Iterable<U> that,
T thisElem,
U thatElem) |
default <S,R> LazyStream<R> |
zipAnyM(com.aol.cyclops.monad.AnyM<? extends S> second,
java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
Generic zip function.
|
default ReactiveStream<javaslang.Tuple2<T,java.lang.Long>> |
zipWithIndex() |
anyM, appendSelf, collect, collect, collectable, collector, dropUntil, fill, futures, futures, futureStream, futureStream, gen, gen, get, groupBy, grouped, hasDefiniteSize, headOption, indexOf, initOption, isTraversableAgain, lastIndexOf, lazyHead, length, match, ofAll, ofAll, ofAll, ofAll, ofAll, ofAll, ofAll, ofAll, ofAll, partition, range, rangeBy, rangeBy, rangeBy, rangeBy, rangeClosed, rangeClosed, rangeClosed, rangeClosedBy, rangeClosedBy, rangeClosedBy, rangeClosedBy, repeat, scan, seq, sequenceM, sliding, sliding, span, splitAt, splitAt, splitAtInclusive, spliterator, stream, streamable, stringPrefix, tabulate, tailOption, toAsyncBlockingQueue, toAsyncQueue, toAsyncQueue, toCollection, toStream, toTraversable, unzip, unzip3indexWhere, lastIndexOfSlice, lastIndexWhere, reverseIterator, segmentLengthapply, containsSlice, endsWith, foldRight, indexOf, indexOfSlice, indexOfSlice, indexWhere, iterator, lastIndexOf, lastIndexOfSlice, lastIndexWhere, prefixLength, startsWith, startsWith, transformaverage, containsAll, count, existsUnique, find, findLast, foldLeft, get, hash, head, isEmpty, isSingleValued, last, lastOption, max, maxBy, maxBy, min, minBy, minBy, mkString, mkString, mkString, product, reduceLeft, reduceLeftOption, reduceRight, reduceRightOption, size, sumcontains, corresponds, eq, equals, exists, forAll, forEach, getOption, getOrElse, getOrElse, getOrElseThrow, getOrElseTry, hashCode, isDefined, out, out, stderr, stdout, toArray, toCharSeq, toJavaArray, toJavaArray, toJavaList, toJavaMap, toJavaOptional, toJavaSet, toJavaStream, toLeft, toLeft, toList, toMap, toOption, toQueue, toRight, toRight, toSet, toStack, toString, toTree, toTry, toTry, toVectordefault <U> U foldRight2(U zero,
java.util.function.BiFunction<? super U,? super T,? extends U> f)
static <T> ReactiveStream<T> cons(java.util.function.Supplier<T> head, java.util.function.Supplier<? extends LazyStream<? extends T>> tailSupplier)
cons in interface LazyStream<T>T - value typehead - The head element of the StreamtailSupplier - A supplier of the tail values. To end the stream, return
LazyStream.empty().static ReactiveStream<java.lang.Integer> from(int value)
LazyStreamfrom.
The Stream extends to Integer.MIN_VALUE when passing Integer.MAX_VALUE.
from in interface LazyStream<T>from in interface javaslang.collection.Stream<T>value - a start int valuefromstatic ReactiveStream<java.lang.Long> from(long value)
LazyStreamfrom.
The Stream extends to Integer.MIN_VALUE when passing Long.MAX_VALUE.
from in interface LazyStream<T>from in interface javaslang.collection.Stream<T>value - a start long valuefromstatic <T> ReactiveStream<T> of(T... values)
LazyStreamStream, i.e. a Stream of one element.of in interface LazyStream<T>of in interface javaslang.collection.Stream<T>T - The component typevalues - An element.static <T> ReactiveStream<T> empty()
LazyStreamNil.instance().
Note: this method intentionally returns type Stream and not Nil. This comes handy when folding.
If you explicitly need type Nil use LazyStream.Empty.instance().
empty in interface LazyStream<T>empty in interface javaslang.collection.Stream<T>T - Component type of Nil, determined by type inference in the particular context.static <T> ReactiveStream<T> iterate(T seed, java.util.function.Function<? super T,? extends T> gen)
static ReactiveStream<java.lang.Integer> range(int start, int end)
LazyStreamfrom, extending to toExclusive - 1.
Examples:
Stream.range(0, 0) // = Stream()
Stream.range(2, 0) // = Stream()
Stream.range(-2, 2) // = Stream(-2, -1, 0, 1)
range in interface LazyStream<T>range in interface javaslang.collection.Stream<T>start - the first numberend - the last number + 1Nil if from >= toExclusivestatic ReactiveStream<java.lang.Long> range(long start, long end)
LazyStreamfrom, extending to toExclusive - 1.
Examples:
Stream.range(0L, 0L) // = Stream()
Stream.range(2L, 0L) // = Stream()
Stream.range(-2L, 2L) // = Stream(-2L, -1L, 0L, 1L)
range in interface LazyStream<T>range in interface javaslang.collection.Stream<T>start - the first numberend - the last number + 1Nil if from >= toExclusivestatic <T> ReactiveStream<T> generate(java.util.function.Supplier<T> gen)
static <T> ReactiveStream<T> fromStream(javaslang.collection.Stream<T> stream)
fromStream in interface LazyStream<T>static <T> ReactiveStream<T> fromStreamable(com.aol.cyclops.sequence.streamable.Streamable<T> stream)
static <T> ReactiveStream<T> fromJDK(java.util.stream.BaseStream<T,? extends java.util.stream.BaseStream<T,?>> stream)
static <T> ReactiveStream<T> fromAnyM(com.aol.cyclops.monad.AnyM<T> stream)
static <T> ReactiveStream<T> fromIterable(java.lang.Iterable<T> stream)
static <T> ReactiveStream<T> fromIterator(java.util.Iterator<T> it)
static <T> ReactiveStream<T> fromAsyncQueue(com.aol.simple.react.async.Queue<T> q)
static <T> JavaslangReactiveStreamsSubscriber<T> subscriber()
default <U> ReactiveStream<U> cast(java.lang.Class<U> type)
default <U> ReactiveStream<U> ofType(java.lang.Class<U> type)
default <R> ReactiveStream<R> trampoline(java.util.function.Function<? super T,? extends com.aol.cyclops.trampoline.Trampoline<? extends R>> mapper)
default void subscribe(org.reactivestreams.Subscriber<? super T> s)
subscribe in interface org.reactivestreams.Publisher<T>default void subscribeAsync(java.util.concurrent.Executor ex,
org.reactivestreams.Subscriber<? super T> s)
default com.aol.cyclops.sequence.future.FutureOperations<T> futureOperations(java.util.concurrent.Executor ex)
default JavaslangHotStream<T> pausedHotStream(java.util.concurrent.Executor ex)
default JavaslangHotStream<T> hotStream(java.util.concurrent.Executor ex)
default <R> com.aol.simple.react.stream.traits.LazyFutureStream<R> asyncMap(com.aol.simple.react.stream.lazy.LazyReact react,
java.util.function.Function<? super T,? extends R> fn)
default <R> com.aol.simple.react.stream.traits.LazyFutureStream<R> asyncRetry(com.aol.simple.react.stream.lazy.LazyReact react,
java.util.function.Function<? super T,? extends R> fn)
default javaslang.collection.Iterator<T> iterator()
default ReactiveStream<T> recover(java.util.function.Function<java.lang.Throwable,? extends T> fn)
default <EX extends java.lang.Throwable> ReactiveStream<T> recover(java.lang.Class<EX> type, java.util.function.Function<EX,? extends T> fn)
default <R> ReactiveStream<R> retry(java.util.function.Function<? super T,? extends R> fn)
default ReactiveStream<T> debounce(long time, java.util.concurrent.TimeUnit t)
default ReactiveStream<T> onePer(long time, java.util.concurrent.TimeUnit t)
default ReactiveStream<T> jitter(long jitterInNanos)
default ReactiveStream<T> fixedDelay(long time, java.util.concurrent.TimeUnit unit)
default ReactiveStream<T> xPer(int x, long time, java.util.concurrent.TimeUnit t)
default ReactiveStream<javaslang.Tuple2<T,java.lang.Long>> elapsed()
ReactiveStream.of(1,2,3,4,5)
.elapsed()
.forEach(System.out::println);
default ReactiveStream<javaslang.Tuple2<T,java.lang.Long>> timestamp()
ReactiveStream.of(1,2,3,4,5)
.timestamp()
.forEach(System.out::println)
default ReactiveStream<ReactiveStream<T>> slidingWindow(int windowSize, int increment)
default ReactiveStream<ReactiveStream<T>> slidingWindow(int windowSize)
default ReactiveStream<ReactiveStream<T>> windowByTime(long time, java.util.concurrent.TimeUnit t)
default ReactiveStream<ReactiveStream<T>> windowStatefullyWhile(java.util.function.BiPredicate<com.aol.cyclops.sequence.streamable.Streamable<? super T>,? super T> predicate)
default ReactiveStream<ReactiveStream<T>> windowWhile(java.util.function.Predicate<? super T> predicate)
default ReactiveStream<ReactiveStream<T>> windowUntil(java.util.function.Predicate<? super T> predicate)
default ReactiveStream<ReactiveStream<T>> windowBySizeAndTime(int size, long time, java.util.concurrent.TimeUnit t)
default ReactiveStream<ReactiveStream<T>> windowBySize(int size)
default ReactiveStream<T> subStream(int start, int end)
ReactiveStream.of(1,2,3,4,5,6).subStream(1,3);
//ReactiveStream[2,3]
start - index inclusiveend - index exclusivedefault ReactiveStream<T> cycle()
assertThat(Stream.ofAll(1,2,3)
.cycle()
.limit(6)
.toList(),
equalTo(List.ofAll(1,2,3,1,2,3)));
cycle in interface LazyStream<T>cycle in interface javaslang.collection.Stream<T>s - Stream to cycledefault ReactiveStream<T> cycle(int times)
default ReactiveStream<T> cycleWhile(java.util.function.Predicate<? super T> predicate)
int count = 0;
assertThat(Stream.ofAll(1, 2, 2, 3)
.cycleWhile(next -> count++ < 6)
.toList()), equalTo(Arrays.asList(1, 2, 2, 1, 2, 2));
predicate - repeat while truedefault ReactiveStream<T> cycleUntil(LazyStream<T> stream, java.util.function.Predicate<? super T> predicate)
count =0;
assertThat(Stream.ofAll(1,2,2,3)
.cycleUntil(next -> count++>10 )
.toList(),equalTo(Arrays.asList(1, 2, 2, 3, 1, 2, 2, 3, 1, 2, 2)));
predicate - repeat while truedefault <U> LazyStream<U> scanRight(U identity, java.util.function.BiFunction<? super T,? super U,? extends U> combiner)
scanRight in interface LazyStream<T>scanRight in interface javaslang.collection.LinearSeq<T>scanRight in interface javaslang.collection.Seq<T>scanRight in interface javaslang.collection.Stream<T>scanRight in interface javaslang.collection.Traversable<T>default ReactiveStream<T> scanRight(com.aol.cyclops.sequence.Monoid<T> monoid)
default <U> ReactiveStream<U> scanLeft(U identity, java.util.function.BiFunction<? super U,? super T,? extends U> combiner)
scanLeft in interface LazyStream<T>scanLeft in interface javaslang.collection.LinearSeq<T>scanLeft in interface javaslang.collection.Seq<T>scanLeft in interface javaslang.collection.Stream<T>scanLeft in interface javaslang.collection.Traversable<T>default ReactiveStream<T> scanLeft(com.aol.cyclops.sequence.Monoid<T> monoid)
monoid - default boolean xMatch(int num,
java.util.function.Predicate<? super T> c)
assertTrue(SequenceM.of(1,2,3,5,6,7).xMatch(3, i-> i>4 ));
default ReactiveStream<T> take(long time, java.util.concurrent.TimeUnit unit)
default ReactiveStream<T> drop(long time, java.util.concurrent.TimeUnit unit)
default ReactiveStream<T> onEmptySwitch(java.util.function.Supplier<LazyStream<T>> switchTo)
assertThat(ReactiveStream.of(4,5,6)
.onEmptySwitch(()->SequenceM.of(1,2,3))
.toJavaList(),
equalTo(Arrays.asList(4,5,6)));
switchTo - Supplier that will generate the alternative Streamdefault ReactiveStream<T> onEmpty(T value)
default ReactiveStream<T> onEmptyGet(java.util.function.Supplier<T> supplier)
default <X extends java.lang.Throwable> ReactiveStream<T> onEmptyThrow(java.util.function.Supplier<X> supplier)
<R1,R2,R> ReactiveStream<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.lang.Iterable<R2>>> stream2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
SequenceM.of(1,2)
.forEach3(a->IntStream.range(10,13),
a->b->Stream.of(""+(a+b),"hello world"),
a->b->c->c+":"a+":"+b);
//SequenceM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
stream1 - Nested Stream to iterate overstream2 - Nested Stream to iterate overyieldingFunction - Function with pointers to the current element from both
Streams that generates the new elements<R1,R2,R> ReactiveStream<R> forEach3(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends java.lang.Iterable<R2>>> stream2, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,java.lang.Boolean>>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.util.function.Function<? super R2,? extends R>>> yieldingFunction)
SequenceM.of(1,2,3)
.forEach3(a->IntStream.range(10,13),
a->b->Stream.of(""+(a+b),"hello world"),
a->b->c-> c!=3,
a->b->c->c+":"a+":"+b);
//SequenceM[11:1:2,hello world:1:2,14:1:4,hello world:1:4,12:1:2,hello world:1:2,15:1:5,hello world:1:5]
stream1 - Nested Stream to iterate overstream2 - Nested Stream to iterate overfilterFunction - Filter to apply over elements before passing non-filtered
values to the yielding functionyieldingFunction - Function with pointers to the current element from both
Streams that generates the new elements<R1,R> ReactiveStream<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
SequenceM.of(1,2,3)
.forEach2(a->IntStream.range(10,13),
a->b->a+b);
//SequenceM[11,14,12,15,13,16]
stream1 - Nested Stream to iterate overyieldingFunction - Function with pointers to the current element from both
Streams that generates the new elements<R1,R> ReactiveStream<R> forEach2(java.util.function.Function<? super T,? extends java.lang.Iterable<R1>> stream1, java.util.function.Function<? super T,java.util.function.Function<? super R1,java.lang.Boolean>> filterFunction, java.util.function.Function<? super T,java.util.function.Function<? super R1,? extends R>> yieldingFunction)
SequenceM.of(1,2,3)
.forEach2(a->IntStream.range(10,13),
a->b-> a<3 && b>10,
a->b->a+b);
//SequenceM[14,15]
stream1 - Nested Stream to iterate overfilterFunction - Filter to apply over elements before passing non-filtered
values to the yielding functionyieldingFunction - Function with pointers to the current element from both
Streams that generates the new elementsdefault javaslang.collection.List<T> reduce(LazyStream<com.aol.cyclops.sequence.Monoid<T>> reducers)
{
@code
Monoid<String> concat = Monoid.of("", (a, b) -> a + b);
Monoid<String> join = Monoid.of("", (a, b) -> a + "," + b);
assertThat(StreamUtils.reduce(Stream.ofAll("hello", "world", "woo!"), Stream.ofAll(concat, join)),
equalTo(Arrays.asList("helloworldwoo!", ",hello,world,woo!")));
}
stream - Stream to reducereducers - Reducers to reduce Streamdefault <R> R mapReduce(com.aol.cyclops.sequence.Monoid<R> reducer)
reducer - Monoid to reduce valuesdefault <R> R mapReduce(java.util.function.Function<? super T,? extends R> mapper, com.aol.cyclops.sequence.Monoid<R> reducer)
mapper - Function to map Monad typereducer - Monoid to reduce valuesdefault T reduce(com.aol.cyclops.sequence.Monoid<T> reducer)
reducer - Use supplied Monoid to reduce values starting via foldLeftdefault T foldRight(com.aol.cyclops.sequence.Monoid<T> reducer)
reducer - Use supplied Monoid to reduce values starting via foldRightdefault <S,R> LazyStream<R> zipAnyM(com.aol.cyclops.monad.AnyM<? extends S> second, java.util.function.BiFunction<? super T,? super S,? extends R> zipper)
{
@code
Stream<List<Integer>> zipped = StreamUtils.zip(Stream.ofAll(1, 2, 3), anyM(Optional.of(2)), (a, b) -> Arrays.asList(a, b));
List<Integer> zip = zipped.collect(Collectors.toList()).get(0);
assertThat(zip.get(0), equalTo(1));
assertThat(zip.get(1), equalTo(2));
}
default T single()
//1
SequenceM.of(1).single();
//UnsupportedOperationException
SequenceM.of().single();
//UnsupportedOperationException
SequenceM.of(1,2,3).single();
default javaslang.control.Option<T> singleOption()
//Some[1]
ReactiveStream.of(1).singleOption();
//None
ReactiveStream.of().singleOpion();
//None
ReactiveStream.of(1,2,3).singleOption();
default ReactiveStream<T> append(T element)
default ReactiveStream<T> append(T... elements)
default ReactiveStream<T> appendAll(java.lang.Iterable<? extends T> elements)
default ReactiveStream<T> clear()
clear in interface LazyStream<T>clear in interface javaslang.collection.LinearSeq<T>clear in interface javaslang.collection.Seq<T>clear in interface javaslang.collection.Stream<T>clear in interface javaslang.collection.Traversable<T>default ReactiveStream<javaslang.Tuple2<T,T>> crossProduct()
crossProduct in interface LazyStream<T>crossProduct in interface javaslang.collection.LinearSeq<T>crossProduct in interface javaslang.collection.Seq<T>crossProduct in interface javaslang.collection.Stream<T>default ReactiveStream<javaslang.collection.Stream<T>> crossProduct(int power)
crossProduct in interface LazyStream<T>crossProduct in interface javaslang.collection.LinearSeq<T>crossProduct in interface javaslang.collection.Seq<T>crossProduct in interface javaslang.collection.Stream<T>default <U> ReactiveStream<javaslang.Tuple2<T,U>> crossProduct(java.lang.Iterable<? extends U> that)
crossProduct in interface LazyStream<T>crossProduct in interface javaslang.collection.LinearSeq<T>crossProduct in interface javaslang.collection.Seq<T>crossProduct in interface javaslang.collection.Stream<T>default ReactiveStream<javaslang.collection.Stream<T>> combinations()
combinations in interface LazyStream<T>combinations in interface javaslang.collection.LinearSeq<T>combinations in interface javaslang.collection.Seq<T>combinations in interface javaslang.collection.Stream<T>default ReactiveStream<javaslang.collection.Stream<T>> combinations(int k)
combinations in interface LazyStream<T>combinations in interface javaslang.collection.LinearSeq<T>combinations in interface javaslang.collection.Seq<T>combinations in interface javaslang.collection.Stream<T>default ReactiveStream<T> distinct()
distinct in interface LazyStream<T>distinct in interface javaslang.collection.LinearSeq<T>distinct in interface javaslang.collection.Seq<T>distinct in interface javaslang.collection.Stream<T>distinct in interface javaslang.collection.Traversable<T>default ReactiveStream<T> distinctBy(java.util.Comparator<? super T> comparator)
distinctBy in interface LazyStream<T>distinctBy in interface javaslang.collection.LinearSeq<T>distinctBy in interface javaslang.collection.Seq<T>distinctBy in interface javaslang.collection.Stream<T>distinctBy in interface javaslang.collection.Traversable<T>default <U> ReactiveStream<T> distinctBy(java.util.function.Function<? super T,? extends U> keyExtractor)
distinctBy in interface LazyStream<T>distinctBy in interface javaslang.collection.LinearSeq<T>distinctBy in interface javaslang.collection.Seq<T>distinctBy in interface javaslang.collection.Stream<T>distinctBy in interface javaslang.collection.Traversable<T>default ReactiveStream<T> drop(long n)
drop in interface LazyStream<T>drop in interface javaslang.collection.LinearSeq<T>drop in interface javaslang.collection.Seq<T>drop in interface javaslang.collection.Stream<T>drop in interface javaslang.collection.Traversable<T>default ReactiveStream<T> dropRight(long n)
dropRight in interface LazyStream<T>dropRight in interface javaslang.collection.LinearSeq<T>dropRight in interface javaslang.collection.Seq<T>dropRight in interface javaslang.collection.Stream<T>dropRight in interface javaslang.collection.Traversable<T>default ReactiveStream<T> dropWhile(java.util.function.Predicate<? super T> predicate)
dropWhile in interface LazyStream<T>dropWhile in interface javaslang.collection.LinearSeq<T>dropWhile in interface javaslang.collection.Seq<T>dropWhile in interface javaslang.collection.Stream<T>dropWhile in interface javaslang.collection.Traversable<T>default ReactiveStream<T> filter(java.util.function.Predicate<? super T> predicate)
filter in interface LazyStream<T>filter in interface javaslang.collection.LinearSeq<T>filter in interface javaslang.collection.Seq<T>filter in interface javaslang.collection.Stream<T>filter in interface javaslang.collection.Traversable<T>default <U> ReactiveStream<U> flatMap(java.util.function.Function<? super T,? extends java.lang.Iterable<? extends U>> mapper)
flatMap in interface LazyStream<T>flatMap in interface javaslang.collection.LinearSeq<T>flatMap in interface javaslang.collection.Seq<T>flatMap in interface javaslang.collection.Stream<T>flatMap in interface javaslang.collection.Traversable<T>default <U> ReactiveStream<U> flatten()
default <C> javaslang.collection.Map<C,? extends ReactiveStream<T>> groupByReactive(java.util.function.Function<? super T,? extends C> classifier)
default ReactiveStream<T> init()
init in interface LazyStream<T>init in interface javaslang.collection.LinearSeq<T>init in interface javaslang.collection.Seq<T>init in interface javaslang.collection.Stream<T>init in interface javaslang.collection.Traversable<T>default javaslang.control.Option<? extends ReactiveStream<T>> initOptionReactive()
default ReactiveStream<T> insert(int index, T element)
default ReactiveStream<T> insertAll(int index, java.lang.Iterable<? extends T> elements)
default ReactiveStream<T> intersperse(T element)
intersperse in interface LazyStream<T>intersperse in interface javaslang.collection.LinearSeq<T>intersperse in interface javaslang.collection.Seq<T>intersperse in interface javaslang.collection.Stream<T>default <U> ReactiveStream<U> map(java.util.function.Function<? super T,? extends U> mapper)
map in interface com.aol.cyclops.lambda.monads.Functor<T>map in interface LazyStream<T>map in interface javaslang.collection.LinearSeq<T>map in interface javaslang.collection.Seq<T>map in interface javaslang.collection.Stream<T>map in interface javaslang.collection.Traversable<T>map in interface javaslang.Value<T>default ReactiveStream<T> padTo(int length, T element)
default ReactiveStream<T> patch(int from, java.lang.Iterable<? extends T> that, int replaced)
default javaslang.Tuple2<? extends ReactiveStream<T>,? extends ReactiveStream<T>> partitionReactive(java.util.function.Predicate<? super T> predicate)
default ReactiveStream<T> peek(java.util.function.Consumer<? super T> action)
peek in interface com.aol.cyclops.lambda.monads.Functor<T>peek in interface LazyStream<T>peek in interface javaslang.collection.LinearSeq<T>peek in interface javaslang.collection.Seq<T>peek in interface javaslang.collection.Stream<T>peek in interface javaslang.collection.Traversable<T>peek in interface javaslang.Value<T>default ReactiveStream<javaslang.collection.Stream<T>> permutations()
permutations in interface LazyStream<T>permutations in interface javaslang.collection.LinearSeq<T>permutations in interface javaslang.collection.Seq<T>permutations in interface javaslang.collection.Stream<T>default ReactiveStream<T> prepend(T element)
default ReactiveStream<T> prepend(T... elements)
default ReactiveStream<T> prependAll(java.lang.Iterable<? extends T> elements)
prependAll in interface LazyStream<T>prependAll in interface javaslang.collection.LinearSeq<T>prependAll in interface javaslang.collection.Seq<T>prependAll in interface javaslang.collection.Stream<T>default ReactiveStream<T> remove(T element)
default ReactiveStream<T> removeFirst(java.util.function.Predicate<T> predicate)
removeFirst in interface LazyStream<T>removeFirst in interface javaslang.collection.LinearSeq<T>removeFirst in interface javaslang.collection.Seq<T>removeFirst in interface javaslang.collection.Stream<T>default ReactiveStream<T> removeLast(java.util.function.Predicate<T> predicate)
removeLast in interface LazyStream<T>removeLast in interface javaslang.collection.LinearSeq<T>removeLast in interface javaslang.collection.Seq<T>removeLast in interface javaslang.collection.Stream<T>default ReactiveStream<T> removeAt(int index)
default ReactiveStream<T> removeBetween(int start, int end)
default ReactiveStream<T> removeAll(T element)
default ReactiveStream<T> removeAll(java.lang.Iterable<? extends T> elements)
default ReactiveStream<T> replace(T currentElement, T newElement)
replace in interface LazyStream<T>replace in interface javaslang.collection.LinearSeq<T>replace in interface javaslang.collection.Seq<T>replace in interface javaslang.collection.Stream<T>replace in interface javaslang.collection.Traversable<T>default ReactiveStream<T> replaceAll(T currentElement, T newElement)
replaceAll in interface LazyStream<T>replaceAll in interface javaslang.collection.LinearSeq<T>replaceAll in interface javaslang.collection.Seq<T>replaceAll in interface javaslang.collection.Stream<T>replaceAll in interface javaslang.collection.Traversable<T>default ReactiveStream<T> retainAll(java.lang.Iterable<? extends T> elements)
retainAll in interface LazyStream<T>retainAll in interface javaslang.collection.LinearSeq<T>retainAll in interface javaslang.collection.Seq<T>retainAll in interface javaslang.collection.Stream<T>retainAll in interface javaslang.collection.Traversable<T>default ReactiveStream<T> reverse()
default ReactiveStream<T> slice(long beginIndex, long endIndex)
default ReactiveStream<T> sort()
default ReactiveStream<T> sort(java.util.Comparator<? super T> comparator)
default <U extends java.lang.Comparable<? super U>> ReactiveStream<T> sortBy(java.util.function.Function<? super T,? extends U> mapper)
default <U> ReactiveStream<T> sortBy(java.util.Comparator<? super U> comparator, java.util.function.Function<? super T,? extends U> mapper)
default javaslang.Tuple2<? extends ReactiveStream<T>,? extends ReactiveStream<T>> spanReactive(java.util.function.Predicate<? super T> predicate)
default ReactiveStream<T> subSequence(int beginIndex)
subSequence in interface LazyStream<T>subSequence in interface javaslang.collection.LinearSeq<T>subSequence in interface javaslang.collection.Seq<T>subSequence in interface javaslang.collection.Stream<T>default ReactiveStream<T> subSequence(int beginIndex, int endIndex)
subSequence in interface LazyStream<T>subSequence in interface javaslang.collection.LinearSeq<T>subSequence in interface javaslang.collection.Seq<T>subSequence in interface javaslang.collection.Stream<T>default javaslang.control.Option<? extends ReactiveStream<T>> tailOptionReactive()
default ReactiveStream<T> take(long n)
take in interface LazyStream<T>take in interface javaslang.collection.LinearSeq<T>take in interface javaslang.collection.Seq<T>take in interface javaslang.collection.Stream<T>take in interface javaslang.collection.Traversable<T>default ReactiveStream<T> takeRight(long n)
takeRight in interface LazyStream<T>takeRight in interface javaslang.collection.LinearSeq<T>takeRight in interface javaslang.collection.Seq<T>takeRight in interface javaslang.collection.Stream<T>takeRight in interface javaslang.collection.Traversable<T>default ReactiveStream<T> takeUntil(java.util.function.Predicate<? super T> predicate)
takeUntil in interface LazyStream<T>takeUntil in interface javaslang.collection.LinearSeq<T>takeUntil in interface javaslang.collection.Seq<T>takeUntil in interface javaslang.collection.Stream<T>takeUntil in interface javaslang.collection.Traversable<T>default ReactiveStream<T> takeWhile(java.util.function.Predicate<? super T> predicate)
takeWhile in interface LazyStream<T>takeWhile in interface javaslang.collection.LinearSeq<T>takeWhile in interface javaslang.collection.Seq<T>takeWhile in interface javaslang.collection.Stream<T>takeWhile in interface javaslang.collection.Traversable<T>default <U> ReactiveStream<U> unit(java.lang.Iterable<? extends U> iterable)
default <T1,T2> javaslang.Tuple2<? extends ReactiveStream<T1>,? extends ReactiveStream<T2>> unzipReactive(java.util.function.Function<? super T,javaslang.Tuple2<? extends T1,? extends T2>> unzipper)
default ReactiveStream<T> update(int index, T element)
default <U> ReactiveStream<javaslang.Tuple2<T,U>> zip(java.lang.Iterable<U> that)
default <U> ReactiveStream<javaslang.Tuple2<T,U>> zipAll(java.lang.Iterable<U> that, T thisElem, U thatElem)
zipAll in interface LazyStream<T>zipAll in interface javaslang.collection.LinearSeq<T>zipAll in interface javaslang.collection.Seq<T>zipAll in interface javaslang.collection.Stream<T>zipAll in interface javaslang.collection.Traversable<T>default ReactiveStream<javaslang.Tuple2<T,java.lang.Long>> zipWithIndex()
zipWithIndex in interface LazyStream<T>zipWithIndex in interface javaslang.collection.LinearSeq<T>zipWithIndex in interface javaslang.collection.Seq<T>zipWithIndex in interface javaslang.collection.Stream<T>zipWithIndex in interface javaslang.collection.Traversable<T>default javaslang.Tuple2<? extends ReactiveStream<T>,? extends ReactiveStream<T>> splitAtReactive(int n)
default javaslang.Tuple2<? extends ReactiveStream<T>,? extends ReactiveStream<T>> splitAtReactive(java.util.function.Predicate<? super T> predicate)
default javaslang.Tuple2<? extends ReactiveStream<T>,? extends ReactiveStream<T>> splitAtInclusiveReactive(java.util.function.Predicate<? super T> predicate)
default <T1,T2,T3> javaslang.Tuple3<? extends ReactiveStream<T1>,? extends ReactiveStream<T2>,? extends ReactiveStream<T3>> unzip3Reactive(java.util.function.Function<? super T,javaslang.Tuple3<? extends T1,? extends T2,? extends T3>> unzipper)
default ReactiveStream<T> tail()
tail in interface LazyStream<T>tail in interface javaslang.collection.LinearSeq<T>tail in interface javaslang.collection.Seq<T>tail in interface javaslang.collection.Stream<T>tail in interface javaslang.collection.Traversable<T>default JavaslangHotStream<T> schedule(java.lang.String cron, java.util.concurrent.ScheduledExecutorService ex)
//run at 8PM every night
ReactiveStream.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
.schedule("0 20 * * *",Executors.newScheduledThreadPool(1));
Connect to the Scheduled Stream
{
@code
HotStream<Data> dataStream = ReactiveStream.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
.schedule("0 20 * * *", Executors.newScheduledThreadPool(1));
data.connect().forEach(this::logToDB);
}
cron - Expression that determines when each job will runex - ScheduledExecutorServicedefault JavaslangHotStream<T> scheduleFixedDelay(long delay, java.util.concurrent.ScheduledExecutorService ex)
//run every 60 seconds after last job completes
ReactiveStream.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
.scheduleFixedDelay(60_000,Executors.newScheduledThreadPool(1));
Connect to the Scheduled Stream
{
@code
HotStream<Data> dataStream = ReactiveStream.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
.scheduleFixedDelay(60_000, Executors.newScheduledThreadPool(1));
data.connect().forEach(this::logToDB);
}
delay - Between last element completes passing through the Stream
until the next one startsex - ScheduledExecutorServicedefault JavaslangHotStream<T> scheduleFixedRate(long rate, java.util.concurrent.ScheduledExecutorService ex)
//run every 60 seconds
ReactiveStream.generate(()->"next job:"+formatDate(new Date()))
.map(this::processJob)
.scheduleFixedRate(60_000,Executors.newScheduledThreadPool(1));
Connect to the Scheduled Stream
{
@code
HotStream<Data> dataStream = ReactiveStream.generate(() -> "next job:" + formatDate(new Date())).map(this::processJob)
.scheduleFixedRate(60_000, Executors.newScheduledThreadPool(1));
data.connect().forEach(this::logToDB);
}
rate - Time in millis between job runsex - ScheduledExecutorService