Package org.apache.xbean.propertyeditor

Class ReferenceIdentityMap

java.lang.Object
org.apache.xbean.propertyeditor.ReferenceIdentityMap
All Implemented Interfaces:
Map
public class ReferenceIdentityMap extends Object implements Map
Streamlined version of a WeakIdentityHashMap. Provides Identity semantics with Weak References to keys. This allows proxies to be GC'ed when no longer referenced by clients. BasicProxymanager.destroyProxy() need not be invoked when a proxy is no longer needed. Note that this is not a full Map implementation. The iteration and collection capabilities of Map have been discarded to keep the implementation lightweight.

Much of this code was cribbed from the Commons Collection 3.1 implementation of ReferenceIdentityMap and AbstractReferenceMap.

  • Field Details

    • DEFAULT_CAPACITY

      private static final int DEFAULT_CAPACITY
      The default capacity to use. Always use a power of 2!!!
      See Also:

    • DEFAULT_LOAD_FACTOR

      private static final float DEFAULT_LOAD_FACTOR
      The default load factor to use
      See Also:

    • MAXIMUM_CAPACITY

      private static final int MAXIMUM_CAPACITY
      The maximum capacity allowed
      See Also:

    • loadFactor

      private float loadFactor
      Load factor, normally 0.75

    • size

      private transient int size
      The size of the map

    • data

      private transient ReferenceIdentityMap.ReferenceEntry[] data
      Map entries

    • threshold

      private transient int threshold
      Size at which to rehash

    • purgeQueue

      private ReferenceQueue purgeQueue
      ReferenceQueue used to eliminate GC'ed entries.

  • Constructor Details

    • ReferenceIdentityMap

      public ReferenceIdentityMap()

  • Method Details

    • size

      public int size()
      Gets the size of the map.
      Specified by:
      size in interface Map
      Returns:
      the size

    • isEmpty

      public boolean isEmpty()
      Checks whether the map is currently empty.
      Specified by:
      isEmpty in interface Map
      Returns:
      true if the map is currently size zero

    • containsKey

      public boolean containsKey(Object key)
      Checks whether the map contains the specified key.
      Specified by:
      containsKey in interface Map
      Parameters:
      key - the key to search for
      Returns:
      true if the map contains the key

    • containsValue

      public boolean containsValue(Object value)
      Checks whether the map contains the specified value.
      Specified by:
      containsValue in interface Map
      Parameters:
      value - the value to search for
      Returns:
      true if the map contains the value

    • get

      public Object get(Object key)
      Gets the value mapped to the key specified.
      Specified by:
      get in interface Map
      Parameters:
      key - the key
      Returns:
      the mapped value, null if no match

    • put

      public Object put(Object key, Object value)
      Puts a key-value entry into this map. Neither the key nor the value may be null.
      Specified by:
      put in interface Map
      Parameters:
      key - the key to add, must not be null
      value - the value to add, must not be null
      Returns:
      the value previously mapped to this key, null if none

    • remove

      public Object remove(Object key)
      Removes the specified mapping from this map.
      Specified by:
      remove in interface Map
      Parameters:
      key - the mapping to remove
      Returns:
      the value mapped to the removed key, null if key not in map

    • clear

      public void clear()
      Clears the map, resetting the size to zero and nullifying references to avoid garbage collection issues.
      Specified by:
      clear in interface Map

    • values

      public Collection values()
      Specified by:
      values in interface Map

    • putAll

      public void putAll(Map t)
      Specified by:
      putAll in interface Map

    • entrySet

      public Set entrySet()
      Specified by:
      entrySet in interface Map

    • keySet

      public Set keySet()
      Specified by:
      keySet in interface Map

    • getEntry

      private ReferenceIdentityMap.ReferenceEntry getEntry(Object key)
      Gets the entry mapped to the key specified.
      Parameters:
      key - the key
      Returns:
      the entry, null if no match

    • createEntry

      private ReferenceIdentityMap.ReferenceEntry createEntry(int index, int hashCode, Object key, Object value)
      Creates a new ReferenceEntry.
      Parameters:
      index - the index into the data map
      hashCode - the hash code for the new entry
      key - the key to store
      value - the value to store
      Returns:
      the newly created entry

    • removeEntry

      private void removeEntry(ReferenceIdentityMap.ReferenceEntry entry, int hashIndex, ReferenceIdentityMap.ReferenceEntry previous)
      Removes an entry from the chain stored in a particular index.

      This implementation removes the entry from the data storage table. The size is not updated.

      Parameters:
      entry - the entry to remove
      hashIndex - the index into the data structure
      previous - the previous entry in the chain

    • checkCapacity

      private void checkCapacity()
      Checks the capacity of the map and enlarges it if necessary.

      This implementation uses the threshold to check if the map needs enlarging

    • ensureCapacity

      private void ensureCapacity(int newCapacity)
      Changes the size of the data structure to the capacity proposed.
      Parameters:
      newCapacity - the new capacity of the array (a power of two, less or equal to max)

    • calculateThreshold

      private int calculateThreshold(int newCapacity, float factor)
      Calculates the new threshold of the map, where it will be resized. This implementation uses the load factor.
      Parameters:
      newCapacity - the new capacity
      factor - the load factor
      Returns:
      the new resize threshold

    • hash

      private int hash(Object key)
      Gets the hash code for the key specified.

      This implementation uses the identity hash code.

      Parameters:
      key - the key to get a hash code for
      Returns:
      the hash code

    • hashIndex

      private int hashIndex(int hashCode, int dataSize)
      Gets the index into the data storage for the hashCode specified. This implementation uses the least significant bits of the hashCode.
      Parameters:
      hashCode - the hash code to use
      dataSize - the size of the data to pick a bucket from
      Returns:
      the bucket index

    • purge

      private void purge()
      Purges stale mappings from this map.

      Note that this method is not synchronized! Special care must be taken if, for instance, you want stale mappings to be removed on a periodic basis by some background thread.

    • purge

      private void purge(Reference purgedEntry)
      Purges the specified reference.
      Parameters:
      purgedEntry - the reference to purge