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.cc;

import org.openconcerto.utils.CompareUtils;

import java.util.AbstractMap;

import java.util.AbstractSet;

import java.util.Collections;

import java.util.HashMap;

import java.util.Iterator;

import java.util.Map;

import java.util.Set;

import net.jcip.annotations.ThreadSafe;

/**

 * A thread-safe map in which all mutative operations (put, remove, and so on) are implemented by

 * making a fresh copy of the underlying map. The instance of the underlying map can be customized

 * with {@link #copy(Map)}. The underlying immutable map is available with {@link #getImmutable()}.

 *

 * @author Sylvain

 *

 * @param <K> the type of keys maintained by this map

 * @param <V> the type of mapped values

 */

@ThreadSafe

public class CopyOnWriteMap<K, V> extends AbstractMap<K, V> {

    private Map<K, V> immutable;

    private Set<Entry<K, V>> entrySet = null;

    public CopyOnWriteMap() {

        this.immutable = Collections.emptyMap();

    }

    public CopyOnWriteMap(final Map<K, V> m) {

        this.immutable = Collections.unmodifiableMap(copy(m));

    }

    /**

     * Create a copy of the passed map.

     *

     * @param src the map to copy, not <code>null</code>.

     * @return a shallow copy of <code>src</code>.

     */

    public Map<K, V> copy(Map<? extends K, ? extends V> src) {

        return new HashMap<K, V>(src);

    }

    // write

    @Override

    public synchronized V put(final K key, final V value) {

        final Map<K, V> copy = copy(this.immutable);

        final V res = copy.put(key, value);

        this.immutable = Collections.unmodifiableMap(copy);

        return res;

    }

    @Override

    public synchronized V remove(final Object key) {

        final Map<K, V> copy = copy(this.immutable);

        final V res = copy.remove(key);

        this.immutable = Collections.unmodifiableMap(copy);

        return res;

    }

    @Override

    public synchronized void putAll(final Map<? extends K, ? extends V> m) {

        final Map<K, V> copy = copy(this.immutable);

        copy.putAll(m);

        this.immutable = Collections.unmodifiableMap(copy);

    }

    @Override

    public synchronized void clear() {

        this.immutable = Collections.emptyMap();

    }

    // read

    public synchronized final Map<K, V> getImmutable() {

        return this.immutable;

    }

    @Override

    public int size() {

        return this.getImmutable().size();

    }

    @Override

    public boolean isEmpty() {

        return this.getImmutable().isEmpty();

    }

    @Override

    public boolean containsKey(final Object key) {

        return this.getImmutable().containsKey(key);

    }

    @Override

    public boolean containsValue(final Object value) {

        return this.getImmutable().containsValue(value);

    }

    @Override

    public V get(final Object key) {

        return this.getImmutable().get(key);

    }

    @Override

    public synchronized Set<Entry<K, V>> entrySet() {

        if (this.entrySet == null)

            this.entrySet = new EntrySet();

        return this.entrySet;

    }

    private final class EntrySet extends AbstractSet<Entry<K, V>> {

        public Iterator<Entry<K, V>> iterator() {

            return new Iterator<Entry<K, V>>() {

                private final Iterator<Entry<K, V>> delegate = CopyOnWriteMap.this.immutable.entrySet().iterator();

                private Entry<K, V> current = null;

                @Override

                public boolean hasNext() {

                    return this.delegate.hasNext();

                }

                @Override

                public Entry<K, V> next() {

                    return (this.current = this.delegate.next());

                }

                @Override

                public void remove() {

                    if (this.current == null)

                        throw new IllegalStateException();

                    EntrySet.this.remove(this.current);

                }

            };

        }

        public boolean contains(Object o) {

            if (!(o instanceof Entry))

                return false;

            final Entry<?, ?> e = (Entry<?, ?>) o;

            return CompareUtils.equals(e.getValue(), get(e.getKey()));

        }

        public boolean remove(Object o) {

            if (!(o instanceof Entry))

                return false;

            return CopyOnWriteMap.this.remove(((Entry<?, ?>) o).getKey()) != null;

        }

        public int size() {

            return CopyOnWriteMap.this.size();

        }

        public void clear() {

            CopyOnWriteMap.this.clear();

        }

    }

    // equals

    @Override

    public boolean equals(final Object o) {

        return this.getImmutable().equals(o);

    }

    @Override

    public int hashCode() {

        return this.getImmutable().hashCode();

    }

}