1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20 package org.apache.mina.util;
21
22 import java.util.Collection;
23 import java.util.Map;
24 import java.util.Set;
25 import java.util.concurrent.ConcurrentHashMap;
26 import java.util.concurrent.ConcurrentMap;
27
28 import org.apache.mina.core.buffer.IoBuffer;
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46 public class LazyInitializedCacheMap<K, V> implements Map<K, V> {
47 private ConcurrentMap<K, LazyInitializer<V>> cache;
48
49
50
51
52
53 public class NoopInitializer extends LazyInitializer<V> {
54 private V value;
55
56
57
58
59
60
61 public NoopInitializer(V value) {
62 this.value = value;
63 }
64
65
66
67
68 @Override
69 public V init() {
70 return value;
71 }
72 }
73
74
75
76
77
78 public LazyInitializedCacheMap() {
79 this.cache = new ConcurrentHashMap<>();
80 }
81
82
83
84
85
86
87
88 public LazyInitializedCacheMap(ConcurrentHashMap<K, LazyInitializer<V>> map) {
89 this.cache = map;
90 }
91
92
93
94
95 @Override
96 public V get(Object key) {
97 LazyInitializer<V> c = cache.get(key);
98
99 if (c != null) {
100 return c.get();
101 }
102
103 return null;
104 }
105
106
107
108
109 @Override
110 public V remove(Object key) {
111 LazyInitializer<V> c = cache.remove(key);
112
113 if (c != null) {
114 return c.get();
115 }
116
117 return null;
118 }
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137 public V putIfAbsent(K key, LazyInitializer<V> value) {
138 LazyInitializer<V> v = cache.get(key);
139
140 if (v == null) {
141 v = cache.putIfAbsent(key, value);
142
143 if (v == null) {
144 return value.get();
145 }
146 }
147
148 return v.get();
149 }
150
151
152
153
154 @Override
155 public V put(K key, V value) {
156 LazyInitializer<V> c = cache.put(key, new NoopInitializer(value));
157
158 if (c != null) {
159 return c.get();
160 }
161
162 return null;
163 }
164
165
166
167
168
169 @Override
170 public boolean containsValue(Object value) {
171 throw new UnsupportedOperationException();
172 }
173
174
175
176
177
178 @Override
179 public Collection<V> values() {
180 throw new UnsupportedOperationException();
181 }
182
183
184
185
186
187 @Override
188 public Set<java.util.Map.Entry<K, V>> entrySet() {
189 throw new UnsupportedOperationException();
190 }
191
192
193
194
195 @Override
196 public void putAll(Map<? extends K, ? extends V> m) {
197 for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
198 cache.put(e.getKey(), new NoopInitializer(e.getValue()));
199 }
200 }
201
202
203
204
205 public Collection<LazyInitializer<V>> getValues() {
206 return cache.values();
207 }
208
209
210
211
212 @Override
213 public void clear() {
214 cache.clear();
215 }
216
217
218
219
220 @Override
221 public boolean containsKey(Object key) {
222 return cache.containsKey(key);
223 }
224
225
226
227
228 @Override
229 public boolean isEmpty() {
230 return cache.isEmpty();
231 }
232
233
234
235
236 @Override
237 public Set<K> keySet() {
238 return cache.keySet();
239 }
240
241
242
243
244 @Override
245 public int size() {
246 return cache.size();
247 }
248 }