• Home
• com.commercetools.sdk
• rmf-java-base
• 17.15.1
• source code
• ClientUtils.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.

io.vrap.rmf.base.client.utils.ClientUtils Maven / Gradle / Ivy

package io.vrap.rmf.base.client.utils;

import static java.util.stream.Collectors.toList;

import java.time.Duration;
import java.util.List;
import java.util.concurrent.*;
import java.util.function.Function;
import java.util.stream.Collector;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import io.vrap.rmf.base.client.ApiHttpRequest;
import io.vrap.rmf.base.client.error.RmfTimeoutException;

public class ClientUtils {
    /**
     * Waits with a timeout for RESPONSES of a client wrapped in a {@link CompletionStage}.
     * This method should not be used for other {@link CompletionStage}s since it is throwing {@link io.vrap.rmf.base.client.error.BaseException}s.
     *
     * @param completionStage the future monad to wait for
     * @param request the request belonging to the completionStage
     * @param duration the maximum duration to wait for this single request
     * @param  type of the result for the request
     * @return the wrapped value of {@code completionStage}
     * @throws RmfTimeoutException if a timeout occurs
     */
    public static  T blockingWait(final CompletionStage completionStage, final ApiHttpRequest request,
            final Duration duration) {
        return blockingWait(completionStage, request, duration.toMillis(), TimeUnit.MILLISECONDS);
    }

    /**
     * Waits with a timeout for RESPONSES of a client wrapped in a {@link CompletionStage}.
     * This method should not be used for other {@link CompletionStage}s since it is throwing {@link io.vrap.rmf.base.client.error.BaseException}s.
     *
     * @param completionStage the future monad to wait for
     * @param duration the maximum duration to wait for this single request
     * @param  type of the result for the request
     * @return the wrapped value of {@code completionStage}
     * @throws RmfTimeoutException if a timeout occurs
     */
    public static  T blockingWait(final CompletionStage completionStage, final Duration duration) {
        return blockingWait(completionStage, duration.toMillis(), TimeUnit.MILLISECONDS);
    }

    /**
     * Waits with a timeout for RESPONSES of a client wrapped in a {@link CompletionStage}.
     * This method should not be used for other {@link CompletionStage}s since it is throwing {@link io.vrap.rmf.base.client.error.BaseException}s.
     *
     * @param completionStage the future monad to wait for
     * @param timeout the maximum time to wait for this single request
     * @param unit the time unit of the timeout argument
     * @param  type of the result for the request
     * @return the wrapped value of {@code completionStage}
     * @throws RmfTimeoutException if a timeout occurs
     */
    public static  T blockingWait(final CompletionStage completionStage, final long timeout,
            final TimeUnit unit) {
        return blockingWait(completionStage, null, timeout, unit);
    }

    /**
     * Waits with a timeout for RESPONSES of a client wrapped in a {@link CompletionStage}.
     * This method should not be used for other {@link CompletionStage}s since it is throwing {@link io.vrap.rmf.base.client.error.BaseException}s.
     *
     * @param completionStage the future monad to wait for
     * @param request the request belonging to the completionStage
     * @param timeout the maximum time to wait for this single request
     * @param unit the time unit of the timeout argument
     * @param  type of the result for the request
     * @return the wrapped value of {@code completionStage}
     * @throws RmfTimeoutException if a timeout occurs
     */
    public static  T blockingWait(final CompletionStage completionStage, final ApiHttpRequest request,
            final long timeout, final TimeUnit unit) {
        try {
            return completionStage.toCompletableFuture().get(timeout, unit);
        }
        catch (InterruptedException e) {
            Thread.currentThread().interrupt();
            throw new CompletionException(e);
        }
        catch (ExecutionException e) {
            final Throwable cause = e.getCause() != null ? e.getCause() : e;
            throw cause instanceof RuntimeException ? (RuntimeException) cause : new CompletionException(cause);
        }
        catch (final TimeoutException e) {
            throw new RmfTimeoutException(e, request);
        }
    }

    public static  List blockingWaitForEach(final Stream> stream,
            final Duration duration) {
        return blockingWaitForEach(stream, duration.toMillis(), TimeUnit.MILLISECONDS);
    }

    public static  List blockingWaitForEach(final Stream> stream, final long timeout,
            final TimeUnit unit) {
        return stream.map(stage -> blockingWait(stage, timeout, unit)).collect(toList());
    }

    public static  List blockingWaitForEach(final List> list,
            final Duration duration) {
        return blockingWaitForEach(list, duration.toMillis(), TimeUnit.MILLISECONDS);
    }

    public static  List blockingWaitForEach(final List> list, final long timeout,
            final TimeUnit unit) {
        return blockingWaitForEach(list.stream(), timeout, unit);
    }

    public static , T> Collector> blockingWaitForEachCollector(
            final long timeout, final TimeUnit unit) {
        final Function, T> mapper = stage -> blockingWait(stage, timeout, unit);
        return Collectors.mapping(mapper, toList());
    }

    public static , T> Collector> blockingWaitForEachCollector(
            final Duration duration) {
        return blockingWaitForEachCollector(duration.toMillis(), TimeUnit.MILLISECONDS);
    }
}