one.microstream.reference

Interface Lazy<T>

Type Parameters:

T - the type of the lazily referenced element

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 and Description
static interface	Lazy.Check
static interface	Lazy.Checker
static interface	Lazy.ClearingEvaluator
static class	Lazy.Default<T>

Method Summary

Modifier and Type	Method and Description
static Lazy.Checker	Checker()
static Lazy.Checker	Checker(double memoryQuota)
static Lazy.Checker	Checker(Lazy.Check customCheck)
static Lazy.Checker	Checker(long millisecondTimeout)
static Lazy.Checker	Checker(long millisecondTimeout, double memoryQuota)
static Lazy.Checker	Checker(long millisecondTimeout, double memoryQuota, Lazy.Check customCheck, LazyReferenceManager.CycleEvaluator cycleEvaluator)
static Lazy.Checker	CheckerMemory(double memoryQuota)
static Lazy.Checker	CheckerTimeout(long millisecondTimeout)
T	clear()
boolean	clear(Lazy.ClearingEvaluator clearingEvaluator)
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)
long	lastTouched() Returns the timestamp (corresponding to System.currentTimeMillis()) when this instance has last been "touched", meaning having its reference modified or queried.
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. The value returned by lastTouched() will not be changed by calling this method.

Returns:

the currently present reference.

clear

T clear()

isStored

boolean isStored()

isLoaded

boolean isLoaded()

lastTouched

long lastTouched()

Returns the timestamp (corresponding to System.currentTimeMillis()) when this instance has last been "touched", meaning having its reference modified or queried.

Returns:

the time this instance has last been significantly used.

clear

boolean clear(Lazy.ClearingEvaluator clearingEvaluator)

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)

register

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

Checker

static Lazy.Checker Checker()

Checker

static Lazy.Checker Checker(long millisecondTimeout)

Checker

static Lazy.Checker Checker(double memoryQuota)

Checker

static Lazy.Checker Checker(long millisecondTimeout,
                            double memoryQuota)

Checker

static Lazy.Checker Checker(Lazy.Check customCheck)

Checker

static Lazy.Checker Checker(long millisecondTimeout,
                            double memoryQuota,
                            Lazy.Check customCheck,
                            LazyReferenceManager.CycleEvaluator cycleEvaluator)

CheckerTimeout

static Lazy.Checker CheckerTimeout(long millisecondTimeout)

CheckerMemory

static Lazy.Checker CheckerMemory(double memoryQuota)