From 98cdf435d4974f4cca8f7b4eb4026da2c88cbc4c Mon Sep 17 00:00:00 2001
From: bculkin2442 <bjculkin@mix.wvu.edu>
Date: Sun, 26 Mar 2017 11:30:43 -0400
Subject: Update

---
 .../java/bjc/utils/data/internals/BoundLazy.java    | 21 +++++++++++----------
 .../bjc/utils/data/internals/BoundLazyPair.java     |  3 ++-
 .../bjc/utils/data/internals/BoundListHolder.java   |  1 +
 .../bjc/utils/data/internals/HalfBoundLazyPair.java |  1 +
 .../java/bjc/utils/data/internals/WrappedLazy.java  |  1 +
 .../bjc/utils/data/internals/WrappedOption.java     |  1 +
 6 files changed, 17 insertions(+), 11 deletions(-)

(limited to 'BJC-Utils2/src/main/java/bjc/utils/data')

diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundLazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundLazy.java
index 0ec69f0..cc1c0c0 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundLazy.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundLazy.java
@@ -9,9 +9,10 @@ import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.function.UnaryOperator;
 
-/**
+/*
  * Implements a lazy holder that has been bound
  */
+@SuppressWarnings("javadoc")
 public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundContainedType> {
 	/*
 	 * The old value
@@ -48,7 +49,7 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 
 	@Override
 	public <BoundType> IHolder<BoundType> bind(Function<BoundContainedType, IHolder<BoundType>> bindr) {
-		if(bindr == null) throw new NullPointerException("Binder must not be null");
+		if (bindr == null) throw new NullPointerException("Binder must not be null");
 
 		/*
 		 * Prepare a list of pending actions
@@ -65,7 +66,7 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 			/*
 			 * Bind the value if it hasn't been bound before
 			 */
-			if(!holderBound) {
+			if (!holderBound) {
 				oldHolder = oldSupplier.get().unwrap(binder);
 			}
 
@@ -83,7 +84,7 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 	@Override
 	public <NewType> Function<BoundContainedType, IHolder<NewType>> lift(
 			Function<BoundContainedType, NewType> func) {
-		if(func == null) throw new NullPointerException("Function to lift must not be null");
+		if (func == null) throw new NullPointerException("Function to lift must not be null");
 
 		return (val) -> {
 			return new Lazy<>(func.apply(val));
@@ -92,7 +93,7 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 
 	@Override
 	public <MappedType> IHolder<MappedType> map(Function<BoundContainedType, MappedType> mapper) {
-		if(mapper == null) throw new NullPointerException("Mapper must not be null");
+		if (mapper == null) throw new NullPointerException("Mapper must not be null");
 
 		// Prepare a list of pending actions
 		IList<UnaryOperator<BoundContainedType>> pendingActions = new FunctionalList<>();
@@ -103,7 +104,7 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 			IHolder<BoundContainedType> oldHolder = boundHolder;
 
 			// Bound the value if it hasn't been bound
-			if(!holderBound) {
+			if (!holderBound) {
 				oldHolder = oldSupplier.get().unwrap(binder);
 			}
 
@@ -117,14 +118,14 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 
 	@Override
 	public String toString() {
-		if(holderBound) return boundHolder.toString();
+		if (holderBound) return boundHolder.toString();
 
 		return "(unmaterialized)";
 	}
 
 	@Override
 	public IHolder<BoundContainedType> transform(UnaryOperator<BoundContainedType> transformer) {
-		if(transformer == null) throw new NullPointerException("Transformer must not be null");
+		if (transformer == null) throw new NullPointerException("Transformer must not be null");
 
 		actions.add(transformer);
 
@@ -133,9 +134,9 @@ public class BoundLazy<OldType, BoundContainedType> implements IHolder<BoundCont
 
 	@Override
 	public <UnwrappedType> UnwrappedType unwrap(Function<BoundContainedType, UnwrappedType> unwrapper) {
-		if(unwrapper == null) throw new NullPointerException("Unwrapper must not be null");
+		if (unwrapper == null) throw new NullPointerException("Unwrapper must not be null");
 
-		if(!holderBound) {
+		if (!holderBound) {
 			boundHolder = oldSupplier.get().unwrap(binder::apply);
 		}
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundLazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundLazyPair.java
index 6ab8121..de290a6 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundLazyPair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundLazyPair.java
@@ -9,9 +9,10 @@ import java.util.function.BiFunction;
 import java.util.function.Function;
 import java.util.function.Supplier;
 
-/**
+/*
  * Implements a lazy pair that has been bound
  */
+@SuppressWarnings("javadoc")
 public class BoundLazyPair<OldLeft, OldRight, NewLeft, NewRight> implements IPair<NewLeft, NewRight> {
 	/*
 	 * The supplier of the left value
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundListHolder.java b/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundListHolder.java
index 467d55d..c838ce7 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundListHolder.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/internals/BoundListHolder.java
@@ -10,6 +10,7 @@ import java.util.function.UnaryOperator;
 /*
  * Holds a list, converted into a holder
  */
+@SuppressWarnings("javadoc")
 public class BoundListHolder<ContainedType> implements IHolder<ContainedType> {
 	private IList<IHolder<ContainedType>> heldHolders;
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/internals/HalfBoundLazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/internals/HalfBoundLazyPair.java
index c5e9c9f..35df1c3 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/internals/HalfBoundLazyPair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/internals/HalfBoundLazyPair.java
@@ -12,6 +12,7 @@ import java.util.function.Supplier;
 /*
  * A lazy pair, with only one side bound
  */
+@SuppressWarnings("javadoc")
 public class HalfBoundLazyPair<OldType, NewLeft, NewRight> implements IPair<NewLeft, NewRight> {
 	private Supplier<OldType> oldSupplier;
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/internals/WrappedLazy.java b/BJC-Utils2/src/main/java/bjc/utils/data/internals/WrappedLazy.java
index f400345..de161e5 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/internals/WrappedLazy.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/internals/WrappedLazy.java
@@ -6,6 +6,7 @@ import bjc.utils.data.Lazy;
 import java.util.function.Function;
 import java.util.function.UnaryOperator;
 
+@SuppressWarnings("javadoc")
 public class WrappedLazy<ContainedType> implements IHolder<ContainedType> {
 	private IHolder<IHolder<ContainedType>> held;
 
diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/internals/WrappedOption.java b/BJC-Utils2/src/main/java/bjc/utils/data/internals/WrappedOption.java
index 1639351..e98332c 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/internals/WrappedOption.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/internals/WrappedOption.java
@@ -6,6 +6,7 @@ import bjc.utils.data.Option;
 import java.util.function.Function;
 import java.util.function.UnaryOperator;
 
+@SuppressWarnings("javadoc")
 public class WrappedOption<ContainedType> implements IHolder<ContainedType> {
 	private IHolder<IHolder<ContainedType>> held;
 
-- 
cgit v1.2.3