fabric.common.util

Class Cache<K,V>

java.lang.Object

fabric.common.util.Cache<K,V>

public class Cache<K,V>
extends java.lang.Object

A map that has soft references to its values and supports concurrent accesses. When a value in the map is garbage collected by the JVM, its corresponding key is removed from the map. Null values are not supported because the underlying ConcurrentMap does not support them.

Constructor Summary

Constructors

Constructor and Description
Cache()

Method Summary

Modifier and Type	Method and Description
void	clear()
boolean	containsKey(K key)
V	get(K key)
java.util.Set<K>	keys() Returns a snapshot of the keys currently in the cache.
java.util.Set<K>	keySet()
V	put(K key, V value)
V	putIfAbsent(K key, V value) If the specified key is not already associated with a value, associate it with the given value.
V	remove(K key)
boolean	remove(K key, V value) Removes the entry for a key only if currently mapped to a given value.
V	replace(K key, V value) Replaces the entry for a key only if currently mapped to some value.
boolean	replace(K key, V oldValue, V newValue) Replaces the entry for a key only if currently mapped to a given value.

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Cache

public Cache()

Method Detail

clear

public void clear()

containsKey

public boolean containsKey(K key)

keySet

public java.util.Set<K> keySet()

get

public V get(K key)

put

public V put(K key,
             V value)

putIfAbsent

public V putIfAbsent(K key,
                     V value)

If the specified key is not already associated with a value, associate it with the given value. This is equivalent to if (!cache.containsKey(key)) return map.put(key, value); else return map.get(key); except that the action is performed atomically.

Returns:

the previous value associated with the specified key, or null if there was no mapping for the key.

replace

public V replace(K key,
                 V value)

Replaces the entry for a key only if currently mapped to some value. This is equivalent to if (cache.containsKey(key)) { return cache.put(key, value); } else return null; except that the action is performed atomically.

Parameters:

key - key with which the specified value is associated.

value - value to be associated with the specified key.

Returns:

the previous value associated with the specified key, or null if there was no mapping for the key.

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)

Replaces the entry for a key only if currently mapped to a given value. This is equivalent to if (cache.containsKey(key) && cache.get(key).equals(oldValue)) { cache.put(key, newValue); return true; } else return false; except that the action is performed atomically.

Parameters:

key - key with which the specified value is associated.

oldValue - value expected to be associated with the specified key.

newValue - value to be associated with the specified key.

Returns:

true iff the value was replaced.

remove

public V remove(K key)

remove

public boolean remove(K key,
                      V value)

Removes the entry for a key only if currently mapped to a given value. This is equivalent to if (cache.containsKey(key) && cache.get(key).equals(value)) { cache.remove(key); return true; } else return false; except that the action is performed atomically.

Parameters:

key - key with which the specified value is associated.

value - value expected to be associated with the specified key.

Returns:

true iff the value was removed.

keys

public java.util.Set<K> keys()

Returns a snapshot of the keys currently in the cache. This set is NOT backed by the underlying map. If new keys are inserted or removed from the cache, they will not be reflected by the set returned. However, no synchronization is needed for working with the set.