Lines Matching full:delegate
58 private final Object delegate;
61 public SynchronizedObject(Object delegate, @Nullable Object mutex) {
62 this.delegate = checkNotNull(delegate);
66 protected Object delegate() {
67 return delegate;
74 return delegate.toString();
125 Collection<E> delegate, @Nullable Object mutex) {
126 super(delegate, mutex);
130 @Override protected Collection<E> delegate() {
131 return (Collection<E>) super.delegate();
136 return delegate().add(e);
142 return delegate().addAll(c);
148 delegate().clear();
154 return delegate().contains(o);
160 return delegate().containsAll(c);
166 return delegate().isEmpty();
171 return delegate().iterator(); // manually synchronized
176 return delegate().remove(o);
182 return delegate().removeAll(c);
188 return delegate().retainAll(c);
194 return delegate().size();
200 return delegate().toArray();
206 return delegate().toArray(a);
243 public SynchronizedSet(Set<E> delegate, @Nullable Object mutex) {
244 super(delegate, mutex);
247 @Override protected Set<E> delegate() {
248 return (Set<E>) super.delegate();
256 return delegate().equals(o);
262 return delegate().hashCode();
301 SortedSet<E> delegate, @Nullable Object mutex) {
302 super(delegate, mutex);
305 @Override protected SortedSet<E> delegate() {
306 return (SortedSet<E>) super.delegate();
311 return delegate().comparator();
317 return sortedSet(delegate().subSet(fromElement, toElement), mutex);
323 return sortedSet(delegate().headSet(toElement), mutex);
329 return sortedSet(delegate().tailSet(fromElement), mutex);
335 return delegate().first();
341 return delegate().last();
383 public SynchronizedList(List<E> delegate, @Nullable Object mutex) {
384 super(delegate, mutex);
387 @Override protected List<E> delegate() {
388 return (List<E>) super.delegate();
393 delegate().add(index, element);
399 return delegate().addAll(index, c);
405 return delegate().get(index);
411 return delegate().indexOf(o);
417 return delegate().lastIndexOf(o);
422 return delegate().listIterator(); // manually synchronized
426 return delegate().listIterator(index); // manually synchronized
431 return delegate().remove(index);
437 return delegate().set(index, element);
444 return list(Platform.subList(delegate(), fromIndex, toIndex), mutex);
453 return delegate().equals(o);
459 return delegate().hashCode();
510 public SynchronizedMultiset(Multiset<E> delegate, @Nullable Object mutex) {
511 super(delegate, mutex);
514 @Override protected Multiset<E> delegate() {
515 return (Multiset<E>) super.delegate();
520 return delegate().count(o);
526 return delegate().add(e, n);
532 return delegate().remove(o, n);
538 return delegate().setCount(element, count);
544 return delegate().setCount(element, oldCount, newCount);
551 elementSet = typePreservingSet(delegate().elementSet(), mutex);
560 entrySet = typePreservingSet(delegate().entrySet(), mutex);
571 return delegate().equals(o);
577 return delegate().hashCode();
626 @Override protected Multimap<K, V> delegate() {
627 return (Multimap<K, V>) super.delegate();
630 SynchronizedMultimap(Multimap<K, V> delegate, @Nullable Object mutex) {
631 super(delegate, mutex);
636 return delegate().size();
642 return delegate().isEmpty();
648 return delegate().containsKey(key);
654 return delegate().containsValue(value);
660 return delegate().containsEntry(key, value);
666 return typePreservingCollection(delegate().get(key), mutex);
672 return delegate().put(key, value);
678 return delegate().putAll(key, values);
684 return delegate().putAll(multimap);
690 return delegate().replaceValues(key, values); // copy not synchronized
696 return delegate().remove(key, value);
702 return delegate().removeAll(key); // copy not synchronized
708 delegate().clear();
715 keySet = typePreservingSet(delegate().keySet(), mutex);
724 valuesCollection = collection(delegate().values(), mutex);
733 entries = typePreservingCollection(delegate().entries(), mutex);
742 asMap = new SynchronizedAsMap<K, V>(delegate().asMap(), mutex);
751 keys = multiset(delegate().keys(), mutex);
762 return delegate().equals(o);
768 return delegate().hashCode();
793 ListMultimap<K, V> delegate, @Nullable Object mutex) {
794 super(delegate, mutex);
796 @Override protected ListMultimap<K, V> delegate() {
797 return (ListMultimap<K, V>) super.delegate();
801 return list(delegate().get(key), mutex);
806 return delegate().removeAll(key); // copy not synchronized
812 return delegate().replaceValues(key, values); // copy not synchronized
837 SetMultimap<K, V> delegate, @Nullable Object mutex) {
838 super(delegate, mutex);
840 @Override protected SetMultimap<K, V> delegate() {
841 return (SetMultimap<K, V>) super.delegate();
845 return set(delegate().get(key), mutex);
850 return delegate().removeAll(key); // copy not synchronized
856 return delegate().replaceValues(key, values); // copy not synchronized
862 entrySet = set(delegate().entries(), mutex);
888 SortedSetMultimap<K, V> delegate, @Nullable Object mutex) {
889 super(delegate, mutex);
891 @Override protected SortedSetMultimap<K, V> delegate() {
892 return (SortedSetMultimap<K, V>) super.delegate();
896 return sortedSet(delegate().get(key), mutex);
901 return delegate().removeAll(key); // copy not synchronized
907 return delegate().replaceValues(key, values); // copy not synchronized
912 return delegate().valueComparator();
999 Set<Map.Entry<K, Collection<V>>> delegate, @Nullable Object mutex) {
1000 super(delegate, mutex);
1007 @Override protected Iterator<Map.Entry<K, Collection<V>>> delegate() {
1014 @Override protected Map.Entry<K, Collection<V>> delegate() {
1029 return ObjectArrays.toArrayImpl(delegate());
1034 return ObjectArrays.toArrayImpl(delegate(), array);
1039 return Maps.containsEntryImpl(delegate(), o);
1044 return Collections2.containsAll(delegate(), c);
1052 return Collections2.setEquals(delegate(), o);
1057 return Maps.removeEntryImpl(delegate(), o);
1062 return Iterators.removeAll(delegate().iterator(), c);
1067 return Iterators.retainAll(delegate().iterator(), c);
1112 public SynchronizedMap(Map<K, V> delegate, @Nullable Object mutex) {
1113 super(delegate, mutex);
1117 @Override protected Map<K, V> delegate() {
1118 return (Map<K, V>) super.delegate();
1123 delegate().clear();
1129 return delegate().containsKey(key);
1135 return delegate().containsValue(value);
1142 entrySet = set(delegate().entrySet(), mutex);
1150 return delegate().get(key);
1156 return delegate().isEmpty();
1163 keySet = set(delegate().keySet(), mutex);
1171 return delegate().put(key, value);
1177 delegate().putAll(map);
1183 return delegate().remove(key);
1189 return delegate().size();
1196 values = collection(delegate().values(), mutex);
1207 return delegate().equals(o);
1213 return delegate().hashCode();
1259 BiMap<K, V> delegate, @Nullable Object mutex,
1261 super(delegate, mutex);
1265 @Override protected BiMap<K, V> delegate() {
1266 return (BiMap<K, V>) super.delegate();
1272 valueSet = set(delegate().values(), mutex);
1280 return delegate().forcePut(key, value);
1288 = new SynchronizedBiMap<V, K>(delegate().inverse(), mutex, this);
1304 Map<K, Collection<V>> delegate, @Nullable Object mutex) {
1305 super(delegate, mutex);
1320 delegate().entrySet(), mutex);
1330 = new SynchronizedAsMapValues<V>(delegate().values(), mutex);
1348 Collection<Collection<V>> delegate, @Nullable Object mutex) {
1349 super(delegate, mutex);
1356 @Override protected Iterator<Collection<V>> delegate() {
