added demos

Author: svenruppert

pom.xml

@@ -24,7 +24,7 @@
   <parent>
     <groupId>org.rapidpm</groupId>
     <artifactId>rapidpm-dependencies</artifactId>
-    <version>04.07.05-136</version>
+    <version>04.07.04-RPM</version>
   </parent>
 
   <groupId>org.rapidpm</groupId>

src/test/java/demo/DemoCase.java

@@ -0,0 +1,27 @@
+package demo;
+
+import org.junit.jupiter.api.Test;
+import org.rapidpm.frp.matcher.Case;
+import org.rapidpm.frp.model.Result;
+
+import static org.rapidpm.frp.matcher.Case.matchCase;
+
+public class DemoCase {
+
+
+  @Test
+  void test001() {
+
+    String value = "A";
+    Result<String> result
+        = Case.match(
+            matchCase(() -> Result.failure("nothing fit")),
+            matchCase(() -> value.contains("A"),
+                      () -> Result.success("Got A")),
+            matchCase(() -> value.contains("B"),
+                      () -> Result.success("Got B"))
+                    );
+
+
+  }
+}

src/test/java/demo/DemoCompletableFuture.java

@@ -0,0 +1,55 @@
+package demo;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.function.Supplier;
+
+import static java.util.concurrent.CompletableFuture.supplyAsync;
+
+public class DemoCompletableFuture {
+
+
+  @Test
+  void test001() {
+    ExecutorService exServ = Executors
+        .newFixedThreadPool(2);
+
+    Supplier<String> dataSource = () -> "Hello World";
+    CompletableFuture<String> cf = supplyAsync(dataSource, exServ);
+    String result = cf.join();
+    System.out.println(result);
+    exServ.shutdown();
+  }
+
+  @Test
+  void test002() {
+    ExecutorService exServ = Executors
+        .newFixedThreadPool(2);
+
+    Supplier<String> dataSource = () -> "Hello World";
+    supplyAsync(dataSource, exServ)
+        .thenAcceptAsync(System.out::println, exServ)
+        .join();
+    exServ.shutdown();
+  }
+
+  @Test
+  void test003() {
+    ExecutorService exServ = Executors
+        .newFixedThreadPool(2);
+
+    CompletableFuture<String> cfA = supplyAsync(() -> "A", exServ);
+    CompletableFuture<String> cfB = supplyAsync(() -> "B", exServ);
+    CompletableFuture<String> cfC = supplyAsync(() -> "C", exServ);
+
+    cfA.thenCombineAsync(cfB, (a, b) -> a + b)
+       .thenCombineAsync(cfC, (ab, c) -> ab + c)
+       .thenAcceptAsync(System.out::println, exServ)
+       .join();
+    exServ.shutdown();
+  }
+
+}

src/test/java/demo/DemoCompletableFutureQueue.java

@@ -0,0 +1,36 @@
+package demo;
+
+import org.junit.jupiter.api.Test;
+import org.rapidpm.frp.reactive.CompletableFutureQueue;
+
+import java.util.concurrent.CompletableFuture;
+import java.util.function.Function;
+
+public class DemoCompletableFutureQueue {
+
+
+  @Test
+  void test001() {
+    Function<Integer, CompletableFuture<Integer>> f = CompletableFutureQueue
+        .<Integer, Integer>define((a) -> a + 10)
+        .thenCombineAsync((b) -> b + 20)
+        .thenCombineAsync((c) -> c + 30)
+        .resultFunction();
+
+    f.apply(1)
+     .thenAcceptAsync(System.out::println)
+     .join();
+  }
+
+  @Test
+  void test002() {
+    CompletableFutureQueue
+        .<Integer, Integer>define((a) -> a + 10)
+        .thenCombineAsync((b) -> b + 20)
+        .thenCombineAsync((c) -> c + 30)
+        .resultFunction()
+        .apply(1)
+        .thenAcceptAsync(System.out::println)
+        .join();
+  }
+}

src/test/java/demo/DemoExtraction.java

@@ -0,0 +1,83 @@
+package demo;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.List;
+import java.util.function.BiFunction;
+import java.util.function.Consumer;
+import java.util.function.Function;
+import java.util.function.Predicate;
+
+import static java.util.Arrays.asList;
+
+public class DemoExtraction {
+
+
+  @Test
+  void test001() {
+    List<String> names = asList("Hugo",
+                                "Willy",
+                                "Lotta",
+                                "Maria");
+    names.stream()
+         .filter(v -> v.contains("L"))
+         .forEach(System.out::println);
+    names.stream()
+         .filter(v -> v.contains("H"))
+         .forEach(System.out::println);
+  }
+
+  @Test
+  void test002() {
+    List<String> names = asList("Hugo",
+                                "Willy",
+                                "Lotta",
+                                "Maria");
+    Consumer<String> println = System.out::println;
+    String           l       = "L";//final
+    names.stream()
+         .filter(v -> v.contains(l))
+         .forEach(println);
+
+    String h = "H"; //final
+    names.stream()
+         .filter(v -> v.contains(h))
+         .forEach(println);
+  }
+
+  @Test
+  void test003() {
+    List<String> names = asList("Hugo",
+                                "Willy",
+                                "Lotta",
+                                "Maria");
+    Consumer<String> println = System.out::println;
+
+    String l = "L";//final
+    String h = "H"; //final
+
+    Function<String, Predicate<String>> f
+        = input -> s -> s.contains(input);
+
+    names.stream()
+         .filter(f.apply(l))
+         .forEach(println);
+
+    names.stream()
+         .filter(f.apply(h))
+         .forEach(println);
+
+
+    BiFunction<List<String>, String, Void>
+        f2 = (list, input) -> {
+          list.stream()
+                .filter(f.apply(input))
+                .forEach(println);
+          return null;
+        };
+
+    f2.apply(names, l);
+    f2.apply(names, h);
+
+  }
+}

src/test/java/demo/DemoMemoizingLegacy.java

@@ -0,0 +1,33 @@
+package demo;
+
+import org.junit.Assert;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+import org.rapidpm.frp.memoizer.Memoizer;
+
+import java.util.function.Function;
+
+public class DemoMemoizingLegacy {
+
+  @Test
+  void test001() {
+
+    class Legacy {
+      public String doWork(Integer input) {
+        return input.toString()
+               + "-"
+               + System.nanoTime();
+      }
+    }
+
+    Legacy legacy = new Legacy();
+    Function<Integer, String> f = legacy::doWork;
+    Function<Integer, String> fMemo = Memoizer.memoize(f);
+    String a1 = fMemo.apply(1);
+    Assertions.assertEquals(fMemo.apply(1), a1);
+
+    String aLegacy = f.apply(1);
+    Assertions.assertNotEquals(f.apply(1), aLegacy);
+
+  }
+}

src/test/java/demo/DemoMigration.java

@@ -0,0 +1,27 @@
+package demo;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.function.Function;
+
+public class DemoMigration {
+
+
+  @Test
+  void test001() {
+
+
+    Function<Integer, Integer> plus2 = (i)-> i + 2;
+    Function<Integer, Integer> plus5 = (i)-> i + 5;
+    Function<Integer, Integer> plus10 = (i)-> i + 10;
+
+    Function<Integer, Function<Integer, Integer>>
+        adder = (con) -> (i) -> i+con;
+
+    Function<Integer, Integer> plusTwo
+        = adder.apply(2);
+
+
+
+  }
+}

src/test/java/demo/DemoObserver.java

@@ -0,0 +1,45 @@
+package demo;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
+
+import static java.lang.System.out;
+
+public class DemoObserver {
+
+
+  @Test
+  void test001() {
+
+    class Observer<KEY, VALUE> {
+      private ConcurrentHashMap<KEY, Consumer<VALUE>> listener
+          = new ConcurrentHashMap<>();
+
+      public void register(KEY key,
+                           Consumer<VALUE> consumer) {
+        listener.put(key, consumer);
+      }
+
+      public void remove(KEY key) {
+        listener.remove(key);
+      }
+
+      public void senEvent(VALUE value) {
+        listener.values()
+                .forEach(c -> c.accept(value));
+      }
+    }
+
+
+    Observer<String, Integer> observer = new Observer<>();
+
+    observer.register("key1", out::println);
+    observer.senEvent(2);
+    observer.remove("key1");
+    observer.senEvent(2);
+
+
+  }
+}

src/test/java/demo/DemoRegistration.java

@@ -0,0 +1,44 @@
+package demo;
+
+import org.junit.jupiter.api.Test;
+
+import java.util.Set;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Consumer;
+
+import static java.lang.System.out;
+
+public class DemoRegistration {
+
+  interface Registration {
+    void remove();
+  }
+
+  @Test
+  void test001() {
+
+    class Observer<KEY, VALUE> {
+      private Set<Consumer<VALUE>> listener
+          = ConcurrentHashMap.newKeySet();
+
+      public Registration register(Consumer<VALUE> consumer) {
+        listener.add(consumer);
+        return () -> listener.remove(consumer);
+      }
+
+      public void senEvent(VALUE value) {
+        listener.forEach(c -> c.accept(value));
+      }
+    }
+
+
+    Observer<String, Integer> observer = new Observer<>();
+
+    Registration reg = observer.register(out::println);
+    observer.senEvent(2);
+    reg.remove();
+    observer.senEvent(2);
+
+
+  }
+}