Spring/spring-data-commons
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Polishing.

Browse Source 
Refine Javadoc. Add unit tests.

See #2929
Original pull request: #2930
This commit is contained in:
Mark Paluch
2023-09-14 10:35:05 +02:00
parent 107f268eb5
commit b1a0bb4ff6
2 changed files with 137 additions and 134 deletions
Download Patch File Download Diff File Expand all files Collapse all files

268
src/main/java/org/springframework/data/util/Lazy.java
View File

@@ -25,8 +25,10 @@ import org.springframework.util.ObjectUtils;
/**
* Simple value type to delay the creation of an object using a {@link Supplier} returning the produced object for
* subsequent lookups. Note, that no concurrency control is applied during the lookup of {@link #get()}, which means in
* concurrent access scenarios, the provided {@link Supplier} can be called multiple times.
* subsequent lookups.
* <p>
* Note, that no concurrency control is applied during the lookup of {@link #get()}, which means in concurrent access
* scenarios, the provided {@link Supplier} can be called multiple times.
*
* @author Oliver Gierke
* @author Mark Paluch
@@ -45,17 +47,12 @@ public class Lazy<T> implements Supplier<T> {
private @Nullable T value;
private volatile boolean resolved;
/**
* Creates a new {@link Lazy} instance for the given supplier.
*
* @param supplier
*/
private Lazy(Supplier<? extends T> supplier) {
this(supplier, null, false);
}
/**
* Creates a new {@link Lazy} for the given {@link Supplier}, value and whether it has been resolved or not.
* Creates a new {@code Lazy} for the given {@link Supplier}, value and whether it has been resolved or not.
*
* @param supplier must not be {@literal null}.
* @param value can be {@literal null}.
@@ -69,22 +66,22 @@ public class Lazy<T> implements Supplier<T> {
}
/**
* Creates a new {@link Lazy} to produce an object lazily.
* Creates a new {@code Lazy} to produce an object lazily.
*
* @param <T> the type of which to produce an object of eventually.
* @param supplier the {@link Supplier} to create the object lazily.
* @return
* @return a {@code Lazy} wrapping the given {@link Supplier}.
*/
public static <T> Lazy<T> of(Supplier<? extends T> supplier) {
return new Lazy<>(supplier);
}
/**
* Creates a new {@link Lazy} to return the given value.
* Creates a new {@code Lazy} to return the given value.
*
* @param <T> the type of the value to return eventually.
* @param value the value to return.
* @return
* @return a {@code Lazy} wrapping {@code value}.
*/
public static <T> Lazy<T> of(T value) {
@@ -94,9 +91,9 @@ public class Lazy<T> implements Supplier<T> {
}
/**
* Creates a pre-resolved empty {@link Lazy}.
* Creates a pre-resolved empty {@code Lazy}.
*
* @return
* @return an empty {@code Lazy}.
* @since 2.1
*/
@SuppressWarnings("unchecked")
@@ -105,11 +102,12 @@ public class Lazy<T> implements Supplier<T> {
}
/**
* Returns the value created by the configured {@link Supplier}. Will return the calculated instance for subsequent
* lookups.
* Returns the value created by the configured {@link Supplier}. Will return the same instance for subsequent lookups.
*
* @return
* @return the value created by the configured {@link Supplier}. Will return the same instance for subsequent lookups.
* @throws IllegalStateException if the resolved value is {@literal null}.
*/
@Override
public T get() {
T value = getNullable();
@@ -121,119 +119,10 @@ public class Lazy<T> implements Supplier<T> {
return value;
}
/**
* Returns the {@link Optional} value created by the configured {@link Supplier}, allowing the absence of values in
* contrast to {@link #get()}. Will return the calculated instance for subsequent lookups.
*
* @return
*/
public Optional<T> getOptional() {
return Optional.ofNullable(getNullable());
}
/**
* Returns a new Lazy that will consume the given supplier in case the current one does not yield in a result.
*
* @param supplier must not be {@literal null}.
* @return
*/
public Lazy<T> or(Supplier<? extends T> supplier) {
Assert.notNull(supplier, "Supplier must not be null");
return Lazy.of(() -> orElseGet(supplier));
}
/**
* Returns a new Lazy that will return the given value in case the current one does not yield in a result.
*
* @param value must not be {@literal null}.
* @return
*/
public Lazy<T> or(T value) {
Assert.notNull(value, "Value must not be null");
return Lazy.of(() -> orElse(value));
}
/**
* Returns the value of the lazy computation or the given default value in case the computation yields
* {@literal null}.
*
* @param value
* @return
*/
@Nullable
public T orElse(@Nullable T value) {
T nullable = getNullable();
return nullable == null ? value : nullable;
}
/**
* Returns the value of the lazy computation or the value produced by the given {@link Supplier} in case the original
* value is {@literal null}.
*
* @param supplier must not be {@literal null}.
* @return
*/
@Nullable
public T orElseGet(Supplier<? extends T> supplier) {
Assert.notNull(supplier, "Default value supplier must not be null");
T value = getNullable();
return value == null ? supplier.get() : value;
}
/**
* Creates a new {@link Lazy} with the given {@link Function} lazily applied to the current one.
*
* @param function must not be {@literal null}.
* @return
*/
public <S> Lazy<S> map(Function<? super T, ? extends S> function) {
Assert.notNull(function, "Function must not be null");
return Lazy.of(() -> function.apply(get()));
}
/**
* Creates a new {@link Lazy} with the given {@link Function} lazily applied to the current one.
*
* @param function must not be {@literal null}.
* @return
*/
public <S> Lazy<S> flatMap(Function<? super T, Lazy<? extends S>> function) {
Assert.notNull(function, "Function must not be null");
return Lazy.of(() -> function.apply(get()).get());
}
/**
* Returns the {@link String} representation of the already resolved value or the one provided through the given
* {@link Supplier} if the value has not been resolved yet.
*
* @param fallback must not be {@literal null}.
* @return will never be {@literal null}.
* @since 3.0.1
*/
public String toString(Supplier<String> fallback) {
Assert.notNull(fallback, "Fallback must not be null!");
return resolved ? toString() : fallback.get();
}
/**
* Returns the value of the lazy evaluation.
*
* @return
* @return the value of the lazy evaluation, can be {@literal null}.
* @since 2.2
*/
@Nullable
@@ -249,14 +138,102 @@ public class Lazy<T> implements Supplier<T> {
return value;
}
@Override
public String toString() {
/**
* Returns the {@link Optional} value created by the configured {@link Supplier}, allowing the absence of values in
* contrast to {@link #get()}. Will return the calculated instance for subsequent lookups.
*
* @return an {@link Optional} value created by the configured {@link Supplier} or an empty {@link Optional} if the
* resolved value is {@literal null}.
*/
public Optional<T> getOptional() {
return Optional.ofNullable(getNullable());
}
if (!resolved) {
return UNRESOLVED;
}
/**
* Returns a new {@code Lazy} that will return the given value in case the current one does not yield in a result.
*
* @param other must not be {@literal null}.
* @return a new {@code Lazy} that will yield its value if present, otherwise {@code other}.
*/
public Lazy<T> or(T other) {
return value == null ? "null" : value.toString();
Assert.notNull(other, "Other value must not be null");
return Lazy.of(() -> orElse(other));
}
/**
* Returns a new {@code Lazy} that will consume the given supplier in case the current one does not yield in a result.
*
* @param supplier the supplying function that produces a value to be returned, must not be {@literal null}.
* @return a new {@code Lazy} that will yield its value if present, otherwise the result produced by the supplying
* function.
*/
public Lazy<T> or(Supplier<? extends T> supplier) {
Assert.notNull(supplier, "Supplier must not be null");
return Lazy.of(() -> orElseGet(supplier));
}
/**
* Returns the value of the lazy computation or the given default value in case the computation yields
* {@literal null}.
*
* @param other the value to be returned, if no value is present. May be {@literal null}.
* @return the value, if present, otherwise {@code other}.
*/
@Nullable
public T orElse(@Nullable T other) {
T nullable = getNullable();
return nullable == null ? other : nullable;
}
/**
* Returns the value of the lazy computation or the value produced by the given {@link Supplier} in case the original
* value is {@literal null}.
*
* @param supplier the supplying function that produces a value to be returned, must not be {@literal null}.
* @return the value, if present, otherwise the result produced by the supplying function.
*/
@Nullable
public T orElseGet(Supplier<? extends T> supplier) {
Assert.notNull(supplier, "Default value supplier must not be null");
T value = getNullable();
return value == null ? supplier.get() : value;
}
/**
* Creates a new {@code Lazy} with the given {@link Function} lazily applied to the current one.
*
* @param function must not be {@literal null}.
* @return an {@code Lazy} describing the result of applying a mapping function to the value of this {@code Lazy} or
* throwing {@link IllegalStateException} if the {@code Lazy} is empty.
*/
public <S> Lazy<S> map(Function<? super T, ? extends S> function) {
Assert.notNull(function, "Function must not be null");
return Lazy.of(() -> function.apply(get()));
}
/**
* Creates a new {@code Lazy} with the given {@link Function} lazily applied to the current one.
*
* @param function must not be {@literal null}.
* @return the result of applying an {@code Lazy}-bearing mapping function to the value of this {@code Lazy} or a
* {@code Lazy} throwing {@link IllegalStateException} if the {@code Lazy} is empty.
*/
public <S> Lazy<S> flatMap(Function<? super T, Lazy<? extends S>> function) {
Assert.notNull(function, "Function must not be null");
return Lazy.of(() -> function.apply(get()).get());
}
@Override
@@ -291,4 +268,29 @@ public class Lazy<T> implements Supplier<T> {
return result;
}
@Override
public String toString() {
if (!resolved) {
return UNRESOLVED;
}
return value == null ? "null" : value.toString();
}
/**
* Returns the {@link String} representation of the already resolved value or the one provided through the given
* {@link Supplier} if the value has not been resolved yet.
*
* @param fallback must not be {@literal null}.
* @return will never be {@literal null}.
* @since 3.0.1
*/
public String toString(Supplier<String> fallback) {
Assert.notNull(fallback, "Fallback must not be null!");
return resolved ? toString() : fallback.get();
}
}