1 /*
2 * Copyright (C) 2007 The Guava Authors
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 package com.google.common.collect;
18
19 import static com.google.common.base.Preconditions.checkNotNull;
20
21 import com.google.common.annotations.GwtCompatible;
22 import com.google.common.annotations.GwtIncompatible;
23 import com.google.common.annotations.VisibleForTesting;
24 import com.google.j2objc.annotations.RetainedWith;
25 import java.io.IOException;
26 import java.io.ObjectOutputStream;
27 import java.io.Serializable;
28 import java.util.Collection;
29 import java.util.Comparator;
30 import java.util.Deque;
31 import java.util.Iterator;
32 import java.util.List;
33 import java.util.ListIterator;
34 import java.util.Map;
35 import java.util.Map.Entry;
36 import java.util.NavigableMap;
37 import java.util.NavigableSet;
38 import java.util.Queue;
39 import java.util.RandomAccess;
40 import java.util.Set;
41 import java.util.SortedMap;
42 import java.util.SortedSet;
43 import java.util.Spliterator;
44 import java.util.function.BiConsumer;
45 import java.util.function.BiFunction;
46 import java.util.function.Consumer;
47 import java.util.function.Function;
48 import java.util.function.Predicate;
49 import java.util.function.UnaryOperator;
50 import java.util.stream.Stream;
51 import org.checkerframework.checker.nullness.qual.Nullable;
52
53 /**
54 * Synchronized collection views. The returned synchronized collection views are serializable if the
55 * backing collection and the mutex are serializable.
56 *
57 * <p>If {@code null} is passed as the {@code mutex} parameter to any of this class's top-level
58 * methods or inner class constructors, the created object uses itself as the synchronization mutex.
59 *
60 * <p>This class should be used by other collection classes only.
61 *
62 * @author Mike Bostock
63 * @author Jared Levy
64 */
65 @GwtCompatible(emulated = true)
66 final class Synchronized {
67 private Synchronized() {}
68
69 static class SynchronizedObject implements Serializable {
70 final Object delegate;
71 final Object mutex;
72
73 SynchronizedObject(Object delegate, @Nullable Object mutex) {
74 this.delegate = checkNotNull(delegate);
75 this.mutex = (mutex == null) ? this : mutex;
76 }
77
78 Object delegate() {
79 return delegate;
80 }
81
82 // No equals and hashCode; see ForwardingObject for details.
83
84 @Override
85 public String toString() {
86 synchronized (mutex) {
87 return delegate.toString();
88 }
89 }
90
91 // Serialization invokes writeObject only when it's private.
92 // The SynchronizedObject subclasses don't need a writeObject method since
93 // they don't contain any non-transient member variables, while the
94 // following writeObject() handles the SynchronizedObject members.
95
96 @GwtIncompatible // java.io.ObjectOutputStream
97 private void writeObject(ObjectOutputStream stream) throws IOException {
98 synchronized (mutex) {
99 stream.defaultWriteObject();
100 }
101 }
102
103 @GwtIncompatible // not needed in emulated source
104 private static final long serialVersionUID = 0;
105 }
106
107 private static <E> Collection<E> collection(Collection<E> collection, @Nullable Object mutex) {
108 return new SynchronizedCollection<E>(collection, mutex);
109 }
110
111 @VisibleForTesting
112 static class SynchronizedCollection<E> extends SynchronizedObject implements Collection<E> {
113 private SynchronizedCollection(Collection<E> delegate, @Nullable Object mutex) {
114 super(delegate, mutex);
115 }
116
117 @SuppressWarnings("unchecked")
118 @Override
119 Collection<E> delegate() {
120 return (Collection<E>) super.delegate();
121 }
122
123 @Override
124 public boolean add(E e) {
125 synchronized (mutex) {
126 return delegate().add(e);
127 }
128 }
129
130 @Override
131 public boolean addAll(Collection<? extends E> c) {
132 synchronized (mutex) {
133 return delegate().addAll(c);
134 }
135 }
136
137 @Override
138 public void clear() {
139 synchronized (mutex) {
140 delegate().clear();
141 }
142 }
143
144 @Override
145 public boolean contains(Object o) {
146 synchronized (mutex) {
147 return delegate().contains(o);
148 }
149 }
150
151 @Override
152 public boolean containsAll(Collection<?> c) {
153 synchronized (mutex) {
154 return delegate().containsAll(c);
155 }
156 }
157
158 @Override
159 public boolean isEmpty() {
160 synchronized (mutex) {
161 return delegate().isEmpty();
162 }
163 }
164
165 @Override
166 public Iterator<E> iterator() {
167 return delegate().iterator(); // manually synchronized
168 }
169
170 @Override
171 public Spliterator<E> spliterator() {
172 synchronized (mutex) {
173 return delegate().spliterator();
174 }
175 }
176
177 @Override
178 public Stream<E> stream() {
179 synchronized (mutex) {
180 return delegate().stream();
181 }
182 }
183
184 @Override
185 public Stream<E> parallelStream() {
186 synchronized (mutex) {
187 return delegate().parallelStream();
188 }
189 }
190
191 @Override
192 public void forEach(Consumer<? super E> action) {
193 synchronized (mutex) {
194 delegate().forEach(action);
195 }
196 }
197
198 @Override
199 public boolean remove(Object o) {
200 synchronized (mutex) {
201 return delegate().remove(o);
202 }
203 }
204
205 @Override
206 public boolean removeAll(Collection<?> c) {
207 synchronized (mutex) {
208 return delegate().removeAll(c);
209 }
210 }
211
212 @Override
213 public boolean retainAll(Collection<?> c) {
214 synchronized (mutex) {
215 return delegate().retainAll(c);
216 }
217 }
218
219 @Override
220 public boolean removeIf(Predicate<? super E> filter) {
221 synchronized (mutex) {
222 return delegate().removeIf(filter);
223 }
224 }
225
226 @Override
227 public int size() {
228 synchronized (mutex) {
229 return delegate().size();
230 }
231 }
232
233 @Override
234 public Object[] toArray() {
235 synchronized (mutex) {
236 return delegate().toArray();
237 }
238 }
239
240 @Override
241 public <T> T[] toArray(T[] a) {
242 synchronized (mutex) {
243 return delegate().toArray(a);
244 }
245 }
246
247 private static final long serialVersionUID = 0;
248 }
249
250 @VisibleForTesting
251 static <E> Set<E> set(Set<E> set, @Nullable Object mutex) {
252 return new SynchronizedSet<E>(set, mutex);
253 }
254
255 static class SynchronizedSet<E> extends SynchronizedCollection<E> implements Set<E> {
256
257 SynchronizedSet(Set<E> delegate, @Nullable Object mutex) {
258 super(delegate, mutex);
259 }
260
261 @Override
262 Set<E> delegate() {
263 return (Set<E>) super.delegate();
264 }
265
266 @Override
267 public boolean equals(Object o) {
268 if (o == this) {
269 return true;
270 }
271 synchronized (mutex) {
272 return delegate().equals(o);
273 }
274 }
275
276 @Override
277 public int hashCode() {
278 synchronized (mutex) {
279 return delegate().hashCode();
280 }
281 }
282
283 private static final long serialVersionUID = 0;
284 }
285
286 private static <E> SortedSet<E> sortedSet(SortedSet<E> set, @Nullable Object mutex) {
287 return new SynchronizedSortedSet<E>(set, mutex);
288 }
289
290 static class SynchronizedSortedSet<E> extends SynchronizedSet<E> implements SortedSet<E> {
291 SynchronizedSortedSet(SortedSet<E> delegate, @Nullable Object mutex) {
292 super(delegate, mutex);
293 }
294
295 @Override
296 SortedSet<E> delegate() {
297 return (SortedSet<E>) super.delegate();
298 }
299
300 @Override
301 public Comparator<? super E> comparator() {
302 synchronized (mutex) {
303 return delegate().comparator();
304 }
305 }
306
307 @Override
308 public SortedSet<E> subSet(E fromElement, E toElement) {
309 synchronized (mutex) {
310 return sortedSet(delegate().subSet(fromElement, toElement), mutex);
311 }
312 }
313
314 @Override
315 public SortedSet<E> headSet(E toElement) {
316 synchronized (mutex) {
317 return sortedSet(delegate().headSet(toElement), mutex);
318 }
319 }
320
321 @Override
322 public SortedSet<E> tailSet(E fromElement) {
323 synchronized (mutex) {
324 return sortedSet(delegate().tailSet(fromElement), mutex);
325 }
326 }
327
328 @Override
329 public E first() {
330 synchronized (mutex) {
331 return delegate().first();
332 }
333 }
334
335 @Override
336 public E last() {
337 synchronized (mutex) {
338 return delegate().last();
339 }
340 }
341
342 private static final long serialVersionUID = 0;
343 }
344
345 private static <E> List<E> list(List<E> list, @Nullable Object mutex) {
346 return (list instanceof RandomAccess)
347 ? new SynchronizedRandomAccessList<E>(list, mutex)
348 : new SynchronizedList<E>(list, mutex);
349 }
350
351 private static class SynchronizedList<E> extends SynchronizedCollection<E> implements List<E> {
352 SynchronizedList(List<E> delegate, @Nullable Object mutex) {
353 super(delegate, mutex);
354 }
355
356 @Override
357 List<E> delegate() {
358 return (List<E>) super.delegate();
359 }
360
361 @Override
362 public void add(int index, E element) {
363 synchronized (mutex) {
364 delegate().add(index, element);
365 }
366 }
367
368 @Override
369 public boolean addAll(int index, Collection<? extends E> c) {
370 synchronized (mutex) {
371 return delegate().addAll(index, c);
372 }
373 }
374
375 @Override
376 public E get(int index) {
377 synchronized (mutex) {
378 return delegate().get(index);
379 }
380 }
381
382 @Override
383 public int indexOf(Object o) {
384 synchronized (mutex) {
385 return delegate().indexOf(o);
386 }
387 }
388
389 @Override
390 public int lastIndexOf(Object o) {
391 synchronized (mutex) {
392 return delegate().lastIndexOf(o);
393 }
394 }
395
396 @Override
397 public ListIterator<E> listIterator() {
398 return delegate().listIterator(); // manually synchronized
399 }
400
401 @Override
402 public ListIterator<E> listIterator(int index) {
403 return delegate().listIterator(index); // manually synchronized
404 }
405
406 @Override
407 public E remove(int index) {
408 synchronized (mutex) {
409 return delegate().remove(index);
410 }
411 }
412
413 @Override
414 public E set(int index, E element) {
415 synchronized (mutex) {
416 return delegate().set(index, element);
417 }
418 }
419
420 @Override
421 public void replaceAll(UnaryOperator<E> operator) {
422 synchronized (mutex) {
423 delegate().replaceAll(operator);
424 }
425 }
426
427 @Override
428 public void sort(Comparator<? super E> c) {
429 synchronized (mutex) {
430 delegate().sort(c);
431 }
432 }
433
434 @Override
435 public List<E> subList(int fromIndex, int toIndex) {
436 synchronized (mutex) {
437 return list(delegate().subList(fromIndex, toIndex), mutex);
438 }
439 }
440
441 @Override
442 public boolean equals(Object o) {
443 if (o == this) {
444 return true;
445 }
446 synchronized (mutex) {
447 return delegate().equals(o);
448 }
449 }
450
451 @Override
452 public int hashCode() {
453 synchronized (mutex) {
454 return delegate().hashCode();
455 }
456 }
457
458 private static final long serialVersionUID = 0;
459 }
460
461 private static class SynchronizedRandomAccessList<E> extends SynchronizedList<E>
462 implements RandomAccess {
463 SynchronizedRandomAccessList(List<E> list, @Nullable Object mutex) {
464 super(list, mutex);
465 }
466
467 private static final long serialVersionUID = 0;
468 }
469
470 static <E> Multiset<E> multiset(Multiset<E> multiset, @Nullable Object mutex) {
471 if (multiset instanceof SynchronizedMultiset || multiset instanceof ImmutableMultiset) {
472 return multiset;
473 }
474 return new SynchronizedMultiset<E>(multiset, mutex);
475 }
476
477 private static class SynchronizedMultiset<E> extends SynchronizedCollection<E>
478 implements Multiset<E> {
479 transient @Nullable Set<E> elementSet;
480 transient @Nullable Set<Entry<E>> entrySet;
481
482 SynchronizedMultiset(Multiset<E> delegate, @Nullable Object mutex) {
483 super(delegate, mutex);
484 }
485
486 @Override
487 Multiset<E> delegate() {
488 return (Multiset<E>) super.delegate();
489 }
490
491 @Override
492 public int count(Object o) {
493 synchronized (mutex) {
494 return delegate().count(o);
495 }
496 }
497
498 @Override
499 public int add(E e, int n) {
500 synchronized (mutex) {
501 return delegate().add(e, n);
502 }
503 }
504
505 @Override
506 public int remove(Object o, int n) {
507 synchronized (mutex) {
508 return delegate().remove(o, n);
509 }
510 }
511
512 @Override
513 public int setCount(E element, int count) {
514 synchronized (mutex) {
515 return delegate().setCount(element, count);
516 }
517 }
518
519 @Override
520 public boolean setCount(E element, int oldCount, int newCount) {
521 synchronized (mutex) {
522 return delegate().setCount(element, oldCount, newCount);
523 }
524 }
525
526 @Override
527 public Set<E> elementSet() {
528 synchronized (mutex) {
529 if (elementSet == null) {
530 elementSet = typePreservingSet(delegate().elementSet(), mutex);
531 }
532 return elementSet;
533 }
534 }
535
536 @Override
537 public Set<Entry<E>> entrySet() {
538 synchronized (mutex) {
539 if (entrySet == null) {
540 entrySet = typePreservingSet(delegate().entrySet(), mutex);
541 }
542 return entrySet;
543 }
544 }
545
546 @Override
547 public boolean equals(Object o) {
548 if (o == this) {
549 return true;
550 }
551 synchronized (mutex) {
552 return delegate().equals(o);
553 }
554 }
555
556 @Override
557 public int hashCode() {
558 synchronized (mutex) {
559 return delegate().hashCode();
560 }
561 }
562
563 private static final long serialVersionUID = 0;
564 }
565
566 static <K, V> Multimap<K, V> multimap(Multimap<K, V> multimap, @Nullable Object mutex) {
567 if (multimap instanceof SynchronizedMultimap || multimap instanceof BaseImmutableMultimap) {
568 return multimap;
569 }
570 return new SynchronizedMultimap<>(multimap, mutex);
571 }
572
573 private static class SynchronizedMultimap<K, V> extends SynchronizedObject
574 implements Multimap<K, V> {
575 transient @Nullable Set<K> keySet;
576 transient @Nullable Collection<V> valuesCollection;
577 transient @Nullable Collection<Entry<K, V>> entries;
578 transient @Nullable Map<K, Collection<V>> asMap;
579 transient @Nullable Multiset<K> keys;
580
581 @SuppressWarnings("unchecked")
582 @Override
583 Multimap<K, V> delegate() {
584 return (Multimap<K, V>) super.delegate();
585 }
586
587 SynchronizedMultimap(Multimap<K, V> delegate, @Nullable Object mutex) {
588 super(delegate, mutex);
589 }
590
591 @Override
592 public int size() {
593 synchronized (mutex) {
594 return delegate().size();
595 }
596 }
597
598 @Override
599 public boolean isEmpty() {
600 synchronized (mutex) {
601 return delegate().isEmpty();
602 }
603 }
604
605 @Override
606 public boolean containsKey(Object key) {
607 synchronized (mutex) {
608 return delegate().containsKey(key);
609 }
610 }
611
612 @Override
613 public boolean containsValue(Object value) {
614 synchronized (mutex) {
615 return delegate().containsValue(value);
616 }
617 }
618
619 @Override
620 public boolean containsEntry(Object key, Object value) {
621 synchronized (mutex) {
622 return delegate().containsEntry(key, value);
623 }
624 }
625
626 @Override
627 public Collection<V> get(K key) {
628 synchronized (mutex) {
629 return typePreservingCollection(delegate().get(key), mutex);
630 }
631 }
632
633 @Override
634 public boolean put(K key, V value) {
635 synchronized (mutex) {
636 return delegate().put(key, value);
637 }
638 }
639
640 @Override
641 public boolean putAll(K key, Iterable<? extends V> values) {
642 synchronized (mutex) {
643 return delegate().putAll(key, values);
644 }
645 }
646
647 @Override
648 public boolean putAll(Multimap<? extends K, ? extends V> multimap) {
649 synchronized (mutex) {
650 return delegate().putAll(multimap);
651 }
652 }
653
654 @Override
655 public Collection<V> replaceValues(K key, Iterable<? extends V> values) {
656 synchronized (mutex) {
657 return delegate().replaceValues(key, values); // copy not synchronized
658 }
659 }
660
661 @Override
662 public boolean remove(Object key, Object value) {
663 synchronized (mutex) {
664 return delegate().remove(key, value);
665 }
666 }
667
668 @Override
669 public Collection<V> removeAll(Object key) {
670 synchronized (mutex) {
671 return delegate().removeAll(key); // copy not synchronized
672 }
673 }
674
675 @Override
676 public void clear() {
677 synchronized (mutex) {
678 delegate().clear();
679 }
680 }
681
682 @Override
683 public Set<K> keySet() {
684 synchronized (mutex) {
685 if (keySet == null) {
686 keySet = typePreservingSet(delegate().keySet(), mutex);
687 }
688 return keySet;
689 }
690 }
691
692 @Override
693 public Collection<V> values() {
694 synchronized (mutex) {
695 if (valuesCollection == null) {
696 valuesCollection = collection(delegate().values(), mutex);
697 }
698 return valuesCollection;
699 }
700 }
701
702 @Override
703 public Collection<Entry<K, V>> entries() {
704 synchronized (mutex) {
705 if (entries == null) {
706 entries = typePreservingCollection(delegate().entries(), mutex);
707 }
708 return entries;
709 }
710 }
711
712 @Override
713 public void forEach(BiConsumer<? super K, ? super V> action) {
714 synchronized (mutex) {
715 delegate().forEach(action);
716 }
717 }
718
719 @Override
720 public Map<K, Collection<V>> asMap() {
721 synchronized (mutex) {
722 if (asMap == null) {
723 asMap = new SynchronizedAsMap<>(delegate().asMap(), mutex);
724 }
725 return asMap;
726 }
727 }
728
729 @Override
730 public Multiset<K> keys() {
731 synchronized (mutex) {
732 if (keys == null) {
733 keys = multiset(delegate().keys(), mutex);
734 }
735 return keys;
736 }
737 }
738
739 @Override
740 public boolean equals(Object o) {
741 if (o == this) {
742 return true;
743 }
744 synchronized (mutex) {
745 return delegate().equals(o);
746 }
747 }
748
749 @Override
750 public int hashCode() {
751 synchronized (mutex) {
752 return delegate().hashCode();
753 }
754 }
755
756 private static final long serialVersionUID = 0;
757 }
758
759 static <K, V> ListMultimap<K, V> listMultimap(
760 ListMultimap<K, V> multimap, @Nullable Object mutex) {
761 if (multimap instanceof SynchronizedListMultimap || multimap instanceof BaseImmutableMultimap) {
762 return multimap;
763 }
764 return new SynchronizedListMultimap<>(multimap, mutex);
765 }
766
767 private static class SynchronizedListMultimap<K, V> extends SynchronizedMultimap<K, V>
768 implements ListMultimap<K, V> {
769 SynchronizedListMultimap(ListMultimap<K, V> delegate, @Nullable Object mutex) {
770 super(delegate, mutex);
771 }
772
773 @Override
774 ListMultimap<K, V> delegate() {
775 return (ListMultimap<K, V>) super.delegate();
776 }
777
778 @Override
779 public List<V> get(K key) {
780 synchronized (mutex) {
781 return list(delegate().get(key), mutex);
782 }
783 }
784
785 @Override
786 public List<V> removeAll(Object key) {
787 synchronized (mutex) {
788 return delegate().removeAll(key); // copy not synchronized
789 }
790 }
791
792 @Override
793 public List<V> replaceValues(K key, Iterable<? extends V> values) {
794 synchronized (mutex) {
795 return delegate().replaceValues(key, values); // copy not synchronized
796 }
797 }
798
799 private static final long serialVersionUID = 0;
800 }
801
802 static <K, V> SetMultimap<K, V> setMultimap(SetMultimap<K, V> multimap, @Nullable Object mutex) {
803 if (multimap instanceof SynchronizedSetMultimap || multimap instanceof BaseImmutableMultimap) {
804 return multimap;
805 }
806 return new SynchronizedSetMultimap<>(multimap, mutex);
807 }
808
809 private static class SynchronizedSetMultimap<K, V> extends SynchronizedMultimap<K, V>
810 implements SetMultimap<K, V> {
811 transient @Nullable Set<Entry<K, V>> entrySet;
812
813 SynchronizedSetMultimap(SetMultimap<K, V> delegate, @Nullable Object mutex) {
814 super(delegate, mutex);
815 }
816
817 @Override
818 SetMultimap<K, V> delegate() {
819 return (SetMultimap<K, V>) super.delegate();
820 }
821
822 @Override
823 public Set<V> get(K key) {
824 synchronized (mutex) {
825 return set(delegate().get(key), mutex);
826 }
827 }
828
829 @Override
830 public Set<V> removeAll(Object key) {
831 synchronized (mutex) {
832 return delegate().removeAll(key); // copy not synchronized
833 }
834 }
835
836 @Override
837 public Set<V> replaceValues(K key, Iterable<? extends V> values) {
838 synchronized (mutex) {
839 return delegate().replaceValues(key, values); // copy not synchronized
840 }
841 }
842
843 @Override
844 public Set<Entry<K, V>> entries() {
845 synchronized (mutex) {
846 if (entrySet == null) {
847 entrySet = set(delegate().entries(), mutex);
848 }
849 return entrySet;
850 }
851 }
852
853 private static final long serialVersionUID = 0;
854 }
855
856 static <K, V> SortedSetMultimap<K, V> sortedSetMultimap(
857 SortedSetMultimap<K, V> multimap, @Nullable Object mutex) {
858 if (multimap instanceof SynchronizedSortedSetMultimap) {
859 return multimap;
860 }
861 return new SynchronizedSortedSetMultimap<>(multimap, mutex);
862 }
863
864 private static class SynchronizedSortedSetMultimap<K, V> extends SynchronizedSetMultimap<K, V>
865 implements SortedSetMultimap<K, V> {
866 SynchronizedSortedSetMultimap(SortedSetMultimap<K, V> delegate, @Nullable Object mutex) {
867 super(delegate, mutex);
868 }
869
870 @Override
871 SortedSetMultimap<K, V> delegate() {
872 return (SortedSetMultimap<K, V>) super.delegate();
873 }
874
875 @Override
876 public SortedSet<V> get(K key) {
877 synchronized (mutex) {
878 return sortedSet(delegate().get(key), mutex);
879 }
880 }
881
882 @Override
883 public SortedSet<V> removeAll(Object key) {
884 synchronized (mutex) {
885 return delegate().removeAll(key); // copy not synchronized
886 }
887 }
888
889 @Override
890 public SortedSet<V> replaceValues(K key, Iterable<? extends V> values) {
891 synchronized (mutex) {
892 return delegate().replaceValues(key, values); // copy not synchronized
893 }
894 }
895
896 @Override
897 public Comparator<? super V> valueComparator() {
898 synchronized (mutex) {
899 return delegate().valueComparator();
900 }
901 }
902
903 private static final long serialVersionUID = 0;
904 }
905
906 private static <E> Collection<E> typePreservingCollection(
907 Collection<E> collection, @Nullable Object mutex) {
908 if (collection instanceof SortedSet) {
909 return sortedSet((SortedSet<E>) collection, mutex);
910 }
911 if (collection instanceof Set) {
912 return set((Set<E>) collection, mutex);
913 }
914 if (collection instanceof List) {
915 return list((List<E>) collection, mutex);
916 }
917 return collection(collection, mutex);
918 }
919
920 private static <E> Set<E> typePreservingSet(Set<E> set, @Nullable Object mutex) {
921 if (set instanceof SortedSet) {
922 return sortedSet((SortedSet<E>) set, mutex);
923 } else {
924 return set(set, mutex);
925 }
926 }
927
928 private static class SynchronizedAsMapEntries<K, V>
929 extends SynchronizedSet<Entry<K, Collection<V>>> {
930 SynchronizedAsMapEntries(Set<Entry<K, Collection<V>>> delegate, @Nullable Object mutex) {
931 super(delegate, mutex);
932 }
933
934 @Override
935 public Iterator<Entry<K, Collection<V>>> iterator() {
936 // Must be manually synchronized.
937 return new TransformedIterator<Entry<K, Collection<V>>, Entry<K, Collection<V>>>(
938 super.iterator()) {
939 @Override
940 Entry<K, Collection<V>> transform(final Entry<K, Collection<V>> entry) {
941 return new ForwardingMapEntry<K, Collection<V>>() {
942 @Override
943 protected Entry<K, Collection<V>> delegate() {
944 return entry;
945 }
946
947 @Override
948 public Collection<V> getValue() {
949 return typePreservingCollection(entry.getValue(), mutex);
950 }
951 };
952 }
953 };
954 }
955
956 // See Collections.CheckedMap.CheckedEntrySet for details on attacks.
957
958 @Override
959 public Object[] toArray() {
960 synchronized (mutex) {
961 return ObjectArrays.toArrayImpl(delegate());
962 }
963 }
964
965 @Override
966 public <T> T[] toArray(T[] array) {
967 synchronized (mutex) {
968 return ObjectArrays.toArrayImpl(delegate(), array);
969 }
970 }
971
972 @Override
973 public boolean contains(Object o) {
974 synchronized (mutex) {
975 return Maps.containsEntryImpl(delegate(), o);
976 }
977 }
978
979 @Override
980 public boolean containsAll(Collection<?> c) {
981 synchronized (mutex) {
982 return Collections2.containsAllImpl(delegate(), c);
983 }
984 }
985
986 @Override
987 public boolean equals(Object o) {
988 if (o == this) {
989 return true;
990 }
991 synchronized (mutex) {
992 return Sets.equalsImpl(delegate(), o);
993 }
994 }
995
996 @Override
997 public boolean remove(Object o) {
998 synchronized (mutex) {
999 return Maps.removeEntryImpl(delegate(), o);
1000 }
1001 }
1002
1003 @Override
1004 public boolean removeAll(Collection<?> c) {
1005 synchronized (mutex) {
1006 return Iterators.removeAll(delegate().iterator(), c);
1007 }
1008 }
1009
1010 @Override
1011 public boolean retainAll(Collection<?> c) {
1012 synchronized (mutex) {
1013 return Iterators.retainAll(delegate().iterator(), c);
1014 }
1015 }
1016
1017 private static final long serialVersionUID = 0;
1018 }
1019
1020 @VisibleForTesting
1021 static <K, V> Map<K, V> map(Map<K, V> map, @Nullable Object mutex) {
1022 return new SynchronizedMap<>(map, mutex);
1023 }
1024
1025 private static class SynchronizedMap<K, V> extends SynchronizedObject implements Map<K, V> {
1026 transient @Nullable Set<K> keySet;
1027 transient @Nullable Collection<V> values;
1028 transient @Nullable Set<Entry<K, V>> entrySet;
1029
1030 SynchronizedMap(Map<K, V> delegate, @Nullable Object mutex) {
1031 super(delegate, mutex);
1032 }
1033
1034 @SuppressWarnings("unchecked")
1035 @Override
1036 Map<K, V> delegate() {
1037 return (Map<K, V>) super.delegate();
1038 }
1039
1040 @Override
1041 public void clear() {
1042 synchronized (mutex) {
1043 delegate().clear();
1044 }
1045 }
1046
1047 @Override
1048 public boolean containsKey(Object key) {
1049 synchronized (mutex) {
1050 return delegate().containsKey(key);
1051 }
1052 }
1053
1054 @Override
1055 public boolean containsValue(Object value) {
1056 synchronized (mutex) {
1057 return delegate().containsValue(value);
1058 }
1059 }
1060
1061 @Override
1062 public Set<Entry<K, V>> entrySet() {
1063 synchronized (mutex) {
1064 if (entrySet == null) {
1065 entrySet = set(delegate().entrySet(), mutex);
1066 }
1067 return entrySet;
1068 }
1069 }
1070
1071 @Override
1072 public void forEach(BiConsumer<? super K, ? super V> action) {
1073 synchronized (mutex) {
1074 delegate().forEach(action);
1075 }
1076 }
1077
1078 @Override
1079 public V get(Object key) {
1080 synchronized (mutex) {
1081 return delegate().get(key);
1082 }
1083 }
1084
1085 @Override
1086 public V getOrDefault(Object key, V defaultValue) {
1087 synchronized (mutex) {
1088 return delegate().getOrDefault(key, defaultValue);
1089 }
1090 }
1091
1092 @Override
1093 public boolean isEmpty() {
1094 synchronized (mutex) {
1095 return delegate().isEmpty();
1096 }
1097 }
1098
1099 @Override
1100 public Set<K> keySet() {
1101 synchronized (mutex) {
1102 if (keySet == null) {
1103 keySet = set(delegate().keySet(), mutex);
1104 }
1105 return keySet;
1106 }
1107 }
1108
1109 @Override
1110 public V put(K key, V value) {
1111 synchronized (mutex) {
1112 return delegate().put(key, value);
1113 }
1114 }
1115
1116 @Override
1117 public V putIfAbsent(K key, V value) {
1118 synchronized (mutex) {
1119 return delegate().putIfAbsent(key, value);
1120 }
1121 }
1122
1123 @Override
1124 public boolean replace(K key, V oldValue, V newValue) {
1125 synchronized (mutex) {
1126 return delegate().replace(key, oldValue, newValue);
1127 }
1128 }
1129
1130 @Override
1131 public V replace(K key, V value) {
1132 synchronized (mutex) {
1133 return delegate().replace(key, value);
1134 }
1135 }
1136
1137 @Override
1138 public V computeIfAbsent(K key, Function<? super K, ? extends V> mappingFunction) {
1139 synchronized (mutex) {
1140 return delegate().computeIfAbsent(key, mappingFunction);
1141 }
1142 }
1143
1144 @Override
1145 public V computeIfPresent(
1146 K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
1147 synchronized (mutex) {
1148 return delegate().computeIfPresent(key, remappingFunction);
1149 }
1150 }
1151
1152 @Override
1153 public V compute(K key, BiFunction<? super K, ? super V, ? extends V> remappingFunction) {
1154 synchronized (mutex) {
1155 return delegate().compute(key, remappingFunction);
1156 }
1157 }
1158
1159 @Override
1160 public V merge(
1161 K key, V value, BiFunction<? super V, ? super V, ? extends V> remappingFunction) {
1162 synchronized (mutex) {
1163 return delegate().merge(key, value, remappingFunction);
1164 }
1165 }
1166
1167 @Override
1168 public void putAll(Map<? extends K, ? extends V> map) {
1169 synchronized (mutex) {
1170 delegate().putAll(map);
1171 }
1172 }
1173
1174 @Override
1175 public void replaceAll(BiFunction<? super K, ? super V, ? extends V> function) {
1176 synchronized (mutex) {
1177 delegate().replaceAll(function);
1178 }
1179 }
1180
1181 @Override
1182 public V remove(Object key) {
1183 synchronized (mutex) {
1184 return delegate().remove(key);
1185 }
1186 }
1187
1188 @Override
1189 public boolean remove(Object key, Object value) {
1190 synchronized (mutex) {
1191 return delegate().remove(key, value);
1192 }
1193 }
1194
1195 @Override
1196 public int size() {
1197 synchronized (mutex) {
1198 return delegate().size();
1199 }
1200 }
1201
1202 @Override
1203 public Collection<V> values() {
1204 synchronized (mutex) {
1205 if (values == null) {
1206 values = collection(delegate().values(), mutex);
1207 }
1208 return values;
1209 }
1210 }
1211
1212 @Override
1213 public boolean equals(Object o) {
1214 if (o == this) {
1215 return true;
1216 }
1217 synchronized (mutex) {
1218 return delegate().equals(o);
1219 }
1220 }
1221
1222 @Override
1223 public int hashCode() {
1224 synchronized (mutex) {
1225 return delegate().hashCode();
1226 }
1227 }
1228
1229 private static final long serialVersionUID = 0;
1230 }
1231
1232 static <K, V> SortedMap<K, V> sortedMap(SortedMap<K, V> sortedMap, @Nullable Object mutex) {
1233 return new SynchronizedSortedMap<>(sortedMap, mutex);
1234 }
1235
1236 static class SynchronizedSortedMap<K, V> extends SynchronizedMap<K, V>
1237 implements SortedMap<K, V> {
1238
1239 SynchronizedSortedMap(SortedMap<K, V> delegate, @Nullable Object mutex) {
1240 super(delegate, mutex);
1241 }
1242
1243 @Override
1244 SortedMap<K, V> delegate() {
1245 return (SortedMap<K, V>) super.delegate();
1246 }
1247
1248 @Override
1249 public Comparator<? super K> comparator() {
1250 synchronized (mutex) {
1251 return delegate().comparator();
1252 }
1253 }
1254
1255 @Override
1256 public K firstKey() {
1257 synchronized (mutex) {
1258 return delegate().firstKey();
1259 }
1260 }
1261
1262 @Override
1263 public SortedMap<K, V> headMap(K toKey) {
1264 synchronized (mutex) {
1265 return sortedMap(delegate().headMap(toKey), mutex);
1266 }
1267 }
1268
1269 @Override
1270 public K lastKey() {
1271 synchronized (mutex) {
1272 return delegate().lastKey();
1273 }
1274 }
1275
1276 @Override
1277 public SortedMap<K, V> subMap(K fromKey, K toKey) {
1278 synchronized (mutex) {
1279 return sortedMap(delegate().subMap(fromKey, toKey), mutex);
1280 }
1281 }
1282
1283 @Override
1284 public SortedMap<K, V> tailMap(K fromKey) {
1285 synchronized (mutex) {
1286 return sortedMap(delegate().tailMap(fromKey), mutex);
1287 }
1288 }
1289
1290 private static final long serialVersionUID = 0;
1291 }
1292
1293 static <K, V> BiMap<K, V> biMap(BiMap<K, V> bimap, @Nullable Object mutex) {
1294 if (bimap instanceof SynchronizedBiMap || bimap instanceof ImmutableBiMap) {
1295 return bimap;
1296 }
1297 return new SynchronizedBiMap<>(bimap, mutex, null);
1298 }
1299
1300 @VisibleForTesting
1301 static class SynchronizedBiMap<K, V> extends SynchronizedMap<K, V>
1302 implements BiMap<K, V>, Serializable {
1303 private transient @Nullable Set<V> valueSet;
1304 @RetainedWith private transient @Nullable BiMap<V, K> inverse;
1305
1306 private SynchronizedBiMap(
1307 BiMap<K, V> delegate, @Nullable Object mutex, @Nullable BiMap<V, K> inverse) {
1308 super(delegate, mutex);
1309 this.inverse = inverse;
1310 }
1311
1312 @Override
1313 BiMap<K, V> delegate() {
1314 return (BiMap<K, V>) super.delegate();
1315 }
1316
1317 @Override
1318 public Set<V> values() {
1319 synchronized (mutex) {
1320 if (valueSet == null) {
1321 valueSet = set(delegate().values(), mutex);
1322 }
1323 return valueSet;
1324 }
1325 }
1326
1327 @Override
1328 public V forcePut(K key, V value) {
1329 synchronized (mutex) {
1330 return delegate().forcePut(key, value);
1331 }
1332 }
1333
1334 @Override
1335 public BiMap<V, K> inverse() {
1336 synchronized (mutex) {
1337 if (inverse == null) {
1338 inverse = new SynchronizedBiMap<>(delegate().inverse(), mutex, this);
1339 }
1340 return inverse;
1341 }
1342 }
1343
1344 private static final long serialVersionUID = 0;
1345 }
1346
1347 private static class SynchronizedAsMap<K, V> extends SynchronizedMap<K, Collection<V>> {
1348 transient @Nullable Set<Entry<K, Collection<V>>> asMapEntrySet;
1349 transient @Nullable Collection<Collection<V>> asMapValues;
1350
1351 SynchronizedAsMap(Map<K, Collection<V>> delegate, @Nullable Object mutex) {
1352 super(delegate, mutex);
1353 }
1354
1355 @Override
1356 public Collection<V> get(Object key) {
1357 synchronized (mutex) {
1358 Collection<V> collection = super.get(key);
1359 return (collection == null) ? null : typePreservingCollection(collection, mutex);
1360 }
1361 }
1362
1363 @Override
1364 public Set<Entry<K, Collection<V>>> entrySet() {
1365 synchronized (mutex) {
1366 if (asMapEntrySet == null) {
1367 asMapEntrySet = new SynchronizedAsMapEntries<>(delegate().entrySet(), mutex);
1368 }
1369 return asMapEntrySet;
1370 }
1371 }
1372
1373 @Override
1374 public Collection<Collection<V>> values() {
1375 synchronized (mutex) {
1376 if (asMapValues == null) {
1377 asMapValues = new SynchronizedAsMapValues<V>(delegate().values(), mutex);
1378 }
1379 return asMapValues;
1380 }
1381 }
1382
1383 @Override
1384 public boolean containsValue(Object o) {
1385 // values() and its contains() method are both synchronized.
1386 return values().contains(o);
1387 }
1388
1389 private static final long serialVersionUID = 0;
1390 }
1391
1392 private static class SynchronizedAsMapValues<V> extends SynchronizedCollection<Collection<V>> {
1393 SynchronizedAsMapValues(Collection<Collection<V>> delegate, @Nullable Object mutex) {
1394 super(delegate, mutex);
1395 }
1396
1397 @Override
1398 public Iterator<Collection<V>> iterator() {
1399 // Must be manually synchronized.
1400 return new TransformedIterator<Collection<V>, Collection<V>>(super.iterator()) {
1401 @Override
1402 Collection<V> transform(Collection<V> from) {
1403 return typePreservingCollection(from, mutex);
1404 }
1405 };
1406 }
1407
1408 private static final long serialVersionUID = 0;
1409 }
1410
1411 @GwtIncompatible // NavigableSet
1412 @VisibleForTesting
1413 static class SynchronizedNavigableSet<E> extends SynchronizedSortedSet<E>
1414 implements NavigableSet<E> {
1415 SynchronizedNavigableSet(NavigableSet<E> delegate, @Nullable Object mutex) {
1416 super(delegate, mutex);
1417 }
1418
1419 @Override
1420 NavigableSet<E> delegate() {
1421 return (NavigableSet<E>) super.delegate();
1422 }
1423
1424 @Override
1425 public E ceiling(E e) {
1426 synchronized (mutex) {
1427 return delegate().ceiling(e);
1428 }
1429 }
1430
1431 @Override
1432 public Iterator<E> descendingIterator() {
1433 return delegate().descendingIterator(); // manually synchronized
1434 }
1435
1436 transient @Nullable NavigableSet<E> descendingSet;
1437
1438 @Override
1439 public NavigableSet<E> descendingSet() {
1440 synchronized (mutex) {
1441 if (descendingSet == null) {
1442 NavigableSet<E> dS = Synchronized.navigableSet(delegate().descendingSet(), mutex);
1443 descendingSet = dS;
1444 return dS;
1445 }
1446 return descendingSet;
1447 }
1448 }
1449
1450 @Override
1451 public E floor(E e) {
1452 synchronized (mutex) {
1453 return delegate().floor(e);
1454 }
1455 }
1456
1457 @Override
1458 public NavigableSet<E> headSet(E toElement, boolean inclusive) {
1459 synchronized (mutex) {
1460 return Synchronized.navigableSet(delegate().headSet(toElement, inclusive), mutex);
1461 }
1462 }
1463
1464 @Override
1465 public SortedSet<E> headSet(E toElement) {
1466 return headSet(toElement, false);
1467 }
1468
1469 @Override
1470 public E higher(E e) {
1471 synchronized (mutex) {
1472 return delegate().higher(e);
1473 }
1474 }
1475
1476 @Override
1477 public E lower(E e) {
1478 synchronized (mutex) {
1479 return delegate().lower(e);
1480 }
1481 }
1482
1483 @Override
1484 public E pollFirst() {
1485 synchronized (mutex) {
1486 return delegate().pollFirst();
1487 }
1488 }
1489
1490 @Override
1491 public E pollLast() {
1492 synchronized (mutex) {
1493 return delegate().pollLast();
1494 }
1495 }
1496
1497 @Override
1498 public NavigableSet<E> subSet(
1499 E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) {
1500 synchronized (mutex) {
1501 return Synchronized.navigableSet(
1502 delegate().subSet(fromElement, fromInclusive, toElement, toInclusive), mutex);
1503 }
1504 }
1505
1506 @Override
1507 public SortedSet<E> subSet(E fromElement, E toElement) {
1508 return subSet(fromElement, true, toElement, false);
1509 }
1510
1511 @Override
1512 public NavigableSet<E> tailSet(E fromElement, boolean inclusive) {
1513 synchronized (mutex) {
1514 return Synchronized.navigableSet(delegate().tailSet(fromElement, inclusive), mutex);
1515 }
1516 }
1517
1518 @Override
1519 public SortedSet<E> tailSet(E fromElement) {
1520 return tailSet(fromElement, true);
1521 }
1522
1523 private static final long serialVersionUID = 0;
1524 }
1525
1526 @GwtIncompatible // NavigableSet
1527 static <E> NavigableSet<E> navigableSet(NavigableSet<E> navigableSet, @Nullable Object mutex) {
1528 return new SynchronizedNavigableSet<E>(navigableSet, mutex);
1529 }
1530
1531 @GwtIncompatible // NavigableSet
1532 static <E> NavigableSet<E> navigableSet(NavigableSet<E> navigableSet) {
1533 return navigableSet(navigableSet, null);
1534 }
1535
1536 @GwtIncompatible // NavigableMap
1537 static <K, V> NavigableMap<K, V> navigableMap(NavigableMap<K, V> navigableMap) {
1538 return navigableMap(navigableMap, null);
1539 }
1540
1541 @GwtIncompatible // NavigableMap
1542 static <K, V> NavigableMap<K, V> navigableMap(
1543 NavigableMap<K, V> navigableMap, @Nullable Object mutex) {
1544 return new SynchronizedNavigableMap<>(navigableMap, mutex);
1545 }
1546
1547 @GwtIncompatible // NavigableMap
1548 @VisibleForTesting
1549 static class SynchronizedNavigableMap<K, V> extends SynchronizedSortedMap<K, V>
1550 implements NavigableMap<K, V> {
1551
1552 SynchronizedNavigableMap(NavigableMap<K, V> delegate, @Nullable Object mutex) {
1553 super(delegate, mutex);
1554 }
1555
1556 @Override
1557 NavigableMap<K, V> delegate() {
1558 return (NavigableMap<K, V>) super.delegate();
1559 }
1560
1561 @Override
1562 public Entry<K, V> ceilingEntry(K key) {
1563 synchronized (mutex) {
1564 return nullableSynchronizedEntry(delegate().ceilingEntry(key), mutex);
1565 }
1566 }
1567
1568 @Override
1569 public K ceilingKey(K key) {
1570 synchronized (mutex) {
1571 return delegate().ceilingKey(key);
1572 }
1573 }
1574
1575 transient @Nullable NavigableSet<K> descendingKeySet;
1576
1577 @Override
1578 public NavigableSet<K> descendingKeySet() {
1579 synchronized (mutex) {
1580 if (descendingKeySet == null) {
1581 return descendingKeySet = Synchronized.navigableSet(delegate().descendingKeySet(), mutex);
1582 }
1583 return descendingKeySet;
1584 }
1585 }
1586
1587 transient @Nullable NavigableMap<K, V> descendingMap;
1588
1589 @Override
1590 public NavigableMap<K, V> descendingMap() {
1591 synchronized (mutex) {
1592 if (descendingMap == null) {
1593 return descendingMap = navigableMap(delegate().descendingMap(), mutex);
1594 }
1595 return descendingMap;
1596 }
1597 }
1598
1599 @Override
1600 public Entry<K, V> firstEntry() {
1601 synchronized (mutex) {
1602 return nullableSynchronizedEntry(delegate().firstEntry(), mutex);
1603 }
1604 }
1605
1606 @Override
1607 public Entry<K, V> floorEntry(K key) {
1608 synchronized (mutex) {
1609 return nullableSynchronizedEntry(delegate().floorEntry(key), mutex);
1610 }
1611 }
1612
1613 @Override
1614 public K floorKey(K key) {
1615 synchronized (mutex) {
1616 return delegate().floorKey(key);
1617 }
1618 }
1619
1620 @Override
1621 public NavigableMap<K, V> headMap(K toKey, boolean inclusive) {
1622 synchronized (mutex) {
1623 return navigableMap(delegate().headMap(toKey, inclusive), mutex);
1624 }
1625 }
1626
1627 @Override
1628 public SortedMap<K, V> headMap(K toKey) {
1629 return headMap(toKey, false);
1630 }
1631
1632 @Override
1633 public Entry<K, V> higherEntry(K key) {
1634 synchronized (mutex) {
1635 return nullableSynchronizedEntry(delegate().higherEntry(key), mutex);
1636 }
1637 }
1638
1639 @Override
1640 public K higherKey(K key) {
1641 synchronized (mutex) {
1642 return delegate().higherKey(key);
1643 }
1644 }
1645
1646 @Override
1647 public Entry<K, V> lastEntry() {
1648 synchronized (mutex) {
1649 return nullableSynchronizedEntry(delegate().lastEntry(), mutex);
1650 }
1651 }
1652
1653 @Override
1654 public Entry<K, V> lowerEntry(K key) {
1655 synchronized (mutex) {
1656 return nullableSynchronizedEntry(delegate().lowerEntry(key), mutex);
1657 }
1658 }
1659
1660 @Override
1661 public K lowerKey(K key) {
1662 synchronized (mutex) {
1663 return delegate().lowerKey(key);
1664 }
1665 }
1666
1667 @Override
1668 public Set<K> keySet() {
1669 return navigableKeySet();
1670 }
1671
1672 transient @Nullable NavigableSet<K> navigableKeySet;
1673
1674 @Override
1675 public NavigableSet<K> navigableKeySet() {
1676 synchronized (mutex) {
1677 if (navigableKeySet == null) {
1678 return navigableKeySet = Synchronized.navigableSet(delegate().navigableKeySet(), mutex);
1679 }
1680 return navigableKeySet;
1681 }
1682 }
1683
1684 @Override
1685 public Entry<K, V> pollFirstEntry() {
1686 synchronized (mutex) {
1687 return nullableSynchronizedEntry(delegate().pollFirstEntry(), mutex);
1688 }
1689 }
1690
1691 @Override
1692 public Entry<K, V> pollLastEntry() {
1693 synchronized (mutex) {
1694 return nullableSynchronizedEntry(delegate().pollLastEntry(), mutex);
1695 }
1696 }
1697
1698 @Override
1699 public NavigableMap<K, V> subMap(
1700 K fromKey, boolean fromInclusive, K toKey, boolean toInclusive) {
1701 synchronized (mutex) {
1702 return navigableMap(delegate().subMap(fromKey, fromInclusive, toKey, toInclusive), mutex);
1703 }
1704 }
1705
1706 @Override
1707 public SortedMap<K, V> subMap(K fromKey, K toKey) {
1708 return subMap(fromKey, true, toKey, false);
1709 }
1710
1711 @Override
1712 public NavigableMap<K, V> tailMap(K fromKey, boolean inclusive) {
1713 synchronized (mutex) {
1714 return navigableMap(delegate().tailMap(fromKey, inclusive), mutex);
1715 }
1716 }
1717
1718 @Override
1719 public SortedMap<K, V> tailMap(K fromKey) {
1720 return tailMap(fromKey, true);
1721 }
1722
1723 private static final long serialVersionUID = 0;
1724 }
1725
1726 @GwtIncompatible // works but is needed only for NavigableMap
1727 private static <K, V> Entry<K, V> nullableSynchronizedEntry(
1728 @Nullable Entry<K, V> entry, @Nullable Object mutex) {
1729 if (entry == null) {
1730 return null;
1731 }
1732 return new SynchronizedEntry<>(entry, mutex);
1733 }
1734
1735 @GwtIncompatible // works but is needed only for NavigableMap
1736 private static class SynchronizedEntry<K, V> extends SynchronizedObject implements Entry<K, V> {
1737
1738 SynchronizedEntry(Entry<K, V> delegate, @Nullable Object mutex) {
1739 super(delegate, mutex);
1740 }
1741
1742 @SuppressWarnings("unchecked") // guaranteed by the constructor
1743 @Override
1744 Entry<K, V> delegate() {
1745 return (Entry<K, V>) super.delegate();
1746 }
1747
1748 @Override
1749 public boolean equals(Object obj) {
1750 synchronized (mutex) {
1751 return delegate().equals(obj);
1752 }
1753 }
1754
1755 @Override
1756 public int hashCode() {
1757 synchronized (mutex) {
1758 return delegate().hashCode();
1759 }
1760 }
1761
1762 @Override
1763 public K getKey() {
1764 synchronized (mutex) {
1765 return delegate().getKey();
1766 }
1767 }
1768
1769 @Override
1770 public V getValue() {
1771 synchronized (mutex) {
1772 return delegate().getValue();
1773 }
1774 }
1775
1776 @Override
1777 public V setValue(V value) {
1778 synchronized (mutex) {
1779 return delegate().setValue(value);
1780 }
1781 }
1782
1783 private static final long serialVersionUID = 0;
1784 }
1785
1786 static <E> Queue<E> queue(Queue<E> queue, @Nullable Object mutex) {
1787 return (queue instanceof SynchronizedQueue) ? queue : new SynchronizedQueue<E>(queue, mutex);
1788 }
1789
1790 private static class SynchronizedQueue<E> extends SynchronizedCollection<E> implements Queue<E> {
1791
1792 SynchronizedQueue(Queue<E> delegate, @Nullable Object mutex) {
1793 super(delegate, mutex);
1794 }
1795
1796 @Override
1797 Queue<E> delegate() {
1798 return (Queue<E>) super.delegate();
1799 }
1800
1801 @Override
1802 public E element() {
1803 synchronized (mutex) {
1804 return delegate().element();
1805 }
1806 }
1807
1808 @Override
1809 public boolean offer(E e) {
1810 synchronized (mutex) {
1811 return delegate().offer(e);
1812 }
1813 }
1814
1815 @Override
1816 public E peek() {
1817 synchronized (mutex) {
1818 return delegate().peek();
1819 }
1820 }
1821
1822 @Override
1823 public E poll() {
1824 synchronized (mutex) {
1825 return delegate().poll();
1826 }
1827 }
1828
1829 @Override
1830 public E remove() {
1831 synchronized (mutex) {
1832 return delegate().remove();
1833 }
1834 }
1835
1836 private static final long serialVersionUID = 0;
1837 }
1838
1839 static <E> Deque<E> deque(Deque<E> deque, @Nullable Object mutex) {
1840 return new SynchronizedDeque<E>(deque, mutex);
1841 }
1842
1843 private static final class SynchronizedDeque<E> extends SynchronizedQueue<E> implements Deque<E> {
1844
1845 SynchronizedDeque(Deque<E> delegate, @Nullable Object mutex) {
1846 super(delegate, mutex);
1847 }
1848
1849 @Override
1850 Deque<E> delegate() {
1851 return (Deque<E>) super.delegate();
1852 }
1853
1854 @Override
1855 public void addFirst(E e) {
1856 synchronized (mutex) {
1857 delegate().addFirst(e);
1858 }
1859 }
1860
1861 @Override
1862 public void addLast(E e) {
1863 synchronized (mutex) {
1864 delegate().addLast(e);
1865 }
1866 }
1867
1868 @Override
1869 public boolean offerFirst(E e) {
1870 synchronized (mutex) {
1871 return delegate().offerFirst(e);
1872 }
1873 }
1874
1875 @Override
1876 public boolean offerLast(E e) {
1877 synchronized (mutex) {
1878 return delegate().offerLast(e);
1879 }
1880 }
1881
1882 @Override
1883 public E removeFirst() {
1884 synchronized (mutex) {
1885 return delegate().removeFirst();
1886 }
1887 }
1888
1889 @Override
1890 public E removeLast() {
1891 synchronized (mutex) {
1892 return delegate().removeLast();
1893 }
1894 }
1895
1896 @Override
1897 public E pollFirst() {
1898 synchronized (mutex) {
1899 return delegate().pollFirst();
1900 }
1901 }
1902
1903 @Override
1904 public E pollLast() {
1905 synchronized (mutex) {
1906 return delegate().pollLast();
1907 }
1908 }
1909
1910 @Override
1911 public E getFirst() {
1912 synchronized (mutex) {
1913 return delegate().getFirst();
1914 }
1915 }
1916
1917 @Override
1918 public E getLast() {
1919 synchronized (mutex) {
1920 return delegate().getLast();
1921 }
1922 }
1923
1924 @Override
1925 public E peekFirst() {
1926 synchronized (mutex) {
1927 return delegate().peekFirst();
1928 }
1929 }
1930
1931 @Override
1932 public E peekLast() {
1933 synchronized (mutex) {
1934 return delegate().peekLast();
1935 }
1936 }
1937
1938 @Override
1939 public boolean removeFirstOccurrence(Object o) {
1940 synchronized (mutex) {
1941 return delegate().removeFirstOccurrence(o);
1942 }
1943 }
1944
1945 @Override
1946 public boolean removeLastOccurrence(Object o) {
1947 synchronized (mutex) {
1948 return delegate().removeLastOccurrence(o);
1949 }
1950 }
1951
1952 @Override
1953 public void push(E e) {
1954 synchronized (mutex) {
1955 delegate().push(e);
1956 }
1957 }
1958
1959 @Override
1960 public E pop() {
1961 synchronized (mutex) {
1962 return delegate().pop();
1963 }
1964 }
1965
1966 @Override
1967 public Iterator<E> descendingIterator() {
1968 synchronized (mutex) {
1969 return delegate().descendingIterator();
1970 }
1971 }
1972
1973 private static final long serialVersionUID = 0;
1974 }
1975
1976 static <R, C, V> Table<R, C, V> table(Table<R, C, V> table, Object mutex) {
1977 return new SynchronizedTable<>(table, mutex);
1978 }
1979
1980 private static final class SynchronizedTable<R, C, V> extends SynchronizedObject
1981 implements Table<R, C, V> {
1982
1983 SynchronizedTable(Table<R, C, V> delegate, Object mutex) {
1984 super(delegate, mutex);
1985 }
1986
1987 @SuppressWarnings("unchecked")
1988 @Override
1989 Table<R, C, V> delegate() {
1990 return (Table<R, C, V>) super.delegate();
1991 }
1992
1993 @Override
1994 public boolean contains(@Nullable Object rowKey, @Nullable Object columnKey) {
1995 synchronized (mutex) {
1996 return delegate().contains(rowKey, columnKey);
1997 }
1998 }
1999
2000 @Override
2001 public boolean containsRow(@Nullable Object rowKey) {
2002 synchronized (mutex) {
2003 return delegate().containsRow(rowKey);
2004 }
2005 }
2006
2007 @Override
2008 public boolean containsColumn(@Nullable Object columnKey) {
2009 synchronized (mutex) {
2010 return delegate().containsColumn(columnKey);
2011 }
2012 }
2013
2014 @Override
2015 public boolean containsValue(@Nullable Object value) {
2016 synchronized (mutex) {
2017 return delegate().containsValue(value);
2018 }
2019 }
2020
2021 @Override
2022 public V get(@Nullable Object rowKey, @Nullable Object columnKey) {
2023 synchronized (mutex) {
2024 return delegate().get(rowKey, columnKey);
2025 }
2026 }
2027
2028 @Override
2029 public boolean isEmpty() {
2030 synchronized (mutex) {
2031 return delegate().isEmpty();
2032 }
2033 }
2034
2035 @Override
2036 public int size() {
2037 synchronized (mutex) {
2038 return delegate().size();
2039 }
2040 }
2041
2042 @Override
2043 public void clear() {
2044 synchronized (mutex) {
2045 delegate().clear();
2046 }
2047 }
2048
2049 @Override
2050 public V put(@Nullable R rowKey, @Nullable C columnKey, @Nullable V value) {
2051 synchronized (mutex) {
2052 return delegate().put(rowKey, columnKey, value);
2053 }
2054 }
2055
2056 @Override
2057 public void putAll(Table<? extends R, ? extends C, ? extends V> table) {
2058 synchronized (mutex) {
2059 delegate().putAll(table);
2060 }
2061 }
2062
2063 @Override
2064 public V remove(@Nullable Object rowKey, @Nullable Object columnKey) {
2065 synchronized (mutex) {
2066 return delegate().remove(rowKey, columnKey);
2067 }
2068 }
2069
2070 @Override
2071 public Map<C, V> row(@Nullable R rowKey) {
2072 synchronized (mutex) {
2073 return map(delegate().row(rowKey), mutex);
2074 }
2075 }
2076
2077 @Override
2078 public Map<R, V> column(@Nullable C columnKey) {
2079 synchronized (mutex) {
2080 return map(delegate().column(columnKey), mutex);
2081 }
2082 }
2083
2084 @Override
2085 public Set<Cell<R, C, V>> cellSet() {
2086 synchronized (mutex) {
2087 return set(delegate().cellSet(), mutex);
2088 }
2089 }
2090
2091 @Override
2092 public Set<R> rowKeySet() {
2093 synchronized (mutex) {
2094 return set(delegate().rowKeySet(), mutex);
2095 }
2096 }
2097
2098 @Override
2099 public Set<C> columnKeySet() {
2100 synchronized (mutex) {
2101 return set(delegate().columnKeySet(), mutex);
2102 }
2103 }
2104
2105 @Override
2106 public Collection<V> values() {
2107 synchronized (mutex) {
2108 return collection(delegate().values(), mutex);
2109 }
2110 }
2111
2112 @Override
2113 public Map<R, Map<C, V>> rowMap() {
2114 synchronized (mutex) {
2115 return map(
2116 Maps.transformValues(
2117 delegate().rowMap(),
2118 new com.google.common.base.Function<Map<C, V>, Map<C, V>>() {
2119 @Override
2120 public Map<C, V> apply(Map<C, V> t) {
2121 return map(t, mutex);
2122 }
2123 }),
2124 mutex);
2125 }
2126 }
2127
2128 @Override
2129 public Map<C, Map<R, V>> columnMap() {
2130 synchronized (mutex) {
2131 return map(
2132 Maps.transformValues(
2133 delegate().columnMap(),
2134 new com.google.common.base.Function<Map<R, V>, Map<R, V>>() {
2135 @Override
2136 public Map<R, V> apply(Map<R, V> t) {
2137 return map(t, mutex);
2138 }
2139 }),
2140 mutex);
2141 }
2142 }
2143
2144 @Override
2145 public int hashCode() {
2146 synchronized (mutex) {
2147 return delegate().hashCode();
2148 }
2149 }
2150
2151 @Override
2152 public boolean equals(@Nullable Object obj) {
2153 if (this == obj) {
2154 return true;
2155 }
2156 synchronized (mutex) {
2157 return delegate().equals(obj);
2158 }
2159 }
2160 }
2161 }