org.asynchttpclient.extras.rxjava.single.AsyncHttpSingle Maven / Gradle / Ivy

Go to download
/*
 * Copyright (c) 2015 AsyncHttpClient Project. All rights reserved.
 *
 * This program is licensed to you under the Apache License Version 2.0,
 * and you may not use this file except in compliance with the Apache License Version 2.0.
 * You may obtain a copy of the Apache License Version 2.0 at http://www.apache.org/licenses/LICENSE-2.0.
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the Apache License Version 2.0 is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the Apache License Version 2.0 for the specific language governing permissions and limitations there under.
 */
package org.asynchttpclient.extras.rxjava.single;

import static java.util.Objects.requireNonNull;

import org.asynchttpclient.AsyncCompletionHandlerBase;
import org.asynchttpclient.AsyncHandler;
import org.asynchttpclient.BoundRequestBuilder;
import org.asynchttpclient.Response;
import org.asynchttpclient.handler.ProgressAsyncHandler;

import java.util.concurrent.Future;

import rx.Single;
import rx.SingleSubscriber;
import rx.functions.Func0;
import rx.functions.Func1;
import rx.subscriptions.Subscriptions;

/**
 * Wraps HTTP requests into RxJava {@code Single} instances.
 *
 * @see https://github.com/
 *      ReactiveX/RxJava
 */
public final class AsyncHttpSingle {

    /**
     * Emits the responses to HTTP requests obtained from {@code builder}.
     *
     * @param builder used to build the HTTP request that is to be executed
     * @return a {@code Single} that executes new requests on subscription
     *         obtained from {@code builder} on subscription and that emits the
     *         response
     *
     * @throws NullPointerException if {@code builder} is {@code null}
     */
    public static Single create(BoundRequestBuilder builder) {
        requireNonNull(builder);
        return create(builder::execute, AsyncCompletionHandlerBase::new);
    }

    /**
     * Emits the responses to HTTP requests obtained by calling
     * {@code requestTemplate}.
     *
     * @param requestTemplate called to start the HTTP request with an
     *            {@code AysncHandler} that builds the HTTP response and
     *            propagates results to the returned {@code Single}. The
     *            {@code Future} that is returned by {@code requestTemplate}
     *            will be used to cancel the request when the {@code Single} is
     *            unsubscribed.
     *
     * @return a {@code Single} that executes new requests on subscription by
     *         calling {@code requestTemplate} and that emits the response
     *
     * @throws NullPointerException if {@code requestTemplate} is {@code null}
     */
    public static Single create(Func1, ? extends Future> requestTemplate) {
        return create(requestTemplate, AsyncCompletionHandlerBase::new);
    }

    /**
     * Emits the results of {@code AsyncHandlers} obtained from
     * {@code handlerSupplier} for HTTP requests obtained from {@code builder}.
     *
     * @param builder used to build the HTTP request that is to be executed
     * @param handlerSupplier supplies the desired {@code AsyncHandler}
     *            instances that are used to produce results
     *
     * @return a {@code Single} that executes new requests on subscription
     *         obtained from {@code builder} and that emits the result of the
     *         {@code AsyncHandler} obtained from {@code handlerSupplier}
     *
     * @throws NullPointerException if at least one of the parameters is
     *             {@code null}
     */
    public static  Single create(BoundRequestBuilder builder, Func0> handlerSupplier) {
        requireNonNull(builder);
        return create(builder::execute, handlerSupplier);
    }

    /**
     * Emits the results of {@code AsyncHandlers} obtained from
     * {@code handlerSupplier} for HTTP requests obtained obtained by calling
     * {@code requestTemplate}.
     *
     * @param requestTemplate called to start the HTTP request with an
     *            {@code AysncHandler} that builds the HTTP response and
     *            propagates results to the returned {@code Single}.  The
     *            {@code Future} that is returned by {@code requestTemplate}
     *            will be used to cancel the request when the {@code Single} is
     *            unsubscribed.
     * @param handlerSupplier supplies the desired {@code AsyncHandler}
     *            instances that are used to produce results
     *
     * @return a {@code Single} that executes new requests on subscription by
     *         calling {@code requestTemplate} and that emits the results
     *         produced by the {@code AsyncHandlers} supplied by
     *         {@code handlerSupplier}
     *
     * @throws NullPointerException if at least one of the parameters is
     *             {@code null}
     */
    public static  Single create(Func1, ? extends Future> requestTemplate,
            Func0> handlerSupplier) {

        requireNonNull(requestTemplate);
        requireNonNull(handlerSupplier);

        return Single.create(subscriber -> {
            final AsyncHandler bridge = createBridge(subscriber, handlerSupplier.call());
            final Future responseFuture = requestTemplate.call(bridge);
            subscriber.add(Subscriptions.from(responseFuture));
        });
    }

    static  AsyncHandler createBridge(SingleSubscriber subscriber, AsyncHandler handler) {

        if (handler instanceof ProgressAsyncHandler) {
            return new ProgressAsyncSingleSubscriberBridge<>(subscriber, (ProgressAsyncHandler) handler);
        }

        return new AsyncSingleSubscriberBridge<>(subscriber, handler);
    }

    private AsyncHttpSingle() {
        throw new AssertionError("No instances for you!");
    }
}