Demo202210Test with some demos, more tests, extra API for demos

Author: magicprinc

jOOL-java-8/src/main/java/org/jooq/lambda/Loops.java

@@ -3,6 +3,7 @@
 import org.jooq.lambda.tuple.Tuple4;
 
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.LongSummaryStatistics;
 import java.util.function.IntConsumer;
 import java.util.function.IntUnaryOperator;
@@ -118,9 +119,10 @@ public static Tuple4<Long, LongSummaryStatistics, Exception, String> loopMeasure
   }
 
 
-  public static class Incrementer {
+  public static class Incrementer implements Cloneable, Iterable<Incrementer> {
     protected final int[] indexes;
     private final IntUnaryOperator maxForIndex;
+    protected long count;
 
     /** All indexes have the same max and rotate in range [0..maxExclusive)
      @param degree size of index vector = how many nested for-loops
@@ -161,8 +163,24 @@ public int maxAt (int indexIndex) {
       return maxForIndex.applyAsInt(indexIndex);
     }
 
+    public long getCount () {
+      return count;
+    }
+
+
     @Override public String toString () {
-      return "Incrementer"+ Arrays.toString(indexes);
+      return "Incrementer"+ Arrays.toString(indexes) +" @ "+getCount();
+    }
+
+
+    private Incrementer (int[] indexes, IntUnaryOperator maxForIndex) {
+      this.indexes = indexes;
+      this.maxForIndex = maxForIndex;
+    }//new
+
+    @SuppressWarnings("CloneDoesntDeclareCloneNotSupportedException")
+    @Override protected Incrementer clone () {
+      return new Incrementer(indexes.clone(), maxForIndex);
     }
 
 
@@ -175,10 +193,9 @@ Increments index vector (array with indexes) by 1.
      @see #forLoop(Predicate)
      */
     public boolean incrementIndexVector () {
-      final int len = indexes.length;
-
-      for (int i = 0; i < len; ) {
-        if (++indexes[i] < maxForIndex.applyAsInt(i)) {
+      count++;
+      for (int i = 0, len = indexes.length; i < len; ) {
+        if (++indexes[i] < maxAt(i)) {
           return false;
 
         } else {// overflow
@@ -206,6 +223,48 @@ public boolean forLoop (Predicate<Incrementer> loopBody) {
         }
       }
     }
+
+
+    public int[] toArray () {
+      return indexes.clone();
+    }
+
+    public Integer[] toIntegerArray () {
+      final int len = indexes.length;
+      Integer[] r = new Integer[len];
+
+      for (int i = 0; i < len; i++) {
+        r[i] = indexes[i];
+      }
+      return r;
+    }
+
+
+    @Override public Iterator<Incrementer> iterator () {
+      return new Iterator<Incrementer>() {
+        final Incrementer snapshot = Incrementer.this.clone();
+        boolean hasNext = true;
+
+        @Override public boolean hasNext () {
+          return hasNext;
+        }
+
+        @Override public Incrementer next () {
+          boolean overflow = snapshot.incrementIndexVector();
+          hasNext = !overflow;
+
+          return snapshot;
+        }
+
+        @Override public String toString () {
+          return "Iterator."+ snapshot + (hasNext? " >":" #");
+        }
+      };
+    }
+
+    public Seq<Incrementer> seq () {
+      return Seq.seq(this);
+    }
   }//Incrementer
 
 }

jOOL-java-8/src/main/java/org/jooq/lambda/Seq.java

@@ -9941,4 +9941,11 @@ default void print(PrintWriter writer) {
     default void print(PrintStream stream) {
         forEach(stream::println);
     }
+
+
+    /**
+     @see Collectable#toList
+     see Stream#toList
+     */
+    List<T> toList (); // makes IDEA and Error-Prone happy
 }

jOOL-java-8/src/main/java/org/jooq/lambda/Wrap.java

@@ -28,9 +28,28 @@
 import org.jooq.lambda.function.Function3;
 import org.jooq.lambda.function.Predicate2;
 import org.jooq.lambda.function.Predicate3;
+import org.jooq.lambda.tuple.Tuple;
+import org.jooq.lambda.tuple.Tuple0;
+import org.jooq.lambda.tuple.Tuple1;
+import org.jooq.lambda.tuple.Tuple10;
+import org.jooq.lambda.tuple.Tuple11;
+import org.jooq.lambda.tuple.Tuple12;
+import org.jooq.lambda.tuple.Tuple13;
+import org.jooq.lambda.tuple.Tuple14;
+import org.jooq.lambda.tuple.Tuple15;
+import org.jooq.lambda.tuple.Tuple16;
+import org.jooq.lambda.tuple.Tuple2;
+import org.jooq.lambda.tuple.Tuple3;
+import org.jooq.lambda.tuple.Tuple4;
+import org.jooq.lambda.tuple.Tuple5;
+import org.jooq.lambda.tuple.Tuple6;
+import org.jooq.lambda.tuple.Tuple7;
+import org.jooq.lambda.tuple.Tuple8;
+import org.jooq.lambda.tuple.Tuple9;
 
 import java.io.IOException;
 import java.io.UncheckedIOException;
+import java.util.Arrays;
 import java.util.concurrent.Callable;
 import java.util.function.BiFunction;
 import java.util.function.BiPredicate;
@@ -101,6 +120,13 @@ private Wrap () {}
    */
   public static final Consumer<Throwable> PRINT_STACK_TRACE = Throwable::printStackTrace;
 
+  /**
+   Can be used in tests:
+   Thread.currentThread().setUncaughtExceptionHandler(Wrap.LOGGING_UNCAUGHT_EXCEPTION_HANDLER);
+   Thread.setDefaultUncaughtExceptionHandler(Wrap.LOGGING_UNCAUGHT_EXCEPTION_HANDLER);
+   */
+  public static final Thread.UncaughtExceptionHandler LOG_WARN_UNCAUGHT_EXCEPTION_HANDLER = LOGGER;
+
   // Safe
 
   public static final Predicate2<Object,Throwable> P1_SILENT_IGNORE_ALL_FALSE = (a,t) -> silentIgnoreAll(t, false);
@@ -168,6 +194,34 @@ public static <T> T cast (Class<? super T> toClazz, Object safer) throws ClassCa
     return (T) toClazz.cast(safer);
   }
 
+
+  @SuppressWarnings({"unchecked", "rawtypes"})
+  public static <T extends Tuple> T tuple (Object... v) {
+    if (v == null || v.length == 0) {
+      return (T) new Tuple0();
+    }
+    switch (v.length) {
+      case 1: return (T) new Tuple1(v[0]);
+      case 2: return (T) new Tuple2(v[0],v[1]);
+      case 3: return (T) new Tuple3(v[0],v[1],v[2]);
+      case 4: return (T) new Tuple4(v[0],v[1],v[2],v[3]);
+      case 5: return (T) new Tuple5(v[0],v[1],v[2],v[3],v[4]);
+      case 6: return (T) new Tuple6(v[0],v[1],v[2],v[3],v[4],v[5]);
+      case 7: return (T) new Tuple7(v[0],v[1],v[2],v[3],v[4],v[5],v[6]);
+      case 8: return (T) new Tuple8(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7]);
+      case 9: return (T) new Tuple9(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8]);
+      case 10: return(T)new Tuple10(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9]);
+      case 11: return(T)new Tuple11(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9],v[10]);
+      case 12: return(T)new Tuple12(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9],v[10],v[11]);
+      case 13: return(T)new Tuple13(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9],v[10],v[11],v[12]);
+      case 14: return(T)new Tuple14(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9],v[10],v[11],v[12],v[13]);
+      case 15: return(T)new Tuple15(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9],v[10],v[11],v[12],v[13],v[14]);
+      case 16: return(T)new Tuple16(v[0],v[1],v[2],v[3],v[4],v[5],v[6],v[7],v[8],v[9],v[10],v[11],v[12],v[13],v[14],v[15]);
+      default: throw new IllegalArgumentException("Unknown Tuple degree: "+v.length+" "+ Arrays.toString(v));
+    }
+  }
+
+
   /** Same as {@link #handleInterruptedException(Throwable)}, but without casting.
    Will be automatically used in "catch (InterruptedException e)" */
   public static void handleInterruptedException (InterruptedException ie) {

jOOL-java-8/src/test/java/org/jooq/lambda/Demo202210Test.java

@@ -0,0 +1,114 @@
+package org.jooq.lambda;
+
+import org.jooq.lambda.fi.lang.SafeRunnable;
+import org.jooq.lambda.function.GenericPredicate;
+import org.jooq.lambda.function.Predicate3;
+import org.junit.Test;
+
+import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
+import java.util.Arrays;
+import java.util.List;
+import java.util.concurrent.CountDownLatch;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.stream.Stream;
+
+import static java.nio.charset.StandardCharsets.*;
+import static java.nio.file.StandardOpenOption.CREATE;
+import static org.junit.Assert.*;
+
+public class Demo202210Test {
+
+  @Test
+  public void wrapFunctionsAreFun () {
+    final String tempDir = "/temp";
+
+    // 1. create vol0.txt - vol2.txt files with text lines in temp
+    Loops.forLoop(3, Unchecked.intConsumer(
+      (i)->{
+        Path file = Paths.get(tempDir, "vol" + i + ".txt");
+
+        Stream<CharSequence> dataGen = Seq.range(1, 101).map(n -> "vol " + i + " line " + n);
+
+        Files.write(file, dataGen::iterator, UTF_8, CREATE);
+
+      }, Wrap.LOG_WARN // Exceptions - if any - go to log
+    ));
+
+    // 2. create empty file (Exceptions - if any - go to log)
+    Wrap.run(()-> Files.createFile(Paths.get(tempDir, "empty.text")));
+
+    List<String> linesFromFiles = Seq.of("vol0", "vol1", "vol2", "empty", "none", "////:::")
+      .map((s)->s+".txt")
+      .map(Wrap.function(f->Paths.get(tempDir, f)))// InvalidPathException
+      .filter(Wrap.predicate(p->p.isPresent() && Files.isRegularFile(p.v1) && Files.size(p.v1)>10))// Exception→log, returns false
+      .map(Either::v1)
+      .map(Wrap.function(p->Files.lines(p, UTF_8)))// seq of Either with lines
+      .filter(Either::isPresent)
+      // .flatMap(Either::stream)
+      .flatMap(Either::v1)
+      .toList();
+
+    assertEquals(3*100, linesFromFiles.size());
+    assertEquals("vol 0 line 1", linesFromFiles.get(0));
+    assertEquals("vol 2 line 100", linesFromFiles.get(linesFromFiles.size()-1));
+
+    int size = 1492-200+(System.lineSeparator().length())*100;
+    Either<Long> sz = Wrap.call(() -> Files.size(Paths.get(tempDir, "vol0.txt")));
+    assertTrue(sz.isSuccess());
+    assertEquals(size, sz.v1.intValue());
+  }
+
+
+  @Test
+  public void safeRunnable () {
+    ExecutorService executor = Executors.newCachedThreadPool();
+
+    Thread.setDefaultUncaughtExceptionHandler(Wrap.LOG_WARN_UNCAUGHT_EXCEPTION_HANDLER);
+
+    CountDownLatch startSignal = new CountDownLatch(1);
+
+    SafeRunnable r = new SafeRunnable() { // can be implemented
+      @Override public void execute () throws Throwable {
+        Thread.currentThread().setUncaughtExceptionHandler(Wrap.LOG_WARN_UNCAUGHT_EXCEPTION_HANDLER);
+
+        startSignal.await();
+        throw new IOException("Try to kill Executor");
+      }
+    };
+
+    Loops.loop(10, ()->executor.execute(r));
+
+    startSignal.countDown();
+
+    Wrap.run(()->Thread.sleep(1000));
+
+    executor.shutdownNow();
+  }
+
+
+  @Test public void testPredicate () {
+    Predicate3<Integer,Integer,Integer> condition1 = (a,b,c)->c==b*b && b == a*a;
+
+    Loops.Incrementer looper = new Loops.Incrementer(3, 100);
+
+    long sz = looper.seq()
+      .map(Loops.Incrementer::toIntegerArray)
+      .filter(array -> GenericPredicate.testDynamicPredicateVarArgs(condition1, (Object[])array))
+      .peek(array -> System.out.println(Arrays.toString(array)))
+      .count();
+    assertEquals(4, sz);
+
+    sz = looper.seq()
+      .map(Loops.Incrementer::toIntegerArray)
+      .map(Wrap::tuple)
+      .filter(t -> condition1.test(Wrap.castUnsafe(t)))
+      .peek(System.out::println)
+      .count();
+    assertEquals(4, sz);
+  }
+
+}

jOOL-java-8/src/test/java/org/jooq/lambda/LoopsTest.java

@@ -5,6 +5,7 @@
 
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Iterator;
 import java.util.List;
 import java.util.LongSummaryStatistics;
 import java.util.concurrent.atomic.AtomicLong;
@@ -206,7 +207,7 @@ public LongSummaryStatisticsP () {}//new
         }
       }
     }
-    assertEquals("Incrementer[0, 0, 0]", x.toString());
+    assertEquals("Incrementer[0, 0, 0] @ 100000", x.toString());
     assertEquals(200, x.maxAt(0));
     assertEquals(50, x.maxAt(1));
     max[2] = 42;
@@ -265,4 +266,41 @@ public LongSummaryStatisticsP () {}//new
   }
 
 
+  @Test
+  public void testIncrementerFunc () {
+    Loops.Incrementer x = new Loops.Incrementer(2, 2);
+    assertEquals("Incrementer[0, 0] @ 0", x.toString());
+
+    x.incrementIndexVector();//common state
+    assertEquals("Incrementer[1, 0] @ 1", x.toString());
+
+    Iterator<Loops.Incrementer> it1 = x.iterator();// start independent snapshot
+    assertEquals("Iterator.Incrementer[1, 0] @ 0 >", it1.toString());
+    it1.next();
+    assertEquals("Iterator.Incrementer[0, 1] @ 1 >", it1.toString());
+
+    Iterator<Loops.Incrementer> it2 = x.iterator();//continue independently, but from this place
+    assertEquals("Iterator.Incrementer[1, 0] @ 0 >", it2.toString());
+
+    it1.next();
+    assertEquals("Iterator.Incrementer[1, 1] @ 2 >", it1.toString());
+    it2.next();
+    assertEquals("Iterator.Incrementer[0, 1] @ 1 >", it2.toString());
+    x.incrementIndexVector();
+    assertEquals("Incrementer[0, 1] @ 2", x.toString());
+
+    it1.next();
+    assertEquals("Iterator.Incrementer[0, 0] @ 3 #", it1.toString());
+    it2.next();
+    assertEquals("Iterator.Incrementer[1, 1] @ 2 >", it2.toString());
+    x.incrementIndexVector();
+    assertEquals("Incrementer[1, 1] @ 3", x.toString());
+
+    it1.next();
+    assertEquals("Iterator.Incrementer[1, 0] @ 4 >", it1.toString());
+    it2.next();
+    assertEquals("Iterator.Incrementer[0, 0] @ 3 #", it2.toString());
+    x.incrementIndexVector();
+    assertEquals("Incrementer[0, 0] @ 4", x.toString());
+  }
 }