org.apache.brooklyn.util.guava

Class Maybe.Absent<T>

java.lang.Object

org.apache.brooklyn.util.guava.Maybe<T>

org.apache.brooklyn.util.guava.Maybe.Absent<T>

All Implemented Interfaces:

java.io.Serializable

Direct Known Subclasses:

Maybe.AbsentNull

Enclosing class:

Maybe<T>

public static class Maybe.Absent<T>
extends Maybe<T>

See Also:

Serialized Form

Nested Class Summary

Nested classes/interfaces inherited from class org.apache.brooklyn.util.guava.Maybe

Maybe.Absent<T>, Maybe.AbsentNull<T>, Maybe.AbstractPresent<T>, Maybe.MaybeSupplier<T>, Maybe.Present<T>, Maybe.SoftlyPresent<T>

Constructor Summary

Constructors

Constructor and Description
Absent()
Absent(<any> exception)

Method Summary

Modifier and Type	Method and Description
static <T> Maybe<T>	castAbsent(Maybe<?> absent) Like Maybe.cast(Maybe) but allows any casting because that is valid for absents.
static <T> Maybe<T>	changeExceptionSupplier(Maybe<T> original, <any> transform)
static <T> Maybe<T>	changeExceptionSupplier(Maybe<T> original, java.lang.Class<? extends java.lang.RuntimeException> type)
T	get()
java.lang.RuntimeException	getException()
<any>	getExceptionSupplier()
boolean	isNull() Whether the value is null, if present, or if it was specified as absent because it was null, e.g.
boolean	isPresent()
T	orThrowUnwrapped() As Maybe.get() but if the Maybe wraps an exception (and where Maybe.get() throws a RuntimeException indicating the caller, caused by the exception in original processing) this throws the original unwrapped exception (masking the caller's location)

Methods inherited from class org.apache.brooklyn.util.guava.Maybe

absent, absent, absent, absent, absent, absentNoTrace, absentNull, absentNull, absentWithTrace, asSet, cast, equals, fromNullable, fromOptional, getException, hashCode, isAbsent, isAbsentOrNull, isPresentAndNonNull, next, of, of, of, ofAllowingNull, ofDisallowingNull, or, or, or, orNull, presentInstances, soft, softThen, toOptional, toString, transform

Methods inherited from class java.lang.Object

getClass, notify, notifyAll, wait, wait, wait

Constructor Detail

Absent

public Absent()

Absent

public Absent(<any> exception)

Method Detail

isPresent

public boolean isPresent()

Specified by:

isPresent in class Maybe<T>

isNull

public boolean isNull()

Description copied from class: Maybe

Whether the value is null, if present, or if it was specified as absent because it was null, e.g. using Maybe.fromNullable(Object).

Specified by:

isNull in class Maybe<T>

get

public T get()

Specified by:

get in class Maybe<T>

orThrowUnwrapped

public T orThrowUnwrapped()

Description copied from class: Maybe

As Maybe.get() but if the Maybe wraps an exception (and where Maybe.get() throws a RuntimeException indicating the caller, caused by the exception in original processing) this throws the original unwrapped exception (masking the caller's location)

As this masks the caller's exception, use with care, typically in a location near the original execution, otherwise it can get confusing. For instance someCallReturningMaybe().orThrowUnwrapped() is a nice idiom, but someMaybeVarReturnedEarlier.orThrowUnwrapped() is usually a bad idea.

The benefit of this is simpler stack traces and preservation of original exception type.

Overrides:

orThrowUnwrapped in class Maybe<T>

getException

public java.lang.RuntimeException getException()

getExceptionSupplier

public <any> getExceptionSupplier()

changeExceptionSupplier

public static <T> Maybe<T> changeExceptionSupplier(Maybe<T> original,
                                                   java.lang.Class<? extends java.lang.RuntimeException> type)

changeExceptionSupplier

public static <T> Maybe<T> changeExceptionSupplier(Maybe<T> original,
                                                   <any> transform)

castAbsent

public static <T> Maybe<T> castAbsent(Maybe<?> absent)

Like Maybe.cast(Maybe) but allows any casting because that is valid for absents. Enforces that the argument really is absent.