Add XTerminatingOperationFactory, Work on #44

pipeline/src/main/java/com/speedment/jpastreamer/pipeline/terminal/DoubleTerminalOperationFactory.java

@@ -0,0 +1,68 @@
+/*
+ * JPAstreamer - Express JPA queries with Java Streams
+ * Copyright (c) 2020-2020, Speedment, Inc. All Rights Reserved.
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * See: https://github.com/speedment/jpa-streamer/blob/master/LICENSE
+ */
+package com.speedment.jpastreamer.pipeline.terminal;
+
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.DoubleStream;
+import java.util.stream.IntStream;
+
+public interface DoubleTerminalOperationFactory extends BaseStreamTerminalOperationFactory {
+
+    TerminalOperation<DoubleStream, Void> createForEach(DoubleConsumer action);
+
+    TerminalOperation<DoubleStream, Void> createForEachOrdered(DoubleConsumer action);
+
+    TerminalOperation<DoubleStream, double[]> acquireToArray();
+
+    TerminalOperation<DoubleStream, Double> createReduce(double identity, DoubleBinaryOperator op);
+
+    TerminalOperation<DoubleStream, OptionalDouble> createReduce(DoubleBinaryOperator op);
+
+    <R> TerminalOperation<DoubleStream, R> createCollect(Supplier<R> supplier,
+                                                         ObjDoubleConsumer<R> accumulator,
+                                                         BiConsumer<R, R> combiner);
+
+    TerminalOperation<DoubleStream, Double> acquireSum();
+
+    TerminalOperation<DoubleStream, OptionalDouble> acquireMin();
+
+    TerminalOperation<DoubleStream, OptionalDouble> acquireMax();
+
+    TerminalOperation<DoubleStream, Long> acquireCount();
+
+
+    TerminalOperation<DoubleStream, OptionalDouble> acquireAverage();
+
+    TerminalOperation<DoubleStream, DoubleSummaryStatistics> acquireSummaryStatistics();
+
+
+    TerminalOperation<DoubleStream, Boolean> createAnyMatch(DoublePredicate predicate);
+
+    TerminalOperation<DoubleStream, Boolean> createAllMatch(DoublePredicate predicate);
+
+    TerminalOperation<DoubleStream, Boolean> createNoneMatch(DoublePredicate predicate);
+
+    TerminalOperation<DoubleStream, OptionalDouble> acquireFindFirst();
+
+    TerminalOperation<DoubleStream, OptionalDouble> acquireFindAny();
+
+    @SuppressWarnings("unchecked")
+    @Override
+    TerminalOperation<DoubleStream, PrimitiveIterator.OfDouble> acquireIterator();
+
+    @SuppressWarnings("unchecked")
+    @Override
+    TerminalOperation<DoubleStream, Spliterator.OfDouble> acquireSpliterator();
+
+}

pipeline/src/main/java/com/speedment/jpastreamer/pipeline/terminal/IntTerminalOperationFactory.java

@@ -0,0 +1,67 @@
+/*
+ * JPAstreamer - Express JPA queries with Java Streams
+ * Copyright (c) 2020-2020, Speedment, Inc. All Rights Reserved.
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * See: https://github.com/speedment/jpa-streamer/blob/master/LICENSE
+ */
+package com.speedment.jpastreamer.pipeline.terminal;
+
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.BaseStream;
+import java.util.stream.IntStream;
+
+public interface IntTerminalOperationFactory extends BaseStreamTerminalOperationFactory {
+
+    TerminalOperation<IntStream, Void> createForEach(IntConsumer action);
+
+    TerminalOperation<IntStream, Void> createForEachOrdered(IntConsumer action);
+
+    TerminalOperation<IntStream, int[]> acquireToArray();
+
+    TerminalOperation<IntStream, Integer> createReduce(int identity, IntBinaryOperator op);
+
+    TerminalOperation<IntStream, OptionalInt> createReduce(IntBinaryOperator op);
+
+    <R> TerminalOperation<IntStream, R> createCollect(Supplier<R> supplier,
+                                                      ObjIntConsumer<R> accumulator,
+                                                      BiConsumer<R, R> combiner);
+
+    TerminalOperation<IntStream, Integer> acquireSum();
+
+    TerminalOperation<IntStream, OptionalInt> acquireMin();
+
+    TerminalOperation<IntStream, OptionalInt> acquireMax();
+
+    TerminalOperation<IntStream, Long> acquireCount();
+
+
+    TerminalOperation<IntStream, OptionalDouble> acquireAverage();
+
+    TerminalOperation<IntStream, IntSummaryStatistics> acquireSummaryStatistics();
+
+
+    TerminalOperation<IntStream, Boolean> createAnyMatch(IntPredicate predicate);
+
+    TerminalOperation<IntStream, Boolean> createAllMatch(IntPredicate predicate);
+
+    TerminalOperation<IntStream, Boolean> createNoneMatch(IntPredicate predicate);
+
+    TerminalOperation<IntStream, OptionalInt> acquireFindFirst();
+
+    TerminalOperation<IntStream, OptionalInt> acquireFindAny();
+
+    @SuppressWarnings("unchecked")
+    @Override
+    TerminalOperation<IntStream, PrimitiveIterator.OfInt> acquireIterator();
+
+    @SuppressWarnings("unchecked")
+    @Override
+    TerminalOperation<IntStream, Spliterator.OfInt> acquireSpliterator();
+}

pipeline/src/main/java/com/speedment/jpastreamer/pipeline/terminal/LongTerminalOperationFactory.java

@@ -0,0 +1,67 @@
+/*
+ * JPAstreamer - Express JPA queries with Java Streams
+ * Copyright (c) 2020-2020, Speedment, Inc. All Rights Reserved.
+ *
+ * License: GNU Lesser General Public License (LGPL), version 2.1 or later.
+ *
+ * This library is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
+ * without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+ * See the GNU Lesser General Public License for more details.
+ *
+ * See: https://github.com/speedment/jpa-streamer/blob/master/LICENSE
+ */
+package com.speedment.jpastreamer.pipeline.terminal;
+
+import java.util.*;
+import java.util.function.*;
+import java.util.stream.LongStream;
+
+public interface LongTerminalOperationFactory extends BaseStreamTerminalOperationFactory {
+
+    TerminalOperation<LongStream, Void> createForEach(LongConsumer action);
+
+    TerminalOperation<LongStream, Void> createForEachOrdered(LongConsumer action);
+
+    TerminalOperation<LongStream, long[]> acquireToArray();
+
+    TerminalOperation<LongStream, Long> createReduce(long identity, LongBinaryOperator op);
+
+    TerminalOperation<LongStream, OptionalLong> createReduce(LongBinaryOperator op);
+
+    <R> TerminalOperation<LongStream, R> createCollect(Supplier<R> supplier,
+                                                       ObjLongConsumer<R> accumulator,
+                                                       BiConsumer<R, R> combiner);
+
+    TerminalOperation<LongStream, Long> acquireSum();
+
+    TerminalOperation<LongStream, OptionalLong> acquireMin();
+
+    TerminalOperation<LongStream, OptionalLong> acquireMax();
+
+    TerminalOperation<LongStream, Long> acquireCount();
+
+
+    TerminalOperation<LongStream, OptionalDouble> acquireAverage();
+
+    TerminalOperation<LongStream, LongSummaryStatistics> acquireSummaryStatistics();
+
+
+    TerminalOperation<LongStream, Boolean> createAnyMatch(LongPredicate predicate);
+
+    TerminalOperation<LongStream, Boolean> createAllMatch(LongPredicate predicate);
+
+    TerminalOperation<LongStream, Boolean> createNoneMatch(LongPredicate predicate);
+
+    TerminalOperation<LongStream, OptionalLong> acquireFindFirst();
+
+    TerminalOperation<LongStream, OptionalLong> acquireFindAny();
+
+    @SuppressWarnings("unchecked")
+    @Override
+    TerminalOperation<LongStream, PrimitiveIterator.OfLong> acquireIterator();
+
+    @SuppressWarnings("unchecked")
+    @Override
+    TerminalOperation<LongStream, Spliterator.OfLong> acquireSpliterator();
+
+}

provider/autoclose-standard/src/test/java/com/speedment/jpastreamer/autoclose/standard/internal/AutoClosingDoubleStreamTest.java

@@ -140,7 +140,7 @@ void testReduce() {
 
     @Test
     void collect() {
-        testTerminal(s -> s.collect(AtomicLong::new, (al, d) -> al.addAndGet((long) d), (a, b) -> a.addAndGet((long) b.get())), (a, b) -> a.get() == b.get());
+        testTerminal(s -> s.collect(AtomicLong::new, (al, d) -> al.addAndGet((long) d), (a, b) -> a.addAndGet(b.get())), (a, b) -> a.get() == b.get());
     }
 
     @Test

provider/autoclose-standard/src/test/java/com/speedment/jpastreamer/autoclose/standard/internal/AutoClosingStreamTest.java

@@ -22,7 +22,7 @@ protected Stream<Integer> initialStream() {
 
     @Override
     protected Stream<Integer> autoClosingStream(Stream<Integer> stream, boolean allowStreamIteratorAndSpliterator) {
-        return new AutoClosingStream(stream, allowStreamIteratorAndSpliterator);
+        return new AutoClosingStream<>(stream, allowStreamIteratorAndSpliterator);
     }
 
     @Override