From 8151ca68121cec8ae9f8487d210d4ffc901cd36d Mon Sep 17 00:00:00 2001
From: Grzegorz Piwowarek <gpw@touk.pl>
Date: Fri, 27 Nov 2015 11:15:50 +0100
Subject: [PATCH] Additional methods

---
 .../touk/pl/function/ThrowingBiFunction.java    |  3 ++-
 .../java/touk/pl/function/ThrowingConsumer.java | 17 +++++++++++++++++
 .../java/touk/pl/function/ThrowingFunction.java |  7 ++++++-
 .../touk/pl/function/ThrowingPredicate.java     |  7 ++++---
 .../java/touk/pl/function/ThrowingRunnable.java |  6 ++++++
 .../java/touk/pl/function/ThrowingSupplier.java | 10 ++++++++++
 .../touk/pl/function/ThrowingUnaryOperator.java | 17 +++++++++++++++++
 7 files changed, 62 insertions(+), 5 deletions(-)
 create mode 100644 src/main/java/touk/pl/function/ThrowingConsumer.java
 create mode 100644 src/main/java/touk/pl/function/ThrowingRunnable.java
 create mode 100644 src/main/java/touk/pl/function/ThrowingSupplier.java
 create mode 100644 src/main/java/touk/pl/function/ThrowingUnaryOperator.java

diff --git a/src/main/java/touk/pl/function/ThrowingBiFunction.java b/src/main/java/touk/pl/function/ThrowingBiFunction.java
index 4e6b38a..0e7ae22 100644
--- a/src/main/java/touk/pl/function/ThrowingBiFunction.java
+++ b/src/main/java/touk/pl/function/ThrowingBiFunction.java
@@ -2,10 +2,11 @@
 
 import java.util.Objects;
 
+@FunctionalInterface
 public interface ThrowingBiFunction<T1, T2, R, E extends Exception> {
     R apply(T1 arg1, T2 arg2) throws E;
 
-    default <V> ThrowingBiFunction<T1, T2, V, E> andThen(ThrowingFunction<? super R, ? extends V, E> after) {
+    default <V> ThrowingBiFunction<T1, T2, V, E> andThen(final ThrowingFunction<? super R, ? extends V, E> after) {
         Objects.requireNonNull(after);
 
         return (arg1, arg2) -> after.apply(apply(arg1, arg2));
diff --git a/src/main/java/touk/pl/function/ThrowingConsumer.java b/src/main/java/touk/pl/function/ThrowingConsumer.java
new file mode 100644
index 0000000..b398a40
--- /dev/null
+++ b/src/main/java/touk/pl/function/ThrowingConsumer.java
@@ -0,0 +1,17 @@
+package touk.pl.function;
+
+import java.util.Objects;
+
+@FunctionalInterface
+public interface ThrowingConsumer<T, E extends Exception> {
+    void accept(T t) throws E;
+
+    default ThrowingConsumer<T, E> andThenConsume(final ThrowingConsumer<? super T, E> after) {
+        Objects.requireNonNull(after);
+
+        return t -> {
+            accept(t);
+            after.accept(t);
+        };
+    }
+}
diff --git a/src/main/java/touk/pl/function/ThrowingFunction.java b/src/main/java/touk/pl/function/ThrowingFunction.java
index bcd9c6b..d13bebb 100644
--- a/src/main/java/touk/pl/function/ThrowingFunction.java
+++ b/src/main/java/touk/pl/function/ThrowingFunction.java
@@ -4,16 +4,21 @@
 import java.util.Optional;
 import java.util.function.Function;
 
+@FunctionalInterface
 public interface ThrowingFunction<T,R,E extends Exception> {
     R apply(T arg) throws E;
 
+    static <T, E extends Exception> ThrowingFunction<T, T, E> identity() {
+        return t -> t;
+    }
+
     default <V> ThrowingFunction<V, R, E> compose(final ThrowingFunction<? super V, ? extends T, E> before) {
         Objects.requireNonNull(before);
 
         return (V v) -> apply(before.apply(v));
     }
 
-    default <V> ThrowingFunction<T, V, E> andThen(ThrowingFunction<? super R, ? extends V, E> after) {
+    default <V> ThrowingFunction<T, V, E> andThen(final ThrowingFunction<? super R, ? extends V, E> after) {
         Objects.requireNonNull(after);
         return (T t) -> after.apply(apply(t));
     }
diff --git a/src/main/java/touk/pl/function/ThrowingPredicate.java b/src/main/java/touk/pl/function/ThrowingPredicate.java
index abd8b55..18c815a 100644
--- a/src/main/java/touk/pl/function/ThrowingPredicate.java
+++ b/src/main/java/touk/pl/function/ThrowingPredicate.java
@@ -3,22 +3,23 @@
 import java.util.Objects;
 import java.util.Optional;
 
+@FunctionalInterface
 public interface ThrowingPredicate<T, E extends Exception> {
     boolean test(T t) throws E;
 
-    default ThrowingPredicate<T, E> and(ThrowingPredicate<? super T, E> other) {
+    default ThrowingPredicate<T, E> and(final ThrowingPredicate<? super T, E> other) {
         Objects.requireNonNull(other);
 
         return t -> test(t) && other.test(t);
     }
 
-    default ThrowingPredicate<T, E> or(ThrowingPredicate<? super T, E> other) {
+    default ThrowingPredicate<T, E> or(final ThrowingPredicate<? super T, E> other) {
         Objects.requireNonNull(other);
 
         return t -> test(t) || other.test(t);
     }
 
-    default ThrowingPredicate<T, E> xor(ThrowingPredicate<? super T, E> other) {
+    default ThrowingPredicate<T, E> xor(final ThrowingPredicate<? super T, E> other) {
         Objects.requireNonNull(other);
 
         return t -> test(t) ^ other.test(t);
diff --git a/src/main/java/touk/pl/function/ThrowingRunnable.java b/src/main/java/touk/pl/function/ThrowingRunnable.java
new file mode 100644
index 0000000..6e8833c
--- /dev/null
+++ b/src/main/java/touk/pl/function/ThrowingRunnable.java
@@ -0,0 +1,6 @@
+package touk.pl.function;
+
+@FunctionalInterface
+public interface ThrowingRunnable<E extends Exception> {
+    void run() throws E;
+}
diff --git a/src/main/java/touk/pl/function/ThrowingSupplier.java b/src/main/java/touk/pl/function/ThrowingSupplier.java
new file mode 100644
index 0000000..04a016c
--- /dev/null
+++ b/src/main/java/touk/pl/function/ThrowingSupplier.java
@@ -0,0 +1,10 @@
+package touk.pl.function;
+
+@FunctionalInterface
+public interface ThrowingSupplier<T, E extends Exception> {
+    T get() throws E;
+
+    static <T, E extends Exception> ThrowingSupplier<T, E> empty() {
+        return () -> null;
+    }
+}
diff --git a/src/main/java/touk/pl/function/ThrowingUnaryOperator.java b/src/main/java/touk/pl/function/ThrowingUnaryOperator.java
new file mode 100644
index 0000000..582bc04
--- /dev/null
+++ b/src/main/java/touk/pl/function/ThrowingUnaryOperator.java
@@ -0,0 +1,17 @@
+package touk.pl.function;
+
+@FunctionalInterface
+public interface ThrowingUnaryOperator<T, E extends Exception> extends ThrowingFunction<T, T, E> {
+
+    static <T, E extends Exception> ThrowingUnaryOperator<T, E> identity() {
+        return t -> t;
+    }
+
+    default ThrowingUnaryOperator<T, E> applyBefore(final ThrowingUnaryOperator<T, E> operator) {
+        return t -> operator.apply(apply(t));
+    }
+
+    default ThrowingUnaryOperator<T, E> applyAfter(final ThrowingUnaryOperator<T, E> operator) {
+        return t -> apply(operator.apply(t));
+    }
+}