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

/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 * 
 * Copyright 2011 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.AbstractMapDecorator;

import java.util.AbstractCollection;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;

/**
 * Allow to map keys to collections. This map always allow <code>null</code> items inside mapped
 * collections, but it may restrict null collections, see {@link Mode}.
 * 
 * @author Sylvain
 * 
 * @param <K> the type of keys maintained by this map
 * @param <C> the type of mapped collections
 * @param <V> the type of elements of the collections
 */
public abstract class CollectionMap2<K, C extends Collection<V>, V> extends AbstractMapDecorator<K, C> implements Cloneable, CollectionMap2Itf<K, C, V> {

    static final int DEFAULT_INITIAL_CAPACITY = 16;

    private static final String toStr(final Object o) {
        return o == null ? "null" : "'" + o + "'";
    }

    public static enum Mode {
        /**
         * Mapped collections cannot be <code>null</code>.
         */
        NULL_FORBIDDEN,
        /**
         * Mapped collections can be <code>null</code>, but some methods may throw
         * {@link NullPointerException}.
         * 
         * @see CollectionMap2#addAll(Object, Collection)
         * @see CollectionMap2#removeAll(Object, Collection)
         */
        NULL_ALLOWED,
        /**
         * Mapped collections can be <code>null</code>, meaning every possible item. Thus no method
         * throws {@link NullPointerException}.
         */
        NULL_MEANS_ALL
    }

    static protected final Mode DEFAULT_MODE = Mode.NULL_FORBIDDEN;
    static private final Boolean DEFAULT_emptyCollSameAsNoColl = null;

    private final boolean emptyCollSameAsNoColl;
    private final Mode mode;
    private transient Collection<V> allValues = null;

    public CollectionMap2() {
        this(DEFAULT_MODE);
    }

    public CollectionMap2(final Mode mode) {
        this(mode, DEFAULT_emptyCollSameAsNoColl);
    }

    public CollectionMap2(final Map<K, C> delegate, final Mode mode) {
        this(delegate, mode, DEFAULT_emptyCollSameAsNoColl);
    }

    public CollectionMap2(final Mode mode, final Boolean emptyCollSameAsNoColl) {
        this(DEFAULT_INITIAL_CAPACITY, mode, emptyCollSameAsNoColl);
    }

    public CollectionMap2(final int initialCapacity) {
        this(initialCapacity, DEFAULT_MODE, DEFAULT_emptyCollSameAsNoColl);
    }

    public CollectionMap2(final int initialCapacity, final Mode mode, final Boolean emptyCollSameAsNoColl) {
        this(new HashMap<K, C>(initialCapacity), mode, emptyCollSameAsNoColl);
    }

    /**
     * Create a new instance with the passed delegate. The delegate is *not* cleared, this allows to
     * decorate an existing Map but it also means that the existing collections might not be the
     * exact same type as those returned by {@link #createCollection(Collection)}.
     * 
     * @param delegate the map to use, it must not be modified afterwards.
     * @param mode how to handle null values.
     * @param emptyCollSameAsNoColl for {@link #getCollection(Object)} : whether the lack of an
     *        entry is the same as an entry with an empty collection, can be <code>null</code>.
     */
    public CollectionMap2(final Map<K, C> delegate, final Mode mode, final Boolean emptyCollSameAsNoColl) {
        super(delegate);
        if (mode == null)
            throw new NullPointerException("Null mode");
        this.mode = mode;
        this.emptyCollSameAsNoColl = emptyCollSameAsNoColl == null ? mode == Mode.NULL_MEANS_ALL : emptyCollSameAsNoColl;
        checkMode();
    }

    private final void checkMode() {
        assert this.mode != null : "Called too early";
        if (this.mode == Mode.NULL_FORBIDDEN && this.containsValue(null))
            throw new IllegalArgumentException("Null collection");
    }

    // ** copy constructors

    // ATTN getDelegate() is not in CollectionMap2Itf, so if one copies an unmodifiableMap() this
    // constructor won't be used and the delegate will be the default HashMap (even if the source
    // used a LinkedHashMap).
    public CollectionMap2(final CollectionMap2<K, C, ? extends V> m) {
        this(CopyUtils.copy(m.getDelegate()), m);
    }

    public CollectionMap2(final Map<? extends K, ? extends Collection<? extends V>> m) {
        this(new HashMap<K, C>(m.size()), m);
    }

    /**
     * Create a new instance with the passed delegate and filling it with the passed map.
     * 
     * @param delegate the map to use, it will be cleared and must not be modified afterwards.
     * @param m the values to put in this, if it's an instance of {@link CollectionMap2} the
     *        {@link #getMode() mode} and {@link #isEmptyCollSameAsNoColl()} will be copied as well.
     */
    public CollectionMap2(final Map<K, C> delegate, final Map<? extends K, ? extends Collection<? extends V>> m) {
        // don't use super(Map) since it doesn't copy the collections
        // also its type is more restrictive
        super(delegate);
        if (m instanceof CollectionMap2) {
            final CollectionMap2<?, ?, ?> collM = (CollectionMap2<?, ?, ?>) m;
            this.mode = collM.getMode();
            this.emptyCollSameAsNoColl = collM.isEmptyCollSameAsNoColl();
        } else {
            this.mode = DEFAULT_MODE;
            this.emptyCollSameAsNoColl = this.mode == Mode.NULL_MEANS_ALL;
        }
        // delegate might not contain the same instances of collections (i.e. LinkedList vs
        // ArrayList)
        this.clear();
        this.putAllCollections(m);
    }

    @Override
    public final Mode getMode() {
        return this.mode;
    }

    @Override
    public final boolean isEmptyCollSameAsNoColl() {
        return this.emptyCollSameAsNoColl;
    }

    public final C getNonNullIfMissing(final Object key) {
        return this.get(key, false, true);
    }

    @Override
    public final C getNonNull(final K key) {
        return this.get(key, false, false);
    }

    private final C getNonNullColl(final C res) {
        return res == null ? this.createCollection(Collections.<V> emptySet()) : res;
    }

    /**
     * Get the collection mapped to the passed key. Note : <code>get(key, true, true)</code> is
     * equivalent to <code>get(key)</code>.
     * 
     * @param key the key whose associated value is to be returned.
     * @param nullIfMissing only relevant if the key isn't contained : if <code>true</code>
     *        <code>null</code> will be returned, otherwise an empty collection.
     * @param nullIfPresent only relevant if the key is mapped to <code>null</code> : if
     *        <code>true</code> <code>null</code> will be returned, otherwise an empty collection.
     * @return the non {@code null} value to which the specified key is mapped, otherwise
     *         {@code null} or empty collection depending on the other parameters.
     */
    @Override
    public final C get(final Object key, final boolean nullIfMissing, final boolean nullIfPresent) {
        if (nullIfMissing == nullIfPresent) {
            final C res = super.get(key);
            if (res != null || nullIfMissing && nullIfPresent) {
                return res;
            } else {
                assert !nullIfMissing && !nullIfPresent;
                return getNonNullColl(null);
            }
        } else if (nullIfMissing) {
            assert !nullIfPresent;
            if (!this.containsKey(key))
                return null;
            else
                return getNonNullColl(super.get(key));
        } else {
            assert !nullIfMissing && nullIfPresent;
            if (this.containsKey(key))
                return super.get(key);
            else
                return getNonNullColl(null);
        }
    }

    @Override
    public final C getCollection(final Object key) {
        return this.get(key, !this.isEmptyCollSameAsNoColl(), true);
    }

    @Override
    public boolean containsInCollection(K key, V val) throws NullPointerException {
        final C c = this.get(key);
        if (c != null)
            return c.contains(val);
        else if (!this.containsKey(key))
            return false;
        else if (getMode() == Mode.NULL_MEANS_ALL)
            return true;
        else
            throw new NullPointerException("Null value for " + key);
    }

    /**
     * Returns a {@link Collection} view of all the values contained in this map. The collection is
     * backed by the map, so changes to the map are reflected in the collection, and vice-versa. If
     * the map is modified while an iteration over the collection is in progress (except through the
     * iterator's own <tt>remove</tt> operation), the results of the iteration are undefined. The
     * collection supports element removal, which removes the corresponding values from the map, via
     * the <tt>Iterator.remove</tt>, <tt>Collection.remove</tt>, <tt>removeAll</tt>,
     * <tt>retainAll</tt> and <tt>clear</tt> operations. Note that it doesn't remove entries only
     * values : keySet() doesn't change, use {@link #removeAllEmptyCollections()} and
     * {@link #removeAllNullCollections()} afterwards. It does not support the <tt>add</tt> or
     * <tt>addAll</tt> operations.
     * 
     * @return a view all values in all entries, <code>null</code> collections are ignored.
     */
    @Override
    public Collection<V> allValues() {
        if (this.allValues == null)
            this.allValues = new AllValues();
        return this.allValues;
    }

    private final class AllValues extends AbstractCollection<V> {
        @Override
        public Iterator<V> iterator() {
            return new AllValuesIterator();
        }

        @Override
        public int size() {
            int compt = 0;
            for (final C c : values()) {
                if (c != null)
                    compt += c.size();
            }
            return compt;
        }

        // don't overload clear() to call Map.clear() as this would be incoherent with removeAll() :
        // this last method only removes values, resulting in empty and null collections
    }

    private final class AllValuesIterator implements Iterator<V> {
        private final Iterator<C> mapIterator;
        private Iterator<V> tempIterator;

        private AllValuesIterator() {
            this.mapIterator = values().iterator();
            this.tempIterator = null;
        }

        private boolean searchNextIterator() {
            // tempIterator == null initially and when a collection is null
            while (this.tempIterator == null || !this.tempIterator.hasNext()) {
                if (!this.mapIterator.hasNext()) {
                    return false;
                }
                final C nextCol = this.mapIterator.next();
                this.tempIterator = nextCol == null ? null : nextCol.iterator();
            }
            return true;
        }

        @Override
        public boolean hasNext() {
            return searchNextIterator();
        }

        @Override
        public V next() {
            // search next iterator if necessary
            if (!hasNext())
                throw new NoSuchElementException();
            return this.tempIterator.next();
        }

        @Override
        public void remove() {
            if (this.tempIterator == null)
                throw new IllegalStateException();
            this.tempIterator.remove();
        }
    }

    @Override
    public Set<Map.Entry<K, C>> entrySet() {
        if (getMode() == Mode.NULL_FORBIDDEN) {
            // prevent null insertion
            // MAYBE cache
            return new EntrySet(super.entrySet());
        } else {
            return super.entrySet();
        }
    }

    private final class EntrySet extends AbstractCollection<Map.Entry<K, C>> implements Set<Map.Entry<K, C>> {

        private final Set<Map.Entry<K, C>> delegate;

        public EntrySet(final Set<java.util.Map.Entry<K, C>> delegate) {
            super();
            this.delegate = delegate;
        }

        @Override
        public int size() {
            return this.delegate.size();
        }

        @Override
        public boolean contains(final Object o) {
            return this.delegate.contains(o);
        }

        @Override
        public boolean remove(final Object o) {
            return this.delegate.remove(o);
        }

        @Override
        public void clear() {
            this.delegate.clear();
        }

        @Override
        public Iterator<Map.Entry<K, C>> iterator() {
            return new Iterator<Map.Entry<K, C>>() {

                private final Iterator<Map.Entry<K, C>> delegateIter = EntrySet.this.delegate.iterator();

                @Override
                public boolean hasNext() {
                    return this.delegateIter.hasNext();
                }

                @Override
                public Map.Entry<K, C> next() {
                    final Map.Entry<K, C> delegate = this.delegateIter.next();
                    return new Map.Entry<K, C>() {
                        @Override
                        public K getKey() {
                            return delegate.getKey();
                        }

                        @Override
                        public C getValue() {
                            return delegate.getValue();
                        }

                        @Override
                        public C setValue(final C value) {
                            if (value == null)
                                throw new NullPointerException("Putting null collection for " + toStr(getKey()));
                            return delegate.setValue(value);
                        }
                    };
                }

                @Override
                public void remove() {
                    this.delegateIter.remove();
                }
            };
        }

        @Override
        public boolean equals(final Object o) {
            return this.delegate.equals(o);
        }

        @Override
        public int hashCode() {
            return this.delegate.hashCode();
        }

        @Override
        public boolean removeAll(final Collection<?> c) {
            return this.delegate.removeAll(c);
        }
    }

    @Override
    public final C put(final K key, final C value) {
        return this.putCollection(key, value);
    }

    // copy passed collection
    @Override
    public final C putCollection(final K key, final Collection<? extends V> value) {
        if (value == null && this.getMode() == Mode.NULL_FORBIDDEN)
            throw new NullPointerException("Putting null collection for " + toStr(key));
        return super.put(key, value == null ? null : createCollection(value));
    }

    @SafeVarargs
    public final C putCollection(final K key, final V... value) {
        return this.putCollection(key, Arrays.asList(value));
    }

    public void putAllCollections(final Map<? extends K, ? extends Collection<? extends V>> m) {
        this.putAllCollections(m, false);
    }

    public void putAllCollections(final Map<? extends K, ? extends Collection<? extends V>> m, final boolean removeEmptyCollections) {
        for (final Map.Entry<? extends K, ? extends Collection<? extends V>> e : m.entrySet()) {
            if (!removeEmptyCollections || !e.getValue().isEmpty())
                this.putCollection(e.getKey(), e.getValue());
        }
    }

    // ** add/remove collection

    @Override
    public final boolean add(final K k, final V v) {
        return this.addAll(k, Collections.singleton(v));
    }

    @SafeVarargs
    public final boolean addAll(final K k, final V... v) {
        return this.addAll(k, Arrays.asList(v));
    }

    @Override
    public final boolean addAll(final K k, final Collection<? extends V> v) {
        final boolean nullIsAll = getMode() == Mode.NULL_MEANS_ALL;
        if (v == null && !nullIsAll)
            throw new NullPointerException("Adding null collection for " + toStr(k));
        final boolean containsKey = this.containsKey(k);
        if (v == null) {
            return this.putCollection(k, v) != null;
        } else if (!containsKey) {
            this.putCollection(k, v);
            return true;
        } else {
            final C currentColl = this.get(k);
            if (nullIsAll && currentColl == null) {
                // ignore since we can't add something to everything
                return false;
            } else {
                // will throw if currentCol is null
                return currentColl.addAll(v);
            }
        }
    }

    @Override
    public final void merge(final Map<? extends K, ? extends Collection<? extends V>> mm) {
        for (final Map.Entry<? extends K, ? extends Collection<? extends V>> e : mm.entrySet()) {
            this.addAll(e.getKey(), e.getValue());
        }
    }

    @Override
    public final void mergeScalarMap(final Map<? extends K, ? extends V> scalarMap) {
        for (final Map.Entry<? extends K, ? extends V> e : scalarMap.entrySet()) {
            this.add(e.getKey(), e.getValue());
        }
    }

    @Override
    public final boolean removeOne(final K k, final V v) {
        return this.remove(k, null, v, false, true);
    }

    @Override
    public final boolean removeAllInstancesOfItem(final K k, final V v) {
        return this.removeAll(k, Collections.singleton(v));
    }

    @Override
    public final boolean removeAll(final K k, final Collection<? extends V> coll) {
        return remove(k, coll, null, true, true);
    }

    private final boolean remove(final K k, final Collection<? extends V> coll, final V item, final boolean removeAll, final boolean removeEmptyColl) {
        assert removeAll && item == null || !removeAll && coll == null : "Non null value ignored";
        if (!this.containsKey(k) || removeAll && coll != null && coll.isEmpty())
            return false;
        boolean removeK = false;
        boolean modified = false;
        if (getMode() == Mode.NULL_MEANS_ALL) {
            if (removeAll && coll == null) {
                removeK = true;
            } else {
                final C currentColl = this.get(k);
                if (currentColl == null)
                    throw new IllegalStateException("Cannot remove from all for " + toStr(k));
                if (removeAll)
                    modified = currentColl.removeAll(coll);
                else
                    modified = currentColl.remove(item);
                if (removeEmptyColl && currentColl.isEmpty())
                    removeK = true;
            }
        } else {
            final C currentColl = this.get(k);
            // like addAll(), will throw if currentCol is null
            if (removeAll) {
                modified = currentColl.removeAll(coll);
            } else {
                modified = currentColl.remove(item);
            }
            if (removeEmptyColl && currentColl.isEmpty())
                removeK = true;
        }
        if (removeK) {
            this.remove(k);
            // since we just tested containsKey()
            modified = true;
        }
        return modified;
    }

    @Override
    public final boolean removeAll(final Map<? extends K, ? extends Collection<? extends V>> mm) {
        // allow mm.removeAll(mm)
        if (this == mm) {
            if (this.isEmpty())
                return false;
            this.clear();
            return true;
        }
        boolean modified = false;
        for (final Map.Entry<? extends K, ? extends Collection<? extends V>> e : mm.entrySet()) {
            modified |= this.removeAll(e.getKey(), e.getValue());
        }
        return modified;
    }

    @Override
    public final boolean removeAllScalar(final Map<? extends K, ? extends V> m) {
        boolean modified = false;
        // incompatible types, allowing removal without ConcurrentModificationException
        assert m != this;
        for (final Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
            modified |= this.removeAllInstancesOfItem(e.getKey(), e.getValue());
        }
        return modified;
    }

    // ** remove empty/null collections

    public final C removeIfEmpty(final K k) {
        final C v = this.get(k);
        if (v != null && v.isEmpty())
            return this.remove(k);
        else
            return null;
    }

    public final void removeIfNull(final K k) {
        if (this.get(k) == null)
            this.remove(k);
    }

    @Override
    public final Set<K> removeAllEmptyCollections() {
        return this.removeAll(true);
    }

    @Override
    public final Set<K> removeAllNullCollections() {
        return this.removeAll(false);
    }

    private final Set<K> removeAll(final boolean emptyOrNull) {
        final Set<K> removed = new HashSet<K>();
        final Iterator<Map.Entry<K, C>> iter = this.entrySet().iterator();
        while (iter.hasNext()) {
            final Map.Entry<K, C> e = iter.next();
            final C val = e.getValue();
            if ((emptyOrNull && val != null && val.isEmpty()) || (!emptyOrNull && val == null)) {
                iter.remove();
                removed.add(e.getKey());
            }
        }
        return removed;
    }

    public abstract C createCollection(Collection<? extends V> v);

    @Override
    public int hashCode() {
        if (this.mode == Mode.NULL_MEANS_ALL)
            return this.hashCodeExact();
        else
            return super.hashCode();
    }

    public int hashCodeExact() {
        final int prime = 31;
        int result = super.hashCode();
        result = prime * result + (this.emptyCollSameAsNoColl ? 1231 : 1237);
        result = prime * result + this.mode.hashCode();
        return result;
    }

    /**
     * Compares the specified object with this map for equality. Except for
     * {@link Mode#NULL_MEANS_ALL}, returns <tt>true</tt> if the given object is also a map and the
     * two maps represent the same mappings (as required by {@link Map}).
     * <code>NULL_MEANS_ALL</code> maps are tested using {@link #equalsExact(Object)}, meaning they
     * don't conform to the Map interface.
     * 
     * @param obj object to be compared for equality with this map
     * @return <tt>true</tt> if the specified object is equal to this map
     * @see #equalsExact(Object)
     */
    @Override
    public final boolean equals(final Object obj) {
        return this.equals(obj, false);
    }

    /**
     * Compares the specified object with this map for complete equality. This method not only
     * checks for equality of values (as required by {@link Map}) but also the class and attributes.
     * 
     * @param obj object to be compared for equality with this map
     * @return <tt>true</tt> if the specified object is exactly equal to this map.
     */
    public final boolean equalsExact(final Object obj) {
        return this.equals(obj, true);
    }

    private final boolean equals(final Object obj, final boolean forceExact) {
        if (this == obj)
            return true;
        if (!super.equals(obj))
            return false;
        assert obj != null;
        final CollectionMap2<?, ?, ?> other = obj instanceof CollectionMap2 ? (CollectionMap2<?, ?, ?>) obj : null;
        if (forceExact || this.mode == Mode.NULL_MEANS_ALL || (other != null && other.mode == Mode.NULL_MEANS_ALL)) {
            if (getClass() != obj.getClass())
                return false;
            // no need to test createCollection(), since values are tested by super.equals()
            return this.emptyCollSameAsNoColl == other.emptyCollSameAsNoColl && this.mode == other.mode && this.getDelegate().getClass() == other.getDelegate().getClass();
        } else {
            return true;
        }
    }

    @Override
    public CollectionMap2<K, C, V> clone() {
        @SuppressWarnings("unchecked")
        final CollectionMap2<K, C, V> result = (CollectionMap2<K, C, V>) super.clone();
        // allValues has a reference to this
        result.allValues = null;
        // clone each collection value
        for (final Map.Entry<K, C> entry : result.entrySet()) {
            final C coll = entry.getValue();
            entry.setValue(createCollection(coll));
        }
        return result;
    }
}