Cleanup pass

Pass to do some cleanups

1 files changed, 31 insertions, 19 deletions

diff --git a/src/main/java/bjc/data/internals/BoundListHolder.java b/src/main/java/bjc/data/internals/BoundListHolder.java
index 8f8cab4..1193c8d 100644
--- a/src/main/java/bjc/data/internals/BoundListHolder.java
+++ b/src/main/java/bjc/data/internals/BoundListHolder.java
@@ -21,48 +21,58 @@ public class BoundListHolder<ContainedType> implements IHolder<ContainedType> {
 	 * Create a new list of holders.
 	 *
 	 * @param toHold
-	 *        The list of holders to, well, hold.
+	 *               The list of holders to, well, hold.
 	 */
 	public BoundListHolder(final IList<IHolder<ContainedType>> toHold) {
 		heldHolders = toHold;
 	}
 
 	@Override
-	public <BoundType> IHolder<BoundType> bind(final Function<ContainedType, IHolder<BoundType>> binder) {
-		if(binder == null) throw new NullPointerException("Binder must not be null");
+	public <BoundType> IHolder<BoundType>
+			bind(final Function<ContainedType, IHolder<BoundType>> binder) {
+		if (binder == null)
+			throw new NullPointerException("Binder must not be null");
 
-		final IList<IHolder<BoundType>> boundHolders = heldHolders.map((containedHolder) -> {
-			return containedHolder.bind(binder);
-		});
+		final IList<IHolder<BoundType>> boundHolders
+				= heldHolders.map(containedHolder -> {
+					return containedHolder.bind(binder);
+				});
 
 		return new BoundListHolder<>(boundHolders);
 	}
 
 	@Override
-	public <NewType> Function<ContainedType, IHolder<NewType>> lift(final Function<ContainedType, NewType> func) {
-		if(func == null) throw new NullPointerException("Function to lift must not be null");
+	public <NewType> Function<ContainedType, IHolder<NewType>>
+			lift(final Function<ContainedType, NewType> func) {
+		if (func == null)
+			throw new NullPointerException("Function to lift must not be null");
 
-		return (val) -> {
+		return val -> {
 			return new ListHolder<>(func.apply(val));
 		};
 	}
 
 	@Override
-	public <MappedType> IHolder<MappedType> map(final Function<ContainedType, MappedType> mapper) {
-		if(mapper == null) throw new NullPointerException("Mapper must not be null");
+	public <MappedType> IHolder<MappedType>
+			map(final Function<ContainedType, MappedType> mapper) {
+		if (mapper == null)
+			throw new NullPointerException("Mapper must not be null");
 
-		final IList<IHolder<MappedType>> mappedHolders = heldHolders.map((containedHolder) -> {
-			return containedHolder.map(mapper);
-		});
+		final IList<IHolder<MappedType>> mappedHolders
+				= heldHolders.map(containedHolder -> {
+					return containedHolder.map(mapper);
+				});
 
 		return new BoundListHolder<>(mappedHolders);
 	}
 
 	@Override
-	public IHolder<ContainedType> transform(final UnaryOperator<ContainedType> transformer) {
-		if(transformer == null) throw new NullPointerException("Transformer must not be null");
+	public IHolder<ContainedType>
+			transform(final UnaryOperator<ContainedType> transformer) {
+		if (transformer == null)
+			throw new NullPointerException("Transformer must not be null");
 
-		heldHolders.forEach((containedHolder) -> {
+		heldHolders.forEach(containedHolder -> {
 			containedHolder.transform(transformer);
 		});
 
@@ -70,8 +80,10 @@ public class BoundListHolder<ContainedType> implements IHolder<ContainedType> {
 	}
 
 	@Override
-	public <UnwrappedType> UnwrappedType unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
-		if(unwrapper == null) throw new NullPointerException("Unwrapper must not be null");
+	public <UnwrappedType> UnwrappedType
+			unwrap(final Function<ContainedType, UnwrappedType> unwrapper) {
+		if (unwrapper == null)
+			throw new NullPointerException("Unwrapper must not be null");
 
 		/*
 		 * @NOTE Is there another way we could want to do this?