Merge pull request #3 from ZoftWhere/feature/release-1.2.0

zoftwhere-admin · web-flow · commit 73703e967196 · 2019-09-21T12:49:30.000+02:00
Release v1.2.0
diff --git a/.idea/codeStyles/Project.xml b/.idea/codeStyles/Project.xml
diff --git a/main-java/app/zoftwhere/function/Consumer3.java b/main-java/app/zoftwhere/function/Consumer3.java
@@ -0,0 +1,6 @@
+package app.zoftwhere.function;
+
+public interface Consumer3<T1, T2, T3> {
+
+    void accept(T1 t1, T2 t2, T3 t3);
+}
diff --git a/main-java/app/zoftwhere/function/Consumer4.java b/main-java/app/zoftwhere/function/Consumer4.java
@@ -0,0 +1,6 @@
+package app.zoftwhere.function;
+
+public interface Consumer4<T1, T2, T3, T4> {
+
+    void accept(T1 t1, T2 t2, T3 t3, T4 t4);
+}
diff --git a/main-java/app/zoftwhere/function/ThrowingConsumer1.java b/main-java/app/zoftwhere/function/ThrowingConsumer1.java
@@ -1,6 +1,5 @@
 package app.zoftwhere.function;
 
-@SuppressWarnings("unused")
 public interface ThrowingConsumer1<T> {
 
     void accept(T t) throws Throwable;
diff --git a/main-java/app/zoftwhere/function/ThrowingConsumer2.java b/main-java/app/zoftwhere/function/ThrowingConsumer2.java
@@ -1,6 +1,5 @@
 package app.zoftwhere.function;
 
-@SuppressWarnings("unused")
 public interface ThrowingConsumer2<T1, T2> {
 
     void accept(T1 t1, T2 t2) throws Throwable;
diff --git a/main-java/app/zoftwhere/function/ThrowingConsumer3.java b/main-java/app/zoftwhere/function/ThrowingConsumer3.java
@@ -0,0 +1,6 @@
+package app.zoftwhere.function;
+
+public interface ThrowingConsumer3<T1, T2, T3> {
+
+    void accept(T1 t1, T2 t2, T3 t3) throws Throwable;
+}
diff --git a/main-java/app/zoftwhere/function/ThrowingConsumer4.java b/main-java/app/zoftwhere/function/ThrowingConsumer4.java
@@ -0,0 +1,6 @@
+package app.zoftwhere.function;
+
+public interface ThrowingConsumer4<T1, T2, T3, T4> {
+
+    void accept(T1 t1, T2 t2, T3 t3, T4 t4) throws Throwable;
+}
diff --git a/main-java/app/zoftwhere/function/ThrowingFunction0.java b/main-java/app/zoftwhere/function/ThrowingFunction0.java
@@ -1,6 +1,5 @@
 package app.zoftwhere.function;
 
-@SuppressWarnings({"RedundantThrows", "RedundantSuppression", "unused"})
 public interface ThrowingFunction0<R> {
 
     R accept() throws Throwable;
diff --git a/main-java/app/zoftwhere/function/ThrowingFunction1.java b/main-java/app/zoftwhere/function/ThrowingFunction1.java
@@ -1,6 +1,5 @@
 package app.zoftwhere.function;
 
-@SuppressWarnings({"RedundantThrows", "RedundantSuppression", "unused"})
 public interface ThrowingFunction1<T, R> {
 
     R accept(T t) throws Throwable;
diff --git a/main-java/app/zoftwhere/function/ThrowingFunction2.java b/main-java/app/zoftwhere/function/ThrowingFunction2.java
@@ -1,6 +1,5 @@
 package app.zoftwhere.function;
 
-@SuppressWarnings({"RedundantThrows", "RedundantSuppression", "unused"})
 public interface ThrowingFunction2<T1, T2, R> {
 
     R accept(T1 t1, T2 t2) throws Throwable;
diff --git a/main-java/app/zoftwhere/function/ThrowingFunction3.java b/main-java/app/zoftwhere/function/ThrowingFunction3.java
@@ -0,0 +1,6 @@
+package app.zoftwhere.function;
+
+public interface ThrowingFunction3<T1, T2, T3, R> {
+
+    R accept(T1 t1, T2 t2, T3 t3) throws Throwable;
+}
diff --git a/main-java/app/zoftwhere/function/ThrowingFunction4.java b/main-java/app/zoftwhere/function/ThrowingFunction4.java
@@ -0,0 +1,6 @@
+package app.zoftwhere.function;
+
+public interface ThrowingFunction4<T1, T2, T3, T4, R> {
+
+    R accept(T1 t1, T2 t2, T3 t3, T4 t4) throws Throwable;
+}
diff --git a/main-java/app/zoftwhere/function/Transformer3.java b/main-java/app/zoftwhere/function/Transformer3.java
@@ -0,0 +1,5 @@
+package app.zoftwhere.function;
+
+public interface Transformer3<T1, T2, T3, R> extends Consumer3<T1, T2, T3>, PlaceHolder<R> {
+
+}
diff --git a/main-java/app/zoftwhere/function/Transformer4.java b/main-java/app/zoftwhere/function/Transformer4.java
@@ -0,0 +1,5 @@
+package app.zoftwhere.function;
+
+public interface Transformer4<T1, T2, T3, T4, R> extends Consumer4<T1, T2, T3, T4>, PlaceHolder<R> {
+
+}
diff --git a/main-java/app/zoftwhere/mutable/MutableTransformer3.java b/main-java/app/zoftwhere/mutable/MutableTransformer3.java
@@ -0,0 +1,27 @@
+package app.zoftwhere.mutable;
+
+import java.util.function.Function;
+
+import app.zoftwhere.function.Consumer3;
+import app.zoftwhere.function.Transformer3;
+
+public class MutableTransformer3<T1, T2, T3, R> extends MutableValue<R> implements Transformer3<T1, T2, T3, R> {
+
+    private final Consumer3<T1, T2, T3> consumer;
+
+    public MutableTransformer3(Function<MutableTransformer3<T1, T2, T3, R>, Consumer3<T1, T2, T3>> function) {
+        super();
+        this.consumer = function.apply(this);
+    }
+
+    public MutableTransformer3(Function<MutableTransformer3<T1, T2, T3, R>, Consumer3<T1, T2, T3>> function, R value) {
+        super(value);
+        this.consumer = function.apply(this);
+    }
+
+    @Override
+    public void accept(T1 t1, T2 t2, T3 t3) {
+        this.consumer.accept(t1, t2, t3);
+    }
+
+}
diff --git a/main-java/app/zoftwhere/mutable/MutableTransformer4.java b/main-java/app/zoftwhere/mutable/MutableTransformer4.java
@@ -0,0 +1,30 @@
+package app.zoftwhere.mutable;
+
+import java.util.function.Function;
+
+import app.zoftwhere.function.Consumer4;
+import app.zoftwhere.function.Transformer4;
+
+public class MutableTransformer4<T1, T2, T3, T4, R> extends MutableValue<R> implements Transformer4<T1, T2, T3, T4, R> {
+
+    private final Consumer4<T1, T2, T3, T4> consumer;
+
+    public MutableTransformer4(Function<MutableTransformer4<T1, T2, T3, T4, R>, Consumer4<T1, T2, T3, T4>> function)
+    {
+        super();
+        this.consumer = function.apply(this);
+    }
+
+    public MutableTransformer4(Function<MutableTransformer4<T1, T2, T3, T4, R>, Consumer4<T1, T2, T3, T4>> function,
+        R value)
+    {
+        super(value);
+        this.consumer = function.apply(this);
+    }
+
+    @Override
+    public void accept(T1 t1, T2 t2, T3 t3, T4 t4) {
+        this.consumer.accept(t1, t2, t3, t4);
+    }
+
+}
diff --git a/main-java/app/zoftwhere/mutable/MutableValue.java b/main-java/app/zoftwhere/mutable/MutableValue.java
@@ -26,7 +26,7 @@ public void set(T value) {
      * Retrieve variable value.
      *
      * @return Stored value.
-     * @throws NoSuchElementException if no value is present
+     * @exception NoSuchElementException if no value is present
      */
     @Override
     public T get() {
diff --git a/main-java/app/zoftwhere/mutable/OverlayList.java b/main-java/app/zoftwhere/mutable/OverlayList.java
@@ -29,7 +29,6 @@ public OverlayList(List<E> front, List<E> back) {
         }
     }
 
-    @SuppressWarnings("WeakerAccess")
     public OverlayList(E[] front, E[] back) {
         this(Arrays.asList(back), Arrays.asList(front));
     }
diff --git a/pom.xml b/pom.xml
@@ -1,11 +1,11 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns="http://maven.apache.org/POM/4.0.0"
     xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>app.zoftwhere.mutable</groupId>
     <artifactId>mutable-library</artifactId>
-    <version>1.1.0</version>
+    <version>1.2.0</version>
 
     <properties>
         <!-- Settings: maven-resource-plugin -->
diff --git a/test-java/app/zoftwhere/function/ThrowingConsumerTest.java b/test-java/app/zoftwhere/function/ThrowingConsumerTest.java
@@ -0,0 +1,44 @@
+package app.zoftwhere.function;
+
+import org.junit.jupiter.api.Test;
+
+class ThrowingConsumerTest {
+
+    @Test
+    void testTypeThrow() throws Throwable {
+        final ThrowingConsumer0 throw0 = ThrowingConsumerTest::accept;
+        throw0.accept();
+
+        final ThrowingConsumer1<Integer> throw1 = ThrowingConsumerTest::accept;
+        throw1.accept(1);
+
+        final ThrowingConsumer2<Integer, Long> throw2 = ThrowingConsumerTest::accept;
+        throw2.accept(1, 2L);
+
+        final ThrowingConsumer3<Integer, Long, Float> throw3 = ThrowingConsumerTest::accept;
+        throw3.accept(1, 2L, 3f);
+
+        final ThrowingConsumer4<Integer, Long, Float, Double> throw4 = ThrowingConsumerTest::accept;
+        throw4.accept(1, 2L, 3f, 4d);
+    }
+
+    @SuppressWarnings({"RedundantThrows", "EmptyMethod"})
+    private static void accept() throws Throwable {
+    }
+
+    @SuppressWarnings({"RedundantThrows", "EmptyMethod"})
+    private static void accept(Integer t1) throws Throwable {
+    }
+
+    @SuppressWarnings({"RedundantThrows", "EmptyMethod"})
+    private static void accept(Integer t1, Long t2) throws Throwable {
+    }
+
+    @SuppressWarnings({"RedundantThrows", "EmptyMethod"})
+    private static void accept(Integer t1, Long t2, Float t3) throws Throwable {
+    }
+
+    @SuppressWarnings({"RedundantThrows", "EmptyMethod"})
+    private static void accept(Integer t1, Long t2, Float t3, Double t4) throws Throwable {
+    }
+}
diff --git a/test-java/app/zoftwhere/function/ThrowingFunctionTest.java b/test-java/app/zoftwhere/function/ThrowingFunctionTest.java
@@ -0,0 +1,77 @@
+package app.zoftwhere.function;
+
+import org.junit.jupiter.api.Test;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.fail;
+
+class ThrowingFunctionTest {
+
+    @Test
+    void testFunction() throws Throwable {
+        final var value = "void";
+        final ThrowingFunction0<String> empty //
+            = () -> value;
+        assertEquals(value, empty.accept());
+
+        final ThrowingFunction1<Integer, String> single //
+            = (i) -> "number" + i;
+        assertEquals("number5", single.accept(5));
+
+        final ThrowingFunction2<Integer, Integer, String> twin //
+            = (t1, t2) -> "v" + t1 + "." + t2;
+        assertEquals("v4.8", twin.accept(4, 8));
+
+        final ThrowingFunction3<Integer, Integer, Integer, String> triplet //
+            = (t1, t2, t3) -> "" + (t1 * t2 * t3);
+        assertEquals("42", triplet.accept(2, 3, 7));
+
+        final ThrowingFunction4<Integer, Integer, Integer, Integer, String> quartet //
+            = (t1, t2, t3, t4) -> "" + (t1 + t2) * (t3 + t4);
+        assertEquals("42", quartet.accept(1, 2, 5, 9));
+    }
+
+    @Test
+    void testTypeThrow() {
+        final ThrowingFunction0<String> tf0 //
+            = () -> { throw new NullPointerException(); };
+        try {
+            tf0.accept();
+            fail();
+        }
+        catch (Throwable ignored) { }
+
+        final ThrowingFunction1<Integer, String> tf1 //
+            = (Integer t1) -> { throw new NullPointerException(); };
+        try {
+            tf1.accept(1);
+            fail();
+        }
+        catch (Throwable ignored) { }
+
+        final ThrowingFunction2<Integer, Long, String> tf2 //
+            = (Integer t1, Long t2) -> { throw new NullPointerException(); };
+        try {
+            tf2.accept(1, 2L);
+            fail();
+        }
+        catch (Throwable ignored) { }
+
+        final ThrowingFunction3<Integer, Long, Float, String> tf3 //
+            = (Integer t1, Long t2, Float t3) -> { throw new NullPointerException(); };
+        try {
+            tf3.accept(1, 2L, 3f);
+            fail();
+        }
+        catch (Throwable ignored) { }
+
+        final ThrowingFunction4<Integer, Long, Float, Double, String> tf4 //
+            = (Integer t1, Long t2, Float t3, Double t4) -> { throw new NullPointerException(); };
+        try {
+            tf4.accept(1, 2L, 3f, 4d);
+            fail();
+        }
+        catch (Throwable ignored) { }
+    }
+
+}
diff --git a/test-java/app/zoftwhere/function/scope/ThrowingConsumerScopeTest.java b/test-java/app/zoftwhere/function/scope/ThrowingConsumerScopeTest.java
@@ -0,0 +1,54 @@
+package app.zoftwhere.function.scope;
+
+import app.zoftwhere.function.ThrowingConsumer0;
+import app.zoftwhere.function.ThrowingConsumer1;
+import app.zoftwhere.function.ThrowingConsumer2;
+import app.zoftwhere.function.ThrowingConsumer3;
+import app.zoftwhere.function.ThrowingConsumer4;
+import org.junit.jupiter.api.Test;
+
+class ThrowingConsumerScopeTest {
+
+    @Test
+    void simpleInterfaceTest() {
+        final ThrowingConsumer0 throw0 = ThrowingConsumerScopeTest::accept;
+        try { throw0.accept(); }
+        catch (Throwable ignore) {}
+
+        final ThrowingConsumer1<String> throw1 = ThrowingConsumerScopeTest::accept;
+        try { throw1.accept("s1"); }
+        catch (Throwable ignore) {}
+
+        final ThrowingConsumer2<String, String> throw2 = ThrowingConsumerScopeTest::accept;
+        try { throw2.accept("s1", "s2"); }
+        catch (Throwable ignore) {}
+
+        final ThrowingConsumer3<String, String, String> throw3 = ThrowingConsumerScopeTest::accept;
+        try { throw3.accept("s1", "s2", "s3"); }
+        catch (Throwable ignore) {}
+
+        final ThrowingConsumer4<String, String, String, String> throw4 = ThrowingConsumerScopeTest::accept;
+        try { throw4.accept("s1", "s2", "s3", "s4"); }
+        catch (Throwable ignore) {}
+    }
+
+    private static void accept() throws Throwable {
+        throw new Throwable();
+    }
+
+    private static void accept(String s1) throws Throwable {
+        throw new Throwable();
+    }
+
+    private static void accept(String s1, String s2) throws Throwable {
+        throw new Throwable();
+    }
+
+    private static void accept(String s1, String s2, String s3) throws Throwable {
+        throw new Throwable();
+    }
+
+    private static void accept(String s1, String s2, String s3, String s4) throws Throwable {
+        throw new Throwable();
+    }
+}
diff --git a/test-java/app/zoftwhere/function/scope/ThrowingConsumerTest.java b/test-java/app/zoftwhere/function/scope/ThrowingConsumerTest.java
diff --git a/test-java/app/zoftwhere/function/scope/ThrowingFunctionScopeTest.java b/test-java/app/zoftwhere/function/scope/ThrowingFunctionScopeTest.java
diff --git a/test-java/app/zoftwhere/function/scope/ThrowingFunctionTest.java b/test-java/app/zoftwhere/function/scope/ThrowingFunctionTest.java
diff --git a/test-java/app/zoftwhere/mutable/MutableTransformerTest.java b/test-java/app/zoftwhere/mutable/MutableTransformerTest.java
diff --git a/test-java/app/zoftwhere/mutable/scope/MutableTransformerScopeTest.java b/test-java/app/zoftwhere/mutable/scope/MutableTransformerScopeTest.java
