fabric.common.util

Class LongKeyCache<V>

java.lang.Object

fabric.common.util.LongKeyCache<V>

public class LongKeyCache<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 ConcurrentLongKeyMap does not support them.

Constructor Summary

Constructors

Constructor and Description
LongKeyCache()

Method Summary

Modifier and Type	Method and Description
void	clear()
boolean	containsKey(long key)
V	get(long key)
LongSet	keySet()
V	put(long key, V value)
V	putIfAbsent(long key, V value) If the specified key is not already associated with a value, associate it with the given value.
V	remove(long key)
boolean	remove(long key, V value) Removes the entry for a key only if currently mapped to a given value.
V	replace(long key, V value) Replaces the entry for a key only if currently mapped to some value.
boolean	replace(long 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

LongKeyCache

public LongKeyCache()

Method Detail

clear

public void clear()

containsKey

public boolean containsKey(long key)

keySet

public LongSet keySet()

get

public V get(long key)

put

public V put(long key,
             V value)

putIfAbsent

public V putIfAbsent(long 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 cache.put(key, value); else return cache.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(long 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(long 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(long key)

remove

public boolean remove(long 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.