Issue #72 - Add double support for ignore methods

Author: boretti

src/main/java/ch/powerunit/extensions/exceptions/DoubleToIntFunctionWithException.java

@@ -175,4 +175,39 @@ static <E extends Exception> DoubleToIntFunction ignored(DoubleToIntFunctionWith
 		return verifyFunction(function).ignore();
 	}
 
+	/**
+	 * Converts a {@code DoubleToIntFunctionWithException} to a lifted
+	 * {@code DoubleToIntFunction} returning a default value in case of exception.
+	 *
+	 * @param function
+	 *            to be lifted
+	 * @param defaultValue
+	 *            value in case of exception
+	 * @param <E>
+	 *            the type of the potential exception
+	 * @return the lifted function
+	 * @see #ignore()
+	 * @see #ignored(DoubleToIntFunctionWithException)
+	 * @throws NullPointerException
+	 *             if function is null
+	 * @since 3.0.0
+	 */
+	static <E extends Exception> DoubleToIntFunction ignored(DoubleToIntFunctionWithException<E> function,
+			int defaultValue) {
+		verifyFunction(function);
+		return new DoubleToIntFunctionWithException<E>() {
+
+			@Override
+			public int applyAsInt(double value) throws E {
+				return function.applyAsInt(value);
+			}
+
+			@Override
+			public int defaultValue() {
+				return defaultValue;
+			}
+
+		}.ignore();
+	}
+
 }

src/main/java/ch/powerunit/extensions/exceptions/IntBinaryOperatorWithException.java

@@ -178,4 +178,40 @@ static <E extends Exception> IntBinaryOperator ignored(IntBinaryOperatorWithExce
 		return verifyFunction(function).ignore();
 	}
 
+	/**
+	 * Converts a {@code IntBinaryOperatorWithException} to a lifted
+	 * {@code IntBinaryOperator} with a default value as return value in case of
+	 * exception.
+	 *
+	 * @param function
+	 *            to be lifted
+	 * @param defaultValue
+	 *            value in case of exception
+	 * @param <E>
+	 *            the type of the potential exception
+	 * @return the lifted function
+	 * @see #ignore()
+	 * @see #ignored(IntBinaryOperatorWithException)
+	 * @throws NullPointerException
+	 *             if function is null
+	 * @since 3.0.0
+	 */
+	static <E extends Exception> IntBinaryOperator ignored(IntBinaryOperatorWithException<E> function,
+			int defaultValue) {
+		verifyFunction(function);
+		return new IntBinaryOperatorWithException<E>() {
+
+			@Override
+			public int applyAsInt(int left, int right) throws E {
+				return function.applyAsInt(left, right);
+			}
+
+			@Override
+			public int defaultValue() {
+				return defaultValue;
+			}
+
+		}.ignore();
+	}
+
 }

src/main/java/ch/powerunit/extensions/exceptions/IntSupplierWithException.java

@@ -176,4 +176,38 @@ static <E extends Exception> IntSupplier ignored(IntSupplierWithException<E> sup
 		return verifySupplier(supplier).ignore();
 	}
 
+	/**
+	 * Converts a {@code IntSupplierWithException} to a lifted {@code IntSupplier}
+	 * returning a default value in case of exception.
+	 *
+	 * @param supplier
+	 *            to be lifted
+	 * @param defaultValue
+	 *            value in case of exception
+	 * @param <E>
+	 *            the type of the potential exception
+	 * @return the lifted supplier
+	 * @see #ignore()
+	 * @see #ignored(IntSupplierWithException)
+	 * @throws NullPointerException
+	 *             if supplier is null
+	 * @since 3.0.0
+	 */
+	static <E extends Exception> IntSupplier ignored(IntSupplierWithException<E> supplier, int defaultValue) {
+		verifySupplier(supplier);
+		return new IntSupplierWithException<E>() {
+
+			@Override
+			public int getAsInt() throws E {
+				return supplier.getAsInt();
+			}
+
+			@Override
+			public int defaultValue() {
+				return defaultValue;
+			}
+
+		}.ignore();
+	}
+
 }

src/main/java/ch/powerunit/extensions/exceptions/IntUnaryOperatorWithException.java

@@ -227,4 +227,38 @@ static <E extends Exception> IntUnaryOperator ignored(IntUnaryOperatorWithExcept
 		return verifyFunction(function).ignore();
 	}
 
+	/**
+	 * Converts a {@code IntUnaryOperatorWithException} to a lifted
+	 * {@code IntUnaryOperator} returning a default value in case of exception.
+	 *
+	 * @param function
+	 *            to be lifted
+	 * @param defaultValue
+	 *            value in case of exception
+	 * @param <E>
+	 *            the type of the potential exception
+	 * @return the lifted function
+	 * @see #ignore()
+	 * @see #ignored(IntUnaryOperatorWithException)
+	 * @throws NullPointerException
+	 *             if function is null
+	 * @since 3.0.0
+	 */
+	static <E extends Exception> IntUnaryOperator ignored(IntUnaryOperatorWithException<E> function, int defaultValue) {
+		verifyFunction(function);
+		return new IntUnaryOperatorWithException<E>() {
+
+			@Override
+			public int applyAsInt(int operand) throws E {
+				return function.applyAsInt(operand);
+			}
+
+			@Override
+			public int defaultValue() {
+				return defaultValue;
+			}
+
+		}.ignore();
+	}
+
 }

src/main/java/ch/powerunit/extensions/exceptions/LongToIntFunctionWithException.java

@@ -200,4 +200,39 @@ static <E extends Exception> LongToIntFunction ignored(LongToIntFunctionWithExce
 		return verifyFunction(function).ignore();
 	}
 
+	/**
+	 * Converts a {@code LongToIntFunctionWithException} to a lifted
+	 * {@code LongToIntFunction} returning a default value in case of exception.
+	 *
+	 * @param function
+	 *            to be lifted
+	 * @param defaultValue
+	 *            value in case of exception
+	 * @param <E>
+	 *            the type of the potential exception
+	 * @return the lifted function
+	 * @see #ignore()
+	 * @see #ignored(LongToIntFunctionWithException)
+	 * @throws NullPointerException
+	 *             if function is null
+	 * @since 3.0.0
+	 */
+	static <E extends Exception> LongToIntFunction ignored(LongToIntFunctionWithException<E> function,
+			int defaultValue) {
+		verifyFunction(function);
+		return new LongToIntFunctionWithException<E>() {
+
+			@Override
+			public int applyAsInt(long value) throws E {
+				return function.applyAsInt(value);
+			}
+
+			@Override
+			public int defaultValue() {
+				return defaultValue;
+			}
+
+		}.ignore();
+	}
+
 }

src/main/java/ch/powerunit/extensions/exceptions/ToIntBiFunctionWithException.java

@@ -200,4 +200,43 @@ static <T, U, E extends Exception> ToIntBiFunction<T, U> ignored(ToIntBiFunction
 		return verifyFunction(function).ignore();
 	}
 
+	/**
+	 * Converts a {@code ToIntBiFunctionWithException} to a lifted
+	 * {@code ToIntBiFunction} returning a default value in case of exception.
+	 *
+	 * @param function
+	 *            to be lifted
+	 * @param defaultValue
+	 *            value in case of exception
+	 * @param <T>
+	 *            the type of the first argument to the function
+	 * @param <U>
+	 *            the type of the second argument to the function
+	 * @param <E>
+	 *            the type of the potential exception
+	 * @return the lifted function
+	 * @see #ignore()
+	 * @see #ignored(ToIntBiFunctionWithException)
+	 * @throws NullPointerException
+	 *             if function is null
+	 * @since 3.0.0
+	 */
+	static <T, U, E extends Exception> ToIntBiFunction<T, U> ignored(ToIntBiFunctionWithException<T, U, E> function,
+			int defaultValue) {
+		verifyFunction(function);
+		return new ToIntBiFunctionWithException<T, U, E>() {
+
+			@Override
+			public int applyAsInt(T t, U u) throws E {
+				return function.applyAsInt(t, u);
+			}
+
+			@Override
+			public int defaultValue() {
+				return defaultValue;
+			}
+
+		}.ignore();
+	}
+
 }

src/main/java/ch/powerunit/extensions/exceptions/ToIntFunctionWithException.java

@@ -186,4 +186,41 @@ static <T, E extends Exception> ToIntFunction<T> ignored(ToIntFunctionWithExcept
 		return verifyFunction(function).ignore();
 	}
 
+	/**
+	 * Converts a {@code ToLongFunctionWithException} to a lifted
+	 * {@code ToIntFunction} returning a default value in case of exception.
+	 *
+	 * @param function
+	 *            to be lifted
+	 * @param defaultValue
+	 *            value in case of exception.
+	 * @param <T>
+	 *            the type of the input object to the function
+	 * @param <E>
+	 *            the type of the potential exception
+	 * @return the lifted function
+	 * @see #ignore()
+	 * @see #ignored(ToIntFunctionWithException)
+	 * @throws NullPointerException
+	 *             if function is null
+	 * @since 3.0.0
+	 */
+	static <T, E extends Exception> ToIntFunction<T> ignored(ToIntFunctionWithException<T, E> function,
+			int defaultValue) {
+		verifyFunction(function);
+		return new ToIntFunctionWithException<T, E>() {
+
+			@Override
+			public int applyAsInt(T value) throws E {
+				return function.applyAsInt(value);
+			}
+
+			@Override
+			public int defaultValue() {
+				return defaultValue;
+			}
+
+		}.ignore();
+	}
+
 }

src/test/java/ch/powerunit/extensions/exceptions/DoubleToIntFunctionWithExceptionTest.java

@@ -74,4 +74,16 @@ public void testIgnoredException() {
 		}).applyAsInt(1)).is(0);
 	}
 
+	@Test
+	public void testIgnoredDefaultNoException() {
+		assertThat(DoubleToIntFunctionWithException.ignored(x -> 1, 2).applyAsInt(2)).is(1);
+	}
+
+	@Test
+	public void testIgnoredDefaultException() {
+		assertThat(DoubleToIntFunctionWithException.ignored(y -> {
+			throw new Exception();
+		}, 1).applyAsInt(1)).is(1);
+	}
+
 }

src/test/java/ch/powerunit/extensions/exceptions/IntBinaryOperatorWithExceptionTest.java

@@ -73,4 +73,16 @@ public void testIgnoredException() {
 			throw new Exception();
 		}).applyAsInt(1, 2)).is(0);
 	}
+
+	@Test
+	public void testIgnoredDefaultNoException() {
+		assertThat(IntBinaryOperatorWithException.ignored((x, y) -> x + y, 1).applyAsInt(2, 1)).is(3);
+	}
+
+	@Test
+	public void testIgnoredDefaultException() {
+		assertThat(IntBinaryOperatorWithException.ignored((x, y) -> {
+			throw new Exception();
+		}, 1).applyAsInt(1, 2)).is(1);
+	}
 }

src/test/java/ch/powerunit/extensions/exceptions/IntSupplierWithExceptionTest.java

@@ -74,4 +74,16 @@ public void testIgnoredException() {
 		}).getAsInt()).is(0);
 	}
 
+	@Test
+	public void testIgnoredDefaultNoException() {
+		assertThat(IntSupplierWithException.ignored(() -> 2, 1).getAsInt()).is(2);
+	}
+
+	@Test
+	public void testIgnoredDefaultException() {
+		assertThat(IntSupplierWithException.ignored(() -> {
+			throw new Exception();
+		}, 1).getAsInt()).is(1);
+	}
+
 }