| /* |
| * Copyright (c) 2005, 2008, Oracle and/or its affiliates. All rights reserved. |
| * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER. |
| * |
| * This code is free software; you can redistribute it and/or modify it |
| * under the terms of the GNU General Public License version 2 only, as |
| * published by the Free Software Foundation. Oracle designates this |
| * particular file as subject to the "Classpath" exception as provided |
| * by Oracle in the LICENSE file that accompanied this code. |
| * |
| * This code is distributed in the hope that it will be useful, but WITHOUT |
| * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or |
| * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License |
| * version 2 for more details (a copy is included in the LICENSE file that |
| * accompanied this code). |
| * |
| * You should have received a copy of the GNU General Public License version |
| * 2 along with this work; if not, write to the Free Software Foundation, |
| * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA. |
| * |
| * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA |
| * or visit www.oracle.com if you need additional information or have any |
| * questions. |
| */ |
| |
| package com.sun.jmx.mbeanserver; |
| |
| import static com.sun.jmx.mbeanserver.Util.*; |
| |
| import java.lang.ref.Reference; |
| import java.lang.ref.ReferenceQueue; |
| import java.lang.ref.WeakReference; |
| |
| import java.util.Map; |
| |
| |
| /** |
| * <p>A map where keys are compared using identity comparison (like |
| * IdentityHashMap) but where the presence of an object as a key in |
| * the map does not prevent it being garbage collected (like |
| * WeakHashMap). This class does not implement the Map interface |
| * because it is difficult to ensure correct semantics for iterators |
| * over the entrySet().</p> |
| * |
| * <p>Because we do not implement Map, we do not copy the questionable |
| * interface where you can call get(k) or remove(k) for any type of k, |
| * which of course can only have an effect if k is of type K.</p> |
| * |
| * <p>This map does not support null keys.</p> |
| */ |
| /* |
| * The approach |
| * is to wrap each key in a WeakReference and use the wrapped value as |
| * a key in an ordinary HashMap. The WeakReference has to be a |
| * subclass IdentityWeakReference (IWR) where two IWRs are equal if |
| * they refer to the same object. This enables us to find the entry |
| * again. |
| */ |
| class WeakIdentityHashMap<K, V> { |
| private WeakIdentityHashMap() {} |
| |
| static <K, V> WeakIdentityHashMap<K, V> make() { |
| return new WeakIdentityHashMap<K, V>(); |
| } |
| |
| V get(K key) { |
| expunge(); |
| WeakReference<K> keyref = makeReference(key); |
| return map.get(keyref); |
| } |
| |
| public V put(K key, V value) { |
| expunge(); |
| if (key == null) |
| throw new IllegalArgumentException("Null key"); |
| WeakReference<K> keyref = makeReference(key, refQueue); |
| return map.put(keyref, value); |
| } |
| |
| public V remove(K key) { |
| expunge(); |
| WeakReference<K> keyref = makeReference(key); |
| return map.remove(keyref); |
| } |
| |
| private void expunge() { |
| Reference<? extends K> ref; |
| while ((ref = refQueue.poll()) != null) |
| map.remove(ref); |
| } |
| |
| private WeakReference<K> makeReference(K referent) { |
| return new IdentityWeakReference<K>(referent); |
| } |
| |
| private WeakReference<K> makeReference(K referent, ReferenceQueue<K> q) { |
| return new IdentityWeakReference<K>(referent, q); |
| } |
| |
| /** |
| * WeakReference where equals and hashCode are based on the |
| * referent. More precisely, two objects are equal if they are |
| * identical or if they both have the same non-null referent. The |
| * hashCode is the value the original referent had. Even if the |
| * referent is cleared, the hashCode remains. Thus, objects of |
| * this class can be used as keys in hash-based maps and sets. |
| */ |
| private static class IdentityWeakReference<T> extends WeakReference<T> { |
| IdentityWeakReference(T o) { |
| this(o, null); |
| } |
| |
| IdentityWeakReference(T o, ReferenceQueue<T> q) { |
| super(o, q); |
| this.hashCode = (o == null) ? 0 : System.identityHashCode(o); |
| } |
| |
| public boolean equals(Object o) { |
| if (this == o) |
| return true; |
| if (!(o instanceof IdentityWeakReference<?>)) |
| return false; |
| IdentityWeakReference<?> wr = (IdentityWeakReference<?>) o; |
| Object got = get(); |
| return (got != null && got == wr.get()); |
| } |
| |
| public int hashCode() { |
| return hashCode; |
| } |
| |
| private final int hashCode; |
| } |
| |
| private Map<WeakReference<K>, V> map = newMap(); |
| private ReferenceQueue<K> refQueue = new ReferenceQueue<K>(); |
| } |