1 package annotations.util.coll; 2 3 import java.util.Collection; 4 import java.util.Map; 5 import java.util.Set; 6 7 /*>>> 8 import org.checkerframework.checker.nullness.qual.Nullable; 9 */ 10 11 /** 12 * A {@link WrapperMap} is a map all of whose methods delegate by default to 13 * those of a supplied {@linkplain #back backing map}. Subclasses can add or 14 * override methods. Compare to {@link java.io.FilterInputStream}. 15 */ 16 public class WrapperMap<K, V> implements Map<K, V> { 17 /** 18 * The backing map. 19 */ 20 protected final Map<K, V> back; 21 22 /** 23 * Constructs a new {@link WrapperMap} with the given backing map. 24 */ WrapperMap(Map<K, V> back)25 protected WrapperMap(Map<K, V> back) { 26 this.back = back; 27 } 28 29 /** 30 * {@inheritDoc} 31 */ 32 @Override clear()33 public void clear() { 34 back.clear(); 35 } 36 37 /** 38 * {@inheritDoc} 39 */ 40 @Override containsKey(Object key)41 public boolean containsKey(Object key) { 42 return back.containsKey(key); 43 } 44 45 /** 46 * {@inheritDoc} 47 */ 48 @Override containsValue(Object value)49 public boolean containsValue(Object value) { 50 return back.containsValue(value); 51 } 52 53 /** 54 * {@inheritDoc} 55 */ 56 @Override 57 public Set<java.util.Map.Entry<K, V>> entrySet()58 entrySet() { 59 return back.entrySet(); 60 } 61 62 /** 63 * {@inheritDoc} 64 */ 65 @Override get(Object key)66 public V get(Object key) { 67 return back.get(key); 68 } 69 70 /** 71 * {@inheritDoc} 72 */ 73 @Override isEmpty()74 public boolean isEmpty() { 75 return back.isEmpty(); 76 } 77 78 /** 79 * {@inheritDoc} 80 */ 81 @Override keySet()82 public Set<K> keySet() { 83 return back.keySet(); 84 } 85 86 /** 87 * {@inheritDoc} 88 */ 89 @Override put(K key, V value)90 public V put(K key, V value) { 91 return back.put(key, value); 92 } 93 94 /** 95 * {@inheritDoc} 96 */ 97 @Override putAll(Map<? extends K, ? extends V> m)98 public void putAll(Map<? extends K, ? extends V> m) { 99 back.putAll(m); 100 } 101 102 /** 103 * {@inheritDoc} 104 */ 105 @Override remove(Object key)106 public V remove(Object key) { 107 return back.remove(key); 108 } 109 110 /** 111 * {@inheritDoc} 112 */ 113 @Override size()114 public int size() { 115 return back.size(); 116 } 117 118 /** 119 * {@inheritDoc} 120 */ 121 @Override values()122 public Collection<V> values() { 123 return back.values(); 124 } 125 126 /** 127 * {@inheritDoc} 128 */ 129 @Override equals(Object o)130 public boolean equals(Object o) { 131 return back.equals(o); 132 } 133 134 /** 135 * {@inheritDoc} 136 */ 137 @Override hashCode()138 public int hashCode() { 139 return back.hashCode(); 140 } 141 } 142