1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21 package org.efaps.util.cache;
22
23 import java.util.AbstractMap;
24 import java.util.Collections;
25 import java.util.HashSet;
26 import java.util.Map;
27 import java.util.Set;
28 import java.util.concurrent.TimeUnit;
29
30 import org.infinispan.AdvancedCache;
31 import org.infinispan.Cache;
32 import org.infinispan.commons.util.CloseableIterator;
33 import org.infinispan.commons.util.CloseableIteratorCollection;
34 import org.infinispan.commons.util.CloseableIteratorSet;
35 import org.infinispan.commons.util.concurrent.NotifyingFuture;
36 import org.infinispan.configuration.cache.Configuration;
37 import org.infinispan.filter.KeyFilter;
38 import org.infinispan.lifecycle.ComponentStatus;
39 import org.infinispan.manager.EmbeddedCacheManager;
40 import org.infinispan.notifications.cachelistener.filter.CacheEventConverter;
41 import org.infinispan.notifications.cachelistener.filter.CacheEventFilter;
42
43
44
45
46
47
48
49
50
51
52 public class NoOpCache<K, V>
53 extends AbstractMap<K, V>
54 implements Cache<K, V>
55 {
56
57 @Override
58 public V put(final K _key,
59 final V _value)
60 {
61 return _value;
62 }
63
64 @Override
65 public NotifyingFuture<V> putAsync(final K _key,
66 final V _value)
67 {
68 return null;
69 }
70
71 @Override
72 public NotifyingFuture<V> putAsync(final K _key,
73 final V _value,
74 final long _lifespan,
75 final TimeUnit _unit)
76 {
77 return null;
78 }
79
80 @Override
81 public NotifyingFuture<V> putAsync(final K _key,
82 final V _value,
83 final long _lifespan,
84 final TimeUnit _lifespanUnit,
85 final long _maxIdle,
86 final TimeUnit _maxIdleUnit)
87 {
88 return null;
89 }
90
91 @Override
92 public NotifyingFuture<Void> putAllAsync(final Map<? extends K, ? extends V> _data)
93 {
94 return null;
95 }
96
97 @Override
98 public NotifyingFuture<Void> putAllAsync(final Map<? extends K, ? extends V> _data,
99 final long _lifespan,
100 final TimeUnit _unit)
101 {
102 return null;
103 }
104
105 @Override
106 public NotifyingFuture<Void> putAllAsync(final Map<? extends K, ? extends V> _data,
107 final long _lifespan,
108 final TimeUnit _lifespanUnit,
109 final long _maxIdle,
110 final TimeUnit _maxIdleUnit)
111 {
112 return null;
113 }
114
115 @Override
116 public NotifyingFuture<Void> clearAsync()
117 {
118 return null;
119 }
120
121 @Override
122 public NotifyingFuture<V> putIfAbsentAsync(final K _key,
123 final V _value)
124 {
125 return null;
126 }
127
128 @Override
129 public NotifyingFuture<V> putIfAbsentAsync(final K _key,
130 final V _value,
131 final long _lifespan,
132 final TimeUnit _unit)
133 {
134 return null;
135 }
136
137 @Override
138 public NotifyingFuture<V> putIfAbsentAsync(final K _key,
139 final V _value,
140 final long _lifespan,
141 final TimeUnit _lifespanUnit,
142 final long _maxIdle,
143 final TimeUnit _maxIdleUnit)
144 {
145 return null;
146 }
147
148 @Override
149 public NotifyingFuture<V> removeAsync(final Object _key)
150 {
151 return null;
152 }
153
154 @Override
155 public NotifyingFuture<Boolean> removeAsync(final Object _key,
156 final Object _value)
157 {
158 return null;
159 }
160
161 @Override
162 public NotifyingFuture<V> replaceAsync(final K _key,
163 final V _value)
164 {
165 return null;
166 }
167
168 @Override
169 public NotifyingFuture<V> replaceAsync(final K _key,
170 final V _value,
171 final long _lifespan,
172 final TimeUnit _unit)
173 {
174 return null;
175 }
176
177 @Override
178 public NotifyingFuture<V> replaceAsync(final K _key,
179 final V _value,
180 final long _lifespan,
181 final TimeUnit _lifespanUnit,
182 final long _maxIdle,
183 final TimeUnit _maxIdleUnit)
184 {
185 return null;
186 }
187
188 @Override
189 public NotifyingFuture<Boolean> replaceAsync(final K _key,
190 final V _oldValue,
191 final V _newValue)
192 {
193 return null;
194 }
195
196 @Override
197 public NotifyingFuture<Boolean> replaceAsync(final K _key,
198 final V _oldValue,
199 final V _newValue,
200 final long _lifespan,
201 final TimeUnit _unit)
202 {
203 return null;
204 }
205
206 @Override
207 public NotifyingFuture<Boolean> replaceAsync(final K _key,
208 final V _oldValue,
209 final V _newValue,
210 final long _lifespan,
211 final TimeUnit _lifespanUnit,
212 final long _maxIdle,
213 final TimeUnit _maxIdleUnit)
214 {
215 return null;
216 }
217
218 @Override
219 public NotifyingFuture<V> getAsync(final K _key)
220 {
221 return null;
222 }
223
224 @Override
225 public String getName()
226 {
227 return null;
228 }
229
230 @Override
231 public String getVersion()
232 {
233 return null;
234 }
235
236 @Override
237 public V put(final K _key,
238 final V _value,
239 final long _lifespan,
240 final TimeUnit _unit)
241 {
242 return _value;
243 }
244
245 @Override
246 public V putIfAbsent(final K _key,
247 final V _value,
248 final long _lifespan,
249 final TimeUnit _unit)
250 {
251 return _value;
252 }
253
254 @Override
255 public void putAll(final Map<? extends K, ? extends V> _map,
256 final long _lifespan,
257 final TimeUnit _unit)
258 {
259
260 }
261
262 @Override
263 public V replace(final K _key,
264 final V _value,
265 final long _lifespan,
266 final TimeUnit _unit)
267 {
268 return _value;
269 }
270
271 @Override
272 public boolean replace(final K _key,
273 final V _oldValue,
274 final V _value,
275 final long _lifespan,
276 final TimeUnit _unit)
277 {
278 return false;
279 }
280
281 @Override
282 public V put(final K _key,
283 final V _value,
284 final long _lifespan,
285 final TimeUnit _lifespanUnit,
286 final long _maxIdleTime,
287 final TimeUnit _maxIdleTimeUnit)
288 {
289 return _value;
290 }
291
292 @Override
293 public V putIfAbsent(final K _key,
294 final V _value,
295 final long _lifespan,
296 final TimeUnit _lifespanUnit,
297 final long _maxIdleTime,
298 final TimeUnit _maxIdleTimeUnit)
299 {
300 return _value;
301 }
302
303 @Override
304 public void putAll(final Map<? extends K, ? extends V> _map,
305 final long _lifespan,
306 final TimeUnit _lifespanUnit,
307 final long _maxIdleTime,
308 final TimeUnit _maxIdleTimeUnit)
309 {
310
311 }
312
313 @Override
314 public V replace(final K _key,
315 final V _value,
316 final long _lifespan,
317 final TimeUnit _lifespanUnit,
318 final long _maxIdleTime,
319 final TimeUnit _maxIdleTimeUnit)
320 {
321 return _value;
322 }
323
324 @Override
325 public boolean replace(final K _key,
326 final V _oldValue,
327 final V _value,
328 final long _lifespan,
329 final TimeUnit _lifespanUnit,
330 final long _maxIdleTime,
331 final TimeUnit _maxIdleTimeUnit)
332 {
333 return false;
334 }
335
336 @Override
337 public V putIfAbsent(final K _key,
338 final V _value)
339 {
340 return _value;
341 }
342
343 @Override
344 public boolean remove(final Object _key,
345 final Object _value)
346 {
347 return false;
348 }
349
350 @Override
351 public boolean replace(final K _key,
352 final V _oldValue,
353 final V _newValue)
354 {
355 return false;
356 }
357
358 @Override
359 public V replace(final K _key,
360 final V _value)
361 {
362 return _value;
363 }
364
365 @Override
366 public void start()
367 {
368
369 }
370
371 @Override
372 public void stop()
373 {
374
375 }
376
377 @Override
378 public boolean startBatch()
379 {
380 return false;
381 }
382
383 @Override
384 public void endBatch(final boolean _successful)
385 {
386
387 }
388
389 @Override
390 public void addListener(final Object _listener,
391 final KeyFilter<? super K> _filter)
392 {
393
394 }
395
396 @Override
397 public void addListener(final Object _listener)
398 {
399
400 }
401
402 @Override
403 public void removeListener(final Object _listener)
404 {
405
406 }
407
408 @Override
409 public Set<Object> getListeners()
410 {
411 return Collections.<Object>emptySet();
412 }
413
414 @Override
415 public void putForExternalRead(final K _key,
416 final V _value)
417 {
418
419 }
420
421 @Override
422 public void evict(final K _key)
423 {
424
425 }
426
427 @Override
428 public Configuration getCacheConfiguration()
429 {
430 return null;
431 }
432
433 @Override
434 public EmbeddedCacheManager getCacheManager()
435 {
436 return null;
437 }
438
439 @Override
440 public AdvancedCache<K, V> getAdvancedCache()
441 {
442 return null;
443 }
444
445 @Override
446 public ComponentStatus getStatus()
447 {
448 return null;
449 }
450
451 @Override
452 public <C> void addListener(final Object _listener,
453 final CacheEventFilter<? super K, ? super V> _filter,
454 final CacheEventConverter<? super K, ? super V, C> _converter)
455 {
456
457
458 }
459
460 @Override
461 public void putForExternalRead(final K _key,
462 final V _value,
463 final long _lifespan,
464 final TimeUnit _unit)
465 {
466 }
467
468 @Override
469 public void putForExternalRead(final K _key,
470 final V _value,
471 final long _lifespan,
472 final TimeUnit _lifespanUnit,
473 final long _maxIdle,
474 final TimeUnit _maxIdleUnit)
475 {
476 }
477
478 @Override
479 public CloseableIteratorSet<K> keySet()
480 {
481 return new DummySet<K>();
482 }
483
484 @Override
485 public CloseableIteratorCollection<V> values()
486 {
487 return new DummySet<V>();
488 }
489
490 @Override
491 public CloseableIteratorSet<java.util.Map.Entry<K, V>> entrySet()
492 {
493 return new DummySet<java.util.Map.Entry<K, V>>();
494 }
495
496 public static class DummySet<E>
497 extends HashSet<E>
498 implements CloseableIteratorSet<E>
499 {
500
501
502
503
504 private static final long serialVersionUID = 1L;
505
506 @Override
507 public CloseableIterator<E> iterator()
508 {
509 return new DummyIterator<E>();
510 }
511 }
512
513 public static class DummyIterator<E>
514 implements CloseableIterator<E>
515 {
516
517 @Override
518 public boolean hasNext()
519 {
520 return false;
521 }
522
523 @Override
524 public E next()
525 {
526 return null;
527 }
528
529 @Override
530 public void remove()
531 {
532 }
533
534 @Override
535 public void close()
536 {
537 }
538
539 }
540 }