Feather2 / feather2-runtime / src / main / java / uk / co / nickthecoder / feather / runtime / FeatherCollections.java

package uk.co.nickthecoder.feather.runtime;

import java.lang.reflect.Array;
import java.util.*;

final public class FeatherCollections {

    /**
     * Prevent creating instances
     */
    private FeatherCollections() {
    }

    // Make strings similar to arrays/lists
    static int size(CharSequence str) {
        return str.length();
    }

    static CharSequenceIterator iterator(CharSequence seq) {
        return new CharSequenceIterator(seq);
    }

    // Create primitive arrays

    public static boolean[] boolArrayOf(boolean... items) {
        return items;
    }

    public static byte[] byteArrayOf(byte... items) {
        return items;
    }

    public static char[] charArrayOf(char... items) {
        return items;
    }

    public static short[] shortArrayOf(short... items) {
        return items;
    }

    public static int[] intArrayOf(int... items) {
        return items;
    }

    public static long[] longArrayOf(long... items) {
        return items;
    }

    public static float[] floatArrayOf(float... items) {
        return items;
    }

    public static double[] doubleArrayOf(double... items) {
        return items;
    }

    @SafeVarargs
    public static <T> T[] arrayOf(T... items) {
        return items;
    }

    @SafeVarargs
    public static <T> List<T> listOf(T... items) {
        return new ArrayList<>(Arrays.asList(items));
    }

    @SafeVarargs
    public static <T> Set<T> setOf(T... items) {
        return new HashSet<>(Arrays.asList(items));
    }

    @SafeVarargs
    public static <K, V> Map<K, V> mapOf(FPair<K, V>... entries) {
        HashMap<K, V> result = new HashMap<>();
        for (FPair<K, V> entry : entries) {
            result.put(entry.first, entry.second);
        }
        return result;
    }

    public static <T extends Comparable<T>> List<T> sorted(List<T> list) {
        if (list.size() <= 1) return list;
        List<T> copy = toList(list);
        Collections.sort(copy);
        return copy;
    }

    public static <T extends Comparable<T>> void sort(List<T> list) {
        Collections.sort(list);
    }

    /**
     * Converts an array to a List
     */
    public static <T> List<T> toList(T[] array) {
        return new ArrayList<>(Arrays.asList(array));
    }

    /**
     * Converts a Collection to a List
     */
    public static <T> List<T> toList(Collection<T> collection) {
        return new ArrayList<>(collection);
    }


    // This function is too cumbersome unless the type parameters can be calculated, rather than explicit.
    // No! public static <K, V> FPair<K, V> to(K key, V value) {
    //    return new FPair<>(key, value);
    //}

    public static <T> T[] toArray(Class<T> elementClass, Collection<T> collection) {
        @SuppressWarnings("unchecked")
        T[] result = (T[]) Array.newInstance(elementClass, collection.size());
        int i = 0;
        for (T item : collection) {
            result[i] = item;
            i++;
        }

        return result;
    }

    public static boolean[] toBoolArray(Collection<Boolean> collection) {
        boolean[] result = (boolean[]) Array.newInstance(boolean.class, collection.size());
        int i = 0;
        for (boolean item : collection) {
            result[i] = item;
            i++;
        }
        return result;
    }

    public static byte[] toByteArray(Collection<Byte> collection) {
        byte[] result = (byte[]) Array.newInstance(byte.class, collection.size());
        int i = 0;
        for (byte item : collection) {
            result[i] = item;
            i++;
        }
        return result;
    }

    public static char[] toCharArray(Collection<Character> collection) {
        char[] result = (char[]) Array.newInstance(char.class, collection.size());
        int i = 0;
        for (char item : collection) {
            result[i] = item;
            i++;
        }
        return result;
    }

    public static short[] toShortArray(Collection<Short> collection) {
        short[] result = (short[]) Array.newInstance(short.class, collection.size());
        int i = 0;
        for (short item : collection) {
            result[i] = item;
            i++;
        }
        return result;
    }

    public static int[] toIntArray(Collection<Integer> collection) {
        int[] result = (int[]) Array.newInstance(int.class, collection.size());
        int i = 0;
        for (int item : collection) {
            result[i] = item;
            i++;
        }
        return result;
    }

    public static long[] toLongArray(Collection<Long> collection) {
        long[] result = (long[]) Array.newInstance(long.class, collection.size());
        int i = 0;
        for (long item : collection) {
            result[i] = item;
            i++;
        }
        return result;
    }

    public static float[] toFloatArray(Collection<Float> collection) {
        float[] result = (float[]) Array.newInstance(float.class, collection.size());
        int i = 0;
        for (float item : collection) {
            result[i] = item;
            i++;
        }
        return result;
    }

    public static double[] toDoubleArray(Collection<Double> collection) {
        double[] result = (double[]) Array.newInstance(double.class, collection.size());
        int i = 0;
        for (double item : collection) {
            result[i] = item;
            i++;
        }
        return result;
    }

}