Copyright (c) 2016-present, RxJava Contributors.
Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software distributed under the License is
distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
the License for the specific language governing permissions and limitations under the License.
/**
 * Copyright (c) 2016-present, RxJava Contributors.
 *
 * Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in
 * compliance with the License. You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software distributed under the License is
 * distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See
 * the License for the specific language governing permissions and limitations under the License.
 */

package io.reactivex.disposables;

import java.util.concurrent.Future;

import io.reactivex.annotations.NonNull;
import io.reactivex.functions.Action;
import io.reactivex.internal.disposables.EmptyDisposable;
import io.reactivex.internal.functions.*;
import org.reactivestreams.Subscription;

Utility class to help create disposables by wrapping
other types.
Since:
2.0/**
 * Utility class to help create disposables by wrapping
 * other types.
 * @since 2.0
 */
public final class Disposables {
    
Utility class. /** Utility class. */
    private Disposables() {
        throw new IllegalStateException("No instances!");
    }

    
Construct a Disposable by wrapping a Runnable that is
executed exactly once when the Disposable is disposed.
Params:
run – the Runnable to wrap
Returns:
the new Disposable instance/**
     * Construct a Disposable by wrapping a Runnable that is
     * executed exactly once when the Disposable is disposed.
     * @param run the Runnable to wrap
     * @return the new Disposable instance
     */
    @NonNull
    public static Disposable fromRunnable(@NonNull Runnable run) {
        ObjectHelper.requireNonNull(run, "run is null");
        return new RunnableDisposable(run);
    }

    
Construct a Disposable by wrapping a Action that is
executed exactly once when the Disposable is disposed.
Params:
run – the Action to wrap
Returns:
the new Disposable instance/**
     * Construct a Disposable by wrapping a Action that is
     * executed exactly once when the Disposable is disposed.
     * @param run the Action to wrap
     * @return the new Disposable instance
     */
    @NonNull
    public static Disposable fromAction(@NonNull Action run) {
        ObjectHelper.requireNonNull(run, "run is null");
        return new ActionDisposable(run);
    }

    
Construct a Disposable by wrapping a Future that is
cancelled exactly once when the Disposable is disposed.
Params:
future – the Future to wrap
Returns:
the new Disposable instance/**
     * Construct a Disposable by wrapping a Future that is
     * cancelled exactly once when the Disposable is disposed.
     * @param future the Future to wrap
     * @return the new Disposable instance
     */
    @NonNull
    public static Disposable fromFuture(@NonNull Future<?> future) {
        ObjectHelper.requireNonNull(future, "future is null");
        return fromFuture(future, true);
    }

    
Construct a Disposable by wrapping a Future that is
cancelled exactly once when the Disposable is disposed.
Params:
future – the Future to wrap
allowInterrupt – if true, the future cancel happens via Future.cancel(true)
Returns:
the new Disposable instance/**
     * Construct a Disposable by wrapping a Future that is
     * cancelled exactly once when the Disposable is disposed.
     * @param future the Future to wrap
     * @param allowInterrupt if true, the future cancel happens via Future.cancel(true)
     * @return the new Disposable instance
     */
    @NonNull
    public static Disposable fromFuture(@NonNull Future<?> future, boolean allowInterrupt) {
        ObjectHelper.requireNonNull(future, "future is null");
        return new FutureDisposable(future, allowInterrupt);
    }

    
Construct a Disposable by wrapping a Subscription that is
cancelled exactly once when the Disposable is disposed.
Params:
subscription – the Runnable to wrap
Returns:
the new Disposable instance/**
     * Construct a Disposable by wrapping a Subscription that is
     * cancelled exactly once when the Disposable is disposed.
     * @param subscription the Runnable to wrap
     * @return the new Disposable instance
     */
    @NonNull
    public static Disposable fromSubscription(@NonNull Subscription subscription) {
        ObjectHelper.requireNonNull(subscription, "subscription is null");
        return new SubscriptionDisposable(subscription);
    }

    
Returns a new, non-disposed Disposable instance.
Returns:
a new, non-disposed Disposable instance/**
     * Returns a new, non-disposed Disposable instance.
     * @return a new, non-disposed Disposable instance
     */
    @NonNull
    public static Disposable empty() {
        return fromRunnable(Functions.EMPTY_RUNNABLE);
    }

    
Returns a disposed Disposable instance.
Returns:
a disposed Disposable instance/**
     * Returns a disposed Disposable instance.
     * @return a disposed Disposable instance
     */
    @NonNull
    public static Disposable disposed() {
        return EmptyDisposable.INSTANCE;
    }
}