import com.google.common.annotations.Beta;
import com.google.common.util.concurrent.FluentFuture;
import com.google.common.util.concurrent.Futures;
-import com.google.common.util.concurrent.ListenableFuture;
import com.google.common.util.concurrent.SettableFuture;
import java.util.concurrent.CompletableFuture;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Supplier;
-import javax.annotation.concurrent.ThreadSafe;
import org.eclipse.jdt.annotation.NonNullByDefault;
import org.eclipse.jdt.annotation.Nullable;
*/
@Beta
@NonNullByDefault
-@ThreadSafe
-public class CheckedValue<T, E extends Exception> extends Variant<T, E> {
+public class CheckedValue<T, E extends Exception> extends Either<T, E> {
protected CheckedValue(final T value) {
super(value);
}
* @param <E> Exception type
* @return Resulting {@link CheckedValue}
*/
- public static <T, U, E extends Exception> CheckedValue<T, E> ofVariant(final Variant<T, U> variant,
+ public static <T, U, E extends Exception> CheckedValue<T, E> ofVariant(final Either<T, U> variant,
final Function<U, E> mapper) {
requireNonNull(mapper);
return variant.isFirst() ? new CheckedValue<>(variant.first())
@SuppressWarnings("unchecked")
public <X extends Exception> CheckedValue<T, X> mapException(final Function<? super E, X> mapper) {
requireNonNull(mapper);
- if (isFirst()) {
- return (CheckedValue<T, X>) this;
- }
- return new CheckedValue<>(mapper.apply(second()), null);
+ return isFirst() ? (CheckedValue<T, X>) this : new CheckedValue<>(mapper.apply(second()), null);
}
-
@SuppressWarnings("unchecked")
public <U> CheckedValue<U, E> flatMap(final Function<? super T, CheckedValue<U, E>> mapper) {
requireNonNull(mapper);
* @return A {@link CompletableFuture}.
*/
public final CompletableFuture<T> toCompletableFuture() {
- if (isFirst()) {
- return CompletableFuture.completedFuture(first());
- }
- // FIXME: Java 9: use CompletableFuture.failedFuture()
- final CompletableFuture<T> future = new CompletableFuture<>();
- future.completeExceptionally(second());
- return future;
+ return isFirst() ? CompletableFuture.completedFuture(first()) : CompletableFuture.failedFuture(second());
}
/**
* @return A {@link FluentFuture}.
*/
public final FluentFuture<T> toFluentFuture() {
- final ListenableFuture<T> future;
- if (isFirst()) {
- future = Futures.immediateFuture(first());
- } else {
- future = Futures.immediateFailedFuture(second());
- }
- return FluentFuture.from(future);
+ return FluentFuture.from(isFirst() ? Futures.immediateFuture(first())
+ : Futures.immediateFailedFuture(second()));
}
}