Module dk.cloudcreate.essentials.shared

Package dk.cloudcreate.essentials.shared.functional

Interface CheckedTripleFunction<T1,T2,T3,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 CheckedTripleFunction<T1,T2,T3,R>

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

See Also:

safe(CheckedTripleFunction), safe(String, CheckedTripleFunction)

Method Summary

Modifier and Type	Method	Description
R	apply(T1 arg1, T2 arg2, T3 arg3)	This method performs the operation that may fail with a Checked Exception
static <T1,T2,T3,R> TripleFunction<T1,T2,T3,R>	safe(CheckedTripleFunction<T1,T2,T3,R> functionThatCanFailWithACheckedException)	Wraps a CheckedTripleFunction (basically a lambda with three arguments that returns a result and which throws a Checked Exception) by returning a new TripleFunction instance The returned TripleFunction.apply(Object, Object, Object) method delegates directly to the apply(Object, Object, Object) and catches any thrown checked Exception's and rethrows them as a CheckedExceptionRethrownException Unless you provide a context-message (using safe(String, CheckedTripleFunction) 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 TripleFunction with the purpose of the calling the TripleFunction.apply(Object, Object, Object).
static <T1,T2,T3,R> TripleFunction<T1,T2,T3,R>	safe(String contextMessage, CheckedTripleFunction<T1,T2,T3,R> functionThatCanFailWithACheckedException)	Wraps a CheckedTripleFunction (basically a lambda with three arguments that returns a result and which throws a Checked Exception) by returning a new TripleFunction instance The returned TripleFunction.apply(Object, Object, Object) method delegates directly to the apply(Object, 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 TripleFunction with the purpose of the calling the TripleFunction.apply(Object, Object, Object).

Method Detail

safe

static <T1,T2,T3,R> TripleFunction<T1,T2,T3,R> safe(CheckedTripleFunction<T1,T2,T3,R> functionThatCanFailWithACheckedException)

Wraps a CheckedTripleFunction (basically a lambda with three arguments that returns a result and which throws a Checked Exception) by returning a new TripleFunction instance
The returned TripleFunction.apply(Object, Object, Object) method delegates directly to the apply(Object, Object, Object) and catches any thrown checked Exception's and rethrows them as a CheckedExceptionRethrownException
Unless you provide a context-message (using safe(String, CheckedTripleFunction) 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 TripleFunction with the purpose of the calling the TripleFunction.apply(Object, Object, Object).

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

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

      // ... More logic ---
 }
 

The problem will TripleFunction.apply(Object, Object, Object) occurs when TripleFunction calls any API that throws a checked Exception, e.g. the File API.
Since TripleFunction.apply(Object, 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, amount, enabled) -> {
                      try {
                          // Logic that uses the File API
                          return "some-value";
                      } catch (IOException e) {
                          throw new RuntimeException(e);
                      }
                }));
 

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

  someOperation(CheckedFunction.safe((value, amount, 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

T3 - the third argument type

R - the return type

Parameters:

functionThatCanFailWithACheckedException - the CheckedTripleFunction instance that will be wrapped as a TripleFunction

Returns:

a TripleFunction with a TripleFunction.apply(Object, Object, Object) method that ensures that the apply(Object, Object, Object) method is called when TripleFunction.apply(Object, 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, Object) method throws a checked Exception

safe

static <T1,T2,T3,R> TripleFunction<T1,T2,T3,R> safe(String contextMessage,
                                                                                        CheckedTripleFunction<T1,T2,T3,R> functionThatCanFailWithACheckedException)

Wraps a CheckedTripleFunction (basically a lambda with three arguments that returns a result and which throws a Checked Exception) by returning a new TripleFunction instance
The returned TripleFunction.apply(Object, Object, Object) method delegates directly to the apply(Object, 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 TripleFunction with the purpose of the calling the TripleFunction.apply(Object, Object, Object).

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

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

      // ... More logic ---
 }
 

The problem will TripleFunction.apply(Object, Object, Object) occurs when TripleFunction calls any API that throws a checked Exception, e.g. the File API.
Since TripleFunction.apply(Object, 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, amount, enabled) -> {
                      try {
                          // Logic that uses the File API
                          return "some-value";
                      } catch (IOException e) {
                          throw new RuntimeException(e);
                      }
                }));
 

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

  someOperation(CheckedFunction.safe(msg("Processing file {}", fileName),
                (value, amount, 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

T3 - the third argument type

R - the return type

Parameters:

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

functionThatCanFailWithACheckedException - the CheckedTripleFunction instance that will be wrapped as a TripleFunction

Returns:

a TripleFunction with a TripleFunction.apply(Object, Object, Object) method that ensures that the apply(Object, Object, Object) method is called when TripleFunction.apply(Object, 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, Object) method throws a checked Exception

apply

R apply(T1 arg1,
        T2 arg2,
        T3 arg3)
 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

arg3 - the third function argument

Returns:

the result of performing the function

Throws:

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