org.eclipse.jetty.util.Promise Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of ehcache Show documentation
Show all versions of ehcache Show documentation
Ehcache is an open source, standards-based cache used to boost performance,
offload the database and simplify scalability. Ehcache is robust, proven and full-featured and
this has made it the most widely-used Java-based cache.
The newest version!
//
// ========================================================================
// Copyright (c) 1995-2021 Mort Bay Consulting Pty Ltd and others.
// ------------------------------------------------------------------------
// All rights reserved. This program and the accompanying materials
// are made available under the terms of the Eclipse Public License v1.0
// and Apache License v2.0 which accompanies this distribution.
//
// The Eclipse Public License is available at
// http://www.eclipse.org/legal/epl-v10.html
//
// The Apache License v2.0 is available at
// http://www.opensource.org/licenses/apache2.0.php
//
// You may elect to redistribute this code under either of these licenses.
// ========================================================================
//
package org.eclipse.jetty.util;
import java.util.Objects;
import java.util.concurrent.CompletableFuture;
import org.eclipse.jetty.util.log.Log;
/**
* A callback abstraction that handles completed/failed events of asynchronous operations.
*
* @param the type of the context object
*/
public interface Promise
{
/**
* Callback invoked when the operation completes.
*
* @param result the context
* @see #failed(Throwable)
*/
default void succeeded(C result)
{
}
/**
* Callback invoked when the operation fails.
*
* @param x the reason for the operation failure
*/
default void failed(Throwable x)
{
}
/**
* Empty implementation of {@link Promise}.
*
* @param the type of the result
*/
class Adapter implements Promise
{
@Override
public void failed(Throwable x)
{
Log.getLogger(this.getClass()).warn(x);
}
}
/**
* Creates a promise from the given incomplete CompletableFuture.
* When the promise completes, either succeeding or failing, the
* CompletableFuture is also completed, respectively via
* {@link CompletableFuture#complete(Object)} or
* {@link CompletableFuture#completeExceptionally(Throwable)}.
*
* @param completable the CompletableFuture to convert into a promise
* @param the type of the result
* @return a promise that when completed, completes the given CompletableFuture
*/
static Promise from(CompletableFuture completable)
{
if (completable instanceof Promise)
return (Promise)completable;
return new Promise()
{
@Override
public void succeeded(T result)
{
completable.complete(result);
}
@Override
public void failed(Throwable x)
{
completable.completeExceptionally(x);
}
};
}
/**
* A CompletableFuture that is also a Promise.
*
* @param the type of the result
*/
class Completable extends CompletableFuture implements Promise
{
@Override
public void succeeded(S result)
{
complete(result);
}
@Override
public void failed(Throwable x)
{
completeExceptionally(x);
}
}
class Wrapper implements Promise
{
private final Promise promise;
public Wrapper(Promise promise)
{
this.promise = Objects.requireNonNull(promise);
}
@Override
public void succeeded(W result)
{
promise.succeeded(result);
}
@Override
public void failed(Throwable x)
{
promise.failed(x);
}
public Promise getPromise()
{
return promise;
}
public Promise unwrap()
{
Promise result = promise;
while (true)
{
if (result instanceof Wrapper)
result = ((Wrapper)result).unwrap();
else
break;
}
return result;
}
}
}