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 java.util.AbstractMap;
import java.util.AbstractSet;
import java.util.ArrayList;
import java.util.ConcurrentModificationException;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;

public class TinyMap<K, V> extends AbstractMap<K, V> {
    private static final Function<Entry<?, ?>, Object> KEY_GETTER = Entry::getKey;
    private static final Function<Entry<?, ?>, Object> VALUE_GETTER = Entry::getValue;

    private final ArrayList<Entry<K, V>> entries;
    private transient Set<Map.Entry<K, V>> entrySet;
    /**
     * The number of times this HashMap has been structurally modified Structural modifications are
     * those that change the number of mappings in the HashMap or otherwise modify its internal
     * structure (e.g., rehash). This field is used to make iterators on Collection-views of the
     * HashMap fail-fast. (See ConcurrentModificationException).
     */
    transient int modCount = 0;

    public TinyMap() {
        this(10);
    }

    public TinyMap(final int initialCapacity) {
        this.entries = new ArrayList<>(initialCapacity);
    }

    public TinyMap(final Map<? extends K, ? extends V> m) {
        this.entries = new ArrayList<>(m.size());
        // don't call putAll() to avoid indexOfKey()
        for (final Entry<? extends K, ? extends V> e : m.entrySet()) {
            this.entries.add(new SimpleEntry<>(e));
        }
        ++this.modCount;
    }

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

    @Override
    public boolean isEmpty() {
        return this.entries.isEmpty();
    }

    @Override
    public boolean containsKey(final Object key) {
        return indexOfKey(key) >= 0;
    }

    @Override
    public boolean containsValue(final Object value) {
        return this.indexOf(value, VALUE_GETTER) >= 0;
    }

    private int indexOfKey(final Object key) {
        return this.indexOf(key, KEY_GETTER);
    }

    private final int indexOf(final Object o, final Function<Entry<?, ?>, Object> getter) {
        final int stop = this.entries.size();
        for (int i = 0; i < stop; i++) {
            final Entry<K, V> e = this.entries.get(i);
            if (Objects.equals(o, getter.apply(e)))
                return i;
        }
        return -1;
    }

    @Override
    public V get(final Object key) {
        final int i = indexOfKey(key);
        if (i < 0)
            return null;
        return this.entries.get(i).getValue();
    }

    @Override
    public V put(final K key, final V value) {
        final int i = this.indexOfKey(key);
        final V res;
        if (i < 0) {
            this.entries.add(new SimpleEntry<>(key, value));
            ++this.modCount;
            res = null;
        } else {
            res = this.entries.get(i).setValue(value);
        }
        return res;
    }

    @Override
    public V remove(final Object key) {
        return this.remove(indexOfKey(key));
    }

    private V remove(final int i) {
        if (i < 0)
            return null;
        final Entry<K, V> res = this.entries.remove(i);
        ++this.modCount;
        return res.getValue();
    }

    @Override
    public boolean remove(final Object key, final Object value) {
        final int i = indexOfKey(key);
        if (i < 0)
            return false;
        final boolean eqVal = Objects.equals(this.entries.get(i).getValue(), value);
        if (eqVal) {
            this.remove(i);
        }
        return eqVal;
    }

    @Override
    public void clear() {
        this.entries.clear();
        ++this.modCount;
    }

    // Views

    @Override
    public Set<Map.Entry<K, V>> entrySet() {
        Set<Map.Entry<K, V>> es;
        return (es = this.entrySet) == null ? (this.entrySet = new EntrySet()) : es;
    }

    final class EntrySet extends AbstractSet<Map.Entry<K, V>> {
        @Override
        public final int size() {
            return TinyMap.this.size();
        }

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

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

                private int expectedModCount = TinyMap.this.modCount;
                /**
                 * The index last returned, i.e. initial value just before first item.
                 * 
                 * <pre>
                 *    a   b   c
                 * -1   0   1   2
                 * </pre>
                 */
                private int currentPos = -1;
                private Entry<K, V> lastReturned = null;

                @Override
                public boolean hasNext() {
                    final int nextIndex = this.currentPos + 1;
                    return nextIndex < size();
                }

                @Override
                public Entry<K, V> next() {
                    checkForComodification();
                    if (!hasNext())
                        throw new NoSuchElementException();
                    this.currentPos++;
                    final Entry<K, V> res = TinyMap.this.entries.get(this.currentPos);
                    this.lastReturned = res;
                    return res;
                }

                @Override
                public void remove() {
                    checkForComodification();
                    if (this.lastReturned == null)
                        throw new IllegalStateException();
                    TinyMap.this.remove(this.currentPos);
                    this.currentPos--;
                    // per doc : cannot be called twice
                    this.lastReturned = null;
                    this.expectedModCount = TinyMap.this.modCount;
                }

                final void checkForComodification() {
                    if (TinyMap.this.modCount != this.expectedModCount)
                        throw new ConcurrentModificationException();
                }
            };
        }

        @Override
        public final boolean contains(final Object o) {
            if (!(o instanceof Map.Entry))
                return false;
            final Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
            return TinyMap.this.entries.contains(e);
        }

        @Override
        public final boolean remove(final Object o) {
            if (o instanceof Map.Entry) {
                final Map.Entry<?, ?> e = (Map.Entry<?, ?>) o;
                final Object key = e.getKey();
                final Object value = e.getValue();
                return TinyMap.this.remove(key, value);
            }
            return false;
        }
    }
}