Removed old data types

4 files changed, 0 insertions, 689 deletions

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 <T>
- *            The type of the data being held
- */
-public class LazyHolder<T> implements IHolder<T>, ILazy {
-	private static final class LazyHolderHolder<T2>
-			implements IHolder<T2> {
-		private Supplier<IHolder<T2>>				holderSource;
-
-		private IHolder<T2>							holder;
-
-		private IFunctionalList<Function<T2, T2>>	actions	= new FunctionalList<>();
-
-		public LazyHolderHolder(Supplier<IHolder<T2>> source) {
-
-			holderSource = source;
-		}
-
-		@Override
-		public void doWith(Consumer<T2> action) {
-			actions.add((val) -> {
-				action.accept(val);
-
-				return val;
-			});
-		}
-
-		@Override
-		public <NewT> IHolder<NewT> map(Function<T2, NewT> transformer) {
-			// TODO implement me
-			throw new UnsupportedOperationException(
-					"Mapping is not yet supported on bound holders");
-		}
-
-		@Override
-		public IHolder<T2> transform(Function<T2, T2> transformer) {
-			actions.add(transformer);
-
-			return this;
-		}
-
-		@Override
-		public <E> E unwrap(Function<T2, E> unwrapper) {
-			if (holder == null) {
-				holder = holderSource.get();
-			}
-
-			if (!actions.isEmpty()) {
-				actions.forEach((transform) -> {
-					holder.transform(transform);
-				});
-			}
-
-			return holder.unwrap(unwrapper);
-		}
-
-		@Override
-		public <E> IHolder<E> bind(Function<T2, IHolder<E>> 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<NewT, T2>
-			implements Supplier<NewT> {
-		private IFunctionalList<Function<T2, T2>>	pendingActions;
-		private Function<T2, NewT>					pendingTransform;
-
-		private T2									heldValue;
-		private Supplier<T2>						heldSource;
-
-		public LazyHolderSupplier(IFunctionalList<Function<T2, T2>> actons,
-				Function<T2, NewT> transform, T2 heldValue,
-				Supplier<T2> 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<T2, T2> 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<T2, T2>::apply, pendingTransform::apply);
-			}
-
-			return pendingActions.reduceAux(heldValue,
-					Function<T2, T2>::apply, pendingTransform::apply);
-		}
-	}
-
-	/**
-	 * List of queued actions to be performed on realized values
-	 */
-	private IFunctionalList<Function<T, T>>	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<T>						heldSource;
-
-	/**
-	 * Create a new lazy holder with the given supplier
-	 * 
-	 * @param source
-	 *            The supplier for a value when it is neededs
-	 */
-	public LazyHolder(Supplier<T> 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<T> 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 <NewT> IHolder<NewT> map(Function<T, NewT> 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<T> transform(Function<T, T> 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> E unwrap(Function<T, E> 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 <T2> IHolder<T2> bind(Function<T, IHolder<T2>> 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 <L>
- *            The type of value stored on the left side of the pair
- * @param <R>
- *            The type of value stored on the right side of the pair
- */
-public class LazyPair<L, R> implements IPair<L, R>, ILazy {
-	/**
-	 * The backing store for this pair
-	 */
-	protected IHolder<IPair<L, R>>	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<L> leftValueSource,
-			Supplier<R> 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<IPair<L, R>> 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<L, R> 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> E merge(BiFunction<L, R, E> 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 <L2, R2> IPair<L2, R2> bind(
-			BiFunction<L, R, IPair<L2, R2>> binder) {
-		IHolder<IPair<L2, R2>> 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 <L>
- *            The type on the left side of the pair
- * @param <R>
- *            The type on the right side of the pair
- *
- */
-public class NewLazyPair<L, R> implements IPair<L, R>, ILazy {
-	private static class BoundLazyPair<OldL, OldR, NewL, NewR>
-			implements IPair<NewL, NewR> {
-		private Supplier<OldL>								oldLeftSupplier;
-		private Supplier<OldR>								oldRightSupplier;
-
-		private BiFunction<OldL, OldR, IPair<NewL, NewR>>	newPairSupplier;
-
-		private IPair<NewL, NewR>							newPair;
-
-		private boolean										newPairMaterialized;
-
-		public BoundLazyPair(Supplier<OldL> leftSup,
-				Supplier<OldR> rightSup,
-				BiFunction<OldL, OldR, IPair<NewL, NewR>> binder) {
-			oldLeftSupplier = leftSup;
-			oldRightSupplier = rightSup;
-
-			newPairSupplier = binder;
-		}
-
-		@Override
-		public <L2, R2> IPair<L2, R2> bind(
-				BiFunction<NewL, NewR, IPair<L2, R2>> binder) {
-			// TODO Auto-generated method stub
-			return null;
-		}
-
-		@Override
-		public void doWith(BiConsumer<NewL, NewR> action) {
-			// TODO Auto-generated method stub
-
-		}
-
-		@Override
-		public <E> E merge(BiFunction<NewL, NewR, E> merger) {
-			if (!newPairMaterialized) {
-				newPair = newPairSupplier.apply(oldLeftSupplier.get(),
-						oldRightSupplier.get());
-			}
-
-			return newPair.merge(merger);
-		}
-	}
-
-	private L									leftValue;
-	private R									rightValue;
-
-	private Supplier<R>							rightValueSupplier;
-	private Supplier<L>							leftValueSupplier;
-
-	private boolean								rightMaterialized;
-	private boolean								leftMaterialized;
-
-	private IFunctionalList<BiConsumer<L, R>>	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<L> leftSupplier,
-			Supplier<R> 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<Boolean> hasActions,
-			IFunctionalList<BiConsumer<L, R>> pendingActions) {
-		if (hasActions.unwrap((val) -> val) == true) {
-			pendingActions.forEach((action) -> {
-				action.accept(leftValue, rightValue);
-			});
-
-			hasActions.transform((val) -> false);
-		}
-	}
-
-	@Override
-	public <L2, R2> IPair<L2, R2> bind(
-			BiFunction<L, R, IPair<L2, R2>> binder) {
-		GenHolder<Boolean> hasActions = new GenHolder<>(true);
-		IFunctionalList<BiConsumer<L, R>> 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<L, R> 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> E merge(BiFunction<L, R, E> merger) {
-		if (!isMaterialized()) {
-			materialize();
-		}
-
-		applyPendingActions();
-
-		return merger.apply(leftValue, rightValue);
-	}
-}
\ No newline at end of file