org.glowroot.shaded.google.common.collect.Synchronized Maven / Gradle / Ivy
/*
* Copyright (C) 2007 The Guava Authors
*
* 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.glowroot.shaded.google.common.collect;
import static org.glowroot.shaded.google.common.base.Preconditions.checkNotNull;
import org.glowroot.shaded.google.common.annotations.GwtCompatible;
import org.glowroot.shaded.google.common.annotations.GwtIncompatible;
import org.glowroot.shaded.google.common.annotations.VisibleForTesting;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;
import java.util.Collection;
import java.util.Comparator;
import java.util.Deque;
import java.util.Iterator;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import java.util.Map.Entry;
import java.util.NavigableMap;
import java.util.NavigableSet;
import java.util.Queue;
import java.util.RandomAccess;
import java.util.Set;
import java.util.SortedMap;
import java.util.SortedSet;
import javax.annotation.Nullable;
/**
* Synchronized collection views. The returned synchronized collection views are
* serializable if the backing collection and the mutex are serializable.
*
* If {@code null} is passed as the {@code mutex} parameter to any of this
* class's top-level methods or inner class constructors, the created object
* uses itself as the synchronization mutex.
*
*
This class should be used by other collection classes only.
*
* @author Mike Bostock
* @author Jared Levy
*/
@GwtCompatible(emulated = true)
final class Synchronized {
private Synchronized() {}
static class SynchronizedObject implements Serializable {
final Object delegate;
final Object mutex;
SynchronizedObject(Object delegate, @Nullable Object mutex) {
this.delegate = checkNotNull(delegate);
this.mutex = (mutex == null) ? this : mutex;
}
Object delegate() {
return delegate;
}
// No equals and hashCode; see ForwardingObject for details.
@Override public String toString() {
synchronized (mutex) {
return delegate.toString();
}
}
// Serialization invokes writeObject only when it's private.
// The SynchronizedObject subclasses don't need a writeObject method since
// they don't contain any non-transient member variables, while the
// following writeObject() handles the SynchronizedObject members.
@GwtIncompatible("java.io.ObjectOutputStream")
private void writeObject(ObjectOutputStream stream) throws IOException {
synchronized (mutex) {
stream.defaultWriteObject();
}
}
@GwtIncompatible("not needed in emulated source")
private static final long serialVersionUID = 0;
}
private static Collection collection(
Collection collection, @Nullable Object mutex) {
return new SynchronizedCollection(collection, mutex);
}
@VisibleForTesting static class SynchronizedCollection
extends SynchronizedObject implements Collection {
private SynchronizedCollection(
Collection delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@SuppressWarnings("unchecked")
@Override Collection delegate() {
return (Collection) super.delegate();
}
@Override
public boolean add(E e) {
synchronized (mutex) {
return delegate().add(e);
}
}
@Override
public boolean addAll(Collection c) {
synchronized (mutex) {
return delegate().addAll(c);
}
}
@Override
public void clear() {
synchronized (mutex) {
delegate().clear();
}
}
@Override
public boolean contains(Object o) {
synchronized (mutex) {
return delegate().contains(o);
}
}
@Override
public boolean containsAll(Collection c) {
synchronized (mutex) {
return delegate().containsAll(c);
}
}
@Override
public boolean isEmpty() {
synchronized (mutex) {
return delegate().isEmpty();
}
}
@Override
public Iterator iterator() {
return delegate().iterator(); // manually synchronized
}
@Override
public boolean remove(Object o) {
synchronized (mutex) {
return delegate().remove(o);
}
}
@Override
public boolean removeAll(Collection c) {
synchronized (mutex) {
return delegate().removeAll(c);
}
}
@Override
public boolean retainAll(Collection c) {
synchronized (mutex) {
return delegate().retainAll(c);
}
}
@Override
public int size() {
synchronized (mutex) {
return delegate().size();
}
}
@Override
public Object[] toArray() {
synchronized (mutex) {
return delegate().toArray();
}
}
@Override
public T[] toArray(T[] a) {
synchronized (mutex) {
return delegate().toArray(a);
}
}
private static final long serialVersionUID = 0;
}
@VisibleForTesting static Set set(Set set, @Nullable Object mutex) {
return new SynchronizedSet(set, mutex);
}
static class SynchronizedSet
extends SynchronizedCollection implements Set {
SynchronizedSet(Set delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override Set delegate() {
return (Set) super.delegate();
}
@Override public boolean equals(Object o) {
if (o == this) {
return true;
}
synchronized (mutex) {
return delegate().equals(o);
}
}
@Override public int hashCode() {
synchronized (mutex) {
return delegate().hashCode();
}
}
private static final long serialVersionUID = 0;
}
private static SortedSet sortedSet(
SortedSet set, @Nullable Object mutex) {
return new SynchronizedSortedSet(set, mutex);
}
static class SynchronizedSortedSet extends SynchronizedSet
implements SortedSet {
SynchronizedSortedSet(SortedSet delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override SortedSet delegate() {
return (SortedSet) super.delegate();
}
@Override
public Comparator comparator() {
synchronized (mutex) {
return delegate().comparator();
}
}
@Override
public SortedSet subSet(E fromElement, E toElement) {
synchronized (mutex) {
return sortedSet(delegate().subSet(fromElement, toElement), mutex);
}
}
@Override
public SortedSet headSet(E toElement) {
synchronized (mutex) {
return sortedSet(delegate().headSet(toElement), mutex);
}
}
@Override
public SortedSet tailSet(E fromElement) {
synchronized (mutex) {
return sortedSet(delegate().tailSet(fromElement), mutex);
}
}
@Override
public E first() {
synchronized (mutex) {
return delegate().first();
}
}
@Override
public E last() {
synchronized (mutex) {
return delegate().last();
}
}
private static final long serialVersionUID = 0;
}
private static List list(List list, @Nullable Object mutex) {
return (list instanceof RandomAccess)
? new SynchronizedRandomAccessList(list, mutex)
: new SynchronizedList(list, mutex);
}
private static class SynchronizedList extends SynchronizedCollection
implements List {
SynchronizedList(List delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override List delegate() {
return (List) super.delegate();
}
@Override
public void add(int index, E element) {
synchronized (mutex) {
delegate().add(index, element);
}
}
@Override
public boolean addAll(int index, Collection c) {
synchronized (mutex) {
return delegate().addAll(index, c);
}
}
@Override
public E get(int index) {
synchronized (mutex) {
return delegate().get(index);
}
}
@Override
public int indexOf(Object o) {
synchronized (mutex) {
return delegate().indexOf(o);
}
}
@Override
public int lastIndexOf(Object o) {
synchronized (mutex) {
return delegate().lastIndexOf(o);
}
}
@Override
public ListIterator listIterator() {
return delegate().listIterator(); // manually synchronized
}
@Override
public ListIterator listIterator(int index) {
return delegate().listIterator(index); // manually synchronized
}
@Override
public E remove(int index) {
synchronized (mutex) {
return delegate().remove(index);
}
}
@Override
public E set(int index, E element) {
synchronized (mutex) {
return delegate().set(index, element);
}
}
@Override
public List subList(int fromIndex, int toIndex) {
synchronized (mutex) {
return list(delegate().subList(fromIndex, toIndex), mutex);
}
}
@Override public boolean equals(Object o) {
if (o == this) {
return true;
}
synchronized (mutex) {
return delegate().equals(o);
}
}
@Override public int hashCode() {
synchronized (mutex) {
return delegate().hashCode();
}
}
private static final long serialVersionUID = 0;
}
private static class SynchronizedRandomAccessList
extends SynchronizedList implements RandomAccess {
SynchronizedRandomAccessList(List list, @Nullable Object mutex) {
super(list, mutex);
}
private static final long serialVersionUID = 0;
}
static Multiset multiset(
Multiset multiset, @Nullable Object mutex) {
if (multiset instanceof SynchronizedMultiset ||
multiset instanceof ImmutableMultiset) {
return multiset;
}
return new SynchronizedMultiset(multiset, mutex);
}
private static class SynchronizedMultiset extends SynchronizedCollection
implements Multiset {
transient Set elementSet;
transient Set> entrySet;
SynchronizedMultiset(Multiset delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override Multiset delegate() {
return (Multiset) super.delegate();
}
@Override
public int count(Object o) {
synchronized (mutex) {
return delegate().count(o);
}
}
@Override
public int add(E e, int n) {
synchronized (mutex) {
return delegate().add(e, n);
}
}
@Override
public int remove(Object o, int n) {
synchronized (mutex) {
return delegate().remove(o, n);
}
}
@Override
public int setCount(E element, int count) {
synchronized (mutex) {
return delegate().setCount(element, count);
}
}
@Override
public boolean setCount(E element, int oldCount, int newCount) {
synchronized (mutex) {
return delegate().setCount(element, oldCount, newCount);
}
}
@Override
public Set elementSet() {
synchronized (mutex) {
if (elementSet == null) {
elementSet = typePreservingSet(delegate().elementSet(), mutex);
}
return elementSet;
}
}
@Override
public Set> entrySet() {
synchronized (mutex) {
if (entrySet == null) {
entrySet = typePreservingSet(delegate().entrySet(), mutex);
}
return entrySet;
}
}
@Override public boolean equals(Object o) {
if (o == this) {
return true;
}
synchronized (mutex) {
return delegate().equals(o);
}
}
@Override public int hashCode() {
synchronized (mutex) {
return delegate().hashCode();
}
}
private static final long serialVersionUID = 0;
}
static Multimap multimap(
Multimap multimap, @Nullable Object mutex) {
if (multimap instanceof SynchronizedMultimap ||
multimap instanceof ImmutableMultimap) {
return multimap;
}
return new SynchronizedMultimap(multimap, mutex);
}
private static class SynchronizedMultimap extends SynchronizedObject
implements Multimap {
transient Set keySet;
transient Collection valuesCollection;
transient Collection> entries;
transient Map> asMap;
transient Multiset keys;
@SuppressWarnings("unchecked")
@Override Multimap delegate() {
return (Multimap) super.delegate();
}
SynchronizedMultimap(Multimap delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override
public int size() {
synchronized (mutex) {
return delegate().size();
}
}
@Override
public boolean isEmpty() {
synchronized (mutex) {
return delegate().isEmpty();
}
}
@Override
public boolean containsKey(Object key) {
synchronized (mutex) {
return delegate().containsKey(key);
}
}
@Override
public boolean containsValue(Object value) {
synchronized (mutex) {
return delegate().containsValue(value);
}
}
@Override
public boolean containsEntry(Object key, Object value) {
synchronized (mutex) {
return delegate().containsEntry(key, value);
}
}
@Override
public Collection get(K key) {
synchronized (mutex) {
return typePreservingCollection(delegate().get(key), mutex);
}
}
@Override
public boolean put(K key, V value) {
synchronized (mutex) {
return delegate().put(key, value);
}
}
@Override
public boolean putAll(K key, Iterable values) {
synchronized (mutex) {
return delegate().putAll(key, values);
}
}
@Override
public boolean putAll(Multimap multimap) {
synchronized (mutex) {
return delegate().putAll(multimap);
}
}
@Override
public Collection replaceValues(K key, Iterable values) {
synchronized (mutex) {
return delegate().replaceValues(key, values); // copy not synchronized
}
}
@Override
public boolean remove(Object key, Object value) {
synchronized (mutex) {
return delegate().remove(key, value);
}
}
@Override
public Collection removeAll(Object key) {
synchronized (mutex) {
return delegate().removeAll(key); // copy not synchronized
}
}
@Override
public void clear() {
synchronized (mutex) {
delegate().clear();
}
}
@Override
public Set keySet() {
synchronized (mutex) {
if (keySet == null) {
keySet = typePreservingSet(delegate().keySet(), mutex);
}
return keySet;
}
}
@Override
public Collection values() {
synchronized (mutex) {
if (valuesCollection == null) {
valuesCollection = collection(delegate().values(), mutex);
}
return valuesCollection;
}
}
@Override
public Collection> entries() {
synchronized (mutex) {
if (entries == null) {
entries = typePreservingCollection(delegate().entries(), mutex);
}
return entries;
}
}
@Override
public Map> asMap() {
synchronized (mutex) {
if (asMap == null) {
asMap = new SynchronizedAsMap(delegate().asMap(), mutex);
}
return asMap;
}
}
@Override
public Multiset keys() {
synchronized (mutex) {
if (keys == null) {
keys = multiset(delegate().keys(), mutex);
}
return keys;
}
}
@Override public boolean equals(Object o) {
if (o == this) {
return true;
}
synchronized (mutex) {
return delegate().equals(o);
}
}
@Override public int hashCode() {
synchronized (mutex) {
return delegate().hashCode();
}
}
private static final long serialVersionUID = 0;
}
static ListMultimap listMultimap(
ListMultimap multimap, @Nullable Object mutex) {
if (multimap instanceof SynchronizedListMultimap ||
multimap instanceof ImmutableListMultimap) {
return multimap;
}
return new SynchronizedListMultimap(multimap, mutex);
}
private static class SynchronizedListMultimap
extends SynchronizedMultimap implements ListMultimap {
SynchronizedListMultimap(
ListMultimap delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override ListMultimap delegate() {
return (ListMultimap) super.delegate();
}
@Override public List get(K key) {
synchronized (mutex) {
return list(delegate().get(key), mutex);
}
}
@Override public List removeAll(Object key) {
synchronized (mutex) {
return delegate().removeAll(key); // copy not synchronized
}
}
@Override public List replaceValues(
K key, Iterable values) {
synchronized (mutex) {
return delegate().replaceValues(key, values); // copy not synchronized
}
}
private static final long serialVersionUID = 0;
}
static SetMultimap setMultimap(
SetMultimap multimap, @Nullable Object mutex) {
if (multimap instanceof SynchronizedSetMultimap ||
multimap instanceof ImmutableSetMultimap) {
return multimap;
}
return new SynchronizedSetMultimap(multimap, mutex);
}
private static class SynchronizedSetMultimap
extends SynchronizedMultimap implements SetMultimap {
transient Set> entrySet;
SynchronizedSetMultimap(
SetMultimap delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override SetMultimap delegate() {
return (SetMultimap) super.delegate();
}
@Override public Set get(K key) {
synchronized (mutex) {
return set(delegate().get(key), mutex);
}
}
@Override public Set removeAll(Object key) {
synchronized (mutex) {
return delegate().removeAll(key); // copy not synchronized
}
}
@Override public Set replaceValues(
K key, Iterable values) {
synchronized (mutex) {
return delegate().replaceValues(key, values); // copy not synchronized
}
}
@Override public Set> entries() {
synchronized (mutex) {
if (entrySet == null) {
entrySet = set(delegate().entries(), mutex);
}
return entrySet;
}
}
private static final long serialVersionUID = 0;
}
static SortedSetMultimap sortedSetMultimap(
SortedSetMultimap multimap, @Nullable Object mutex) {
if (multimap instanceof SynchronizedSortedSetMultimap) {
return multimap;
}
return new SynchronizedSortedSetMultimap(multimap, mutex);
}
private static class SynchronizedSortedSetMultimap
extends SynchronizedSetMultimap implements SortedSetMultimap {
SynchronizedSortedSetMultimap(
SortedSetMultimap delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override SortedSetMultimap delegate() {
return (SortedSetMultimap) super.delegate();
}
@Override public SortedSet get(K key) {
synchronized (mutex) {
return sortedSet(delegate().get(key), mutex);
}
}
@Override public SortedSet removeAll(Object key) {
synchronized (mutex) {
return delegate().removeAll(key); // copy not synchronized
}
}
@Override public SortedSet replaceValues(
K key, Iterable values) {
synchronized (mutex) {
return delegate().replaceValues(key, values); // copy not synchronized
}
}
@Override
public Comparator valueComparator() {
synchronized (mutex) {
return delegate().valueComparator();
}
}
private static final long serialVersionUID = 0;
}
private static Collection typePreservingCollection(
Collection collection, @Nullable Object mutex) {
if (collection instanceof SortedSet) {
return sortedSet((SortedSet) collection, mutex);
}
if (collection instanceof Set) {
return set((Set) collection, mutex);
}
if (collection instanceof List) {
return list((List) collection, mutex);
}
return collection(collection, mutex);
}
private static Set typePreservingSet(
Set set, @Nullable Object mutex) {
if (set instanceof SortedSet) {
return sortedSet((SortedSet) set, mutex);
} else {
return set(set, mutex);
}
}
private static class SynchronizedAsMapEntries
extends SynchronizedSet>> {
SynchronizedAsMapEntries(
Set>> delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override public Iterator>> iterator() {
// Must be manually synchronized.
final Iterator>> iterator = super.iterator();
return new ForwardingIterator>>() {
@Override protected Iterator>> delegate() {
return iterator;
}
@Override public Map.Entry> next() {
final Map.Entry> entry = super.next();
return new ForwardingMapEntry>() {
@Override protected Map.Entry> delegate() {
return entry;
}
@Override public Collection getValue() {
return typePreservingCollection(entry.getValue(), mutex);
}
};
}
};
}
// See Collections.CheckedMap.CheckedEntrySet for details on attacks.
@Override public Object[] toArray() {
synchronized (mutex) {
return ObjectArrays.toArrayImpl(delegate());
}
}
@Override public T[] toArray(T[] array) {
synchronized (mutex) {
return ObjectArrays.toArrayImpl(delegate(), array);
}
}
@Override public boolean contains(Object o) {
synchronized (mutex) {
return Maps.containsEntryImpl(delegate(), o);
}
}
@Override public boolean containsAll(Collection c) {
synchronized (mutex) {
return Collections2.containsAllImpl(delegate(), c);
}
}
@Override public boolean equals(Object o) {
if (o == this) {
return true;
}
synchronized (mutex) {
return Sets.equalsImpl(delegate(), o);
}
}
@Override public boolean remove(Object o) {
synchronized (mutex) {
return Maps.removeEntryImpl(delegate(), o);
}
}
@Override public boolean removeAll(Collection c) {
synchronized (mutex) {
return Iterators.removeAll(delegate().iterator(), c);
}
}
@Override public boolean retainAll(Collection c) {
synchronized (mutex) {
return Iterators.retainAll(delegate().iterator(), c);
}
}
private static final long serialVersionUID = 0;
}
@VisibleForTesting
static Map map(Map map, @Nullable Object mutex) {
return new SynchronizedMap(map, mutex);
}
private static class SynchronizedMap extends SynchronizedObject
implements Map {
transient Set keySet;
transient Collection values;
transient Set> entrySet;
SynchronizedMap(Map delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@SuppressWarnings("unchecked")
@Override Map delegate() {
return (Map) super.delegate();
}
@Override
public void clear() {
synchronized (mutex) {
delegate().clear();
}
}
@Override
public boolean containsKey(Object key) {
synchronized (mutex) {
return delegate().containsKey(key);
}
}
@Override
public boolean containsValue(Object value) {
synchronized (mutex) {
return delegate().containsValue(value);
}
}
@Override
public Set> entrySet() {
synchronized (mutex) {
if (entrySet == null) {
entrySet = set(delegate().entrySet(), mutex);
}
return entrySet;
}
}
@Override
public V get(Object key) {
synchronized (mutex) {
return delegate().get(key);
}
}
@Override
public boolean isEmpty() {
synchronized (mutex) {
return delegate().isEmpty();
}
}
@Override
public Set keySet() {
synchronized (mutex) {
if (keySet == null) {
keySet = set(delegate().keySet(), mutex);
}
return keySet;
}
}
@Override
public V put(K key, V value) {
synchronized (mutex) {
return delegate().put(key, value);
}
}
@Override
public void putAll(Map map) {
synchronized (mutex) {
delegate().putAll(map);
}
}
@Override
public V remove(Object key) {
synchronized (mutex) {
return delegate().remove(key);
}
}
@Override
public int size() {
synchronized (mutex) {
return delegate().size();
}
}
@Override
public Collection values() {
synchronized (mutex) {
if (values == null) {
values = collection(delegate().values(), mutex);
}
return values;
}
}
@Override public boolean equals(Object o) {
if (o == this) {
return true;
}
synchronized (mutex) {
return delegate().equals(o);
}
}
@Override public int hashCode() {
synchronized (mutex) {
return delegate().hashCode();
}
}
private static final long serialVersionUID = 0;
}
static SortedMap sortedMap(
SortedMap sortedMap, @Nullable Object mutex) {
return new SynchronizedSortedMap(sortedMap, mutex);
}
static class SynchronizedSortedMap extends SynchronizedMap
implements SortedMap {
SynchronizedSortedMap(SortedMap delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override SortedMap delegate() {
return (SortedMap) super.delegate();
}
@Override public Comparator comparator() {
synchronized (mutex) {
return delegate().comparator();
}
}
@Override public K firstKey() {
synchronized (mutex) {
return delegate().firstKey();
}
}
@Override public SortedMap headMap(K toKey) {
synchronized (mutex) {
return sortedMap(delegate().headMap(toKey), mutex);
}
}
@Override public K lastKey() {
synchronized (mutex) {
return delegate().lastKey();
}
}
@Override public SortedMap subMap(K fromKey, K toKey) {
synchronized (mutex) {
return sortedMap(delegate().subMap(fromKey, toKey), mutex);
}
}
@Override public SortedMap tailMap(K fromKey) {
synchronized (mutex) {
return sortedMap(delegate().tailMap(fromKey), mutex);
}
}
private static final long serialVersionUID = 0;
}
static BiMap biMap(BiMap bimap, @Nullable Object mutex) {
if (bimap instanceof SynchronizedBiMap ||
bimap instanceof ImmutableBiMap) {
return bimap;
}
return new SynchronizedBiMap(bimap, mutex, null);
}
@VisibleForTesting static class SynchronizedBiMap
extends SynchronizedMap implements BiMap, Serializable {
private transient Set valueSet;
private transient BiMap inverse;
private SynchronizedBiMap(BiMap delegate, @Nullable Object mutex,
@Nullable BiMap inverse) {
super(delegate, mutex);
this.inverse = inverse;
}
@Override BiMap delegate() {
return (BiMap) super.delegate();
}
@Override public Set values() {
synchronized (mutex) {
if (valueSet == null) {
valueSet = set(delegate().values(), mutex);
}
return valueSet;
}
}
@Override
public V forcePut(K key, V value) {
synchronized (mutex) {
return delegate().forcePut(key, value);
}
}
@Override
public BiMap inverse() {
synchronized (mutex) {
if (inverse == null) {
inverse
= new SynchronizedBiMap(delegate().inverse(), mutex, this);
}
return inverse;
}
}
private static final long serialVersionUID = 0;
}
private static class SynchronizedAsMap
extends SynchronizedMap> {
transient Set>> asMapEntrySet;
transient Collection> asMapValues;
SynchronizedAsMap(Map> delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override public Collection get(Object key) {
synchronized (mutex) {
Collection collection = super.get(key);
return (collection == null) ? null
: typePreservingCollection(collection, mutex);
}
}
@Override public Set>> entrySet() {
synchronized (mutex) {
if (asMapEntrySet == null) {
asMapEntrySet = new SynchronizedAsMapEntries(
delegate().entrySet(), mutex);
}
return asMapEntrySet;
}
}
@Override public Collection> values() {
synchronized (mutex) {
if (asMapValues == null) {
asMapValues
= new SynchronizedAsMapValues(delegate().values(), mutex);
}
return asMapValues;
}
}
@Override public boolean containsValue(Object o) {
// values() and its contains() method are both synchronized.
return values().contains(o);
}
private static final long serialVersionUID = 0;
}
private static class SynchronizedAsMapValues
extends SynchronizedCollection> {
SynchronizedAsMapValues(
Collection> delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override public Iterator> iterator() {
// Must be manually synchronized.
final Iterator> iterator = super.iterator();
return new ForwardingIterator>() {
@Override protected Iterator> delegate() {
return iterator;
}
@Override public Collection next() {
return typePreservingCollection(super.next(), mutex);
}
};
}
private static final long serialVersionUID = 0;
}
@GwtIncompatible("NavigableSet")
@VisibleForTesting
static class SynchronizedNavigableSet extends SynchronizedSortedSet
implements NavigableSet {
SynchronizedNavigableSet(NavigableSet delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override NavigableSet delegate() {
return (NavigableSet) super.delegate();
}
@Override public E ceiling(E e) {
synchronized (mutex) {
return delegate().ceiling(e);
}
}
@Override public Iterator descendingIterator() {
return delegate().descendingIterator(); // manually synchronized
}
transient NavigableSet descendingSet;
@Override public NavigableSet descendingSet() {
synchronized (mutex) {
if (descendingSet == null) {
NavigableSet dS =
Synchronized.navigableSet(delegate().descendingSet(), mutex);
descendingSet = dS;
return dS;
}
return descendingSet;
}
}
@Override public E floor(E e) {
synchronized (mutex) {
return delegate().floor(e);
}
}
@Override public NavigableSet headSet(E toElement, boolean inclusive) {
synchronized (mutex) {
return Synchronized.navigableSet(
delegate().headSet(toElement, inclusive), mutex);
}
}
@Override public E higher(E e) {
synchronized (mutex) {
return delegate().higher(e);
}
}
@Override public E lower(E e) {
synchronized (mutex) {
return delegate().lower(e);
}
}
@Override public E pollFirst() {
synchronized (mutex) {
return delegate().pollFirst();
}
}
@Override public E pollLast() {
synchronized (mutex) {
return delegate().pollLast();
}
}
@Override public NavigableSet subSet(E fromElement,
boolean fromInclusive, E toElement, boolean toInclusive) {
synchronized (mutex) {
return Synchronized.navigableSet(delegate().subSet(
fromElement, fromInclusive, toElement, toInclusive), mutex);
}
}
@Override public NavigableSet tailSet(E fromElement, boolean inclusive) {
synchronized (mutex) {
return Synchronized.navigableSet(
delegate().tailSet(fromElement, inclusive), mutex);
}
}
@Override public SortedSet headSet(E toElement) {
return headSet(toElement, false);
}
@Override public SortedSet subSet(E fromElement, E toElement) {
return subSet(fromElement, true, toElement, false);
}
@Override public SortedSet tailSet(E fromElement) {
return tailSet(fromElement, true);
}
private static final long serialVersionUID = 0;
}
@GwtIncompatible("NavigableSet")
static NavigableSet navigableSet(
NavigableSet navigableSet, @Nullable Object mutex) {
return new SynchronizedNavigableSet(navigableSet, mutex);
}
@GwtIncompatible("NavigableSet")
static NavigableSet navigableSet(NavigableSet navigableSet) {
return navigableSet(navigableSet, null);
}
@GwtIncompatible("NavigableMap")
static NavigableMap navigableMap(
NavigableMap navigableMap) {
return navigableMap(navigableMap, null);
}
@GwtIncompatible("NavigableMap")
static NavigableMap navigableMap(
NavigableMap navigableMap, @Nullable Object mutex) {
return new SynchronizedNavigableMap(navigableMap, mutex);
}
@GwtIncompatible("NavigableMap")
@VisibleForTesting static class SynchronizedNavigableMap
extends SynchronizedSortedMap implements NavigableMap {
SynchronizedNavigableMap(
NavigableMap delegate, @Nullable Object mutex) {
super(delegate, mutex);
}
@Override NavigableMap