cyclops.stream

Interface Spouts

public interface Spouts

reactive : is used toNested denote creational methods for reactive-streams that support non-blocking backpressure async : is used toNested denote creational methods for asynchronous streams that do not support backpressure

Nested Class Summary

Nested Classes

Modifier and Type	Interface and Description
static class	Spouts.Instances

Method Summary

Modifier and Type	Method and Description
static <T> ReactiveSeq<T>	amb(ListX<? extends org.reactivestreams.Publisher<? extends T>> list)
static <T> ReactiveSeq<T>	amb(org.reactivestreams.Publisher<? extends T>... array)
static <T> ReactiveSeq<T>	ambWith(org.reactivestreams.Publisher<? extends T>[] array)
static <T> ReactiveSeq<T>	async(java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>> sub) Create a Stream that accepts data via the Subsriber passed into the supplied Consumer.
static <T> ReactiveSeq<T>	async(java.util.stream.Stream<T> seq, java.util.concurrent.Executor exec) Create a push based Stream with no backpressure fromm the provided Stream.
static <T> ReactiveSeq<T>	asyncStream(com.aol.cyclops2.internal.stream.spliterators.push.Operator<T> s)
static <T> AsyncSubscriber<T>	asyncSubscriber() Create an Subscriber for Observable style asynchronous push based Streams.
static <T> ReactiveSeq<T>	concat(org.reactivestreams.Publisher<org.reactivestreams.Publisher<T>> pubs)
static <T> ReactiveSeq<T>	concat(java.util.stream.Stream<? extends T>... streams)
static <T> ReactiveSeq<T>	deferred(java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends T>> s)
static <T> ReactiveSeq<T>	deferredI(java.util.function.Supplier<? extends java.lang.Iterable<? extends T>> s)
static <T> ReactiveSeq<T>	deferredS(java.util.function.Supplier<? extends java.util.stream.Stream<? extends T>> s)
static <T> ReactiveSeq<T>	empty()
static <T> ReactiveSeq<T>	from(org.reactivestreams.Publisher<? extends T> pub)
static <T> ReactiveSeq<T>	fromIterable(java.lang.Iterable<T> iterable)
static <T> ReactiveSeq<T>	fromSpliterator(java.util.Spliterator<T> spliterator)
static <T> ReactiveSeq<T>	generate(java.util.function.Supplier<T> s)
static ReactiveSeq<java.lang.Integer>	interval(long millis, java.util.concurrent.ScheduledExecutorService exec)
static ReactiveSeq<java.lang.Integer>	interval(java.lang.String cron, java.util.concurrent.ScheduledExecutorService exec)
static <T> ReactiveSeq<T>	iterate(T seed, java.util.function.Predicate<? super T> pred, java.util.function.UnaryOperator<T> f)
static <T> ReactiveSeq<T>	iterate(T seed, java.util.function.UnaryOperator<T> f)
static <T> ReactiveSeq<T>	lazyConcat(org.reactivestreams.Publisher<org.reactivestreams.Publisher<T>> pubs)
static <T> ReactiveSeq<T>	merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<T>> publisher)
static <T> ReactiveSeq<T>	mergeLatest(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<T>> publisher)
static <T> ReactiveSeq<T>	mergeLatest(org.reactivestreams.Publisher<T>... array)
static <T> ReactiveSeq<T>	mergeLatestList(ListX<? extends org.reactivestreams.Publisher<? extends T>> publisher)
static <T> ReactiveSeq<T>	narrowK(Higher<ReactiveSeq.µ,T> future) Convert the raw Higher Kinded Type for ReactiveSeq types into the ReactiveSeq type definition class
static <T> ReactiveSeq<T>	of(T... values)
static <T> ReactiveSeq<T>	of(T value)
static <T> ReactiveSeq<T>	ofNullable(T nullable)
static ReactiveSeq<java.lang.Integer>	range(int start, int end)
static ReactiveSeq<java.lang.Long>	rangeLong(long start, long end)
static <T> ReactiveSeq<T>	reactive(java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>> sub)
static <T> ReactiveSeq<T>	reactive(java.util.stream.Stream<T> seq, java.util.concurrent.Executor exec)
static <T> ReactiveSeq<T>	reactiveStream(com.aol.cyclops2.internal.stream.spliterators.push.Operator<T> s)
static <T> ReactiveSubscriber<T>	reactiveSubscriber() The recommended way toNested connect a Spout toNested a Publisher is via Spouts#from Create an Subscriber for Observable style asynchronous push based Streams, that implements backpressure internally via the reactive-streams spec.
static <T> ReactiveSeq<T>	syncStream(com.aol.cyclops2.internal.stream.spliterators.push.Operator<T> s)
static <U,T> ReactiveSeq<T>	unfold(U seed, java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder) Unfold a function into a ReactiveSeq

Method Detail

asyncSubscriber

static <T> AsyncSubscriber<T> asyncSubscriber()

Create an Subscriber for Observable style asynchronous push based Streams. Streams generated from AsyncSubscribers are not backpressure aware (in cases where backpressue is not needed they may perform better). For backpressure aware Streams see reactiveSubscriber()

Type Parameters:

T - Stream data type

Returns:

Async Stream Subscriber

async

static <T> ReactiveSeq<T> async(java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>> sub)

Create a Stream that accepts data via the Subsriber passed into the supplied Consumer. reactive-streams susbscription is ignored (i.e. this Stream is backpressure free)

     
      ReactiveSeq<Integer> input = Spouts.async(subscriber->{
                                                          listener.onEvent(subscriber::onNext);
                                                          listener.onError(susbscriber::onError);
                                                          closeListener.onEvent(subscriber::onClose);
                                                      });
      
 

Type Parameters:

T -

Parameters:

sub -

Returns:

async

static <T> ReactiveSeq<T> async(java.util.stream.Stream<T> seq,
                                java.util.concurrent.Executor exec)

Create a push based Stream with no backpressure fromm the provided Stream. The provided Stream will be executed on the provided executor and pushed toNested the returned Stream

Type Parameters:

T -

Parameters:

seq - Stream toNested execute and push toNested a new non-backpressure aware Stream

exec -

Returns:

reactive

static <T> ReactiveSeq<T> reactive(java.util.stream.Stream<T> seq,
                                   java.util.concurrent.Executor exec)

reactiveSubscriber

static <T> ReactiveSubscriber<T> reactiveSubscriber()

The recommended way toNested connect a Spout toNested a Publisher is via Spouts#from Create an Subscriber for Observable style asynchronous push based Streams, that implements backpressure internally via the reactive-streams spec. Subscribers signal demand via their subscription and publishers push data toNested subscribers synchronously or asynchronously, never exceeding signalled demand

Type Parameters:

T - Stream data type

Returns:

An async Stream Subscriber that supports efficient backpressure via reactive-streams

reactive

static <T> ReactiveSeq<T> reactive(java.util.function.Consumer<? super org.reactivestreams.Subscriber<T>> sub)

reactiveStream

static <T> ReactiveSeq<T> reactiveStream(com.aol.cyclops2.internal.stream.spliterators.push.Operator<T> s)

asyncStream

static <T> ReactiveSeq<T> asyncStream(com.aol.cyclops2.internal.stream.spliterators.push.Operator<T> s)

syncStream

static <T> ReactiveSeq<T> syncStream(com.aol.cyclops2.internal.stream.spliterators.push.Operator<T> s)

iterate

static <T> ReactiveSeq<T> iterate(T seed,
                                  java.util.function.UnaryOperator<T> f)

iterate

static <T> ReactiveSeq<T> iterate(T seed,
                                  java.util.function.Predicate<? super T> pred,
                                  java.util.function.UnaryOperator<T> f)

range

static ReactiveSeq<java.lang.Integer> range(int start,
                                            int end)

rangeLong

static ReactiveSeq<java.lang.Long> rangeLong(long start,
                                             long end)

of

static <T> ReactiveSeq<T> of(T value)

ofNullable

static <T> ReactiveSeq<T> ofNullable(T nullable)

empty

static <T> ReactiveSeq<T> empty()

of

static <T> ReactiveSeq<T> of(T... values)

fromIterable

static <T> ReactiveSeq<T> fromIterable(java.lang.Iterable<T> iterable)

fromSpliterator

static <T> ReactiveSeq<T> fromSpliterator(java.util.Spliterator<T> spliterator)

generate

static <T> ReactiveSeq<T> generate(java.util.function.Supplier<T> s)

See Also:

Stream.generate(Supplier)

from

static <T> ReactiveSeq<T> from(org.reactivestreams.Publisher<? extends T> pub)

merge

static <T> ReactiveSeq<T> merge(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<T>> publisher)

mergeLatestList

static <T> ReactiveSeq<T> mergeLatestList(ListX<? extends org.reactivestreams.Publisher<? extends T>> publisher)

mergeLatest

static <T> ReactiveSeq<T> mergeLatest(org.reactivestreams.Publisher<? extends org.reactivestreams.Publisher<T>> publisher)

mergeLatest

static <T> ReactiveSeq<T> mergeLatest(org.reactivestreams.Publisher<T>... array)

amb

static <T> ReactiveSeq<T> amb(ListX<? extends org.reactivestreams.Publisher<? extends T>> list)

amb

static <T> ReactiveSeq<T> amb(org.reactivestreams.Publisher<? extends T>... array)

ambWith

static <T> ReactiveSeq<T> ambWith(org.reactivestreams.Publisher<? extends T>[] array)

interval

static ReactiveSeq<java.lang.Integer> interval(java.lang.String cron,
                                               java.util.concurrent.ScheduledExecutorService exec)

interval

static ReactiveSeq<java.lang.Integer> interval(long millis,
                                               java.util.concurrent.ScheduledExecutorService exec)

deferred

static <T> ReactiveSeq<T> deferred(java.util.function.Supplier<? extends org.reactivestreams.Publisher<? extends T>> s)

deferredS

static <T> ReactiveSeq<T> deferredS(java.util.function.Supplier<? extends java.util.stream.Stream<? extends T>> s)

deferredI

static <T> ReactiveSeq<T> deferredI(java.util.function.Supplier<? extends java.lang.Iterable<? extends T>> s)

unfold

static <U,T> ReactiveSeq<T> unfold(U seed,
                                   java.util.function.Function<? super U,java.util.Optional<org.jooq.lambda.tuple.Tuple2<T,U>>> unfolder)

Unfold a function into a ReactiveSeq

 
  ReactiveSeq.unfold(1,i->i<=6 ? Optional.of(Tuple.tuple(i,i+1)) : Optional.empty());

 //(1,2,3,4,5)

 

Parameters:

seed - Initial value

unfolder - Iteratively applied function, terminated by an empty Optional

Returns:

ReactiveSeq generated by unfolder function

concat

static <T> ReactiveSeq<T> concat(org.reactivestreams.Publisher<org.reactivestreams.Publisher<T>> pubs)

lazyConcat

static <T> ReactiveSeq<T> lazyConcat(org.reactivestreams.Publisher<org.reactivestreams.Publisher<T>> pubs)

concat

static <T> ReactiveSeq<T> concat(java.util.stream.Stream<? extends T>... streams)

narrowK

static <T> ReactiveSeq<T> narrowK(Higher<ReactiveSeq.µ,T> future)

Convert the raw Higher Kinded Type for ReactiveSeq types into the ReactiveSeq type definition class

Parameters:

future - HKT encoded list into a ReactiveSeq

Returns:

ReactiveSeq