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 public class LazyInitializedCacheMap<K, V> implements Map<K, V> {
44 private ConcurrentMap<K, LazyInitializer<V>> cache;
45
46
47
48
49
50 public class NoopInitializer extends LazyInitializer<V> {
51 private V value;
52
53 public NoopInitializer(V value) {
54 this.value = value;
55 }
56
57 public V init() {
58 return value;
59 }
60 }
61
62
63
64
65
66 public LazyInitializedCacheMap() {
67 this.cache = new ConcurrentHashMap<K, LazyInitializer<V>>();
68 }
69
70
71
72
73
74 public LazyInitializedCacheMap(final ConcurrentHashMap<K, LazyInitializer<V>> map) {
75 this.cache = map;
76 }
77
78
79
80
81 public V get(Object key) {
82 LazyInitializer<V> c = cache.get(key);
83 if (c != null) {
84 return c.get();
85 }
86
87 return null;
88 }
89
90
91
92
93 public V remove(Object key) {
94 LazyInitializer<V> c = cache.remove(key);
95 if (c != null) {
96 return c.get();
97 }
98
99 return null;
100 }
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120 public V putIfAbsent(K key, LazyInitializer<V> value) {
121 LazyInitializer<V> v = cache.get(key);
122 if (v == null) {
123 v = cache.putIfAbsent(key, value);
124 if (v == null) {
125 return value.get();
126 }
127 }
128
129 return v.get();
130 }
131
132
133
134
135 public V put(K key, V value) {
136 LazyInitializer<V> c = cache.put(key, new NoopInitializer(value));
137 if (c != null) {
138 return c.get();
139 }
140
141 return null;
142 }
143
144
145
146
147
148 public boolean containsValue(Object value) {
149 throw new UnsupportedOperationException();
150 }
151
152
153
154
155
156 public Collection<V> values() {
157 throw new UnsupportedOperationException();
158 }
159
160
161
162
163
164 public Set<java.util.Map.Entry<K, V>> entrySet() {
165 throw new UnsupportedOperationException();
166 }
167
168
169
170
171 public void putAll(Map<? extends K, ? extends V> m) {
172 for (Map.Entry<? extends K, ? extends V> e : m.entrySet()) {
173 cache.put(e.getKey(), new NoopInitializer(e.getValue()));
174 }
175 }
176
177
178
179
180 public Collection<LazyInitializer<V>> getValues() {
181 return cache.values();
182 }
183
184
185
186
187 public void clear() {
188 cache.clear();
189 }
190
191
192
193
194 public boolean containsKey(Object key) {
195 return cache.containsKey(key);
196 }
197
198
199
200
201 public boolean isEmpty() {
202 return cache.isEmpty();
203 }
204
205
206
207
208 public Set<K> keySet() {
209 return cache.keySet();
210 }
211
212
213
214
215 public int size() {
216 return cache.size();
217 }
218 }