Implemented Stream API Collectors for AbstractObject and AbstractArray

Author: JanHolger

src/main/java/org/javawebstack/abstractdata/AbstractArray.java

@@ -1,6 +1,10 @@
 package org.javawebstack.abstractdata;
 
+import org.javawebstack.abstractdata.collector.AbstractArrayCollector;
+
 import java.util.*;
+import java.util.function.Function;
+import java.util.stream.Collector;
 import java.util.stream.Stream;
 
 public class AbstractArray implements AbstractElement, Iterable<AbstractElement> {
@@ -289,4 +293,12 @@ public AbstractElement clone() {
         return array;
     }
 
+    public static <T> Collector<T, ?, AbstractArray> collect(Function<T, AbstractElement> mappingFunction) {
+        return new AbstractArrayCollector<>(mappingFunction);
+    }
+
+    public static <T extends AbstractElement> Collector<T, ?, AbstractArray> collect() {
+        return new AbstractArrayCollector<>(e -> e);
+    }
+
 }

src/main/java/org/javawebstack/abstractdata/AbstractElement.java

@@ -3,16 +3,21 @@
 import org.bson.BsonValue;
 import org.javawebstack.abstractdata.bson.BsonConverter;
 import org.javawebstack.abstractdata.bson.BsonTypeAdapter;
+import org.javawebstack.abstractdata.collector.AbstractObjectCollector;
 import org.javawebstack.abstractdata.json.JsonDumper;
 import org.javawebstack.abstractdata.json.JsonParser;
 import org.javawebstack.abstractdata.util.QueryString;
 import org.yaml.snakeyaml.DumperOptions;
 import org.yaml.snakeyaml.Yaml;
 
 import java.text.ParseException;
+import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+import java.util.stream.Collectors;
 
 public interface AbstractElement {
 
@@ -230,4 +235,5 @@ public boolean isPrimitive() {
             return this == NUMBER || this == BOOLEAN || this == STRING;
         }
     }
+
 }

src/main/java/org/javawebstack/abstractdata/AbstractObject.java

@@ -1,11 +1,16 @@
 package org.javawebstack.abstractdata;
 
+import org.javawebstack.abstractdata.collector.AbstractObjectCollector;
+
 import java.lang.reflect.Field;
 import java.util.HashMap;
 import java.util.LinkedHashMap;
 import java.util.Map;
 import java.util.Set;
 import java.util.function.BiConsumer;
+import java.util.function.Function;
+import java.util.stream.Collector;
+import java.util.stream.Stream;
 
 public class AbstractObject implements AbstractElement {
 
@@ -207,10 +212,18 @@ public AbstractArray values() {
         return AbstractArray.fromList(entries.values());
     }
 
+    public Stream<Map.Entry<String, AbstractElement>> stream() {
+        return entries().stream();
+    }
+
     public AbstractElement clone() {
         AbstractObject object = new AbstractObject();
         forEach((k, v) -> object.set(k, v.clone()));
         return object;
     }
 
+    public static <T> Collector<T, ?, AbstractObject> collect(Function<T, String> keyFunction, Function<T, AbstractElement> valueFunction) {
+        return new AbstractObjectCollector<>(keyFunction, valueFunction);
+    }
+
 }

src/main/java/org/javawebstack/abstractdata/collector/AbstractArrayCollector.java

@@ -0,0 +1,47 @@
+package org.javawebstack.abstractdata.collector;
+
+import org.javawebstack.abstractdata.AbstractArray;
+import org.javawebstack.abstractdata.AbstractElement;
+
+import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+
+public class AbstractArrayCollector<T> implements Collector<T, List<AbstractElement>, AbstractArray> {
+
+    private final Function<T, AbstractElement> mappingFunction;
+
+    public AbstractArrayCollector(Function<T, AbstractElement> mappingFunction) {
+        this.mappingFunction = mappingFunction;
+    }
+
+    public Supplier<List<AbstractElement>> supplier() {
+        return ArrayList::new;
+    }
+
+    public BiConsumer<List<AbstractElement>, T> accumulator() {
+        return (l, e) -> l.add(mappingFunction.apply(e));
+    }
+
+    public BinaryOperator<List<AbstractElement>> combiner() {
+        return (l1, l2) -> { l1.addAll(l2); return l1; };
+    }
+
+    public Function<List<AbstractElement>, AbstractArray> finisher() {
+        return l -> {
+            AbstractArray a = new AbstractArray();
+            l.forEach(a::add);
+            return a;
+        };
+    }
+
+    public Set<Characteristics> characteristics() {
+        Set<Characteristics> characteristics = new HashSet<>();
+        characteristics.add(Characteristics.UNORDERED);
+        return characteristics;
+    }
+
+}

src/main/java/org/javawebstack/abstractdata/collector/AbstractObjectCollector.java

@@ -0,0 +1,49 @@
+package org.javawebstack.abstractdata.collector;
+
+import org.javawebstack.abstractdata.AbstractElement;
+import org.javawebstack.abstractdata.AbstractObject;
+
+import java.util.*;
+import java.util.function.BiConsumer;
+import java.util.function.BinaryOperator;
+import java.util.function.Function;
+import java.util.function.Supplier;
+import java.util.stream.Collector;
+
+public class AbstractObjectCollector<T> implements Collector<T, Map<String, AbstractElement>, AbstractObject> {
+
+    private final Function<T, String> keyFunction;
+    private final Function<T, AbstractElement> valueFunction;
+
+    public AbstractObjectCollector(Function<T, String> keyFunction, Function<T, AbstractElement> valueFunction) {
+        this.keyFunction = keyFunction;
+        this.valueFunction = valueFunction;
+    }
+
+    public Supplier<Map<String, AbstractElement>> supplier() {
+        return HashMap::new;
+    }
+
+    public BiConsumer<Map<String, AbstractElement>, T> accumulator() {
+        return (m, e) -> m.put(keyFunction.apply(e), valueFunction.apply(e));
+    }
+
+    public BinaryOperator<Map<String, AbstractElement>> combiner() {
+        return (m1, m2) -> { m1.putAll(m2); return m1; };
+    }
+
+    public Function<Map<String, AbstractElement>, AbstractObject> finisher() {
+        return m -> {
+            AbstractObject o = new AbstractObject();
+            m.forEach(o::set);
+            return o;
+        };
+    }
+
+    public Set<Characteristics> characteristics() {
+        Set<Characteristics> characteristics = new HashSet<>();
+        characteristics.add(Characteristics.UNORDERED);
+        return characteristics;
+    }
+
+}