/*
 * Copyright 2008-present MongoDB, Inc.
 * Copyright (c) 2008-2014 Atlassian Pty Ltd
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *   http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.bson.util;


import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.Map;
import java.util.Set;
import java.util.concurrent.ConcurrentMap;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;

import static java.util.Collections.unmodifiableCollection;
import static java.util.Collections.unmodifiableSet;
import static org.bson.assertions.Assertions.notNull;

Abstract base class for COW Map implementations that delegate to an internal map.
Type parameters:
  • <K> – The key type
  • <V> – The value type
  • <M> – the internal Map or extension for things like sorted and navigable maps.
/** * Abstract base class for COW {@link java.util.Map} implementations that delegate to an internal map. * * @param <K> The key type * @param <V> The value type * @param <M> the internal {@link java.util.Map} or extension for things like sorted and navigable maps. */
abstract class AbstractCopyOnWriteMap<K, V, M extends Map<K, V>> implements ConcurrentMap<K, V> { // @GuardedBy("lock") private volatile M delegate; // import edu.umd.cs.findbugs.annotations.@SuppressWarnings private final transient Lock lock = new ReentrantLock(); // private final transient EntrySet entrySet = new EntrySet(); // private final transient KeySet keySet = new KeySet(); // private final transient Values values = new Values(); // private final View.Type viewType; private final View<K, V> view;
Create a new CopyOnWriteMap with the supplied Map to initialize the values.
Params:
  • map – the initial map to initialize with
  • viewType – for writable or read-only key, value and entrySet views
/** * Create a new {@link CopyOnWriteMap} with the supplied {@link Map} to initialize the values. * * @param map the initial map to initialize with * @param viewType for writable or read-only key, value and entrySet views */
protected <N extends Map<? extends K, ? extends V>> AbstractCopyOnWriteMap(final N map, final View.Type viewType) { this.delegate = notNull("delegate", copy(notNull("map", map))); this.view = notNull("viewType", viewType).get(this); }
Copy function, implemented by sub-classes.
Params:
  • map – the initial values of the newly created map.
Type parameters:
  • <N> – the map to copy and return.
Returns:a new map. Will never be modified after construction.
/** * Copy function, implemented by sub-classes. * * @param <N> the map to copy and return. * @param map the initial values of the newly created map. * @return a new map. Will never be modified after construction. */
// @GuardedBy("lock") abstract <N extends Map<? extends K, ? extends V>> M copy(N map); // // mutable operations // public final void clear() { lock.lock(); try { set(copy(Collections.<K, V>emptyMap())); } finally { lock.unlock(); } } public final V remove(final Object key) { lock.lock(); try { // short circuit if key doesn't exist if (!delegate.containsKey(key)) { return null; } M map = copy(); try { return map.remove(key); } finally { set(map); } } finally { lock.unlock(); } } public boolean remove(final Object key, final Object value) { lock.lock(); try { if (delegate.containsKey(key) && equals(value, delegate.get(key))) { M map = copy(); map.remove(key); set(map); return true; } else { return false; } } finally { lock.unlock(); } } public boolean replace(final K key, final V oldValue, final V newValue) { lock.lock(); try { if (!delegate.containsKey(key) || !equals(oldValue, delegate.get(key))) { return false; } M map = copy(); map.put(key, newValue); set(map); return true; } finally { lock.unlock(); } } public V replace(final K key, final V value) { lock.lock(); try { if (!delegate.containsKey(key)) { return null; } M map = copy(); try { return map.put(key, value); } finally { set(map); } } finally { lock.unlock(); } } public final V put(final K key, final V value) { lock.lock(); try { M map = copy(); try { return map.put(key, value); } finally { set(map); } } finally { lock.unlock(); } } public V putIfAbsent(final K key, final V value) { lock.lock(); try { if (!delegate.containsKey(key)) { M map = copy(); try { return map.put(key, value); } finally { set(map); } } return delegate.get(key); } finally { lock.unlock(); } } public final void putAll(final Map<? extends K, ? extends V> t) { lock.lock(); try { M map = copy(); map.putAll(t); set(map); } finally { lock.unlock(); } } protected M copy() { lock.lock(); try { return copy(delegate); } finally { lock.unlock(); } } // @GuardedBy("lock") protected void set(final M map) { delegate = map; } // // Collection views // public final Set<Entry<K, V>> entrySet() { return view.entrySet(); } public final Set<K> keySet() { return view.keySet(); } public final Collection<V> values() { return view.values(); } // // delegate operations // public final boolean containsKey(final Object key) { return delegate.containsKey(key); } public final boolean containsValue(final Object value) { return delegate.containsValue(value); } public final V get(final Object key) { return delegate.get(key); } public final boolean isEmpty() { return delegate.isEmpty(); } public final int size() { return delegate.size(); } @Override public final boolean equals(final Object o) { return delegate.equals(o); } @Override public final int hashCode() { return delegate.hashCode(); } protected final M getDelegate() { return delegate; } @Override public String toString() { return delegate.toString(); } // // inner classes // private class KeySet extends CollectionView<K> implements Set<K> { @Override Collection<K> getDelegate() { return delegate.keySet(); } // // mutable operations // public void clear() { lock.lock(); try { M map = copy(); map.keySet().clear(); set(map); } finally { lock.unlock(); } } public boolean remove(final Object o) { return AbstractCopyOnWriteMap.this.remove(o) != null; } public boolean removeAll(final Collection<?> c) { lock.lock(); try { M map = copy(); try { return map.keySet().removeAll(c); } finally { set(map); } } finally { lock.unlock(); } } public boolean retainAll(final Collection<?> c) { lock.lock(); try { M map = copy(); try { return map.keySet().retainAll(c); } finally { set(map); } } finally { lock.unlock(); } } } private final class Values extends CollectionView<V> { @Override Collection<V> getDelegate() { return delegate.values(); } public void clear() { lock.lock(); try { M map = copy(); map.values().clear(); set(map); } finally { lock.unlock(); } } public boolean remove(final Object o) { lock.lock(); try { if (!contains(o)) { return false; } M map = copy(); try { return map.values().remove(o); } finally { set(map); } } finally { lock.unlock(); } } public boolean removeAll(final Collection<?> c) { lock.lock(); try { M map = copy(); try { return map.values().removeAll(c); } finally { set(map); } } finally { lock.unlock(); } } public boolean retainAll(final Collection<?> c) { lock.lock(); try { M map = copy(); try { return map.values().retainAll(c); } finally { set(map); } } finally { lock.unlock(); } } } private class EntrySet extends CollectionView<Entry<K, V>> implements Set<Map.Entry<K, V>> { @Override Collection<java.util.Map.Entry<K, V>> getDelegate() { return delegate.entrySet(); } public void clear() { lock.lock(); try { M map = copy(); map.entrySet().clear(); set(map); } finally { lock.unlock(); } } public boolean remove(final Object o) { lock.lock(); try { if (!contains(o)) { return false; } M map = copy(); try { return map.entrySet().remove(o); } finally { set(map); } } finally { lock.unlock(); } } public boolean removeAll(final Collection<?> c) { lock.lock(); try { M map = copy(); try { return map.entrySet().removeAll(c); } finally { set(map); } } finally { lock.unlock(); } } public boolean retainAll(final Collection<?> c) { lock.lock(); try { M map = copy(); try { return map.entrySet().retainAll(c); } finally { set(map); } } finally { lock.unlock(); } } } private static class UnmodifiableIterator<T> implements Iterator<T> { private final Iterator<T> delegate; UnmodifiableIterator(final Iterator<T> delegate) { this.delegate = delegate; } public boolean hasNext() { return delegate.hasNext(); } public T next() { return delegate.next(); } public void remove() { throw new UnsupportedOperationException(); } } protected abstract static class CollectionView<E> implements Collection<E> { abstract Collection<E> getDelegate(); // // delegate operations // public final boolean contains(final Object o) { return getDelegate().contains(o); } public final boolean containsAll(final Collection<?> c) { return getDelegate().containsAll(c); } public final Iterator<E> iterator() { return new UnmodifiableIterator<E>(getDelegate().iterator()); } public final boolean isEmpty() { return getDelegate().isEmpty(); } public final int size() { return getDelegate().size(); } public final Object[] toArray() { return getDelegate().toArray(); } public final <T> T[] toArray(final T[] a) { return getDelegate().toArray(a); } @Override public int hashCode() { return getDelegate().hashCode(); } @Override public boolean equals(final Object obj) { return getDelegate().equals(obj); } @Override public String toString() { return getDelegate().toString(); } // // unsupported operations // public final boolean add(final E o) { throw new UnsupportedOperationException(); } public final boolean addAll(final Collection<? extends E> c) { throw new UnsupportedOperationException(); } } private boolean equals(final Object o1, final Object o2) { if (o1 == null) { return o2 == null; } return o1.equals(o2); }
Provides access to the views of the underlying key, value and entry collections.
/** * Provides access to the views of the underlying key, value and entry collections. */
public abstract static class View<K, V> { View() { } abstract Set<K> keySet(); abstract Set<Entry<K, V>> entrySet(); abstract Collection<V> values();
The different types of View available
/** * The different types of {@link View} available */
public enum Type { STABLE { @Override <K, V, M extends Map<K, V>> View<K, V> get(final AbstractCopyOnWriteMap<K, V, M> host) { return host.new Immutable(); } }, LIVE { @Override <K, V, M extends Map<K, V>> View<K, V> get(final AbstractCopyOnWriteMap<K, V, M> host) { return host.new Mutable(); } }; abstract <K, V, M extends Map<K, V>> View<K, V> get(AbstractCopyOnWriteMap<K, V, M> host); } } final class Immutable extends View<K, V> { @Override public Set<K> keySet() { return unmodifiableSet(delegate.keySet()); } @Override public Set<Entry<K, V>> entrySet() { return unmodifiableSet(delegate.entrySet()); } @Override public Collection<V> values() { return unmodifiableCollection(delegate.values()); } } final class Mutable extends View<K, V> { private final transient KeySet keySet = new KeySet(); private final transient EntrySet entrySet = new EntrySet(); private final transient Values values = new Values(); @Override public Set<K> keySet() { return keySet; } @Override public Set<Entry<K, V>> entrySet() { return entrySet; } @Override public Collection<V> values() { return values; } } }