Formatting

1 files changed, 24 insertions, 32 deletions

diff --git a/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java b/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java
index e03b46e..29e37ac 100644
--- a/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java
+++ b/BJC-Utils2/src/main/java/bjc/utils/data/LazyPair.java
@@ -13,29 +13,28 @@ import bjc.utils.data.internals.HalfBoundLazyPair;
  * @author ben
  *
  * @param <LeftType>
- *            The type on the left side of the pair
+ *                The type on the left side of the pair
  * @param <RightType>
- *            The type on the right side of the pair
+ *                The type on the right side of the pair
  * 
  */
-public class LazyPair<LeftType, RightType>
-		implements IPair<LeftType, RightType> {
-	private LeftType			leftValue;
-	private RightType			rightValue;
+public class LazyPair<LeftType, RightType> implements IPair<LeftType, RightType> {
+	private LeftType leftValue;
+	private RightType rightValue;
 
-	private Supplier<LeftType>	leftSupplier;
-	private Supplier<RightType>	rightSupplier;
+	private Supplier<LeftType> leftSupplier;
+	private Supplier<RightType> rightSupplier;
 
-	private boolean				leftMaterialized;
-	private boolean				rightMaterialized;
+	private boolean leftMaterialized;
+	private boolean rightMaterialized;
 
 	/**
 	 * Create a new lazy pair, using the set values
 	 * 
 	 * @param leftVal
-	 *            The value for the left side of the pair
+	 *                The value for the left side of the pair
 	 * @param rightVal
-	 *            The value for the right side of the pair
+	 *                The value for the right side of the pair
 	 */
 	public LazyPair(LeftType leftVal, RightType rightVal) {
 		leftValue = leftVal;
@@ -49,12 +48,11 @@ public class LazyPair<LeftType, RightType>
 	 * Create a new lazy pair from the given value sources
 	 * 
 	 * @param leftSupp
-	 *            The source for a value on the left side of the pair
+	 *                The source for a value on the left side of the pair
 	 * @param rightSupp
-	 *            The source for a value on the right side of the pair
+	 *                The source for a value on the right side of the pair
 	 */
-	public LazyPair(Supplier<LeftType> leftSupp,
-			Supplier<RightType> rightSupp) {
+	public LazyPair(Supplier<LeftType> leftSupp, Supplier<RightType> rightSupp) {
 		// Use single suppliers to catch double-instantiation bugs
 		leftSupplier = new SingleSupplier<>(leftSupp);
 		rightSupplier = new SingleSupplier<>(rightSupp);
@@ -70,7 +68,8 @@ public class LazyPair<LeftType, RightType>
 	}
 
 	@Override
-	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
+	public <BoundLeft> IPair<BoundLeft, RightType> bindLeft(
+			Function<LeftType, IPair<BoundLeft, RightType>> leftBinder) {
 		Supplier<LeftType> leftSupp = () -> {
 			if (leftMaterialized) {
 				return leftValue;
@@ -97,17 +96,13 @@ public class LazyPair<LeftType, RightType>
 	}
 
 	@Override
-	public <OtherLeft, OtherRight, CombinedLeft,
-			CombinedRight> IPair<CombinedLeft, CombinedRight> combine(
-					IPair<OtherLeft, OtherRight> otherPair,
-					BiFunction<LeftType, OtherLeft,
-							CombinedLeft> leftCombiner,
-					BiFunction<RightType, OtherRight,
-							CombinedRight> rightCombiner) {
+	public <OtherLeft, OtherRight, CombinedLeft, CombinedRight> IPair<CombinedLeft, CombinedRight> combine(
+			IPair<OtherLeft, OtherRight> otherPair,
+			BiFunction<LeftType, OtherLeft, CombinedLeft> leftCombiner,
+			BiFunction<RightType, OtherRight, CombinedRight> rightCombiner) {
 		return otherPair.bind((otherLeft, otherRight) -> {
 			return bind((leftVal, rightVal) -> {
-				return new LazyPair<>(
-						leftCombiner.apply(leftVal, otherLeft),
+				return new LazyPair<>(leftCombiner.apply(leftVal, otherLeft),
 						rightCombiner.apply(rightVal, otherRight));
 			});
 		});
@@ -136,8 +131,7 @@ public class LazyPair<LeftType, RightType>
 	}
 
 	@Override
-	public <NewLeft> IPair<NewLeft, RightType> mapLeft(
-			Function<LeftType, NewLeft> mapper) {
+	public <NewLeft> IPair<NewLeft, RightType> mapLeft(Function<LeftType, NewLeft> mapper) {
 		Supplier<NewLeft> leftSupp = () -> {
 			if (leftMaterialized) {
 				return mapper.apply(leftValue);
@@ -158,8 +152,7 @@ public class LazyPair<LeftType, RightType>
 	}
 
 	@Override
-	public <NewRight> IPair<LeftType, NewRight> mapRight(
-			Function<RightType, NewRight> mapper) {
+	public <NewRight> IPair<LeftType, NewRight> mapRight(Function<RightType, NewRight> mapper) {
 		Supplier<LeftType> leftSupp = () -> {
 			if (leftMaterialized) {
 				return leftValue;
@@ -180,8 +173,7 @@ public class LazyPair<LeftType, RightType>
 	}
 
 	@Override
-	public <MergedType> MergedType merge(
-			BiFunction<LeftType, RightType, MergedType> merger) {
+	public <MergedType> MergedType merge(BiFunction<LeftType, RightType, MergedType> merger) {
 		if (!leftMaterialized) {
 			leftValue = leftSupplier.get();