net.adamcin.oakpal.api

Class Result<V>

java.lang.Object

net.adamcin.oakpal.api.Result<V>

Type Parameters:

V - The result type.

All Implemented Interfaces:

Serializable

@ProviderType
public abstract class Result<V>
extends Object
implements Serializable

A type representing either a successful result value, or failure, with an error.

See Also:

Serialized Form

Nested Class Summary

Nested Classes

Modifier and Type	Class and Description
static class	Result.Builder<V,A> Builds a result for a wrapped collector.

Method Summary

Modifier and Type	Method and Description
static <V> Result<V>	failure(@NotNull Exception e)
static <V> Result<V>	failure(@NotNull RuntimeException e)
static <V> Result<V>	failure(String message)
static <V> Result<V>	failure(@NotNull String message, @NotNull Exception e)
<E extends Throwable> Optional<E>	findCause(@NotNull Class<E> errorType) Filters the exception stack as a stream, matching causes against the provided error type.
Optional<Throwable>	findCause(@NotNull Predicate<? super Throwable> predicate) Filters the exception stack as a stream using the provided Throwable predicate.
abstract <W> @NotNull Result<W>	flatMap(@NotNull Function<? super V,Result<W>> f) Flat-map it.
abstract void	forEach(@NotNull Consumer<? super V> consumer) Standard forEach method calling a consumer to accept the value.
abstract Optional<RuntimeException>	getError() All Failures will be created with a top-level RuntimeException.
abstract V	getOrDefault(V defaultValue)
abstract V	getOrElse(@NotNull Supplier<? extends V> defaultValue)
boolean	isFailure()
boolean	isSuccess()
static <V> Collector<Result<V>,Stream.Builder<Result<V>>,Stream<Result<V>>>	logAndRestream()
static <V> Collector<Result<V>,Stream.Builder<Result<V>>,Stream<Result<V>>>	logAndRestream(@NotNull String message)
abstract <W> @NotNull Result<W>	map(@NotNull Function<? super V,W> f) Map it.
abstract Result<V>	orElse(@NotNull Supplier<Result<V>> defaultValue)
abstract Stream<V>	stream()
static <V> Result<V>	success(V value)
abstract Result<V>	teeLogError()
<E extends Exception> void	throwCause(@NotNull Class<E> errorType) Feeling down because of too much functional wrapping? This method has you covered.
Optional<V>	toOptional()
static <V,R,A> Collector<Result<V>,Result.Builder<V,A>,Result<R>>	tryCollect(@NotNull Collector<V,A,R> collector) Create a collector that accumulates a stream of Results into a single Result containing either: 1.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method Detail

map

@NotNull
public abstract <W> @NotNull Result<W> map(@NotNull
                                                    @NotNull Function<? super V,W> f)

Map it.

Type Parameters:

W - the result type.

Parameters:

f - the mapping function

Returns:

a mapped result

flatMap

@NotNull
public abstract <W> @NotNull Result<W> flatMap(@NotNull
                                                        @NotNull Function<? super V,Result<W>> f)

Flat-map it.

Type Parameters:

W - the result type

Parameters:

f - the mapping function

Returns:

the flat mapped result

getOrDefault

public abstract V getOrDefault(V defaultValue)

getOrElse

public abstract V getOrElse(@NotNull
                            @NotNull Supplier<? extends V> defaultValue)

orElse

public abstract Result<V> orElse(@NotNull
                                 @NotNull Supplier<Result<V>> defaultValue)

stream

public abstract Stream<V> stream()

teeLogError

public abstract Result<V> teeLogError()

isSuccess

public final boolean isSuccess()

isFailure

public final boolean isFailure()

toOptional

public final Optional<V> toOptional()

getError

public abstract Optional<RuntimeException> getError()

All Failures will be created with a top-level RuntimeException. This method returns it if this result is a failure. Otherwise, Optional.empty() is returned for a success.

Returns:

the top level runtime exception or empty if success

findCause

public final Optional<Throwable> findCause(@NotNull
                                           @NotNull Predicate<? super Throwable> predicate)

Filters the exception stack as a stream using the provided Throwable predicate.

Parameters:

predicate - the Throwable filter

Returns:

some matching throwable or empty

findCause

public final <E extends Throwable> Optional<E> findCause(@NotNull
                                                         @NotNull Class<E> errorType)

Filters the exception stack as a stream, matching causes against the provided error type. Since the top-level exception may be an internal RuntimeException, you can use this method to determine if a particular Throwable type was thrown.

Type Parameters:

E - the particular Throwable type parameter

Parameters:

errorType - the class providing teh particular Exception type parameter

Returns:

an Optional error

throwCause

public final <E extends Exception> void throwCause(@NotNull
                                                   @NotNull Class<E> errorType)
                                            throws E extends Exception

Feeling down because of too much functional wrapping? This method has you covered. Rethrow the highest result error cause matching the provided type to so you can catch it like old times.

Type Parameters:

E - the particular Exception type parameter

Parameters:

errorType - the class providing the particular Exception type parameter

Throws:

E - if any cause in the chain is an instance of the provided errorType, that cause is rethrown

E extends Exception

forEach

public abstract void forEach(@NotNull
                             @NotNull Consumer<? super V> consumer)

Standard forEach method calling a consumer to accept the value. Not executed on a Failure.

Parameters:

consumer - the consumer

failure

public static <V> Result<V> failure(String message)

failure

public static <V> Result<V> failure(@NotNull
                                    @NotNull Exception e)

failure

public static <V> Result<V> failure(@NotNull
                                    @NotNull String message,
                                    @NotNull
                                    @NotNull Exception e)

failure

public static <V> Result<V> failure(@NotNull
                                    @NotNull RuntimeException e)

success

public static <V> Result<V> success(V value)

tryCollect

public static <V,R,A> Collector<Result<V>,Result.Builder<V,A>,Result<R>> tryCollect(@NotNull
                                                                                    @NotNull Collector<V,A,R> collector)

Create a collector that accumulates a stream of Results into a single Result containing either: 1. the collected values of the streamed results according using supplied collector 2. the first encountered failure

This method is indented to invert the relationship between the Result monoid and the Stream/Collector type, such that this transformation becomes easier: List<Result<A>> -> Result<List<A>>

Type Parameters:

V - the incremental value

R - the intended container type

A - the collector's accumulator type

Parameters:

collector - the underlying collector

Returns:

if all successful, a Result of a Collection; otherwise, the first encountered failure

logAndRestream

public static <V> Collector<Result<V>,Stream.Builder<Result<V>>,Stream<Result<V>>> logAndRestream()

logAndRestream

public static <V> Collector<Result<V>,Stream.Builder<Result<V>>,Stream<Result<V>>> logAndRestream(@NotNull
                                                                                                  @NotNull String message)