Lazy (MicroStream API)

Type Parameters:

T -

All Superinterfaces:

Referencing<T>

All Known Implementing Classes:

Lazy.Default
```
public interface Lazy<T>
extends Referencing<T>
```
A reference providing generic lazy-loading functionality.
Note that the shortened name has been chosen intentionally to optimize readability in class design.
Also note that a type like this is strongly required in order to implement lazy loading behavior in an application in an architecturally clean and proper way. I.e. the application's data model design has to define that a certain reference is meant to be capable of lazy-loading. If such a definition is not done, a loading logic is strictly required to always load the encountered reference, as it is defined by the "normal" way of how references work. Any "tricks" of whatever framework to "sneak in" lazy loading behavior where it hasn't actually been defined are nothing more than dirty hacks and mess up if not destroy the program's consistency of state (e.g. antipatterns like secretly replacing a well-defined collection instance with a framework-proprietary proxy instance of a "similar" collection implementation). In proper architectured sofware, if a reference does not define lazy loading capacity, it is not wanted to have that capacity on the business logical level by design in the first place. Any attempts of saying "but I want it anyway in a sneaky 'transparent' way" indicate ambivalent conflicting design errors and thus in the end poor design.

Nested Class Summary

Nested Classes
Modifier and Type Interface Description

static class Lazy.Default<T>

Method Summary

Modifier and Type	Method	Description
`static LazyReferenceManager.Checker`	`Checker(long millisecondTimeout)`
`T`	`clear()`
`static void`	`clear(Lazy<?> reference)`
`T`	`get()`	Returns the referenced object, loading it if required.
`static <T> T`	`get(Lazy<T> reference)`
`boolean`	`isLoaded()`
`static boolean`	`isLoaded(Lazy<?> reference)`
`boolean`	`isStored()`
`static boolean`	`isStored(Lazy<?> reference)`
`static <T> Lazy<T>`	`New(long objectId)`
`static <T> Lazy<T>`	`New(long objectId, ObjectSwizzling loader)`
`static <T> Lazy<T>`	`New(T subject, long objectId, ObjectSwizzling loader)`
`T`	`peek()`	Returns the local reference without loading the referenced object if it is not present.
`static <T> T`	`peek(Lazy<T> reference)`
`static <T> Lazy<T>`	`Reference(T subject)`
`static <T,L extends Lazy<T>> L`	`register(L lazyReference)`

Method Detail

get
```
T get()
```
Returns the referenced object, loading it if required.

Specified by:

get in interface Referencing<T>

Returns:

the lazily loaded referenced object.

peek
```
T peek()
```
Returns the local reference without loading the referenced object if it is not present.

Returns:

the currently present reference.

clear
```
T clear()
```

isStored
```
boolean isStored()
```

isLoaded
```
boolean isLoaded()
```

get

static <T> T get(Lazy<T> reference)

peek

static <T> T peek(Lazy<T> reference)

clear

static void clear(Lazy<?> reference)

isStored

static boolean isStored(Lazy<?> reference)

isLoaded

static boolean isLoaded(Lazy<?> reference)

Reference

static <T> Lazy<T> Reference(T subject)

New

static <T> Lazy<T> New(long objectId)

New

static <T> Lazy<T> New(long objectId,
                       ObjectSwizzling loader)

New

static <T> Lazy<T> New(T subject,
                       long objectId,
                       ObjectSwizzling loader)

Checker

static LazyReferenceManager.Checker Checker(long millisecondTimeout)

register

static <T,L extends Lazy<T>> L register(L lazyReference)