com.google.common.collect
Class ForwardingConcurrentMap<K,V>

java.lang.Object
  extended by com.google.common.collect.ForwardingObject
      extended by com.google.common.collect.ForwardingMap<K,V>
          extended by com.google.common.collect.ForwardingConcurrentMap<K,V>
All Implemented Interfaces:
ConcurrentMap<K,V>, Map<K,V>

@GwtCompatible
public abstract class ForwardingConcurrentMap<K,V>
extends ForwardingMap<K,V>
implements ConcurrentMap<K,V>

A concurrent map which forwards all its method calls to another concurrent map. Subclasses should override one or more methods to modify the behavior of the backing map as desired per the decorator pattern.

Since:
2 (imported from Google Collections Library)
Author:
Charles Fry

Nested Class Summary
 
Nested classes/interfaces inherited from interface java.util.Map
Map.Entry<K,V>
 
Constructor Summary
protected ForwardingConcurrentMap()
          Constructor for use by subclasses.
 
Method Summary
protected abstract  ConcurrentMap<K,V> delegate()
          Returns the backing delegate instance that methods are forwarded to.
 V putIfAbsent(K key, V value)
          If the specified key is not already associated with a value, associate it with the given value.
 boolean remove(Object key, Object 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 com.google.common.collect.ForwardingMap
clear, containsKey, containsValue, entrySet, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, standardClear, standardContainsKey, standardContainsValue, standardEntrySet, standardEquals, standardHashCode, standardIsEmpty, standardKeySet, standardPutAll, standardRemove, standardToString, standardValues, values
 
Methods inherited from class com.google.common.collect.ForwardingObject
toString
 
Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait
 
Methods inherited from interface java.util.Map
clear, containsKey, containsValue, entrySet, equals, get, hashCode, isEmpty, keySet, put, putAll, remove, size, values
 

Constructor Detail

ForwardingConcurrentMap

protected ForwardingConcurrentMap()
Constructor for use by subclasses.

Method Detail

delegate

protected abstract ConcurrentMap<K,V> delegate()
Description copied from class: ForwardingObject
Returns the backing delegate instance that methods are forwarded to. Abstract subclasses generally override this method with an abstract method that has a more specific return type, such as ForwardingSet.delegate(). Concrete subclasses override this method to supply the instance being decorated.

Specified by:
delegate in class ForwardingMap<K,V>

putIfAbsent

public V putIfAbsent(K key,
                     V value)
Description copied from interface: java.util.concurrent.ConcurrentMap
If the specified key is not already associated with a value, associate it with the given value. This is equivalent to
   if (!map.containsKey(key))
       return map.put(key, value);
   else
       return map.get(key);
except that the action is performed atomically.

Specified by:
putIfAbsent in interface ConcurrentMap<K,V>
Parameters:
key - key with which the specified value is to be 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. (A null return can also indicate that the map previously associated null with the key, if the implementation supports null values.)

remove

public boolean remove(Object key,
                      Object value)
Description copied from interface: java.util.concurrent.ConcurrentMap
Removes the entry for a key only if currently mapped to a given value. This is equivalent to
   if (map.containsKey(key) && map.get(key).equals(value)) {
       map.remove(key);
       return true;
   } else return false;
except that the action is performed atomically.

Specified by:
remove in interface ConcurrentMap<K,V>
Parameters:
key - key with which the specified value is associated
value - value expected to be associated with the specified key
Returns:
true if the value was removed

replace

public V replace(K key,
                 V value)
Description copied from interface: java.util.concurrent.ConcurrentMap
Replaces the entry for a key only if currently mapped to some value. This is equivalent to
   if (map.containsKey(key)) {
       return map.put(key, value);
   } else return null;
except that the action is performed atomically.

Specified by:
replace in interface ConcurrentMap<K,V>
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. (A null return can also indicate that the map previously associated null with the key, if the implementation supports null values.)

replace

public boolean replace(K key,
                       V oldValue,
                       V newValue)
Description copied from interface: java.util.concurrent.ConcurrentMap
Replaces the entry for a key only if currently mapped to a given value. This is equivalent to
   if (map.containsKey(key) && map.get(key).equals(oldValue)) {
       map.put(key, newValue);
       return true;
   } else return false;
except that the action is performed atomically.

Specified by:
replace in interface ConcurrentMap<K,V>
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 if the value was replaced