• Home
• org.reactivestreams
• reactive-streams-flow-adapters
• 1.0.2
• source code
• FlowAdapters.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.reactivestreams.FlowAdapters Maven / Gradle / Ivy

/************************************************************************
 * Licensed under Public Domain (CC0)                                    *
 *                                                                       *
 * To the extent possible under law, the person who associated CC0 with  *
 * this code has waived all copyright and related or neighboring         *
 * rights to this code.                                                  *
 *                                                                       *
 * You should have received a copy of the CC0 legalcode along with this  *
 * work. If not, see .*
 ************************************************************************/

package org.reactivestreams;

import java.util.concurrent.Flow;

/**
 * Bridge between Reactive Streams API and the Java 9 {@link java.util.concurrent.Flow} API.
 */
public final class FlowAdapters {
    /** Utility class. */
    private FlowAdapters() {
        throw new IllegalStateException("No instances!");
    }

    /**
     * Converts a Flow Publisher into a Reactive Streams Publisher.
     * @param  the element type
     * @param flowPublisher the source Flow Publisher to convert
     * @return the equivalent Reactive Streams Publisher
     */
    @SuppressWarnings("unchecked")
    public static  org.reactivestreams.Publisher toPublisher(
            Flow.Publisher flowPublisher) {
        if (flowPublisher == null) {
            throw new NullPointerException("flowPublisher");
        }
        if (flowPublisher instanceof FlowPublisherFromReactive) {
            return (org.reactivestreams.Publisher)(((FlowPublisherFromReactive)flowPublisher).reactiveStreams);
        }
        if (flowPublisher instanceof org.reactivestreams.Publisher) {
            return (org.reactivestreams.Publisher)flowPublisher;
        }
        return new ReactivePublisherFromFlow(flowPublisher);
    }

    /**
     * Converts a Reactive Streams Publisher into a Flow Publisher.
     * @param  the element type
     * @param reactiveStreamsPublisher the source Reactive Streams Publisher to convert
     * @return the equivalent Flow Publisher
     */
    @SuppressWarnings("unchecked")
    public static  Flow.Publisher toFlowPublisher(
            org.reactivestreams.Publisher reactiveStreamsPublisher
    ) {
        if (reactiveStreamsPublisher == null) {
            throw new NullPointerException("reactiveStreamsPublisher");
        }
        if (reactiveStreamsPublisher instanceof ReactivePublisherFromFlow) {
            return (Flow.Publisher)(((ReactivePublisherFromFlow)reactiveStreamsPublisher).flow);
        }
        if (reactiveStreamsPublisher instanceof Flow.Publisher) {
            return (Flow.Publisher)reactiveStreamsPublisher;
        }
        return new FlowPublisherFromReactive(reactiveStreamsPublisher);
    }

    /**
     * Converts a Flow Processor into a Reactive Streams Processor.
     * @param  the input value type
     * @param  the output value type
     * @param flowProcessor the source Flow Processor to convert
     * @return the equivalent Reactive Streams Processor
     */
    @SuppressWarnings("unchecked")
    public static  org.reactivestreams.Processor toProcessor(
            Flow.Processor flowProcessor
    ) {
        if (flowProcessor == null) {
            throw new NullPointerException("flowProcessor");
        }
        if (flowProcessor instanceof FlowToReactiveProcessor) {
            return (org.reactivestreams.Processor)(((FlowToReactiveProcessor)flowProcessor).reactiveStreams);
        }
        if (flowProcessor instanceof org.reactivestreams.Processor) {
            return (org.reactivestreams.Processor)flowProcessor;
        }
        return new ReactiveToFlowProcessor(flowProcessor);
    }

    /**
     * Converts a Reactive Streams Processor into a Flow Processor.
     * @param  the input value type
     * @param  the output value type
     * @param reactiveStreamsProcessor the source Reactive Streams Processor to convert
     * @return the equivalent Flow Processor
     */
    @SuppressWarnings("unchecked")
    public static  Flow.Processor toFlowProcessor(
            org.reactivestreams.Processor reactiveStreamsProcessor
        ) {
        if (reactiveStreamsProcessor == null) {
            throw new NullPointerException("reactiveStreamsProcessor");
        }
        if (reactiveStreamsProcessor instanceof ReactiveToFlowProcessor) {
            return (Flow.Processor)(((ReactiveToFlowProcessor)reactiveStreamsProcessor).flow);
        }
        if (reactiveStreamsProcessor instanceof Flow.Processor) {
            return (Flow.Processor)reactiveStreamsProcessor;
        }
        return new FlowToReactiveProcessor(reactiveStreamsProcessor);
    }

    /**
     * Converts a Reactive Streams Subscriber into a Flow Subscriber.
     * @param  the input and output value type
     * @param reactiveStreamsSubscriber the Reactive Streams Subscriber instance to convert
     * @return the equivalent Flow Subscriber
     */
    @SuppressWarnings("unchecked")
    public static  Flow.Subscriber toFlowSubscriber(org.reactivestreams.Subscriber reactiveStreamsSubscriber) {
        if (reactiveStreamsSubscriber == null) {
            throw new NullPointerException("reactiveStreamsSubscriber");
        }
        if (reactiveStreamsSubscriber instanceof ReactiveToFlowSubscriber) {
            return (Flow.Subscriber)((ReactiveToFlowSubscriber)reactiveStreamsSubscriber).flow;
        }
        if (reactiveStreamsSubscriber instanceof Flow.Subscriber) {
            return (Flow.Subscriber)reactiveStreamsSubscriber;
        }
        return new FlowToReactiveSubscriber(reactiveStreamsSubscriber);
    }

    /**
     * Converts a Flow Subscriber into a Reactive Streams Subscriber.
     * @param  the input and output value type
     * @param flowSubscriber the Flow Subscriber instance to convert
     * @return the equivalent Reactive Streams Subscriber
     */
    @SuppressWarnings("unchecked")
    public static  org.reactivestreams.Subscriber toSubscriber(Flow.Subscriber flowSubscriber) {
        if (flowSubscriber == null) {
            throw new NullPointerException("flowSubscriber");
        }
        if (flowSubscriber instanceof FlowToReactiveSubscriber) {
            return (org.reactivestreams.Subscriber)((FlowToReactiveSubscriber)flowSubscriber).reactiveStreams;
        }
        if (flowSubscriber instanceof org.reactivestreams.Subscriber) {
            return (org.reactivestreams.Subscriber)flowSubscriber;
        }
        return new ReactiveToFlowSubscriber(flowSubscriber);
    }

    /**
     * Wraps a Reactive Streams Subscription and converts the calls to a Flow Subscription.
     */
    static final class FlowToReactiveSubscription implements Flow.Subscription {
        final org.reactivestreams.Subscription reactiveStreams;

        public FlowToReactiveSubscription(org.reactivestreams.Subscription reactive) {
            this.reactiveStreams = reactive;
        }

        @Override
        public void request(long n) {
            reactiveStreams.request(n);
        }

        @Override
        public void cancel() {
            reactiveStreams.cancel();
        }

    }

    /**
     * Wraps a Flow Subscription and converts the calls to a Reactive Streams Subscription.
     */
    static final class ReactiveToFlowSubscription implements org.reactivestreams.Subscription {
        final Flow.Subscription flow;

        public ReactiveToFlowSubscription(Flow.Subscription flow) {
            this.flow = flow;
        }

        @Override
        public void request(long n) {
            flow.request(n);
        }

        @Override
        public void cancel() {
            flow.cancel();
        }


    }

    /**
     * Wraps a Reactive Streams Subscriber and forwards methods of the Flow Subscriber to it.
     * @param  the element type
     */
    static final class FlowToReactiveSubscriber
            implements Flow.Subscriber {
        final org.reactivestreams.Subscriber reactiveStreams;

        public FlowToReactiveSubscriber(org.reactivestreams.Subscriber reactive) {
            this.reactiveStreams = reactive;
        }

        @Override
        public void onSubscribe(Flow.Subscription subscription) {
            reactiveStreams.onSubscribe((subscription == null) ? null : new ReactiveToFlowSubscription(subscription));
        }

        @Override
        public void onNext(T item) {
            reactiveStreams.onNext(item);
        }

        @Override
        public void onError(Throwable throwable) {
            reactiveStreams.onError(throwable);
        }

        @Override
        public void onComplete() {
            reactiveStreams.onComplete();
        }

    }

    /**
     * Wraps a Reactive Streams Subscriber and forwards methods of the Flow Subscriber to it.
     * @param  the element type
     */
    static final class ReactiveToFlowSubscriber
            implements org.reactivestreams.Subscriber {
        final Flow.Subscriber flow;

        public ReactiveToFlowSubscriber(Flow.Subscriber flow) {
            this.flow = flow;
        }

        @Override
        public void onSubscribe(org.reactivestreams.Subscription subscription) {
            flow.onSubscribe((subscription == null) ? null : new FlowToReactiveSubscription(subscription));
        }

        @Override
        public void onNext(T item) {
            flow.onNext(item);
        }

        @Override
        public void onError(Throwable throwable) {
            flow.onError(throwable);
        }

        @Override
        public void onComplete() {
            flow.onComplete();
        }

    }

    /**
     * Wraps a Flow Processor and forwards methods of the Reactive Streams Processor to it.
     * @param  the input type
     * @param  the output type
     */
    static final class ReactiveToFlowProcessor
            implements org.reactivestreams.Processor {
        final Flow.Processor flow;

        public ReactiveToFlowProcessor(Flow.Processor flow) {
            this.flow = flow;
        }

        @Override
        public void onSubscribe(org.reactivestreams.Subscription subscription) {
            flow.onSubscribe((subscription == null) ? null : new FlowToReactiveSubscription(subscription));
        }

        @Override
        public void onNext(T t) {
            flow.onNext(t);
        }

        @Override
        public void onError(Throwable t) {
            flow.onError(t);
        }

        @Override
        public void onComplete() {
            flow.onComplete();
        }

        @Override
        public void subscribe(org.reactivestreams.Subscriber s) {
            flow.subscribe((s == null) ? null : new FlowToReactiveSubscriber(s));
        }
    }

    /**
     * Wraps a Reactive Streams Processor and forwards methods of the Flow Processor to it.
     * @param  the input type
     * @param  the output type
     */
    static final class FlowToReactiveProcessor
            implements Flow.Processor {
        final org.reactivestreams.Processor reactiveStreams;

        public FlowToReactiveProcessor(org.reactivestreams.Processor reactive) {
            this.reactiveStreams = reactive;
        }

        @Override
        public void onSubscribe(Flow.Subscription subscription) {
            reactiveStreams.onSubscribe((subscription == null) ? null : new ReactiveToFlowSubscription(subscription));
        }

        @Override
        public void onNext(T t) {
            reactiveStreams.onNext(t);
        }

        @Override
        public void onError(Throwable t) {
            reactiveStreams.onError(t);
        }

        @Override
        public void onComplete() {
            reactiveStreams.onComplete();
        }

        @Override
        public void subscribe(Flow.Subscriber s) {
            reactiveStreams.subscribe((s == null) ? null : new ReactiveToFlowSubscriber(s));
        }
    }

    /**
     * Reactive Streams Publisher that wraps a Flow Publisher.
     * @param  the element type
     */
    static final class ReactivePublisherFromFlow implements org.reactivestreams.Publisher {

        final Flow.Publisher flow;

        public ReactivePublisherFromFlow(Flow.Publisher flowPublisher) {
            this.flow = flowPublisher;
        }

        @Override
        public void subscribe(org.reactivestreams.Subscriber reactive) {
            flow.subscribe((reactive == null) ? null : new FlowToReactiveSubscriber(reactive));
        }
    }

    /**
     * Flow Publisher that wraps a Reactive Streams Publisher.
     * @param  the element type
     */
    static final class FlowPublisherFromReactive implements Flow.Publisher {

        final org.reactivestreams.Publisher reactiveStreams;

        public FlowPublisherFromReactive(org.reactivestreams.Publisher reactivePublisher) {
            this.reactiveStreams = reactivePublisher;
        }

        @Override
        public void subscribe(Flow.Subscriber flow) {
            reactiveStreams.subscribe((flow == null) ? null : new ReactiveToFlowSubscriber(flow));
        }
    }

}