Maybe (Apache Brooklyn)

java.lang.Object
- org.apache.brooklyn.util.guava.Maybe<T>

All Implemented Interfaces:

java.io.Serializable

Direct Known Subclasses:

Maybe.Absent, Maybe.AbstractPresent, Maybe.SoftlyPresent
```
public abstract class Maybe<T>
extends java.lang.Object
implements java.io.Serializable
```
Like Guava Optional but permitting null and permitting errors to be thrown.

See Also:
Serialized Form

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Maybe.Absent<T>`
`static class`	`Maybe.AbsentNull<T>`
`static class`	`Maybe.AbstractPresent<T>`
`static class`	`Maybe.Present<T>`
`static class`	`Maybe.SoftlyPresent<T>`

Constructor Summary

Constructors
Constructor and Description

Maybe()

Constructors
Constructor and Description
`Maybe()`

Method Summary

Methods
Modifier and Type	Method and Description
`static <T> Maybe<T>`	`absent()`
`static <T> Maybe<T>`	`absent( exceptionSupplier)` Creates an absent whose get throws an `RuntimeException` generated on demand from the given supplier
`static <T> Maybe<T>`	`absent(java.lang.String message)` Creates an absent whose get throws an `IllegalStateException` with the indicated message.
`static <T> Maybe<T>`	`absent(java.lang.String message, java.lang.Throwable cause)` Creates an absent whose get throws an `IllegalStateException` with the indicated message and underlying cause.
`static <T> Maybe<T>`	`absent(java.lang.Throwable cause)` Creates an absent whose get throws an `IllegalStateException` with the indicated cause.
`static <T> Maybe<T>`	`absentNull()` as `absentNull(String)` but with a generic message
`static <T> Maybe<T>`	`absentNull(java.lang.String message)` like `absent(String)` but `isNull()` will return true on the result.
`java.util.Set<T>`	`asSet()`
`boolean`	`equals(java.lang.Object obj)`
`static <T> Maybe<T>`	`fromNullable(T value)` Creates a new Maybe object using `ofDisallowingNull(Object)` semantics.
`abstract T`	`get()`
`int`	`hashCode()`
`boolean`	`isAbsent()`
`boolean`	`isAbsentOrNull()`
`abstract boolean`	`isNull()` Whether the value is null, if present, or if it was specified as absent because it was null, e.g.
`abstract boolean`	`isPresent()`
`boolean`	`isPresentAndNonNull()`
`static <T> Maybe<T>`	`next(java.util.Iterator<T> iterator)` returns a Maybe containing the next element in the iterator, or absent if none
`static <T> Maybe<T>`	`of( value)`
`static <T> Maybe<T>`	`of( value)`
`static <T> Maybe<T>`	`of(T value)` Creates a new Maybe object.
`static <T> Maybe<T>`	`ofAllowingNull(T value)` Creates a new Maybe object which is present.
`static <T> Maybe<T>`	`ofDisallowingNull(T value)` Creates a new Maybe object which is present if and only if the argument is not null.
`T`	`or( nextValue)`
`Maybe<T>`	`or(Maybe<T> nextValue)`
`T`	`or(T nextValue)`
`T`	`orNull()`
`static <T> java.lang.Iterable<T>`	`presentInstances(java.lang.Iterable<? extends Maybe<? extends T>> maybes)` Returns the value of each present instance from the supplied `maybes`, in order, skipping over occurrences of `absent()`.
`static <T> Maybe<T>`	`soft(T value)` creates an instance wrapping a `SoftReference`, so it might go absent later on.
`static <T> Maybe<T>`	`softThen(T value, Maybe<T> ifEmpty)` creates an instance wrapping a `SoftReference`, using the second item given if the first argument is dereferenced.
`java.lang.String`	`toString()`
`<V> Maybe<V>`	`transform( f)`

Methods inherited from class java.lang.Object
getClass, notify, notifyAll, wait, wait, wait

- Constructor Detail
  - Maybe
```
public Maybe()
```
- Method Detail
  - absent
```
public static <T> Maybe<T> absent()
```
  - absent
```
public static <T> Maybe<T> absent(java.lang.String message)
```
    Creates an absent whose get throws an IllegalStateException with the indicated message. Both stack traces (the cause and the callers) are provided, which can be quite handy.
  - absent
```
public static <T> Maybe<T> absent(java.lang.Throwable cause)
```
    Creates an absent whose get throws an IllegalStateException with the indicated cause. Both stack traces (the cause and the callers) are provided, which can be quite handy.
  - absent
```
public static <T> Maybe<T> absent(java.lang.String message,
                  java.lang.Throwable cause)
```
    Creates an absent whose get throws an IllegalStateException with the indicated message and underlying cause. Both stack traces (the cause and the callers) are provided, which can be quite handy.
  - absent
```
public static <T> Maybe<T> absent( exceptionSupplier)
```
    Creates an absent whose get throws an RuntimeException generated on demand from the given supplier
  - absentNull
```
public static <T> Maybe<T> absentNull()
```
    as absentNull(String) but with a generic message
  - absentNull
```
public static <T> Maybe<T> absentNull(java.lang.String message)
```
    like absent(String) but isNull() will return true on the result.
  - ofAllowingNull
```
public static <T> Maybe<T> ofAllowingNull(@Nullable
                          T value)
```
    Creates a new Maybe object which is present. The argument may be null and the object still present, which may be confusing in some contexts (traditional Optional usages) but may be natural in others (where null is a valid value, distinguished from no value set). See also ofDisallowingNull(Object).
  - ofDisallowingNull
```
public static <T> Maybe<T> ofDisallowingNull(@Nullable
                             T value)
```
    Creates a new Maybe object which is present if and only if the argument is not null. If the argument is null, then an absentNull() is returned, on which isNull() will be true.
  - of
```
public static <T> Maybe<T> of(@Nullable
              T value)
```
    Creates a new Maybe object. Currently this uses ofAllowingNull(Object) semantics, but it is recommended to use that method for clarity if the argument might be null.
  - fromNullable
```
public static <T> Maybe<T> fromNullable(@Nullable
                        T value)
```
    Creates a new Maybe object using ofDisallowingNull(Object) semantics. It is recommended to use that method for clarity. This method is provided for consistency with Optional#fromNullable(Object).
  - soft
```
public static <T> Maybe<T> soft(@Nonnull
                T value)
```
    creates an instance wrapping a SoftReference, so it might go absent later on. if null is supplied the result is a present null.
  - softThen
```
public static <T> Maybe<T> softThen(T value,
                    Maybe<T> ifEmpty)
```
    creates an instance wrapping a SoftReference, using the second item given if the first argument is dereferenced. however if the first argument is null, this is a permanent present null, as of(Object) with null.
  - of
```
public static <T> Maybe<T> of( value)
```
  - of
```
public static <T> Maybe<T> of( value)
```
  - next
```
public static <T> Maybe<T> next(java.util.Iterator<T> iterator)
```
    returns a Maybe containing the next element in the iterator, or absent if none
  - isPresent
```
public abstract boolean isPresent()
```
  - get
```
public abstract T get()
```
  - isAbsent
```
public boolean isAbsent()
```
  - isAbsentOrNull
```
public boolean isAbsentOrNull()
```
  - isPresentAndNonNull
```
public boolean isPresentAndNonNull()
```
  - isNull
```
public abstract boolean isNull()
```
    Whether the value is null, if present, or if it was specified as absent because it was null, e.g. using fromNullable(Object).
  - or
```
public T or(T nextValue)
```
  - or
```
public Maybe<T> or(Maybe<T> nextValue)
```
  - or
```
public T or( nextValue)
```
  - orNull
```
public T orNull()
```
  - asSet
```
public java.util.Set<T> asSet()
```
  - transform
```
public <V> Maybe<V> transform( f)
```
  - presentInstances
```
public static <T> java.lang.Iterable<T> presentInstances(java.lang.Iterable<? extends Maybe<? extends T>> maybes)
```
    Returns the value of each present instance from the supplied maybes, in order, skipping over occurrences of absent(). Iterators are unmodifiable and are evaluated lazily.
    
    See Also:
    Optional#presentInstances(Iterable)
  - toString
```
public java.lang.String toString()
```
    Overrides:
    
    toString in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Overrides:
    
    hashCode in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object obj)
```
    Overrides:
    
    equals in class java.lang.Object

Class Maybe<T>

Nested Class Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

Maybe

Method Detail

absent

absent

absent

absent

absent

absentNull

absentNull

ofAllowingNull

ofDisallowingNull

of

fromNullable

soft

softThen

of

of

next

isPresent

get

isAbsent

isAbsentOrNull

isPresentAndNonNull

isNull

or

or

or

orNull

asSet

transform

presentInstances

toString

hashCode

equals