From ba07771f8333f1b098ab8a9ec9fec886b72b9cc0 Mon Sep 17 00:00:00 2001 From: bculkin2442 Date: Wed, 13 Apr 2016 16:54:12 -0400 Subject: Removed old data types --- .../src/main/java/bjc/utils/data/lazy/ILazy.java | 35 --- .../main/java/bjc/utils/data/lazy/LazyHolder.java | 284 --------------------- .../main/java/bjc/utils/data/lazy/LazyPair.java | 168 ------------ .../main/java/bjc/utils/data/lazy/NewLazyPair.java | 202 --------------- 4 files changed, 689 deletions(-) delete mode 100644 BJC-Utils2/src/main/java/bjc/utils/data/lazy/ILazy.java delete mode 100644 BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyHolder.java delete mode 100644 BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyPair.java delete mode 100644 BJC-Utils2/src/main/java/bjc/utils/data/lazy/NewLazyPair.java (limited to 'BJC-Utils2/src/main/java/bjc/utils/data/lazy') diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/lazy/ILazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/lazy/ILazy.java deleted file mode 100644 index a4fab67..0000000 --- a/BJC-Utils2/src/main/java/bjc/utils/data/lazy/ILazy.java +++ /dev/null @@ -1,35 +0,0 @@ -package bjc.utils.data.lazy; - -/** - * Interface for some maintenance operations on lazy objects - * - * @author ben - * - */ -public interface ILazy { - /** - * Check if this object has been materialized - * - * @return Whether or not this object has been materialized - */ - public boolean isMaterialized(); - - /** - * Check if there are pending actions that need to be applied - * - * @return Whether or not there are pending actions - */ - public boolean hasPendingActions(); - - /** - * Make this object materialize itelf - */ - public void materialize(); - - /** - * Make this object apply any pending objects - * - * As a requirement, will materialize the object if it is not materialized - */ - public void applyPendingActions(); -} diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyHolder.java b/BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyHolder.java deleted file mode 100644 index 141d558..0000000 --- a/BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyHolder.java +++ /dev/null @@ -1,284 +0,0 @@ -package bjc.utils.data.lazy; - -import java.util.function.Consumer; -import java.util.function.Function; -import java.util.function.Supplier; - -import bjc.utils.data.IHolder; -import bjc.utils.funcdata.FunctionalList; -import bjc.utils.funcdata.IFunctionalList; - -/** - * Holds a single value of a specific type. This is used for indirect - * references to data, and more specifically for accessing non-final - * variables from a lambda. AKA the identity monad - * - * This is a lazy variant of {@link IHolder} - * - * @author ben - * - * @param - * The type of the data being held - */ -public class LazyHolder implements IHolder, ILazy { - private static final class LazyHolderHolder - implements IHolder { - private Supplier> holderSource; - - private IHolder holder; - - private IFunctionalList> actions = new FunctionalList<>(); - - public LazyHolderHolder(Supplier> source) { - - holderSource = source; - } - - @Override - public void doWith(Consumer action) { - actions.add((val) -> { - action.accept(val); - - return val; - }); - } - - @Override - public IHolder map(Function transformer) { - // TODO implement me - throw new UnsupportedOperationException( - "Mapping is not yet supported on bound holders"); - } - - @Override - public IHolder transform(Function transformer) { - actions.add(transformer); - - return this; - } - - @Override - public E unwrap(Function unwrapper) { - if (holder == null) { - holder = holderSource.get(); - } - - if (!actions.isEmpty()) { - actions.forEach((transform) -> { - holder.transform(transform); - }); - } - - return holder.unwrap(unwrapper); - } - - @Override - public IHolder bind(Function> binder) { - return new LazyHolderHolder<>(() -> { - return binder.apply(unwrap((val) -> val)); - }); - } - - @Override - public String toString() { - if (holderSource == null) { - if (holder == null) { - return "(null)"; - } - - return holder.toString(); - } - - if (holder == null) { - return "(unmaterialized values)"; - } - - return holder.toString(); - } - } - - private static final class LazyHolderSupplier - implements Supplier { - private IFunctionalList> pendingActions; - private Function pendingTransform; - - private T2 heldValue; - private Supplier heldSource; - - public LazyHolderSupplier(IFunctionalList> actons, - Function transform, T2 heldValue, - Supplier heldSource) { - // Resolve latent bug I just realized. After a map, adding new - // actions to the original holder could've resulted in changes - // to all unactualized mapped values from that holder - pendingActions = new FunctionalList<>(); - - for (Function action : actons.toIterable()) { - pendingActions.add(action); - } - - this.pendingTransform = transform; - this.heldValue = heldValue; - this.heldSource = heldSource; - } - - @Override - public NewT get() { - if (heldValue == null) { - return pendingActions.reduceAux(heldSource.get(), - Function::apply, pendingTransform::apply); - } - - return pendingActions.reduceAux(heldValue, - Function::apply, pendingTransform::apply); - } - } - - /** - * List of queued actions to be performed on realized values - */ - private IFunctionalList> actions = new FunctionalList<>(); - - /** - * The value internally held by this lazy holder - */ - private T heldValue; - - /** - * The source for a value held by this lazy holder - */ - private Supplier heldSource; - - /** - * Create a new lazy holder with the given supplier - * - * @param source - * The supplier for a value when it is neededs - */ - public LazyHolder(Supplier source) { - if (source == null) { - throw new NullPointerException("Source must be non-null"); - } - - heldSource = source; - heldValue = null; - } - - /** - * Create a new lazy holder with the given value - * - * @param value - * The value held in the holder - */ - public LazyHolder(T value) { - heldSource = () -> value; - } - - @Override - public void doWith(Consumer action) { - if (action == null) { - throw new NullPointerException("Action must be non-null"); - } - - transform((value) -> { - // Do the action with the value - action.accept(value); - - // Return the untransformed value - return value; - }); - } - - @Override - public IHolder map(Function transform) { - if (transform == null) { - throw new NullPointerException("Transform must be non-null"); - } - - // Don't actually map until we need to - return new LazyHolder<>(new LazyHolderSupplier<>(actions, - transform, heldValue, heldSource)); - } - - @Override - public IHolder transform(Function transform) { - if (transform == null) { - throw new NullPointerException("Transform must be non-null"); - } - - // Queue the transform until we need to apply it - actions.add(transform); - - return this; - } - - @Override - public E unwrap(Function unwrapper) { - if (unwrapper == null) { - throw new NullPointerException("Unwrapper must be null"); - } - - // Actualize ourselves - if (heldValue == null) { - heldValue = heldSource.get(); - } - - // Apply all pending transforms - actions.forEach((action) -> heldValue = action.apply(heldValue)); - - return unwrapper.apply(heldValue); - } - - @Override - public boolean isMaterialized() { - if (heldSource != null) { - // We're materialized if a value exists - return heldValue == null; - } - - // We're materialized by default - return true; - } - - @Override - public boolean hasPendingActions() { - return actions.isEmpty(); - } - - @Override - public void materialize() { - // Only materialize if we haven't already - if (!isMaterialized()) { - heldValue = heldSource.get(); - } - } - - @Override - public void applyPendingActions() { - materialize(); - - actions.forEach((action) -> { - heldValue = action.apply(heldValue); - }); - } - - @Override - public IHolder bind(Function> binder) { - return new LazyHolderHolder<>(() -> { - return binder.apply(unwrap((val) -> val)); - }); - } - - @Override - public String toString() { - if (isMaterialized()) { - if (hasPendingActions()) { - return heldValue.toString() + " (has pending actions)"; - } - - return heldValue.toString(); - } - - return "(unmaterialized value)"; - } -} \ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyPair.java deleted file mode 100644 index dcaeeba..0000000 --- a/BJC-Utils2/src/main/java/bjc/utils/data/lazy/LazyPair.java +++ /dev/null @@ -1,168 +0,0 @@ -package bjc.utils.data.lazy; - -import java.util.function.BiConsumer; -import java.util.function.BiFunction; -import java.util.function.Supplier; - -import bjc.utils.data.IHolder; -import bjc.utils.data.IPair; -import bjc.utils.data.Pair; - -/** - * A lazy holder of two values - * - * Lazy variant of {@link IPair} - * - * @author ben - * - * @param - * The type of value stored on the left side of the pair - * @param - * The type of value stored on the right side of the pair - */ -public class LazyPair implements IPair, ILazy { - /** - * The backing store for this pair - */ - protected IHolder> delegatePair; - - private boolean materialized = false; - private boolean pendingActions = false; - - /** - * Create a new blank lazy pair - */ - public LazyPair() { - delegatePair = new LazyHolder<>(new Pair<>()); - } - - /** - * Create a new lazy pair with the specified initial values - * - * @param leftValue - * The initial value for the left side of the pair - * @param rightValue - * The initial value for the right side of the pair - */ - public LazyPair(L leftValue, R rightValue) { - materialized = true; - - delegatePair = new LazyHolder<>(new Pair<>(leftValue, rightValue)); - } - - /** - * Create a new lazy pair with the specified sources for initial values - * - * @param leftValueSource - * The function to call for the left initial value - * @param rightValueSource - * The function to call for the right initial value - */ - public LazyPair(Supplier leftValueSource, - Supplier rightValueSource) { - if (leftValueSource == null || rightValueSource == null) { - throw new NullPointerException("Sources must be non-null"); - } - - delegatePair = new LazyHolder<>(() -> { - return new Pair<>(leftValueSource.get(), - rightValueSource.get()); - }); - } - - /** - * Create a new lazy pair with a specified internal delegate - * - * @param delegate - * The internal delegate for the pair - */ - private LazyPair(IHolder> delegate, boolean mater, - boolean pend) { - materialized = mater; - pendingActions = pend; - - delegatePair = delegate; - } - - /* - * (non-Javadoc) - * - * @see bjc.utils.data.IPair#doWith(java.util.function.BiConsumer) - */ - @Override - public void doWith(BiConsumer action) { - if (action == null) { - throw new NullPointerException("Action must be non-null"); - } - - pendingActions = true; - - delegatePair.doWith((currentPair) -> { - currentPair.doWith(action); - }); - } - - /* - * (non-Javadoc) - * - * @see bjc.utils.data.IPair#merge(java.util.function.BiFunction) - */ - @Override - public E merge(BiFunction merger) { - if (merger == null) { - throw new NullPointerException("Merger must be non-null"); - } - - materialized = true; - pendingActions = false; - - return delegatePair - .unwrap((currentPair) -> currentPair.merge(merger)); - } - - @Override - public boolean isMaterialized() { - return materialized; - } - - @Override - public boolean hasPendingActions() { - return pendingActions; - } - - /* - * Note: Materializing will also apply all currently pending actions - */ - @Override - public void materialize() { - merge((left, right) -> null); - - materialized = true; - pendingActions = false; - } - - @Override - public void applyPendingActions() { - merge((left, right) -> null); - - materialized = true; - pendingActions = false; - } - - @Override - public IPair bind( - BiFunction> binder) { - IHolder> newDelegate = delegatePair - .map((pairVal) -> { - return pairVal.bind(binder); - }); - - return new LazyPair<>(newDelegate, isMaterialized(), - hasPendingActions()); - } - - @Override - public String toString() { - return delegatePair.toString(); - } -} \ No newline at end of file diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/lazy/NewLazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/lazy/NewLazyPair.java deleted file mode 100644 index 4bd3832..0000000 --- a/BJC-Utils2/src/main/java/bjc/utils/data/lazy/NewLazyPair.java +++ /dev/null @@ -1,202 +0,0 @@ -package bjc.utils.data.lazy; - -import java.util.function.BiConsumer; -import java.util.function.BiFunction; -import java.util.function.Supplier; - -import bjc.utils.data.GenHolder; -import bjc.utils.data.IPair; -import bjc.utils.funcdata.FunctionalList; -import bjc.utils.funcdata.IFunctionalList; - -/** - * New implementation of lazy pair not delegating to {@link LazyHolder} - * - * @author ben - * @param - * The type on the left side of the pair - * @param - * The type on the right side of the pair - * - */ -public class NewLazyPair implements IPair, ILazy { - private static class BoundLazyPair - implements IPair { - private Supplier oldLeftSupplier; - private Supplier oldRightSupplier; - - private BiFunction> newPairSupplier; - - private IPair newPair; - - private boolean newPairMaterialized; - - public BoundLazyPair(Supplier leftSup, - Supplier rightSup, - BiFunction> binder) { - oldLeftSupplier = leftSup; - oldRightSupplier = rightSup; - - newPairSupplier = binder; - } - - @Override - public IPair bind( - BiFunction> binder) { - // TODO Auto-generated method stub - return null; - } - - @Override - public void doWith(BiConsumer action) { - // TODO Auto-generated method stub - - } - - @Override - public E merge(BiFunction merger) { - if (!newPairMaterialized) { - newPair = newPairSupplier.apply(oldLeftSupplier.get(), - oldRightSupplier.get()); - } - - return newPair.merge(merger); - } - } - - private L leftValue; - private R rightValue; - - private Supplier rightValueSupplier; - private Supplier leftValueSupplier; - - private boolean rightMaterialized; - private boolean leftMaterialized; - - private IFunctionalList> actions; - - /** - * Create a new lazy pair - * - * @param leftVal - * The left value in the pair - * @param rightVal - * The right value in the pair - */ - public NewLazyPair(L leftVal, R rightVal) { - leftValueSupplier = () -> leftVal; - rightValueSupplier = () -> rightVal; - } - - /** - * Create a new lazy pair - * - * @param leftSupplier - * The supplier for the left value in the pair - * @param rightSupplier - * The supplier for the right value in the pair - */ - public NewLazyPair(Supplier leftSupplier, - Supplier rightSupplier) { - leftValueSupplier = leftSupplier; - rightValueSupplier = rightSupplier; - } - - @Override - public void applyPendingActions() { - if (!isMaterialized()) { - throw new UnsupportedOperationException( - "Can only apply actions to materialized values"); - } - - actions.forEach((action) -> { - action.accept(leftValue, rightValue); - }); - - actions = new FunctionalList<>(); - } - - private void applyPossiblyPendingActions(GenHolder hasActions, - IFunctionalList> pendingActions) { - if (hasActions.unwrap((val) -> val) == true) { - pendingActions.forEach((action) -> { - action.accept(leftValue, rightValue); - }); - - hasActions.transform((val) -> false); - } - } - - @Override - public IPair bind( - BiFunction> binder) { - GenHolder hasActions = new GenHolder<>(true); - IFunctionalList> pendingActions = new FunctionalList<>(); - - actions.forEach(pendingActions::add); - - return new BoundLazyPair<>(() -> { - applyPossiblyPendingActions(hasActions, pendingActions); - - return leftValue; - }, () -> { - applyPossiblyPendingActions(hasActions, pendingActions); - - return rightValue; - }, binder); - } - - @Override - public void doWith(BiConsumer action) { - actions.add(action); - } - - @Override - public boolean hasPendingActions() { - return !actions.isEmpty(); - } - - @Override - public boolean isMaterialized() { - if (leftValueSupplier == null) { - if (rightValueSupplier == null) { - return true; - } - - return rightMaterialized; - } - - if (rightValueSupplier == null) { - return leftMaterialized; - } - - return leftMaterialized && rightMaterialized; - } - - @Override - public void materialize() { - if (isMaterialized()) { - throw new UnsupportedOperationException( - "Cannot materialize lazy object twice"); - } - - if (leftValueSupplier != null) { - leftValue = leftValueSupplier.get(); - } - - if (rightValueSupplier != null) { - rightValue = rightValueSupplier.get(); - } - } - - @Override - public E merge(BiFunction merger) { - if (!isMaterialized()) { - materialize(); - } - - applyPendingActions(); - - return merger.apply(leftValue, rightValue); - } -} \ No newline at end of file -- cgit v1.2.3