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

 /*
  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
- * Copyright 2011 OpenConcerto, by ILM Informatique. All rights reserved.
+ * Copyright 2011-2019 OpenConcerto, by ILM Informatique. All rights reserved.
+ *
  * The contents of this file are subject to the terms of the GNU General Public License Version 3
  * only ("GPL"). You may not use this file except in compliance with the License. You can obtain a
  * copy of the License at http://www.gnu.org/licenses/gpl-3.0.html See the License for the specific
  * language governing permissions and limitations under the License.
  * When distributing the software, include this License Header Notice in each file.
  */
  package org.openconcerto.utils;
+import org.openconcerto.utils.cc.CustomEquals;
 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 java.util.SortedMap;
 import java.util.SortedSet;
 import java.util.TreeMap;
 import java.util.TreeSet;
 import java.util.function.Function;
+import java.util.function.Supplier;
 import java.util.regex.Pattern;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
 /**
  * Une classe regroupant des méthodes utilitaires pour les collections.
+ *
  * @author ILM Informatique 30 sept. 2004
     static public <C extends Collection<?>> boolean containsAny(final C coll1, final C coll2) {
         return !Collections.disjoint(coll1, coll2);
+    }
     static public final boolean identityContains(final Collection<?> coll, final Object item) {
+        final int size = coll.size();
+        if (size > 0) {
+            if (coll instanceof RandomAccess && coll instanceof List) {
+                final List<?> list = (List<?>) coll;
+                for (int i = 0; i < size; i++) {
+                    final Object v = list.get(i);
+                    if (item == v)
+                        return true;
+                }
+            } else {
-        for (final Object v : coll) {
+                for (final Object v : coll) {
-            if (item == v)
+                    if (item == v)
-                return true;
+                        return true;
+                }
+            }
+        }
         return false;
+    }
+    static public final boolean identityRemove(final Collection<?> coll, final Object item) {
+        final int size = coll.size();
+        if (size > 0) {
+            if (coll instanceof RandomAccess && coll instanceof List) {
+                final List<?> list = (List<?>) coll;
+                for (int i = 0; i < size; i++) {
+                    final Object v = list.get(i);
+                    if (item == v) {
+                        list.remove(i);
+                        return true;
+                    }
+                }
+            } else {
+                for (Iterator<?> i = coll.iterator(); i.hasNext();) {
+                    if (item == i.next()) {
+                        i.remove();
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+    static public final <T> int identityIndexOf(final List<T> coll, final T item) {
+        return CustomEquals.indexOf(coll, item, CustomEquals.getIdentity());
+    }
     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())
     public static <E> List<E> castList(final List<?> list, Class<E> c) throws ClassCastException {
         if (list == null) {
             return null;
+        }
+        final List<E> result;
+        if (list instanceof RandomAccess) {
-        final int size = list.size();
+            final int size = list.size();
-        final List<E> result = new ArrayList<E>(size);
+            result = new ArrayList<>(size);
-        for (int i = 0; i < list.size(); i++) {
+            for (int i = 0; i < size; i++) {
-            result.add(c.cast(list.get(i)));
+                result.add(c.cast(list.get(i)));
+            }
+        } else {
+            result = new LinkedList<>();
+            for (final Object o : list) {
+                result.add(c.cast(o));
+            }
+        }
         return result;
+    }
     /**
      * Cast Map
      * @return a new HashMap create from the <code>map</code> or null if <code>map</code> is null
      * @throws ClassCastException if some item of <code>map</code> have a key which the type is not
      *         a <code>E</code> or a value which the type is not a <code>F</code>.
      */
     public static <E, F> Map<E, F> castMap(final Map<?, ?> map, Class<E> cKey, Class<F> cValue) throws ClassCastException {
+        return castMap(map, cKey, cValue, HashMap::new);
+    }
+    public static <E, F> Map<E, F> castMap(final Map<?, ?> map, Class<E> cKey, Class<F> cValue, final Supplier<Map<E, F>> ctor) throws ClassCastException {
         if (map == null) {
             return null;
+        }
-        final Map<E, F> result = new HashMap<E, F>();
+        final Map<E, F> result = ctor.get();
         for (final Entry<?, ?> mapEntry : map.entrySet()) {
             final E key;
             try {
                 key = cKey.cast(mapEntry.getKey());
             } catch (final ClassCastException ex) {
             result.put(key, value);
+        }
         return result;
+    }
+    public static <T> Stream<T> subclassFilter(final Collection<? super T> coll, final Class<T> subclass) {
+        return coll.stream().filter(subclass::isInstance).map(subclass::cast);
+    }
+    public static <T> List<T> subclassFilterToList(final Collection<? super T> coll, final Class<T> subclass) {
+        return subclassFilter(coll, subclass).collect(Collectors.toList());
+    }
     /**
      * The number of equals item between a and b, starting from the end.
+     *
      * @param <T> type of items.
      * @param a the first list, eg [a, b, c].
         private Object readResolve() {
             return EMPTY_SET;
+        }
+    }
+    @SafeVarargs
+    public static final <T> List<T> toImmutableList(final T... items) {
+        final int length = items.length;
+        if (length == 0)
+            return Collections.emptyList();
+        else if (length == 1)
+            return Collections.singletonList(items[0]);
+        return Collections.unmodifiableList(Arrays.asList(Arrays.copyOf(items, length)));
+    }
     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) {
+        return toImmutableList(coll, createColl, true);
+    }
+    /**
+     * Create a new immutable list.
+     *
+     * @param <T> type of items
+     * @param <C> type of collection
+     * @param coll the collection holding the items.
+     * @param createColl how to copy the collection into a new list.
+     * @param std <code>true</code> if the created <code>createColl</code> use
+     *        {@link Object#equals(Object)}, in that case {@link Collections#singletonList(Object)}
+     *        can be returned.
+     * @return an immutable list with the same items as <code>coll</code>.
+     */
+    public static final <T, C extends Collection<? extends T>> List<T> toImmutableList(final C coll, final Function<? super C, ? extends List<T>> createColl, final boolean std) {
+        final int size = coll.size();
-        if (coll.isEmpty())
+        if (size == 0)
             return Collections.emptyList();
+        else if (std && size == 1)
+            return Collections.singletonList(coll.iterator().next());
         return Collections.unmodifiableList(createColl.apply(coll));
+    }
     public static final <T> Set<T> toImmutableSet(final Collection<T> coll) {
         if (coll instanceof SortedSet) {
             // 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);
+            return toImmutableSet((IdentitySet<? extends T>) coll, LinkedIdentitySet::new, false);
         } 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) {
+        return toImmutableSet(coll, createColl, true);
+    }
+    /**
+     * Create a new immutable set.
+     *
+     * @param <T> type of items
+     * @param <C> type of collection
+     * @param coll the collection holding the items.
+     * @param createColl how to copy the collection into a new list.
+     * @param std <code>true</code> if the created <code>createColl</code> use
+     *        {@link Object#equals(Object)}, in that case {@link Collections#singleton(Object)} can
+     *        be returned.
+     * @return an immutable set with the same items as <code>coll</code>.
+     */
+    public static final <T, C extends Collection<? extends T>> Set<T> toImmutableSet(final C coll, final Function<? super C, ? extends Set<T>> createColl, final boolean std) {
+        final int size = coll.size();
-        if (coll.isEmpty())
+        if (size == 0)
             return Collections.emptySet();
+        else if (std && size == 1)
+            return Collections.singleton(coll.iterator().next());
         final Set<T> res = createColl.apply(coll);
         return Collections.unmodifiableSet(res);
+    }
     /**
         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);
+            return toImmutableMap((IdentityHashMap<? extends K, ? extends V>) map, IdentityHashMap::new, false);
         } else {
             // In doubt, keep order
             // ATTN LinkedHashMap extends HashMap
             return toImmutableMap(map, map.getClass() == HashMap.class ? HashMap::new : LinkedHashMap::new);
+        }
+    }
+    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) {
+        return toImmutableMap(map, copyFunction, true);
+    }
     /**
      * 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.
+     *
      *        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.
+     * @param std <code>true</code> if the created <code>createColl</code> use
+     *        {@link Object#equals(Object)}, in that case
+     *        {@link Collections#singletonMap(Object, Object)} can be returned.
      * @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) {
+    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,
+            final boolean std) {
+        final int size = map.size();
-        if (map.isEmpty())
+        if (size == 0) {
             return Collections.emptyMap();
+        } else if (std && size == 1) {
+            final Entry<? extends K, ? extends V> e = map.entrySet().iterator().next();
+            return Collections.singletonMap(e.getKey(), e.getValue());
+        }
         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
             res.put(keyAndVal.get(i), keyAndVal.get(i + 1));
+        }
         return res;
+    }
+    // same as HashMap and HashSet
+    private static final float DEFAULT_LOAD_FACTOR = 0.75f;
+    public static interface MapConstructor<K, V, M extends Map<K, V>> {
+        M create(int initialCapacity, float loadFactor);
+    }
+    public static final int getCapacity(final int plannedSize, final float loadFactor) {
+        return Math.max((int) Math.ceil(plannedSize / loadFactor), 4);
+    }
+    public static final <K, V> LinkedHashMap<K, V> newLinkedHashMap(final int plannedSize) {
+        return newMap(plannedSize, DEFAULT_LOAD_FACTOR, (MapConstructor<K, V, LinkedHashMap<K, V>>) LinkedHashMap::new);
+    }
+    public static final <K, V> HashMap<K, V> newHashMap(final int plannedSize) {
+        return newHashMap(plannedSize, DEFAULT_LOAD_FACTOR);
+    }
+    /**
+     * Create a new map with no rehash operations until at least a certain size.
+     *
+     * @param <K> the type of keys maintained by the new map
+     * @param <V> the type of mapped values
+     * @param plannedSize the number of entries expected to be added to the returned map.
+     * @param loadFactor the load factor of the returned map, not advised to be <code>1.0f</code>
+     *        because it increases the chances of hash collisions.
+     * @return a new map that won't rehash until at least <code>plannedSize</code> items.
+     */
+    public static final <K, V> HashMap<K, V> newHashMap(final int plannedSize, final float loadFactor) {
+        return newMap(plannedSize, loadFactor, (MapConstructor<K, V, HashMap<K, V>>) HashMap::new);
+    }
+    /**
+     * Create a new map with no rehash operations until at least a certain size.
+     *
+     * @param <K> the type of keys maintained by the new map
+     * @param <V> the type of mapped values
+     * @param <M> the type of the new map
+     * @param plannedSize the number of entries expected to be added to the returned map
+     * @param loadFactor the load factor, passed to <code>ctor</code>.
+     * @param ctor how to create the new map, will be passed the computed initial capacity and
+     *        <code>loadFactor</code>, e.g. {@link LinkedHashMap#LinkedHashMap(int, float)
+     *        LinkedHashMap::new}.
+     * @return a new map that won't rehash until at least <code>plannedSize</code> items.
+     */
+    public static final <K, V, M extends Map<K, V>> M newMap(final int plannedSize, final float loadFactor, final MapConstructor<K, V, M> ctor) {
+        return ctor.create(getCapacity(plannedSize, loadFactor), loadFactor);
+    }
+    public static interface SetConstructor<V, S extends Set<V>> {
+        S create(int initialCapacity, float loadFactor);
+    }
+    public static final <V> LinkedHashSet<V> newLinkedHashSet(final int plannedSize) {
+        return newSet(plannedSize, DEFAULT_LOAD_FACTOR, (SetConstructor<V, LinkedHashSet<V>>) LinkedHashSet::new);
+    }
+    public static final <V> HashSet<V> newHashSet(final int plannedSize) {
+        return newHashSet(plannedSize, DEFAULT_LOAD_FACTOR);
+    }
+    public static final <V> HashSet<V> newHashSet(final int plannedSize, final float loadFactor) {
+        return newSet(plannedSize, loadFactor, (SetConstructor<V, HashSet<V>>) HashSet::new);
+    }
+    public static final <V, S extends Set<V>> S newSet(final int plannedSize, final float loadFactor, final SetConstructor<V, S> ctor) {
+        return ctor.create(getCapacity(plannedSize, loadFactor), loadFactor);
+    }
     /**
      * Creates a map with null values.
+     *
      * @param <K> type of key.
      * @param <V> type of value.

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 180 → 182