From 889fac2bdf993dc86f64a8893c0260fdcf848acb Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Mon, 10 Apr 2017 16:40:33 -0400 Subject: Cleanup --- BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java | 84 ++++++++++------------- 1 file changed, 36 insertions(+), 48 deletions(-) (limited to 'BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java') diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java index 719b11f..ca41b62 100644 --- a/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java +++ b/BJC-Utils2/src/main/java/bjc/utils/data/Lazy.java @@ -1,13 +1,13 @@ package bjc.utils.data; -import bjc.utils.data.internals.BoundLazy; -import bjc.utils.funcdata.FunctionalList; -import bjc.utils.funcdata.IList; - import java.util.function.Function; import java.util.function.Supplier; import java.util.function.UnaryOperator; +import bjc.utils.data.internals.BoundLazy; +import bjc.utils.funcdata.FunctionalList; +import bjc.utils.funcdata.IList; + /** * A holder that holds a means to create a value, but doesn't actually compute * the value until it's needed @@ -31,7 +31,7 @@ public class Lazy implements IHolder { * @param value * The seed value to use */ - public Lazy(ContainedType value) { + public Lazy(final ContainedType value) { heldValue = value; valueMaterialized = true; @@ -43,27 +43,26 @@ public class Lazy implements IHolder { * @param supp * The source of a value to use */ - public Lazy(Supplier supp) { + public Lazy(final Supplier supp) { valueSupplier = new SingleSupplier<>(supp); valueMaterialized = false; } - private Lazy(Supplier supp, IList> pendingActions) { + private Lazy(final Supplier supp, final IList> pendingActions) { valueSupplier = supp; actions = pendingActions; } @Override - public IHolder bind(Function> binder) { - IList> pendingActions = new FunctionalList<>(); + public IHolder bind(final Function> binder) { + final IList> pendingActions = new FunctionalList<>(); actions.forEach(pendingActions::add); - Supplier supplier = () -> { - if (valueMaterialized) - return heldValue; + final Supplier supplier = () -> { + if (valueMaterialized) return heldValue; return valueSupplier.get(); }; @@ -74,15 +73,15 @@ public class Lazy implements IHolder { } @Override - public Function> lift(Function func) { + public Function> lift(final Function func) { return val -> { return new Lazy<>(func.apply(val)); }; } @Override - public IHolder map(Function mapper) { - IList> pendingActions = new FunctionalList<>(); + public IHolder map(final Function mapper) { + final IList> pendingActions = new FunctionalList<>(); actions.forEach(pendingActions::add); @@ -103,22 +102,21 @@ public class Lazy implements IHolder { if (valueMaterialized) { if (actions.isEmpty()) return String.format("value[v='%s']", heldValue); - else - return String.format("value[v='%s'] (has pending transforms)", heldValue); + else return String.format("value[v='%s'] (has pending transforms)", heldValue); } return "(unmaterialized)"; } @Override - public IHolder transform(UnaryOperator transformer) { + public IHolder transform(final UnaryOperator transformer) { actions.add(transformer); return this; } @Override - public UnwrappedType unwrap(Function unwrapper) { + public UnwrappedType unwrap(final Function unwrapper) { if (!valueMaterialized) { heldValue = valueSupplier.get(); @@ -139,68 +137,58 @@ public class Lazy implements IHolder { final int prime = 31; int result = 1; - result = prime * result + ((actions == null) ? 0 : actions.hashCode()); - result = prime * result + ((heldValue == null) ? 0 : heldValue.hashCode()); + result = prime * result + (actions == null ? 0 : actions.hashCode()); + result = prime * result + (heldValue == null ? 0 : heldValue.hashCode()); result = prime * result + (valueMaterialized ? 1231 : 1237); return result; } @Override - public boolean equals(Object obj) { - if (this == obj) - return true; - if (obj == null) - return false; - if (!(obj instanceof Lazy)) - return false; + public boolean equals(final Object obj) { + if (this == obj) return true; + if (obj == null) return false; + if (!(obj instanceof Lazy)) return false; - Lazy other = (Lazy) obj; + final Lazy other = (Lazy) obj; - if (valueMaterialized != other.valueMaterialized) - return false; + if (valueMaterialized != other.valueMaterialized) return false; if (valueMaterialized) { if (heldValue == null) { - if (other.heldValue != null) - return false; - } else if (!heldValue.equals(other.heldValue)) - return false; - } else { - return false; - } + if (other.heldValue != null) return false; + } else if (!heldValue.equals(other.heldValue)) return false; + } else return false; if (actions == null) { - if (other.actions != null) - return false; - } else if (actions.getSize() > 0 || other.actions.getSize() > 0) - return false; + if (other.actions != null) return false; + } else if (actions.getSize() > 0 || other.actions.getSize() > 0) return false; return true; } /** * Create a new lazy container with an already present value. - * + * * @param val * The value for the lazy container. - * + * * @return A new lazy container holding that value. */ - public static Lazy lazy(ContainedType val) { + public static Lazy lazy(final ContainedType val) { return new Lazy<>(val); } /** * Create a new lazy container with a suspended value. - * + * * @param supp * The suspended value for the lazy container. - * + * * @return A new lazy container that will un-suspend the value when * necessary. */ - public static Lazy lazy(Supplier supp) { + public static Lazy lazy(final Supplier supp) { return new Lazy<>(supp); } } -- cgit v1.2.3