WebSVN - OpenConcerto - Diff - Rev 177 and 180 - /trunk/OpenConcerto/src/org/openconcerto/utils/CollectionUtils.java

  package org.openconcerto.utils;
 import org.openconcerto.utils.cc.IClosure;
 import org.openconcerto.utils.cc.IPredicate;
 import org.openconcerto.utils.cc.ITransformer;
+import org.openconcerto.utils.cc.ITransformerExn;
 import org.openconcerto.utils.cc.IdentityHashSet;
 import org.openconcerto.utils.cc.IdentitySet;
 import org.openconcerto.utils.cc.LinkedIdentitySet;
 import org.openconcerto.utils.cc.Transformer;
 import java.util.Arrays;
 import java.util.Collection;
 import java.util.Collections;
 import java.util.HashMap;
 import java.util.HashSet;
+import java.util.IdentityHashMap;
 import java.util.Iterator;
 import java.util.LinkedHashMap;
+import java.util.LinkedHashSet;
 import java.util.LinkedList;
 import java.util.List;
 import java.util.ListIterator;
 import java.util.Map;
 import java.util.Map.Entry;
 import java.util.NoSuchElementException;
 import java.util.RandomAccess;
 import java.util.Set;
+import java.util.SortedMap;
+import java.util.SortedSet;
+import java.util.TreeMap;
+import java.util.TreeSet;
+import java.util.function.Function;
 import java.util.regex.Pattern;
 /**
  * Une classe regroupant des méthodes utilitaires pour les collections.
+ *
      */
     static public void delete(List<?> l, int from) {
         delete(l, from, -1);
+    }
-    public static <T> void filter(Collection<T> collection, IPredicate<? super T> predicate) {
-        org.apache.commons.collections.CollectionUtils.filter(collection, predicate);
-    }
     public static <T> boolean exists(Collection<T> collection, IPredicate<? super T> predicate) {
-        return org.apache.commons.collections.CollectionUtils.exists(collection, predicate);
+        return collection.stream().anyMatch(predicate::evaluateChecked);
+    }
     /**
      * Convertit une map en 2 listes, une pour les clefs, une pour les valeurs.
+     *
                 map.put(e.getKey(), e.getValue());
+        }
         return map;
+    }
+    // compared to computeIfAbsent() :
+    // 1. allow exceptions
+    // 2. allow nulls
+    static public <K, V, X extends Exception> V computeIfAbsent(final Map<K, V> map, final K key, final ITransformerExn<K, V, X> function, final boolean allowNullValue) throws X {
+        V res = map.get(key);
+        final boolean contains;
+        if (allowNullValue) {
+            contains = res != null || map.containsKey(key);
+        } else {
+            contains = res != null;
+        }
+        if (!contains) {
+            res = function.transformChecked(key);
+            if (res == null && !allowNullValue)
+                throw new IllegalStateException("Null value computed for key '" + key + "'");
+            map.put(key, res);
+        }
+        assert allowNullValue || res != null;
+        return res;
+    }
     /**
      * Compute the index that have changed (added or removed) between 2 lists. One of the lists MUST
      * be a sublist of the other, ie the to go from one to the other we just add or remove items but
      * we don't do both.
+     *
     static public <C extends Collection<?>> boolean containsAny(final C coll1, final C coll2) {
         return !Collections.disjoint(coll1, coll2);
+    }
-    static public final <T> boolean identityContains(final Collection<T> coll, final T item) {
+    static public final boolean identityContains(final Collection<?> coll, final Object item) {
-        for (final T v : coll) {
+        for (final Object v : coll) {
             if (item == v)
                 return true;
+        }
         return false;
+    }
+    static public final boolean identityEquals(final List<?> coll1, final List<?> coll2) {
+        if (coll1 == coll2)
+            return true;
+        final int size = coll1.size();
+        if (size != coll2.size())
+            return false;
+        if (size == 0)
+            return true;
+        final Iterator<?> iter1 = coll1.iterator();
+        final Iterator<?> iter2 = coll2.iterator();
+        while (iter1.hasNext()) {
+            final Object elem1 = iter1.next();
+            final Object elem2 = iter2.next();
+            if (elem1 != elem2)
+                return false;
+        }
+        assert !iter2.hasNext();
+        return true;
+    }
     /**
      * Convert an array to a list of a different type.
+     *
      * @param <U> type of array
      * @param <T> type of list
         private Object readResolve() {
             return EMPTY_SET;
+        }
+    }
+    public static final <T> List<T> toImmutableList(final Collection<? extends T> coll) {
+        return toImmutableList(coll, ArrayList::new);
+    }
+    public static final <T, C extends Collection<? extends T>> List<T> toImmutableList(final C coll, final Function<? super C, ? extends List<T>> createColl) {
+        if (coll.isEmpty())
+            return Collections.emptyList();
+        return Collections.unmodifiableList(createColl.apply(coll));
+    }
+    public static final <T> Set<T> toImmutableSet(final Collection<T> coll) {
+        if (coll instanceof SortedSet) {
+            // force TreeSet(SortedSet) to keep Comparator
+            // ATTN see eclipse bug below about wrong constructor, we need SortedSet<T>, not
+            // SortedSet<? extends T>, otherwise "Open Declaration" will match to TreeSet(SortedSet)
+            // but not at runtime.
+            return toImmutableSet((SortedSet<T>) coll, TreeSet::new);
+        } else if (coll instanceof IdentitySet) {
+            return toImmutableSet((IdentitySet<? extends T>) coll, LinkedIdentitySet::new);
+        } else {
+            // In doubt, keep order
+            // ATTN LinkedHashSet extends HashSet
+            return toImmutableSet(coll, coll.getClass() == HashSet.class ? HashSet::new : LinkedHashSet::new);
+        }
+    }
+    public static final <T, C extends Collection<? extends T>> Set<T> toImmutableSet(final C coll, final Function<? super C, ? extends Set<T>> createColl) {
+        if (coll.isEmpty())
+            return Collections.emptySet();
+        final Set<T> res = createColl.apply(coll);
+        return Collections.unmodifiableSet(res);
+    }
+    /**
+     * Return an immutable map equal to the passed one.
+     *
+     * @param <K> type of keys.
+     * @param <V> type of values.
+     * @param map the map, not "? extends K" to be able to copy {@link SortedMap}.
+     * @return an immutable map.
+     */
+    public static final <K, V> Map<K, V> toImmutableMap(final Map<K, ? extends V> map) {
+        if (map instanceof SortedMap) {
+            // force TreeMap(SortedMap) to keep Comparator
+            // ATTN see eclipse bug below about wrong constructor
+            return toImmutableMap((SortedMap<K, ? extends V>) map, TreeMap::new);
+        } else if (map instanceof IdentityHashMap) {
+            return toImmutableMap((IdentityHashMap<? extends K, ? extends V>) map, IdentityHashMap::new);
+        } else {
+            // In doubt, keep order
+            // ATTN LinkedHashMap extends HashMap
+            return toImmutableMap(map, map.getClass() == HashMap.class ? HashMap::new : LinkedHashMap::new);
+        }
+    }
+    /**
+     * Return an immutable map with the same entries as the passed one. NOTE: <code>copyMap</code>
+     * <strong>must</strong> copy the entries so that a modification of <code>map</code> doesn't
+     * affect the copy.
+     *
+     * @param <K> type of keys.
+     * @param <V> type of values.
+     * @param <InMap> type of passed map, ATTN if {@link SortedMap} eclipse "Open Declaration"
+     *        matches <code>TreeMap::new</code> to {@link TreeMap#TreeMap(SortedMap)} ignoring
+     *        generic type (i.e. it is declared with "K" but we pass "? extends K") but
+     *        {@link TreeMap#TreeMap(Map)} is (correctly) executed at runtime.
+     * @param map the map.
+     * @param copyFunction how to copy the passed map.
+     * @return an immutable map.
+     */
+    public static final <K, V, InMap extends Map<? extends K, ? extends V>> Map<K, V> toImmutableMap(final InMap map, final Function<? super InMap, ? extends Map<K, V>> copyFunction) {
+        if (map.isEmpty())
+            return Collections.emptyMap();
+        return Collections.unmodifiableMap(copyFunction.apply(map));
+    }
     public static <K, V> Map<K, V> createMap(K key, V val, K key2, V val2) {
         // arguments are ordered, so should the result
         final Map<K, V> res = new LinkedHashMap<K, V>();
         res.put(key, val);
         res.put(key2, val2);

Dépôt officiel du code source de l'ERP OpenConcerto

svn://code.openconcerto.org/openconcerto

(root)/trunk/OpenConcerto/src/org/openconcerto/utils/CollectionUtils.java - Rev 177 → 180