io.neba.api.resourcemodels

Interface Lazy<T>

Type Parameters:

T - the type of the lazy-loaded object.

public interface Lazy<T>

Declares lazy-loading 1:1 relationships in resource models. In addition, as lazy-loading always has to deal with nonexistent values, this interface both features a Optional representation via asOptional() and provides the same API semantics as Optional for convenience.

NEBA automatically detects Lazy fields and provides a suitable lazy-loading implementation. Note that this interface is not required to lazy-load collections, as NEBA automatically provides collection-typed members, such as Reference or Children collections, as lazy-loading proxies.

To declare a lazy reference from resource model "A" to resource model "B", write:

 @ResourceModel(types = "...")
 public class A {
   @Reference
   private Lazy<B> b;
 }
 

This interface may also be used to explicitly lazy-load collection-typed resource model relationships, such as Children or Reference collections:

 @ResourceModel(types = "...")
 public class A {
   @Children
   private Lazy<List<B>> children;
 }
 

However, collection-typed relationships are automatically provided as lazy-loading proxies, thus there usually is no reason to make them Lazy.

Since:

4.3.0

Author:

Olaf Otto

Method Summary

Modifier and Type	Method and Description
Optional<T>	asOptional()
default Lazy<T>	filter(Predicate<? super T> predicate)
default <U> Lazy<U>	flatMap(Function<? super T,Lazy<U>> f)
default T	get()
default void	ifPresent(Consumer<? super T> c)
default boolean	isPresent()
default <U> Lazy<U>	map(Function<? super T,? extends U> f)
default T	orElse(T other)
default T	orElseGet(Supplier<? extends T> other)
default <X extends Throwable> T	orElseThrow(Supplier<? extends X> exceptionSupplier)

Method Detail

asOptional

@Nonnull
Optional<T> asOptional()

Returns:

a Optional representation of the lazy-loaded value, never null.

get

@Nonnull
default T get()

See Also:

Optional.get()

isPresent

default boolean isPresent()

See Also:

Optional.isPresent()

ifPresent

default void ifPresent(Consumer<? super T> c)

See Also:

Optional.ifPresent(java.util.function.Consumer<? super T>)

filter

@Nonnull
default Lazy<T> filter(Predicate<? super T> predicate)

See Also:

Optional.filter(java.util.function.Predicate<? super T>)

map

@Nonnull
default <U> Lazy<U> map(Function<? super T,? extends U> f)

See Also:

Optional.map(java.util.function.Function<? super T, ? extends U>)

flatMap

@Nonnull
default <U> Lazy<U> flatMap(Function<? super T,Lazy<U>> f)

See Also:

Optional.flatMap(java.util.function.Function<? super T, java.util.Optional<U>>)

orElse

@CheckForNull
default T orElse(T other)

See Also:

Optional.orElse(T)

orElseGet

@CheckForNull
default T orElseGet(Supplier<? extends T> other)

See Also:

Optional.orElseGet(java.util.function.Supplier<? extends T>)

orElseThrow

@Nonnull
default <X extends Throwable> T orElseThrow(Supplier<? extends X> exceptionSupplier)
                                               throws X extends Throwable

Throws:

X extends Throwable

See Also:

Optional.orElseThrow(java.util.function.Supplier<? extends X>)