Java Tutorial/Collections/Reference
An implementation of Set that manages a map of soft references to the set values.
/*
* JBoss, Home of Professional Open Source
* Copyright 2005, JBoss Inc., and individual contributors as indicated
* by the @authors tag. See the copyright.txt in the distribution for a
* full listing of individual contributors.
*
* This is free software; you can redistribute it and/or modify it
* under the terms of the GNU Lesser General Public License as
* published by the Free Software Foundation; either version 2.1 of
* the License, or (at your option) any later version.
*
* This software 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
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this software; if not, write to the Free
* Software Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA
* 02110-1301 USA, or see the FSF site: http://www.fsf.org.
*/
import java.lang.ref.ReferenceQueue;
import java.lang.ref.SoftReference;
import java.lang.reflect.Array;
import java.util.Collection;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Set;
/**
* An implementation of Set that manages a map of soft references to the set
* values. The map is keyed by the value hashCode and so this is only useful for
* value whose hashCode is a valid identity representation (String, primative
* wrappers, etc).
*
* @author Scott.Stark@jboss.org
* @version $Revision: 2787 $
*/
@SuppressWarnings("unchecked")
public class SoftSet implements Set {
private HashMap map = new HashMap();
/** The queue of garbage collected soft references */
private ReferenceQueue gcqueue = new ReferenceQueue();
static class ComparableSoftReference extends SoftReference {
private Integer key;
ComparableSoftReference(Integer key, Object o, ReferenceQueue q) {
super(o, q);
this.key = key;
}
Integer getKey() {
return key;
}
}
static class ComparableSoftReferenceIterator implements Iterator {
Iterator theIter;
ComparableSoftReferenceIterator(Iterator theIter) {
this.theIter = theIter;
}
public boolean hasNext() {
return theIter.hasNext();
}
public Object next() {
ComparableSoftReference csr = (ComparableSoftReference) theIter.next();
return csr.get();
}
public void remove() {
theIter.remove();
}
}
/**
*
*/
public SoftSet() {
}
public int size() {
processQueue();
return map.size();
}
public boolean isEmpty() {
processQueue();
return map.isEmpty();
}
public boolean contains(Object o) {
processQueue();
Integer key = new Integer(o.hashCode());
boolean contains = map.containsKey(key);
return contains;
}
public Iterator iterator() {
processQueue();
Iterator theIter = map.values().iterator();
return new ComparableSoftReferenceIterator(theIter);
}
public Object[] toArray() {
processQueue();
return toArray(new Object[0]);
}
public Object[] toArray(Object[] a) {
processQueue();
int size = map.size();
Object[] array = {};
if (a.length >= size)
array = a;
Iterator iter = map.values().iterator();
int index = 0;
while (iter.hasNext()) {
ComparableSoftReference csr = (ComparableSoftReference) iter.next();
Object value = csr.get();
// Create the correct array type
if (array.length == 0) {
if (value == null) {
index++;
continue;
}
Array.newInstance(value.getClass(), size);
}
array[index] = value;
index++;
}
return array;
}
public boolean add(Object o) {
processQueue();
Integer key = new Integer(o.hashCode());
ComparableSoftReference sr = new ComparableSoftReference(key, o, gcqueue);
return map.put(key, sr) == null;
}
public boolean remove(Object o) {
processQueue();
Integer key = new Integer(o.hashCode());
return map.remove(key) != null;
}
public boolean containsAll(Collection c) {
processQueue();
Iterator iter = c.iterator();
boolean contains = true;
while (iter.hasNext()) {
Object value = iter.next();
Integer key = new Integer(value.hashCode());
contains &= map.containsKey(key);
}
return contains;
}
public boolean addAll(Collection c) {
processQueue();
Iterator iter = c.iterator();
boolean added = false;
while (iter.hasNext()) {
Object value = iter.next();
Integer key = new Integer(value.hashCode());
ComparableSoftReference sr = new ComparableSoftReference(key, value, gcqueue);
added |= map.put(key, sr) == null;
}
return added;
}
public boolean retainAll(Collection c) {
Iterator iter = iterator();
boolean removed = false;
while (iter.hasNext()) {
Object value = iter.next();
if (c.contains(value) == false) {
iter.remove();
removed = true;
}
}
return removed;
}
public boolean removeAll(Collection c) {
processQueue();
Iterator iter = c.iterator();
boolean removed = false;
while (iter.hasNext()) {
Object value = iter.next();
removed |= remove(value);
}
return removed;
}
public void clear() {
while (gcqueue.poll() != null)
;
map.clear();
}
public boolean equals(Object o) {
return map.equals(o);
}
public int hashCode() {
return map.hashCode();
}
/**
* Iterate through the gcqueue for for any cleared reference, remove the
* associated value from the underlying set.
*/
private void processQueue() {
ComparableSoftReference cr;
while ((cr = (ComparableSoftReference) gcqueue.poll()) != null) {
map.remove(cr.getKey());
}
}
}
Cache based on SoftReference
/* Copyright 2004 The Apache Software Foundation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
// Revised from xmlbeans
import java.util.HashMap;
import java.lang.ref.SoftReference;
/**
* @author Cezar Andrei (cezar.andrei at bea.ru)
* Date: Apr 26, 2005
*/
public class SoftCache
{
private HashMap map = new HashMap();
public Object get(Object key)
{
SoftReference softRef = (SoftReference)map.get(key);
if (softRef==null)
return null;
return softRef.get();
}
public Object put(Object key, Object value)
{
SoftReference softRef = (SoftReference)map.put(key, new SoftReference(value));
if (softRef==null)
return null;
Object oldValue = softRef.get();
softRef.clear();
return oldValue;
}
public Object remove(Object key)
{
SoftReference softRef = (SoftReference)map.remove(key);
if (softRef==null)
return null;
Object oldValue = softRef.get();
softRef.clear();
return oldValue;
}
}
WeakReference list uses java.lang.ref.WeakReferences to store its contents.
/**
*
* JFreeReport : a free Java reporting library
*
*
* Project Info: http://reporting.pentaho.org/
*
* (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors.
*
* This library is free software; you can redistribute it and/or modify it under the terms
* of the GNU Lesser General Public License as published by the Free Software Foundation;
* either version 2.1 of the License, or (at your option) any later version.
*
* This library 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 Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public License along with this
* library; if not, write to the Free Software Foundation, Inc., 59 Temple Place, Suite 330,
* Boston, MA 02111-1307, USA.
*
* [Java is a trademark or registered trademark of Sun Microsystems, Inc.
* in the United States and other countries.]
*
* ------------
* WeakReferenceList.java
* ------------
* (C) Copyright 2001-2007, by Object Refinery Ltd, Pentaho Corporation and Contributors.
*/
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.Serializable;
import java.lang.ref.Reference;
import java.lang.ref.WeakReference;
/**
* The WeakReference list uses <code>java.lang.ref.WeakReference</code>s to store its contents. In contrast to the
* WeakHashtable, this list knows how to restore missing content, so that garbage collected elements can be restored
* when they are accessed.
* <p/>
* By default this list can contain 25 elements, where the first element is stored using a strong reference, which is
* not garbage collected.
* <p/>
* Restoring the elements is not implemented, concrete implementations will have to override the
* <code>restoreChild(int)</code> method. The <code>getMaxChildCount</code> method defines the maxmimum number of
* children in the list. When more than <code>maxChildCount</code> elements are contained in this list, add will always
* return false to indicate that adding the element failed.
* <p/>
* To customize the list, override createReference to create a different kind of reference.
* <p/>
* This list is able to add or replace elements, but inserting or removing of elements is not possible.
*
* @author Thomas Morgner
*/
public abstract class WeakReferenceList implements Serializable, Cloneable
{
/**
* The master element.
*/
private Object master;
/**
* Storage for the references.
*/
private transient Reference[] childs;
/**
* The current number of elements.
*/
private int size;
/**
* The maximum number of elements.
*/
private final int maxChilds;
/**
* Creates a new weak reference list. The storage of the list is limited to getMaxChildCount() elements.
*
* @param maxChildCount the maximum number of elements.
*/
protected WeakReferenceList(final int maxChildCount)
{
this.maxChilds = maxChildCount;
this.childs = new Reference[maxChildCount - 1];
}
/**
* Returns the maximum number of children in this list.
*
* @return the maximum number of elements in this list.
*/
protected final int getMaxChildCount()
{
return maxChilds;
}
/**
* Returns the master element of this list. The master element is the element stored by a strong reference and cannot
* be garbage collected.
*
* @return the master element
*/
protected Object getMaster()
{
return master;
}
/**
* Attempts to restore the child stored on the given index.
*
* @param index the index.
* @return null if the child could not be restored or the restored child.
*/
protected abstract Object restoreChild(int index);
/**
* Returns the child stored at the given index. If the child has been garbage collected, it gets restored using the
* restoreChild function.
*
* @param index the index.
* @return the object.
*/
public Object get(final int index)
{
if (isMaster(index))
{
return master;
}
else
{
final Reference ref = childs[getChildPos(index)];
if (ref == null)
{
throw new IllegalStateException("State: " + index);
}
Object ob = ref.get();
if (ob == null)
{
ob = restoreChild(index);
childs[getChildPos(index)] = createReference(ob);
}
return ob;
}
}
/**
* Replaces the child stored at the given index with the new child which can be null.
*
* @param report the object.
* @param index the index.
*/
public void set(final Object report, final int index)
{
if (isMaster(index))
{
master = report;
}
else
{
childs[getChildPos(index)] = createReference(report);
}
}
/**
* Creates a new reference for the given object.
*
* @param o the object.
* @return a WeakReference for the object o without any ReferenceQueue attached.
*/
private Reference createReference(final Object o)
{
return new WeakReference(o);
}
/**
* Adds the element to the list. If the maximum size of the list is exceeded, this function returns false to indicate
* that adding failed.
*
* @param rs the object.
* @return true, if the object was successfully added to the list, false otherwise
*/
public boolean add(final Object rs)
{
if (size == 0)
{
master = rs;
size = 1;
return true;
}
else
{
if (size < getMaxChildCount())
{
childs[size - 1] = createReference(rs);
size++;
return true;
}
else
{
// was not able to add this to this list, maximum number of entries reached.
return false;
}
}
}
/**
* Returns true, if the given index denotes a master index of this list.
*
* @param index the index.
* @return true if the index is a master index.
*/
protected boolean isMaster(final int index)
{
return index % getMaxChildCount() == 0;
}
/**
* Returns the internal storage position for the child.
*
* @param index the index.
* @return the internal storage index.
*/
protected int getChildPos(final int index)
{
return index % getMaxChildCount() - 1;
}
/**
* Returns the size of the list.
*
* @return the size.
*/
public int getSize()
{
return size;
}
/**
* Serialisation support. The transient child elements were not saved.
*
* @param in the input stream.
* @throws IOException if there is an I/O error.
* @throws ClassNotFoundException if a serialized class is not defined on this system.
*/
private void readObject(final ObjectInputStream in)
throws IOException, ClassNotFoundException
{
in.defaultReadObject();
childs = new Reference[getMaxChildCount() - 1];
for (int i = 0; i < childs.length; i++)
{
childs[i] = createReference(null);
}
}
/**
* Creates and returns a copy of this object. The precise meaning of "copy" may depend on the class of the object.
* The general intent is that, for any object <tt>x</tt>, the expression: <blockquote>
* <pre>
* x.clone() != x</pre></blockquote>
* will be true, and that the expression: <blockquote>
* <pre>
* x.clone().getClass() == x.getClass()</pre></blockquote>
* will be <tt>true</tt>, but these are not absolute requirements. While it is typically the case that: <blockquote>
* <pre>
* x.clone().equals(x)</pre></blockquote>
* will be <tt>true</tt>, this is not an absolute requirement.
* <p/>
* By convention, the returned object should be obtained by calling <tt>super.clone</tt>. If a class and all of its
* superclasses (except <tt>Object</tt>) obey this convention, it will be the case that <tt>x.clone().getClass() ==
* x.getClass()</tt>.
* <p/>
* By convention, the object returned by this method should be independent of this object (which is being cloned). To
* achieve this independence, it may be necessary to modify one or more fields of the object returned by
* <tt>super.clone</tt> before returning it. Typically, this means copying any mutable objects that comprise the
* internal "deep structure" of the object being cloned and replacing the references to these objects with references
* to the copies. If a class contains only primitive fields or references to immutable objects, then it is usually
* the case that no fields in the object returned by <tt>super.clone</tt> need to be modified.
* <p/>
* The method <tt>clone</tt> for class <tt>Object</tt> performs a specific cloning operation. First, if the class of
* this object does not implement the interface <tt>Cloneable</tt>, then a <tt>CloneNotSupportedException</tt> is
* thrown. Note that all arrays are considered to implement the interface <tt>Cloneable</tt>. Otherwise, this method
* creates a new instance of the class of this object and initializes all its fields with exactly the contents of the
* corresponding fields of this object, as if by assignment; the contents of the fields are not themselves cloned.
* Thus, this method performs a "shallow copy" of this object, not a "deep copy" operation.
* <p/>
* The class <tt>Object</tt> does not itself implement the interface <tt>Cloneable</tt>, so calling the <tt>clone</tt>
* method on an object whose class is <tt>Object</tt> will result in throwing an exception at run time.
*
* @return a clone of this instance.
* @throws CloneNotSupportedException if the object"s class does not support the <code>Cloneable</code> interface.
* Subclasses that override the <code>clone</code> method can also throw this
* exception to indicate that an instance cannot be cloned.
* @see Cloneable
*/
protected Object clone()
throws CloneNotSupportedException
{
final WeakReferenceList list = (WeakReferenceList) super.clone();
list.childs = (Reference[]) childs.clone();
return list;
}
}
