hudson.util.CopyOnWriteMap Maven / Gradle / Ivy

Go to download
package hudson.util;

import com.thoughtworks.xstream.converters.MarshallingContext;
import com.thoughtworks.xstream.converters.UnmarshallingContext;
import com.thoughtworks.xstream.converters.collections.MapConverter;
import com.thoughtworks.xstream.converters.collections.TreeMapConverter;
import com.thoughtworks.xstream.io.HierarchicalStreamReader;
import com.thoughtworks.xstream.io.HierarchicalStreamWriter;
import com.thoughtworks.xstream.mapper.Mapper;

import java.util.Collection;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;

/**
 * {@link Map} that has copy-on-write semantics.
 *
 * 
 * This class is suitable where highly concurrent access is needed, yet
 * the write operation is relatively uncommon.
 *
 * @author Kohsuke Kawaguchi
 */
public abstract class CopyOnWriteMap implements Map {
    protected volatile Map core;
    /**
     * Read-only view of {@link #core}.
     */
    private volatile Map view;

    protected CopyOnWriteMap(Map core) {
        update(core);
    }

    protected CopyOnWriteMap() {
        update(Collections.emptyMap());
    }

    private void update(Map m) {
        core = m;
        view = Collections.unmodifiableMap(core);
    }

    public int size() {
        return core.size();
    }

    public boolean isEmpty() {
        return core.isEmpty();
    }

    public boolean containsKey(Object key) {
        return core.containsKey(key);
    }

    public boolean containsValue(Object value) {
        return core.containsValue(value);
    }

    public V get(Object key) {
        return core.get(key);
    }

    public synchronized V put(K key, V value) {
        Map m = copy();
        V r = m.put(key,value);
        update(m);

        return r;
    }

    public synchronized V remove(Object key) {
        Map m = copy();
        V r = m.remove(key);
        update(m);

        return r;
    }

    public synchronized void putAll(Map t) {
        Map m = copy();
        m.putAll(t);
        update(m);
    }

    protected abstract Map copy();

    public synchronized void clear() {
        update(Collections.emptyMap());
    }

    /**
     * This method will return a read-only {@link Set}.
     */
    public Set keySet() {
        return view.keySet();
    }

    /**
     * This method will return a read-only {@link Collection}.
     */
    public Collection values() {
        return view.values();
    }

    /**
     * This method will return a read-only {@link Set}.
     */
    public Set> entrySet() {
        return view.entrySet();
    }

    /**
     * {@link CopyOnWriteMap} backed by {@link HashMap}.
     */
    public static final class Hash extends CopyOnWriteMap {
        public Hash(Map core) {
            super(new LinkedHashMap(core));
        }

        public Hash() {
        }

        protected Map copy() {
            return new LinkedHashMap(core);
        }

        public static class ConverterImpl extends MapConverter {
            public ConverterImpl(Mapper mapper) {
                super(mapper);
            }

            @Override
            public boolean canConvert(Class type) {
                return type==Hash.class;
            }

            @Override
            public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
                return new Hash((Map) super.unmarshal(reader,context));
            }

            @Override
            public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {
                super.marshal(((Hash)source).core,writer,context);
            }
        }
    }

    /**
     * {@link CopyOnWriteMap} backed by {@link TreeMap}.
     */
    public static final class Tree extends CopyOnWriteMap {
        private final Comparator comparator;

        public Tree(Map core, Comparator comparator) {
            this(comparator);
            putAll(core);
        }

        public Tree(Comparator comparator) {
            this.comparator = comparator;
        }

        public Tree() {
            this(null);
        }

        protected Map copy() {
            TreeMap m = new TreeMap(comparator);
            m.putAll(core);
            return m;
        }

        public static class ConverterImpl extends TreeMapConverter {
            public ConverterImpl(Mapper mapper) {
                super(mapper);
            }

            @Override
            public boolean canConvert(Class type) {
                return type==Tree.class;
            }

            @Override
            public Object unmarshal(HierarchicalStreamReader reader, UnmarshallingContext context) {
                TreeMap tm = (TreeMap) super.unmarshal(reader,context);
                return new Tree(tm,tm.comparator());
            }

            @Override
            public void marshal(Object source, HierarchicalStreamWriter writer, MarshallingContext context) {
                super.marshal(((Tree)source).core,writer,context);
            }
        }
    }
}