package cyclops.reactive;
import com.oath.cyclops.hkt.Higher;
import com.oath.cyclops.internal.stream.spliterators.push.*;
import com.oath.cyclops.types.reactive.BufferOverflowPolicy;
import com.oath.cyclops.types.reactive.PushSubscriber;
import com.oath.cyclops.types.traversable.IterableX;
import com.oath.cyclops.util.ExceptionSoftener;
import cyclops.control.*;
import com.oath.cyclops.internal.stream.ReactiveStreamX;
import com.oath.cyclops.internal.stream.ReactiveStreamX.Type;
import com.oath.cyclops.internal.stream.spliterators.UnfoldSpliterator;
import com.oath.cyclops.types.reactive.AsyncSubscriber;
import com.oath.cyclops.types.reactive.ReactiveSubscriber;
import cyclops.data.Seq;
import com.oath.cyclops.hkt.DataWitness.reactiveSeq;
import cyclops.function.checked.CheckedSupplier;
import org.agrona.concurrent.ManyToManyConcurrentArrayQueue;
import cyclops.data.tuple.Tuple2;
import org.reactivestreams.Publisher;
import org.reactivestreams.Subscriber;
import org.reactivestreams.Subscription;
import java.util.Queue;
import java.util.Spliterator;
import java.util.concurrent.Executor;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.LockSupport;
import java.util.function.*;
import java.util.stream.Stream;
/**
* reactive : is used to denote creational methods for reactive-streams that support non-blocking backpressure
* async : is used to denote creational methods for asynchronous streams that do not support backpressure
*/
public interface Spouts {
static <T> ReactiveSeq<T> once(CheckedSupplier<T> cs){
return Spouts.generate(ExceptionSoftener.softenSupplier(cs)).take(1l);
}
/**
* 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 {@link Spouts#reactiveSubscriber}
*
* @param <T> Stream data type
* @return Async Stream Subscriber
*/
@Deprecated
static <T> AsyncSubscriber<T> asyncSubscriber(){
return new AsyncSubscriber<T>();
}
/**
* 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)
*
* <pre>
* {@code
* ReactiveSeq<Integer> input = Spouts.async(subscriber->{
* listener.onEvent(subscriber::onNext);
* listener.onError(susbscriber::onError);
* closeListener.onEvent(subscriber::onClose);
* });
* }
* </pre>
*
* @param sub
* @param <T>
* @return
*/
@Deprecated
static <T> ReactiveSeq<T> async(Consumer<? super PushSubscriber<T>> sub){
AsyncSubscriber<T> s = asyncSubscriber();
return s.registerAndstream(()->{
while(!s.isInitialized()){
LockSupport.parkNanos(1l);
}
sub.accept(s);
});
}
/**
* Create a push based Stream with <b>no backpressure</b> fromm the provided Stream.
* The provided Stream will be executed on the provided executor and pushed to the returned Stream
*
* @param seq Stream to execute and push to a new non-backpressure aware Stream
* @param exec
* @param <T>
* @return
*/
@Deprecated
static <T> ReactiveSeq<T> async(Stream<T> seq, Executor exec){
return async(s->{
ReactiveSeq.fromStream(seq).foldFuture(exec,t->{
PushSubscriber<T> local = s;
t.forEach(local::onNext,local::onError,local::onComplete);
return null;
});
});
}
/**
* Create a buffering reactive-streams source. Your subscriber can respect or ignore reactive-streams backpressure.
* This operator will buffer incoming data before sending on when downstream streams are ready.
* This operator drops values once buffer size has been exceeded
*
* E.g. In the example below 2 elements are requested, we ignore this and send 30 elements instead
* <pre>
* {@code
* Subscription sub = Spouts.reactive(10, s -> {
s.onSubscribe(new Subscription() {
@Override
public void request(long n) {
//ignore back pressure
//send lots of data downstream regardless
Effect e = () -> {
s.onNext("hello " + i++);
}
e.cycle(30).run();
}
@Override
public void cancel() {
}
});
}).forEach(2, System.out::println);
//only 2 elements will be printed out
//10 will be buffered and potentially 18 dropped
Thread.sleep(500);
sub.request(20);
*
*
* }
*
*
* </pre>
*
* @param buffer
* @param onNext
* @param <T>
* @return
*/
static <T> ReactiveSeq<T> reactiveBuffer(int buffer, Consumer<? super Subscriber<T>> onNext){
return Spouts.reactiveStream(new BufferingSinkOperator<T>(new ManyToManyConcurrentArrayQueue<T>(buffer), onNext, BufferOverflowPolicy.DROP));
}
static <T> ReactiveSeq<T> reactiveBufferBlock(int buffer, Consumer<? super Subscriber<T>> onNext){
return Spouts.reactiveStream(new BufferingSinkOperator<T>(new ManyToManyConcurrentArrayQueue<T>(buffer), onNext,BufferOverflowPolicy.BLOCK));
}
static <T> ReactiveSeq<T> reactiveBuffer(Queue<T> buffer,BufferOverflowPolicy policy, Consumer<? super Subscriber<T>> onNext){
return Spouts.reactiveStream(new BufferingSinkOperator<T>(buffer, onNext, policy));
}
@Deprecated
static <T> ReactiveSeq<T> asyncBuffer(int buffer, Consumer<? super PushSubscriber<T>> onNext){
return Spouts.asyncStream(new BufferingSinkOperator<T>(new ManyToManyConcurrentArrayQueue<T>(buffer),c-> onNext.accept(PushSubscriber.of(c)), BufferOverflowPolicy.DROP));
}
@Deprecated
static <T> ReactiveSeq<T> asyncBufferBlock(int buffer, Consumer<? super PushSubscriber<T>> onNext){
return Spouts.asyncStream(new BufferingSinkOperator<T>(new ManyToManyConcurrentArrayQueue<T>(buffer), c-> onNext.accept(PushSubscriber.of(c)), BufferOverflowPolicy.BLOCK));
}
@Deprecated
static <T> ReactiveSeq<T> asyncBuffer(Queue<T> buffer,BufferOverflowPolicy policy, Consumer<? super PushSubscriber<T>> onNext){
return Spouts.asyncStream(new BufferingSinkOperator<T>(buffer, c-> onNext.accept(PushSubscriber.of(c)), policy));
}
static <T> ReactiveSeq<T> reactive(Stream<T> seq, Executor exec){
Future<Subscriber<T>> subscriber = Future.future();
Future<Subscription> sub = Future.future();
AtomicBoolean complete = new AtomicBoolean();
AtomicLong requested = new AtomicLong(0);
ReactiveSeq.fromStream(seq).foldFuture(exec,t->{
Subscriber<T> local = subscriber.getFuture().join();
Subscription streamSub = t.forEach(0,local::onNext,local::onError,()->{
complete.set(true);
local.onComplete();
});
sub.complete(new Subscription() {
@Override
public void request(long n) {
requested.addAndGet(n);
}
@Override
public void cancel() {
streamSub.cancel();
}
});
while(!complete.get()){
long next = requested.get();
if(next==0){
Thread.yield();
}else {
while (!requested.compareAndSet(next, 0)) {
next = requested.get();
}
streamSub.request(next);
}
}
return null;
});
return reactiveStream(new PublisherToOperator<T>(new Publisher<T>() {
@Override
public void subscribe(Subscriber<? super T> s) {
subscriber.complete((Subscriber<T>)s);
s.onSubscribe(sub.getFuture().join());
}
}));
}
/**
* The recommended way to connect a Spout to 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 to subscribers
* synchronously or asynchronously, never exceeding signalled demand
*
* @param <T> Stream data type
* @return An async Stream Subscriber that supports efficient backpressure via reactive-streams
*/
static <T> ReactiveSubscriber<T> reactiveSubscriber(){
return new ReactiveSubscriber<T>();
}
static <T> ReactiveSeq<T> reactive(Consumer<? super Subscriber<T>> sub){
ReactiveSubscriber<T> reactive = new ReactiveSubscriber<T>();
sub.accept(reactive);
return reactive.reactiveStream();
}
static <T> ReactiveSeq<T> reactiveStream(Operator<T> s){
return new ReactiveStreamX<>(s,Type.BACKPRESSURE);
}
@Deprecated
static <T> ReactiveSeq<T> asyncStream(Operator<T> s){
return new ReactiveStreamX<>(s,Type.NO_BACKPRESSURE);
}
static <T> ReactiveSeq<T> syncStream(Operator<T> s){
return new ReactiveStreamX<>(s);
}
static <T> ReactiveSeq<T> iterate(final T seed, final UnaryOperator<T> f) {
return syncStream(new IterateOperator<T>(seed,f));
}
static <T> ReactiveSeq<T> iterate(final T seed, Predicate<? super T> pred, final UnaryOperator<T> f) {
return syncStream(new IteratePredicateOperator<T>(seed,f,pred));
}
public static ReactiveSeq<Integer> range(int start, int end){
if(start<end)
return syncStream(new RangeIntOperator(start,end));
else
return syncStream(new RangeIntOperator(end,start));
}
public static ReactiveSeq<Long> rangeLong(long start, long end){
if(start<end)
return syncStream(new RangeLongOperator(start,end));
else
return syncStream(new RangeLongOperator(end,start));
}
public static <T> ReactiveSeq<T> of(T value){
return syncStream(new SingleValueOperator<T>(value));
}
public static <T> ReactiveSeq<T> ofNullable(T nullable){
if(nullable==null){
return empty();
}
return of(nullable);
}
public static <T> ReactiveSeq<T> empty(){
return of();
}
public static <T> ReactiveSeq<T> of(T... values){
return syncStream(new ArrayOfValuesOperator<T>(values));
}
public static <T> ReactiveSeq<T> fromIterable(Iterable<T> iterable){
if(iterable instanceof ReactiveStreamX)
return (ReactiveSeq<T>)iterable;
return syncStream(new IterableSourceOperator<T>(iterable));
}
public static <T> ReactiveSeq<T> fromSpliterator(Spliterator<T> spliterator){
return syncStream(new SpliteratorToOperator<T>(spliterator));
}
/**
* @see Stream#generate(Supplier)
*/
static <T> ReactiveSeq<T> generate(final Supplier<T> s) {
return syncStream(new GenerateOperator<T>(s));
}
static <T> ReactiveSeq<T> from(Publisher<? extends T> pub){
if(pub instanceof ReactiveSeq)
return (ReactiveSeq<T>)pub;
return reactiveStream(new PublisherToOperator<T>((Publisher<T>)pub));
}
@Deprecated //use mergeLatest
static <T> ReactiveSeq<T> merge(Publisher<? extends Publisher<T>> publisher){
return mergeLatest(publisher);
}
static <T> ReactiveSeq<T> mergeLatestList(Seq<? extends Publisher<? extends T>> publisher){
return mergeLatest((Publisher[])publisher.toArray(s->new Publisher[s]));
}
static <T> ReactiveSeq<T> mergeLatest(Publisher<? extends Publisher<T>> publisher){
return Spouts.from(publisher).mergeMap(Integer.MAX_VALUE,i->i);
}
static <T> ReactiveSeq<T> mergeLatest(int maxConcurrency,Publisher<T>... array){
return Spouts.of(array).mergeMap(maxConcurrency, i->i);
}
static <T> ReactiveSeq<T> mergeLatest(Publisher<T>... array){
Operator<T>[] op = new Operator[array.length];
for(int i=0;i<array.length;i++){
if(array[i] instanceof ReactiveStreamX){
ReactiveStreamX<T> stream = (ReactiveStreamX<T>)array[i];
op[i] = stream.getSource();
}else{
op[i] = new PublisherToOperator<T>(array[i]);
}
}
return reactiveStream(new MergeLatestOperator<T>(op));
}
static <T> ReactiveSeq<T> amb(IterableX<? extends Publisher<? extends T>> list){
return amb(list.toArray(i->new ReactiveSeq[i]));
}
static <T> ReactiveSeq<T> amb(Publisher<? extends T>... array){
return ambWith(array);
}
static <T> ReactiveSeq<T> ambWith(Publisher<? extends T>[] array){
return reactiveStream(new AmbOperator<T>((Publisher<T>[])array));
}
static ReactiveSeq<Integer> interval(String cron,ScheduledExecutorService exec) {
ReactiveSubscriber<Integer> sub = reactiveSubscriber();
AtomicBoolean isOpen = new AtomicBoolean(true);
Subscription[] s= {null};
sub.onSubscribe(new Subscription() {
@Override
public void request(long n) {
s[0].request(n);
}
@Override
public void cancel() {
isOpen.set(false);
}
});
s[0] = ReactiveSeq.iterate(1, a -> a + 1)
.takeWhile(e -> isOpen.get())
.schedule(cron, exec)
.connect()
.forEach(1, e -> sub.onNext(e));
return sub.reactiveStream();
}
static ReactiveSeq<Integer> interval(final long millis,ScheduledExecutorService exec) {
ReactiveSubscriber<Integer> sub = reactiveSubscriber();
AtomicBoolean isOpen = new AtomicBoolean(true);
Subscription[] s= {null};
sub.onSubscribe(new Subscription() {
@Override
public void request(long n) {
s[0].request(n);
}
@Override
public void cancel() {
isOpen.set(false);
}
});
s[0] = ReactiveSeq.iterate(1, a -> a + 1)
.takeWhile(e -> isOpen.get())
.scheduleFixedDelay(millis, exec)
.connect()
.forEach(1, e -> sub.onNext(e));
return sub.reactiveStream();
}
static <T> ReactiveSeq<T> schedule(final Stream<T> stream,final String cron,final ScheduledExecutorService exec) {
ReactiveSubscriber<T> sub = reactiveSubscriber();
AtomicBoolean isOpen = new AtomicBoolean(true);
Subscription[] s= {null};
sub.onSubscribe(new Subscription() {
@Override
public void request(long n) {
s[0].request(n);
}
@Override
public void cancel() {
isOpen.set(false);
}
});
s[0] = ReactiveSeq.fromStream(stream)
.takeWhile(e -> isOpen.get())
.schedule(cron, exec)
.connect()
.forEach(0, e -> sub.onNext(e),t->sub.onError(t),()->sub.onComplete());
return sub.reactiveStream();
}
static <T> ReactiveSeq<T> defer(final Supplier<? extends Publisher<? extends T>> s){
return of(s).mergeMap(i->i.get());
}
static <T> ReactiveSeq<T> deferFromStream(final Supplier<? extends Stream<? extends T>> s){
return of(s).flatMap(i->i.get());
}
static <T> ReactiveSeq<T> deferFromIterable(final Supplier<? extends Iterable<? extends T>> s){
return of(s).concatMap(i->i.get());
}
/**
* Unfold a function into a ReactiveSeq
*
* <pre>
* {@code
* ReactiveSeq.unfold(1,i->i<=6 ? Optional.of(Tuple.tuple(i,i+1)) : Optional.empty());
*
* //(1,2,3,4,5)
*
* }</code>
*
* @param seed Initial value
* @param unfolder Iteratively applied function, terminated by an empty Optional
* @return ReactiveSeq generated by unfolder function
*/
static <U, T> ReactiveSeq<T> unfold(final U seed, final Function<? super U, Option<Tuple2<T, U>>> unfolder) {
return reactiveStream(new SpliteratorToOperator<T>(new UnfoldSpliterator<>(seed, unfolder)));
}
public static <T> ReactiveSeq<T> concat(Publisher<Publisher<T>> pubs){
return reactiveStream(new LazyArrayConcatonatingOperator<T>(Spouts.from(pubs).seq()
.map(p->new PublisherToOperator<T>(p))));
}
@Deprecated
public static <T> ReactiveSeq<T> lazyConcat(Publisher<Publisher<T>> pubs){
return reactiveStream(new LazyArrayConcatonatingOperator<T>(Spouts.from(pubs).seq()
.map(p->new PublisherToOperator<T>(p))));
}
public static <T> ReactiveSeq<T> concat(Stream<? extends T>... streams){
ReactiveSeq<Stream<T>> rs = ReactiveSeq.of((Stream[]) streams);
return concat(rs.map(ReactiveSeq::fromStream));
}
/**
* Convert the raw Higher Kinded Type for ReactiveSeq types into the ReactiveSeq type definition class
*
* @param future HKT encoded list into a ReactiveSeq
* @return ReactiveSeq
*/
public static <T> ReactiveSeq<T> narrowK(final Higher<reactiveSeq, T> future) {
return (ReactiveSeq<T>) future;
}
}
