more java.util.function utilities

Author: autermann

src/main/java/org/n52/janmayen/function/Consumers.java

@@ -0,0 +1,79 @@
+/*
+ * Copyright 2016-2017 52°North Initiative for Geospatial Open Source
+ * Software GmbH
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *    http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.n52.janmayen.function;
+
+import java.util.Objects;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+
+import javax.annotation.Nonnull;
+
+/**
+ * Utility functions for {@link Consumer}.
+ *
+ * @author Christian Autermann
+ */
+public class Consumers {
+
+    private Consumers() {
+    }
+
+    /**
+     * Curries the second parameter of the {@code BiConsumer} and creates a {@code Consumer}.
+     *
+     * @param <T>      the first parameter type
+     * @param <U>      the second parameter type
+     * @param consumer the consumer
+     * @param t        the curried parameter
+     *
+     * @return the curried consumer
+     */
+    public static <T, U> Consumer<U> curryFirst(@Nonnull BiConsumer<T, U> consumer, T t) {
+        Objects.requireNonNull(consumer);
+        return (u) -> consumer.accept(t, u);
+    }
+
+    /**
+     * Curries the second parameter of the {@code BiConsumer} and creates a {@code Consumer}.
+     *
+     * @param <T>      the first parameter type
+     * @param <U>      the second parameter type
+     * @param consumer the consumer
+     * @param u        the curried parameter
+     *
+     * @return the curried consumer
+     */
+    public static <T, U> Consumer<T> currySecond(@Nonnull BiConsumer<T, U> consumer, U u) {
+        Objects.requireNonNull(consumer);
+        return (t) -> consumer.accept(t, u);
+    }
+
+    /**
+     * Reverses the parameter order of the BiConsumer
+     *
+     * @param <A>      the first parameter type
+     * @param <B>      the second parameter type
+     * @param consumer the consumer
+     *
+     * @return the consumer with switched parameters
+     */
+    public static <A, B> BiConsumer<B, A> reverse(@Nonnull BiConsumer<A, B> consumer) {
+        Objects.requireNonNull(consumer);
+        return (a, b) -> consumer.accept(b, a);
+    }
+
+}

src/main/java/org/n52/janmayen/function/Functions.java

@@ -52,10 +52,12 @@ private Functions() {
      * @param clazz The class of which the input has to be an instance of.
      *
      * @return The predicate.
+     *
+     * @deprecated use {@link Predicates#instanceOf(java.lang.Class)}
      */
+    @Deprecated
     public static <T, U extends T> Predicate<T> instanceOf(@Nonnull Class<? extends U> clazz) {
-        Objects.requireNonNull(clazz);
-        return x -> clazz.isAssignableFrom(x.getClass());
+        return Predicates.instanceOf(clazz);
     }
 
     /**
@@ -102,7 +104,7 @@ public static <T, U extends T> Function<T, U> cast(@Nonnull Class<? extends U> c
      * @return An {@link Optional} containing the input
      */
     public static <T, U extends T> Function<T, Optional<U>> castIfInstanceOf(@Nonnull Class<? extends U> clazz) {
-        Predicate<Object> filter = instanceOf(clazz);
+        Predicate<Object> filter = Predicates.instanceOf(clazz);
         Function<Object, U> mapper = cast(clazz);
         return t -> Optional.ofNullable(t).filter(filter).map(mapper);
     }
@@ -134,24 +136,67 @@ public static <T, U> Function<T, U> constant(@Nullable U u) {
         return t -> u;
     }
 
+    /**
+     * Curries the parameter of the {@code Function} and creates a {@code Consumer}.
+     *
+     * @param <T>      the parameter type
+     * @param <R>      the return type
+     * @param function the function
+     * @param t        the curried parameter
+     *
+     * @return the curried function
+     */
     public static <T, R> Supplier<R> curry(@Nonnull Function<? super T, ? extends R> function, T t) {
         Objects.requireNonNull(function);
         return () -> function.apply(t);
     }
 
+    /**
+     * Curries the first parameter of the {@code BiFunction} and creates a {@code Function}.
+     *
+     * @param <T1>       the first parameter type
+     * @param <T2>       the second parameter type
+     * @param <R>        the return type
+     * @param bifunction the function
+     * @param t1         the curried parameter
+     *
+     * @return the curried function
+     */
     public static <T1, T2, R> Function<T2, R> curryFirst(@Nonnull BiFunction<T1, T2, R> bifunction, T1 t1) {
         Objects.requireNonNull(bifunction);
         return t2 -> bifunction.apply(t1, t2);
     }
 
+    /**
+     * Curries the second parameter of the {@code BiFunction} and creates a {@code Function}.
+     *
+     * @param <T1>       the first parameter type
+     * @param <T2>       the second parameter type
+     * @param <R>        the return type
+     * @param bifunction the function
+     * @param t2         the curried parameter
+     *
+     * @return the curried function
+     */
     public static <T1, T2, R> Function<T1, R> currySecond(@Nonnull BiFunction<T1, T2, R> bifunction, T2 t2) {
         Objects.requireNonNull(bifunction);
         return t1 -> bifunction.apply(t1, t2);
     }
 
+    /**
+     * Reverses the parameter order of the BiConsumer
+     *
+     * @param <A>      the first parameter type
+     * @param <B>      the second parameter type
+     * @param consumer the consumer
+     *
+     * @return the consumer with switched parameters
+     *
+     * @deprecated use {@link Consumers#reverse(java.util.function.BiConsumer)}
+     */
+    @Deprecated
     public static <A, B> BiConsumer<B, A> reverse(@Nonnull BiConsumer<A, B> consumer) {
-        Objects.requireNonNull(consumer);
-        return (a, b) -> consumer.accept(b, a);
+        return Consumers.reverse(consumer);
     }
 
     public static <T> BinaryOperator<T> mergeLeft(@Nonnull BiConsumer<T, T> merger) {
@@ -203,7 +248,7 @@ public static <K, V> Function<Map<K, V>, Stream<K>> keyStreamWhereValues(Predica
      *
      * @return A function that applies the consumer and returns it's input.
      */
-    public static <T> Function<T, T> mutate(Consumer<? super T> action) {
+    public static <T> Function<T, T> mutate(@Nonnull Consumer<? super T> action) {
         Objects.requireNonNull(action);
         return (T t) -> {
             action.accept(t);
@@ -222,7 +267,8 @@ public static <T> Function<T, T> mutate(Consumer<? super T> action) {
      *
      * @return the wrapped function.
      */
-    public static <S, T, X extends Exception> Function<S, T> errorWrapper(ThrowingFunction<S, T, X> fun) {
+    public static <S, T, X extends Exception> Function<S, T> errorWrapper(@Nonnull ThrowingFunction<S, T, X> fun) {
+        Objects.requireNonNull(fun);
         return s -> {
             try {
                 return fun.apply(s);

src/main/java/org/n52/janmayen/function/Predicates.java

@@ -16,8 +16,12 @@
  */
 package org.n52.janmayen.function;
 
+import java.util.Objects;
+import java.util.function.BiPredicate;
 import java.util.function.Predicate;
 
+import javax.annotation.Nonnull;
+
 /**
  * Utility functions for {@link Predicate}.
  *
@@ -85,4 +89,48 @@ public static <T> Predicate<T> alwaysTrue() {
     public static <T> Predicate<T> constant(boolean value) {
         return t -> value;
     }
+
+    /**
+     * Creates a {@link Predicate} that checks if it's input is an instance of {@code clazz}.
+     *
+     * @param <T>   The input type.
+     * @param <U>   The type of which the input has to be an instance of.
+     * @param clazz The class of which the input has to be an instance of.
+     *
+     * @return The predicate.
+     */
+    public static <T, U extends T> Predicate<T> instanceOf(@Nonnull Class<? extends U> clazz) {
+        Objects.requireNonNull(clazz);
+        return x -> clazz.isAssignableFrom(x.getClass());
+    }
+
+    /**
+     * Curries the first parameter of the {@code BiPredicate} and creates a {@code Predicate}.
+     *
+     * @param <T>       the first parameter type
+     * @param <U>       the second parameter type
+     * @param predicate the predicate
+     * @param t         the curried parameter
+     *
+     * @return the curried predicate
+     */
+    public static <T, U> Predicate<U> curryFirst(@Nonnull BiPredicate<T, U> predicate, T t) {
+        Objects.requireNonNull(predicate);
+        return (u) -> predicate.test(t, u);
+    }
+
+    /**
+     * Curries the second parameter of the {@code BiPredicate} and creates a {@code Predicate}.
+     *
+     * @param <T>       the first parameter type
+     * @param <U>       the second parameter type
+     * @param predicate the predicate
+     * @param u         the curried parameter
+     *
+     * @return the curried predicate
+     */
+    public static <T, U> Predicate<T> currySecond(@Nonnull BiPredicate<T, U> predicate, U u) {
+        Objects.requireNonNull(predicate);
+        return (t) -> predicate.test(t, u);
+    }
 }