WeakList.java
/*
** Module : WeakList.java
** Abstract : List of weak references that cleans up on iteration
**
** Copyright (c) 2006-2020, Golden Code Development Corporation.
**
** -#- -I- --Date-- --JPRM-- ------------------Description-------------------
** 001 ECF 20061102 @30965 Created initial version. A list which holds weak
** references to its elements.
** 002 ECF 20061120 @31321 Added isEmpty() method.
** 003 ECF 20090521 @42988 Integrated generics.
** 004 SVL 20150821 Added remove() method.
** 005 VVT 20200203 WeakList now implements Iterable
*/
/*
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU Affero General Public License as
** published by the Free Software Foundation, either version 3 of the
** License, or (at your option) any later version.
**
** This program 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 Affero General Public License for more details.
**
** You may find a copy of the GNU Affero GPL version 3 at the following
** location: https://www.gnu.org/licenses/agpl-3.0.en.html
**
** Additional terms under GNU Affero GPL version 3 section 7:
**
** Under Section 7 of the GNU Affero GPL version 3, the following additional
** terms apply to the works covered under the License. These additional terms
** are non-permissive additional terms allowed under Section 7 of the GNU
** Affero GPL version 3 and may not be removed by you.
**
** 0. Attribution Requirement.
**
** You must preserve all legal notices or author attributions in the covered
** work or Appropriate Legal Notices displayed by works containing the covered
** work. You may not remove from the covered work any author or developer
** credit already included within the covered work.
**
** 1. No License To Use Trademarks.
**
** This license does not grant any license or rights to use the trademarks
** Golden Code, FWD, any Golden Code or FWD logo, or any other trademarks
** of Golden Code Development Corporation. You are not authorized to use the
** name Golden Code, FWD, or the names of any author or contributor, for
** publicity purposes without written authorization.
**
** 2. No Misrepresentation of Affiliation.
**
** You may not represent yourself as Golden Code Development Corporation or FWD.
**
** You may not represent yourself for publicity purposes as associated with
** Golden Code Development Corporation, FWD, or any author or contributor to
** the covered work, without written authorization.
**
** 3. No Misrepresentation of Source or Origin.
**
** You may not represent the covered work as solely your work. All modified
** versions of the covered work must be marked in a reasonable way to make it
** clear that the modified work is not originating from Golden Code Development
** Corporation or FWD. All modified versions must contain the notices of
** attribution required in this license.
*/
package com.goldencode.p2j.util;
import java.lang.ref.*;
import java.util.*;
/**
* A wrapper for a linked list of weak references. This implementation allows
* entries to be garbage collected if they are no longer strongly referenced
* by any other objects. Each entry added is stored using a weak reference.
* Upon iteration, references to objects which have been garbage collected are
* removed from the list.
* <p>
* This is a very simple list implementation which does not implement the
* standard Java collection <code>List</code> interface. Currently, it has
* only methods to add an entry to the end of the list, to iterate over all
* elements from first to last, to indicate whether the list is empty and to
* remove the specific element.
*
* @param <E>
* Element being wrapped by the list.
*/
public final class WeakList<E>
implements Iterable<E>
{
/** The internal list being wrapped */
private final List<Reference<E>> list;
/**
* Default constructor.
*/
public WeakList()
{
this.list = new LinkedList<Reference<E>>();
}
/**
* Add an entry to the end of the list. It will be connected to the list
* by a weak reference.
*
* @param o
* Object to be added via weak reference.
*
* @return <code>true</code> if the list was changed as a result of the
* call (always will return <code>true</code>).
*/
public boolean add(E o)
{
return list.add(new WeakReference<E>(o));
}
/**
* Indicate whether the list is empty.
*
* @return <code>true</code> if the list contains no elements, else
* <code>false</code>.
*/
public boolean isEmpty()
{
return !iterator().hasNext();
}
/**
* Remove an entry from the list.
*
* @param o
* Object to be removed.
*
* @return <code>true</code> if the list was changed as a result of the call.
*/
public boolean remove(E o)
{
boolean res = false;
Iterator iter = iterator();
while (iter.hasNext())
{
Object element = iter.next();
if (element.equals(o))
{
iter.remove();
res = true;
}
}
return res;
}
/**
* Return an iterator on the elements in the list, starting from the first
* and proceeding in order to the last. If any entry has been garbage
* collected, such that the weak reference no longer holds an object, that
* entry is removed from the list.
*
* @return Iterator on the objects in the list.
*/
public Iterator<E> iterator()
{
return new Iterator<E>()
{
private Iterator<Reference<E>> iter = list.iterator();
private E next = null;
public boolean hasNext()
{
while (iter.hasNext())
{
Reference<E> ref = iter.next();
next = ref.get();
if (next != null)
{
return true;
}
// If referent was garbage collected, remove the reference
// from the list.
iter.remove();
}
return false;
}
public E next()
{
if (next == null)
{
throw new NoSuchElementException();
}
return next;
}
public void remove()
{
iter.remove();
}
};
}
}