Module dk.cloudcreate.essentials.shared

Package dk.cloudcreate.essentials.shared.functional

Interface CheckedBiFunction<T1,T2,R>

Functional Interface:

This is a functional interface and can therefore be used as the assignment target for a lambda expression or method reference.

@FunctionalInterface
public interface CheckedBiFunction<T1,T2,R>

Variant of BiFunction that behaves like BiFunction, but which allows checked Exception's to be thrown from its apply(Object, Object) method
– the first function argument type – the second function argument type – the function result type

See Also:

safe(CheckedBiFunction), safe(String, CheckedBiFunction)

Method Summary

Modifier and Type	Method	Description
R	apply(T1 arg1, T2 arg2)	This method performs the operation that may fail with a Checked Exception
static <T1,T2,R> BiFunction<T1,T2,R>	safe(CheckedBiFunction<T1,T2,R> functionThatCanFailWithACheckedException)	Wraps a CheckedBiFunction (basically a lambda with two arguments that returns a result and which throws a Checked Exception) by returning a new BiFunction instance The returned BiFunction.apply(Object, Object) method delegates directly to the apply(Object, Object) and catches any thrown checked Exception's and rethrows them as a CheckedExceptionRethrownException Unless you provide a context-message (using safe(String, CheckedBiFunction) then any caught checked Exception's message also becomes the CheckedExceptionRethrownException's message. Any RuntimeException's thrown aren't caught and the calling code will receive the original RuntimeException thrown. Usage example: Let's say we have a method called someOperation that cannot change, but which accepts a BiFunction with the purpose of the calling the BiFunction.apply(Object, Object).
static <T1,T2,R> BiFunction<T1,T2,R>	safe(String contextMessage, CheckedBiFunction<T1,T2,R> functionThatCanFailWithACheckedException)	Wraps a CheckedBiFunction (basically a lambda with two arguments that returns a result and which throws a Checked Exception) by returning a new BiFunction instance The returned BiFunction.apply(Object, Object) method delegates directly to the apply(Object, Object) and catches any thrown checked Exception's and rethrows them as a CheckedExceptionRethrownException Any RuntimeException's thrown aren't caught and the calling code will receive the original RuntimeException thrown. Usage example: Let's say we have a method called someOperation that cannot change, but which accepts a BiFunction with the purpose of the calling the BiFunction.apply(Object, Object).

Method Detail

safe

static <T1,T2,R> BiFunction<T1,T2,R> safe(CheckedBiFunction<T1,T2,R> functionThatCanFailWithACheckedException)

Wraps a CheckedBiFunction (basically a lambda with two arguments that returns a result and which throws a Checked Exception) by returning a new BiFunction instance
The returned BiFunction.apply(Object, Object) method delegates directly to the apply(Object, Object) and catches any thrown checked Exception's and rethrows them as a CheckedExceptionRethrownException
Unless you provide a context-message (using safe(String, CheckedBiFunction) then any caught checked Exception's message also becomes the CheckedExceptionRethrownException's message.
Any RuntimeException's thrown aren't caught and the calling code will receive the original RuntimeException thrown.

Usage example:
Let's say we have a method called someOperation that cannot change, but which accepts a BiFunction with the purpose of the calling the BiFunction.apply(Object, Object).

 public void someOperation(Function<Integer, Boolean, String> operation) {
      // ... Logic ...

      String value = operation.apply(10, true);

      // ... More logic ---
 }
 

The problem will BiFunction.apply(Object, Object) occurs when BiFunction calls any API that throws a checked Exception, e.g. the File API.
Since BiFunction.apply(Object, Object) doesn't define that it throws any Exception's we're forced to add a try/catch to handle the IOException for the code to compile:

  someOperation((value, enabled) -> {
                      try {
                          // Logic that uses the File API
                          return "some-value";
                      } catch (IOException e) {
                          throw new RuntimeException(e);
                      }
                }));
 

This is where the CheckedBiFunction comes to the aid as its apply(Object, Object) methods defines that it throws a Checked Exception and its safe(CheckedBiFunction) will return a new BiFunction instance with a BiFunction.apply(Object, Object) method that ensures that the apply(Object, Object) method is called and any checked Exception's thrown will be caught and rethrown as a CheckedExceptionRethrownException:

  someOperation(CheckedBiFunction.safe((value, enabled) -> {
                      // Logic that uses the File API that throws IOException
                      return "some-value";
                }));
 
 

Type Parameters:

T1 - the first argument type

T2 - the second argument type

R - the return type

Parameters:

functionThatCanFailWithACheckedException - the CheckedBiFunction instance that will be wrapped as a BiFunction

Returns:

a BiFunction with a BiFunction.apply(Object, Object) method that ensures that the apply(Object, Object) method is called when BiFunction.apply(Object, Object) and any checked Exception's thrown will be caught and rethrown as a CheckedExceptionRethrownException.
Any RuntimeException's thrown aren't caught and the calling code will receive the original RuntimeException thrown.

Throws:

CheckedExceptionRethrownException - in case the apply(Object, Object) method throws a checked Exception

safe

static <T1,T2,R> BiFunction<T1,T2,R> safe(String contextMessage,
                                                                  CheckedBiFunction<T1,T2,R> functionThatCanFailWithACheckedException)

Wraps a CheckedBiFunction (basically a lambda with two arguments that returns a result and which throws a Checked Exception) by returning a new BiFunction instance
The returned BiFunction.apply(Object, Object) method delegates directly to the apply(Object, Object) and catches any thrown checked Exception's and rethrows them as a CheckedExceptionRethrownException
Any RuntimeException's thrown aren't caught and the calling code will receive the original RuntimeException thrown.

Usage example:
Let's say we have a method called someOperation that cannot change, but which accepts a BiFunction with the purpose of the calling the BiFunction.apply(Object, Object).

 public void someOperation(Function<Integer, Boolean, String> operation) {
      // ... Logic ...

      String value = operation.apply(10, true);

      // ... More logic ---
 }
 

The problem will BiFunction.apply(Object, Object) occurs when BiFunction calls any API that throws a checked Exception, e.g. the File API.
Since BiFunction.apply(Object, Object) doesn't define that it throws any Exception's we're forced to add a try/catch to handle the IOException for the code to compile:

  someOperation((value, enabled) -> {
                      try {
                          // Logic that uses the File API
                          return "some-value";
                      } catch (IOException e) {
                          throw new RuntimeException(e);
                      }
                }));
 

This is where the CheckedBiFunction comes to the aid as its apply(Object, Object) methods defines that it throws a Checked Exception and its safe(CheckedBiFunction) will return a new BiFunction instance with a BiFunction.apply(Object, Object) method that ensures that the apply(Object, Object) method is called and any checked Exception's thrown will be caught and rethrown as a CheckedExceptionRethrownException:

  someOperation(CheckedBiFunction.safe(msg("Processing file {}", fileName),
                (value, enabled) -> {
                      // Logic that uses the File API that throws IOException
                      return "some-value";
                }));
 
 

Type Parameters:

T1 - the first argument type

T2 - the second argument type

R - the return type

Parameters:

contextMessage - a string that the described the content for the CheckedBiFunction and which will be used as message in any CheckedExceptionRethrownException thrown

functionThatCanFailWithACheckedException - the CheckedBiFunction instance that will be wrapped as a BiFunction

Returns:

a BiFunction with a BiFunction.apply(Object, Object) method that ensures that the apply(Object, Object) method is called when BiFunction.apply(Object, Object) and any checked Exception's thrown will be caught and rethrown as a CheckedExceptionRethrownException.
Any RuntimeException's thrown aren't caught and the calling code will receive the original RuntimeException thrown.

Throws:

CheckedExceptionRethrownException - in case the apply(Object, Object) method throws a checked Exception

apply

R apply(T1 arg1,
        T2 arg2)
 throws Exception

This method performs the operation that may fail with a Checked Exception

Parameters:

arg1 - the first function argument

arg2 - the second function argument

Returns:

the result of performing the function

Throws:

Exception - this method can throw both checked Exception's as well as RuntimeException's