Expand Func.java to include more functional utils

Author: mythz

src/AndroidClient/client/src/main/java/net/servicestack/client/Func.java

@@ -1,19 +1,171 @@
 package net.servicestack.client;
 
+import com.android.internal.util.Predicate;
+
 import java.util.ArrayList;
-import java.util.List;
+import java.util.Collections;
 
 public class Func {
     public static interface Function<T,R> {
         public R apply(T t);
     }
 
-    public static <T,R> ArrayList<R> map(List<T> xs, Function<T,R> f) {
+    public static interface Reducer<T,E> {
+        public E reduce(E prev, T item);
+    }
+
+    public static <T,R> ArrayList<R> map(Iterable<T> xs, Function<T,R> f) {
         ArrayList<R> to = new ArrayList<>();
         for (T x : xs) {
             R ret = f.apply(x);
             to.add(ret);
         }
         return to;
     }
+
+    public static <T> ArrayList<T> toList(Iterable<T> xs){
+        ArrayList<T> to = new ArrayList<>();
+        for (T x : xs) {
+            to.add(x);
+        }
+        return to;
+    }
+
+    public static <T> ArrayList<T> filter(Iterable<T> xs, Predicate<T> predicate){
+        ArrayList<T> to = new ArrayList<>();
+        for (T x : xs) {
+            if (predicate.apply(x)){
+                to.add(x);
+            }
+        }
+        return to;
+    }
+
+    public static <T> T first(Iterable<T> xs, Predicate<T> predicate){
+        for (T x : xs) {
+            if (predicate.apply(x)){
+                return x;
+            }
+        }
+        return null;
+    }
+
+    public static <T> T last(Iterable<T> xs, Predicate<T> predicate){
+        for (T x : reverse(xs)) {
+            if (predicate.apply(x)){
+                return x;
+            }
+        }
+        return null;
+    }
+
+    public static <T> ArrayList<T> skip(Iterable<T> xs, int skip){
+        int i = 0;
+        ArrayList<T> to = new ArrayList<>();
+        for (T x : xs) {
+            if (i++ >= skip){
+                to.add(x);
+            }
+        }
+        return to;
+    }
+
+    public static <T> ArrayList<T> skip(Iterable<T> xs, Predicate<T> predicate){
+        ArrayList<T> to = new ArrayList<>();
+        for (T x : xs) {
+            if (predicate.apply(x)){
+                to.add(x);
+            }
+        }
+        return to;
+    }
+
+    public static <T> ArrayList<T> take(Iterable<T> xs, Predicate<T> predicate){
+        ArrayList<T> to = new ArrayList<>();
+        for (T x : xs) {
+            if (predicate.apply(x)){
+                return to;
+            }
+            to.add(x);
+        }
+        return to;
+    }
+
+    public static <T> ArrayList<T> take(Iterable<T> xs, int take){
+        int i = 0;
+        ArrayList<T> to = new ArrayList<>();
+        for (T x : xs) {
+            if (i++ >= take){
+                return to;
+            }
+            to.add(x);
+        }
+        return to;
+    }
+
+    public static <T> boolean any(Iterable<T> xs, Predicate<T> predicate){
+        for (T x : xs) {
+            if (predicate.apply(x)){
+                return true;
+            }
+        }
+        return false;
+    }
+
+    public static <T> boolean all(Iterable<T> xs, Predicate<T> predicate){
+        for (T x : xs) {
+            if (!predicate.apply(x)){
+                return false;
+            }
+        }
+        return true;
+    }
+
+    public static <T> ArrayList<T> expand(Iterable<T>... xss){
+        ArrayList<T> to = new ArrayList<>();
+        for (Iterable<T> xs : xss) {
+            for (T x : xs){
+                to.add(x);
+            }
+        }
+        return to;
+    }
+
+    public static <T> T elementAt(Iterable<T> xs, int index){
+        int i = 0;
+        for (T x : xs){
+            if (i++ == index){
+                return x;
+            }
+        }
+        return null;
+    }
+
+    public static <T> ArrayList<T> reverse(Iterable<T> xs){
+        ArrayList<T> clone = toList(xs);
+        Collections.reverse(clone);
+        return clone;
+    }
+
+    public static <T,E> E reduce(Iterable<T> xs, E initialValue, Reducer<T,E> reducer){
+        E currentValue = initialValue;
+        for (T x : xs){
+            currentValue = reducer.reduce(currentValue, x);
+        }
+        return currentValue;
+    }
+
+    public static <T,E> E reduceRight(Iterable<T> xs, E initialValue, Reducer<T,E> reducer){
+        return reduce(reverse(xs), initialValue, reducer);
+    }
+
+    public static <T> String join(Iterable<T> xs, String separator){
+        StringBuilder sb = new StringBuilder();
+        for (T x : xs){
+            if (sb.length() > 0)
+                sb.append(separator);
+            sb.append(x);
+        }
+        return sb.toString();
+    }
 }