Interface Disposable

reactor-core/src/main/java/reactor/core/Disposable.java:28–168

Indicates that a task or resource can be cancelled/disposed. Call to the dispose method is/should be idempotent.

 * <p>Call to the dispose method is/should be idempotent.
 */
@FunctionalInterface
public interface Disposable {

	/**
	 * Cancel or dispose the underlying task or resource.
	 * <p>
	 * Implementations are required to make this method idempotent.
	 */
	void dispose();

	/**
	 * Optionally return {@literal true} when the resource or task is disposed.
	 * <p>
	 * Implementations are not required to track disposition and as such may never
	 * return {@literal true} even when disposed. However, they MUST only return true
	 * when there's a guarantee the resource or task is disposed.
	 *
	 * @return {@literal true} when there's a guarantee the resource or task is disposed.
	 */
	default boolean isDisposed() {
		return false;
	}

	/**
	 * A {@link Disposable} container that allows updating/replacing its inner Disposable
	 * atomically and with respect of disposing the container itself.
	 *
	 * @author Simon Baslé
	 */
	interface Swap extends Disposable, Supplier<Disposable> {

		/**
		 * Atomically set the next {@link Disposable} on this container and dispose the previous
		 * one (if any). If the container has been disposed, fall back to disposing {@code next}.
		 *
		 * @param next the {@link Disposable} to set, may be null
		 * @return true if the operation succeeded, false if the container has been disposed
		 * @see #replace(Disposable)
		 */
		boolean update(@Nullable Disposable next);

		/**
		 * Atomically set the next {@link Disposable} on this container but don't dispose the previous
		 * one (if any). If the container has been disposed, fall back to disposing {@code next}.
		 *
		 * @param next the {@link Disposable} to set, may be null
		 * @return true if the operation succeeded, false if the container has been disposed
		 * @see #update(Disposable)
		 */
		boolean replace(@Nullable Disposable next);
	}

	/**
	 * A container of {@link Disposable} that is itself {@link Disposable}. Accumulate
	 * disposables and dispose them all in one go by using {@link #dispose()}. Using
	 * the {@link #add(Disposable)} methods give ownership to the container, which is now
	 * responsible for disposing them. You can however retake ownership of individual
	 * elements by keeping a reference and using {@link #remove(Disposable)}, which puts