From d209a5f02eed225872da42481d442b0eca81e980 Mon Sep 17 00:00:00 2001
From: Ivan Hetman <Ihromant@users.noreply.github.com>
Date: Tue, 6 Jun 2023 12:08:15 +0300
Subject: [PATCH] classlib: add Collectors.reducing (#704)

---
 .../org/teavm/classlib/java/lang/TString.java | 17 +++++
 .../java/util/stream/TCollectors.java         | 66 +++++++++++++++++++
 .../java/util/stream/CollectorsTest.java      | 24 +++++++
 3 files changed, 107 insertions(+)

diff --git a/classlib/src/main/java/org/teavm/classlib/java/lang/TString.java b/classlib/src/main/java/org/teavm/classlib/java/lang/TString.java
index be541ea68..16c7d6dd3 100644
--- a/classlib/src/main/java/org/teavm/classlib/java/lang/TString.java
+++ b/classlib/src/main/java/org/teavm/classlib/java/lang/TString.java
@@ -749,4 +749,21 @@ public class TString extends TObject implements TSerializable, TComparable<TStri
         }
         return sb.toString();
     }
+
+    public String repeat(int count) {
+        if (count < 0) {
+            throw new IllegalArgumentException();
+        }
+        if (count == 1) {
+            return this.toString();
+        }
+        if (characters.length == 0 || count == 0) {
+            return "";
+        }
+        TStringBuilder builder = new TStringBuilder(characters.length * count);
+        for (int i = 0; i < count; i++) {
+            builder.append(this.toString());
+        }
+        return builder.toString();
+    }
 }
diff --git a/classlib/src/main/java/org/teavm/classlib/java/util/stream/TCollectors.java b/classlib/src/main/java/org/teavm/classlib/java/util/stream/TCollectors.java
index 0bda46df3..cc4c95005 100644
--- a/classlib/src/main/java/org/teavm/classlib/java/util/stream/TCollectors.java
+++ b/classlib/src/main/java/org/teavm/classlib/java/util/stream/TCollectors.java
@@ -18,11 +18,13 @@ package org.teavm.classlib.java.util.stream;
 import java.util.ArrayList;
 import java.util.Collection;
 import java.util.Collections;
+import java.util.Comparator;
 import java.util.EnumSet;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.Set;
 import java.util.function.BiConsumer;
 import java.util.function.BinaryOperator;
@@ -187,4 +189,68 @@ public final class TCollectors {
                 newCharacteristics);
     }
 
+    private static class Reducer<T> {
+        private final BinaryOperator<T> op;
+        private boolean present;
+        private T value;
+
+        private Reducer(BinaryOperator<T> op) {
+            this.op = op;
+        }
+
+        private Reducer(BinaryOperator<T> op, T value) {
+            this.op = op;
+            consume(value);
+        }
+
+        private void consume(T t) {
+            if (present) {
+                value = op.apply(value, t);
+            } else {
+                value = t;
+                present = true;
+            }
+        }
+
+        private Reducer<T> merge(Reducer<T> other) {
+            if (other.present) {
+                consume(other.value);
+            }
+            return this;
+        }
+
+        private Optional<T> getOpt() {
+            return present ? Optional.of(value) : Optional.empty();
+        }
+
+        private T get() {
+            return value;
+        }
+    }
+
+    public static <T> TCollector<T, ?, Optional<T>> reducing(BinaryOperator<T> op) {
+        return TCollector.of(() -> new Reducer<>(op), Reducer::consume, Reducer::merge, Reducer::getOpt);
+    }
+
+    public static <T> TCollector<T, ?, T> reducing(T identity, BinaryOperator<T> op) {
+        return TCollector.of(() -> new Reducer<>(op, identity), Reducer::consume, Reducer::merge, Reducer::get);
+    }
+
+    public static <T, U> TCollector<T, ?, U> reducing(U identity,
+            Function<? super T, ? extends U> mapper, BinaryOperator<U> op) {
+        return TCollector.of(() -> new Reducer<>(op, identity),
+                (red, t) -> red.consume(mapper.apply(t)), Reducer::merge, Reducer::get);
+    }
+
+    public static <T> TCollector<T, ?, Optional<T>> minBy(Comparator<? super T> comparator) {
+        return reducing(BinaryOperator.minBy(comparator));
+    }
+
+    public static <T> TCollector<T, ?, Optional<T>> maxBy(Comparator<? super T> comparator) {
+        return reducing(BinaryOperator.maxBy(comparator));
+    }
+
+    public static <T> TCollector<T, ?, Long> counting() {
+        return reducing(0L, e -> 1L, Long::sum);
+    }
 }
diff --git a/tests/src/test/java/org/teavm/classlib/java/util/stream/CollectorsTest.java b/tests/src/test/java/org/teavm/classlib/java/util/stream/CollectorsTest.java
index c249ce4d0..832c6c9a0 100644
--- a/tests/src/test/java/org/teavm/classlib/java/util/stream/CollectorsTest.java
+++ b/tests/src/test/java/org/teavm/classlib/java/util/stream/CollectorsTest.java
@@ -18,10 +18,12 @@ package org.teavm.classlib.java.util.stream;
 import static org.junit.Assert.assertEquals;
 import java.util.ArrayList;
 import java.util.Arrays;
+import java.util.Comparator;
 import java.util.HashMap;
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
+import java.util.Optional;
 import java.util.function.Function;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -90,4 +92,26 @@ public class CollectorsTest {
                         Collectors.collectingAndThen(Collectors.toList(),
                                 l -> l.stream().mapToInt(i -> i).sum()))));
     }
+
+    @Test
+    public void reducing() {
+        assertEquals(Optional.of("abc"), Stream.of("a", "b", "c")
+                .collect(Collectors.reducing(String::concat)));
+        assertEquals(Optional.empty(), Stream.<String>empty()
+                .collect(Collectors.reducing(String::concat)));
+        assertEquals("abc", Stream.of("a", "b", "c")
+                .collect(Collectors.reducing("", String::concat)));
+        assertEquals("aabbcc", Stream.of("a", "b", "c")
+                .collect(Collectors.reducing("", s -> s.repeat(2), String::concat)));
+    }
+
+    @Test
+    public void minMax() {
+        assertEquals(Optional.of("a"), Stream.of("a", "bb", "ccc")
+                .collect(Collectors.minBy(Comparator.comparing(String::length))));
+        assertEquals(Optional.of("ccc"), Stream.of("a", "bb", "ccc")
+                .collect(Collectors.maxBy(Comparator.naturalOrder())));
+        assertEquals(Optional.empty(), Stream.<String>empty()
+                .collect(Collectors.minBy(Comparator.naturalOrder())));
+    }
 }