Java Flow.Publisher方法代码示例

import java.util.concurrent.Flow; //导入方法依赖的package包/类
@Override
public void onError(Throwable throwable) {
    if (once) {
        actual.onError(throwable);
        return;
    }
    once = true;
    Flow.Publisher<? extends T> p;

    try {
        p = Objects.requireNonNull(handler.apply(throwable), "The handler returned a null Flow.Publisher");
    } catch (Throwable ex) {
        actual.onError(new CompositeThrowable(throwable, ex));
        return;
    }

    long c = produced;
    if (c != 0) {
        arbiterProduced(c);
    }
    p.subscribe(this);
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
@Override
protected void subscribeActual(FolyamSubscriber<? super R> s) {
    Flow.Publisher<? extends R> p;
    ConnectableFolyam<U> conn;
    try {
        conn = Objects.requireNonNull(multicaster.apply(source), "The multicaster returned a null ConnectableFolyam");
        p = Objects.requireNonNull(handler.apply(conn), "The handler returned a null Flow.Publisher");
    } catch (Throwable ex) {
        EmptySubscription.error(s, ex);
        return;
    }

    SequentialAutoDisposable sd = new SequentialAutoDisposable();

    if (s instanceof ConditionalSubscriber) {
        p.subscribe(new FolyamPublish.PublishConditionalSubscriber<>((ConditionalSubscriber<? super R>)s, sd));
    } else {
        p.subscribe(new FolyamPublish.PublishSubscriber<>(s, sd));
    }

    conn.connect(sd::replace);
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
@Override
public Flow.Publisher<List<Long>> createFlowPublisher(long elements) {
    return
        Folyam.fromIterable(iterate(elements))
        .buffer(Folyam.just(1).concatWith(Folyam.<Integer>never()))
        .onBackpressureLatest()
    ;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
@Override
public boolean tryOnNext(T item) {

    boolean b = false;

    long idx = (long)INDEX.getAcquire(this);

    if (idx != Long.MAX_VALUE && INDEX.compareAndSet(this, idx, idx + 1)) {
        AutoDisposable d = task;
        if (d != null && d != DisposableHelper.CLOSED) {
            task = null;
            b = !SubscriptionHelper.cancel((ItemSubscriber<?>)d);
        }

        Flow.Publisher<?> p;
        try {
            p = Objects.requireNonNull(itemDebouncer.apply(item), "The itemDebouncer returned a null Flow.Publisher");
        } catch (Throwable ex) {
            upstream.cancel();
            onError(ex);
            return false;
        }

        ItemSubscriber<T> inner = new ItemSubscriber<>(idx + 1, item, this);
        if (DisposableHelper.replace(this, TASK, inner)) {
            p.subscribe(inner);
        }
    }

    return b;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
@Override
public Flow.Publisher<Integer> createFlowPublisher(long elements) {
    return
            Folyam.range(0, (int)elements)
            .flatMap(Folyam::just)
        ;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
public FolyamSwitchFlatMap(Folyam<T> source,
                    CheckedFunction<? super T, ? extends Flow.Publisher<? extends R>> mapper,
                      int maxActive, int bufferSize) {
    super();
    this.source = source;
    this.mapper = mapper;
    this.maxActive = maxActive;
    this.bufferSize = bufferSize;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
SwitchFlatMapSubscriber(FolyamSubscriber<? super R> actual,
                        CheckedFunction<? super T, ? extends Flow.Publisher<? extends R>> mapper, int maxActive,
                        int bufferSize) {
    this.actual = actual;
    this.mapper = mapper;
    this.maxActive = maxActive;
    this.bufferSize = bufferSize;
    this.active = new ArrayDeque<>();
    this.activeCache = new SfmInnerSubscriber[maxActive];
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
@SuppressWarnings("unchecked")
@Override
public Flow.Publisher<Long> createFlowPublisher(long elements) {
    return
        Folyam.combineLatest(Arrays.asList(
                Folyam.just(1L),
                Folyam.fromIterable(iterate(elements))
            ),
                a -> (Long)a[0]
        )
    ;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
protected ConcatArraySubscriber(FolyamSubscriber<? super T> actual, Flow.Publisher<? extends T>[] sources, boolean delayError) {
    super(sources, delayError);
    this.actual = actual;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
protected TimeoutTimedSelectorFallbackConditionalSubscriber(ConditionalSubscriber<? super T> actual, Flow.Publisher<?> firstTimeout, CheckedFunction<? super T, ? extends Flow.Publisher<?>> itemTimeoutSelector, Flow.Publisher<? extends T> fallback) {
    super(firstTimeout, itemTimeoutSelector, fallback);
    this.actual = actual;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
@Override
public Flow.Publisher<Integer> createFlowPublisher(final long elements) {
    return
            Folyam.range(1, 1000).reduce((a, b) -> a + b).toFolyam()
        ;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
public FolyamCombineLatestIterable(Iterable<? extends Flow.Publisher<? extends T>> sources, CheckedFunction<? super Object[], ? extends R> combiner, int prefetch, boolean delayError) {
    this.sources = sources;
    this.combiner = combiner;
    this.prefetch = prefetch;
    this.delayError = delayError;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
public ReactivePublisherFromFlow(Flow.Publisher<? extends T> flowPublisher) {
    this.flow = flowPublisher;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
@Override
public Flow.Publisher<Integer> createFlowPublisher(long elements) {
    return
            Folyam.range(0, (int)elements * 2).skipLast((int)elements)
    ;
}
 

import java.util.concurrent.Flow; //导入方法依赖的package包/类
AbstractConcatIterable(boolean delayError, Iterator<? extends Flow.Publisher<? extends T>> sources) {
    this.delayError = delayError;
    this.sources = sources;
}