Package com.google.common.collect

Class 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.

    default method warning: This class forwards calls to only some default methods. Specifically, it forwards calls only for methods that existed before default methods were introduced. For newer methods, like forEach, it inherits their default implementations. When those implementations invoke methods, they invoke methods on the ForwardingConcurrentMap.

    Since:
    2.0
    Author:
    Charles Fry

    • 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

        @CanIgnoreReturnValue
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, associates it with the given value. This is equivalent to, for this map: 
         
 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>
        Specified by:
        putIfAbsent in interface Map<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

        @CanIgnoreReturnValue
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, for this map: 
         
 if (map.containsKey(key)
     && Objects.equals(map.get(key), value)) {
   map.remove(key);
   return true;
 } else {
   return false;
 }
        except that the action is performed atomically.
        Specified by:
        remove in interface ConcurrentMap<K,V>
        Specified by:
        remove in interface Map<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

        @CanIgnoreReturnValue
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, for this map: 
         
 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>
        Specified by:
        replace in interface Map<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

        @CanIgnoreReturnValue
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, for this map: 
         
 if (map.containsKey(key)
     && Objects.equals(map.get(key), 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>
        Specified by:
        replace in interface Map<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