All Downloads are FREE. Search and download functionalities are using the official Maven repository.

com.sun.jdo.spi.persistence.utility.WeakValueHashMap Maven / Gradle / Ivy

There is a newer version: 4.1.2.181
Show newest version
/*
 * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
 *
 * Copyright (c) 1997-2012 Oracle and/or its affiliates. All rights reserved.
 *
 * The contents of this file are subject to the terms of either the GNU
 * General Public License Version 2 only ("GPL") or the Common Development
 * and Distribution License("CDDL") (collectively, the "License").  You
 * may not use this file except in compliance with the License.  You can
 * obtain a copy of the License at
 * https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
 * or packager/legal/LICENSE.txt.  See the License for the specific
 * language governing permissions and limitations under the License.
 *
 * When distributing the software, include this License Header Notice in each
 * file and include the License file at packager/legal/LICENSE.txt.
 *
 * GPL Classpath Exception:
 * Oracle designates this particular file as subject to the "Classpath"
 * exception as provided by Oracle in the GPL Version 2 section of the License
 * file that accompanied this code.
 *
 * Modifications:
 * If applicable, add the following below the License Header, with the fields
 * enclosed by brackets [] replaced by your own identifying information:
 * "Portions Copyright [year] [name of copyright owner]"
 *
 * Contributor(s):
 * If you wish your version of this file to be governed by only the CDDL or
 * only the GPL Version 2, indicate your decision by adding "[Contributor]
 * elects to include this software in this distribution under the [CDDL or GPL
 * Version 2] license."  If you don't indicate a single choice of license, a
 * recipient has the option to distribute your version of this file under
 * either the CDDL, the GPL Version 2 or to extend the choice of license to
 * its licensees as provided above.  However, if you add GPL Version 2 code
 * and therefore, elected the GPL Version 2 license, then the option applies
 * only if the new code is made subject to such option by the copyright
 * holder.
 */

package com.sun.jdo.spi.persistence.utility;

import java.lang.ref.ReferenceQueue;
import java.lang.ref.WeakReference;

import java.util.AbstractCollection;
import java.util.AbstractSet;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.NoSuchElementException;
import java.util.Set;

/**
 * A WeakValueHashMap is implemented as a HashMap that maps keys to
 * WeakValues.  Because we don't have access to the innards of the
 * HashMap, we have to wrap/unwrap value objects with WeakValues on
 * every operation.  Fortunately WeakValues are small, short-lived
 * objects, so the added allocation overhead is tolerable. This
 * implementaton directly extends java.util.HashMap.
 *
 * @author	Markus Fuchs
 * @see		java.util.HashMap
 * @see     java.lang.ref.WeakReference
 */

public class WeakValueHashMap extends HashMap {

    /**
     *  Reference queue for cleared WeakValues.
     *  We do not expect instance of this class to be serialized. Marking a non serializable member as transient to make findbugs happy.
     */
    private transient ReferenceQueue queue = new ReferenceQueue();

    /**
     * Returns the number of key-value mappings in this map.

* @return the number of key-value mappings in this map. */ public int size() { // delegate to entrySet, as super.size() also counts WeakValues return entrySet().size(); } /** * Returns true if this map contains no key-value mappings.

* @return true if this map contains no key-value mappings. */ public boolean isEmpty() { return size() == 0; } /** * Returns true if this map contains a mapping for the specified * key.

* @param key key whose presence in this map is to be tested * @return true if this map contains a mapping for the specified * key. */ public boolean containsKey(Object key) { // need to clean up gc'ed values before invoking super method processQueue(); return super.containsKey(key); } /** * Returns true if this map maps one or more keys to the * specified value.

* @param value value whose presence in this map is to be tested * @return true if this map maps one or more keys to this value. */ public boolean containsValue(Object value) { return super.containsValue(WeakValue.create(value)); } /** * Gets the value for the given key.

* @param key key whose associated value, if any, is to be returned * @return the value to which this map maps the specified key. */ public Object get(Object key) { // We don't need to remove garbage collected values here; // if they are garbage collected, the get() method returns null; // the next put() call with the same key removes the old value // automatically so that it can be completely garbage collected return getReferenceObject((WeakReference) super.get(key)); } /** * Puts a new (key,value) into the map.

* @param key key with which the specified value is to be associated. * @param value value to be associated with the specified key. * @return previous value associated with specified key, or null * if there was no mapping for key or the value has been garbage * collected by the garbage collector. */ public Object put(Object key, Object value) { // If the map already contains an equivalent key, the new key // of a (key, value) pair is NOT stored in the map but the new // value only. But as the key is strongly referenced by the // map, it can not be removed from the garbage collector, even // if the key becomes weakly reachable due to the old // value. So, it isn't necessary to remove all garbage // collected values with their keys from the map before the // new entry is made. We only clean up here to distribute // clean up calls on different operations. processQueue(); WeakValue oldValue = (WeakValue)super.put(key, WeakValue.create(key, value, queue)); return getReferenceObject(oldValue); } /** * Removes key and value for the given key.

* @param key key whose mapping is to be removed from the map. * @return previous value associated with specified key, or null * if there was no mapping for key or the value has been garbage * collected by the garbage collector. */ public Object remove(Object key) { return getReferenceObject((WeakReference) super.remove(key)); } /** * A convenience method to return the object held by the * weak reference or null if it does not exist. */ private final Object getReferenceObject(WeakReference ref) { return (ref == null) ? null : ref.get(); } /** * Removes all garbage collected values with their keys from the map. * Since we don't know how much the ReferenceQueue.poll() operation * costs, we should not call it every map operation. */ private void processQueue() { WeakValue wv = null; while ((wv = (WeakValue) this.queue.poll()) != null) { // "super" is not really necessary but use it // to be on the safe side super.remove(wv.key); } } /* -- Helper classes -- */ /** * We need this special class to keep the backward reference from * the value to the key, so that we are able to remove the key if * the value is garbage collected. */ private static class WeakValue extends WeakReference { /** * It's the same as the key in the map. We need the key to remove * the value if it is garbage collected. */ private Object key; private WeakValue(Object value) { super(value); } /** * Creates a new weak reference without adding it to a * ReferenceQueue. */ private static WeakValue create(Object value) { if (value == null) return null; else return new WeakValue(value); } private WeakValue(Object key, Object value, ReferenceQueue queue) { super(value, queue); this.key = key; } /** * Creates a new weak reference and adds it to the given queue. */ private static WeakValue create(Object key, Object value, ReferenceQueue queue) { if (value == null) return null; else return new WeakValue(key, value, queue); } /** * A WeakValue is equal to another WeakValue iff they both refer * to objects that are, in turn, equal according to their own * equals methods. */ public boolean equals(Object obj) { if (this == obj) return true; if (!(obj instanceof WeakValue)) return false; Object ref1 = this.get(); Object ref2 = ((WeakValue) obj).get(); if (ref1 == ref2) return true; if ((ref1 == null) || (ref2 == null)) return false; return ref1.equals(ref2); } /** * */ public int hashCode() { Object ref = this.get(); return (ref == null) ? 0 : ref.hashCode(); } } /** * Internal class for entries. This class wraps/unwraps the * values of the Entry objects returned from the underlying map. */ private class Entry implements Map.Entry { private Map.Entry ent; private Object value; /* Strong reference to value, so that the GC will leave it alone as long as this Entry exists */ Entry(Map.Entry ent, Object value) { this.ent = ent; this.value = value; } public Object getKey() { return ent.getKey(); } public Object getValue() { return value; } public Object setValue(Object value) { // This call changes the map. Please see the comment on // the put method for the correctness remark. Object oldValue = this.value; this.value = value; ent.setValue(WeakValue.create(getKey(), value, queue)); return oldValue; } private boolean valEquals(Object o1, Object o2) { return (o1 == null) ? (o2 == null) : o1.equals(o2); } public boolean equals(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry e = (Map.Entry) o; return (valEquals(ent.getKey(), e.getKey()) && valEquals(value, e.getValue())); } public int hashCode() { Object k; return ((((k = ent.getKey()) == null) ? 0 : k.hashCode()) ^ ((value == null) ? 0 : value.hashCode())); } } /** * Internal class for entry sets to unwrap/wrap WeakValues stored * in the map. */ private class EntrySet extends AbstractSet { public Iterator iterator() { // remove garbage collected elements processQueue(); return new Iterator() { Iterator hashIterator = hashEntrySet.iterator(); Entry next = null; public boolean hasNext() { if (hashIterator.hasNext()) { // since we removed garbage collected elements, // we can simply return the next entry. Map.Entry ent = (Map.Entry) hashIterator.next(); WeakValue wv = (WeakValue) ent.getValue(); Object v = (wv == null) ? null : wv.get(); next = new Entry(ent, v); return true; } return false; } public Object next() { if ((next == null) && !hasNext()) throw new NoSuchElementException(); Entry e = next; next = null; return e; } public void remove() { hashIterator.remove(); } }; } public boolean isEmpty() { return !(iterator().hasNext()); } public int size() { int j = 0; for (Iterator i = iterator(); i.hasNext(); i.next()) j++; return j; } public boolean remove(Object o) { if (!(o instanceof Map.Entry)) return false; Map.Entry e = (Map.Entry) o; Object ek = e.getKey(); Object ev = e.getValue(); Object hv = WeakValueHashMap.this.get(ek); if (hv == null) { // if the map's value is null, we have to check, if the // entry's value is null and the map contains the key if ((ev == null) && WeakValueHashMap.this.containsKey(ek)) { WeakValueHashMap.this.remove(ek); return true; } else { return false; } // otherwise, simply compare the values } else if (hv.equals(ev)) { WeakValueHashMap.this.remove(ek); return true; } return false; } public int hashCode() { int h = 0; for (Iterator i = hashEntrySet.iterator(); i.hasNext(); ) { Map.Entry ent = (Map.Entry) i.next(); Object k; WeakValue wv = (WeakValue) ent.getValue(); if (wv == null) continue; h += ((((k = ent.getKey()) == null) ? 0 : k.hashCode()) ^ wv.hashCode()); } return h; } } // internal helper variable, because we can't access // entrySet from the superclass inside the EntrySet class private Set hashEntrySet = null; // stores the EntrySet instance private Set entrySet = null; /** * Returns a Set view of the mappings in this map.

* @return a Set view of the mappings in this map. */ public Set entrySet() { if (entrySet == null) { hashEntrySet = super.entrySet(); entrySet = new EntrySet(); } return entrySet; } // stores the value collection private transient Collection values = null; /** * Returns a Collection view of the values contained * in this map.

* @return a Collection view of the values contained * in this map. */ public Collection values() { // delegates to entrySet, because super method returns // WeakValues instead of value objects if (values == null) { values = new AbstractCollection() { public Iterator iterator() { return new Iterator() { private Iterator i = entrySet().iterator(); public boolean hasNext() { return i.hasNext(); } public Object next() { return ((Entry)i.next()).getValue(); } public void remove() { i.remove(); } }; } public int size() { return WeakValueHashMap.this.size(); } public boolean contains(Object v) { return WeakValueHashMap.this.containsValue(v); } }; } return values; } }





© 2015 - 2024 Weber Informatics LLC | Privacy Policy