ca.odell.glazedlists.impl.WeakReferenceProxy Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of glazedlists_java15 Show documentation
Event-driven lists for dynamically filtered and sorted tables
The newest version!
/* Glazed Lists                                                 (c) 2003-2006 */
/* http://publicobject.com/glazedlists/                      publicobject.com,*/
/*                                                     O'Dell Engineering Ltd.*/
package ca.odell.glazedlists.impl;

// the core Glazed Lists package
import ca.odell.glazedlists.EventList;
import ca.odell.glazedlists.event.ListEvent;
import ca.odell.glazedlists.event.ListEventListener;

import java.lang.ref.WeakReference;

/**
 * This class is a proxy to another ListEventListener that may go out of scope
 * without explicitly removing itself from the source list's set of listeners.
 *
 * WeakReferenceProxy exists to solve a garbage collection problem. Suppose
 * there exists an EventList L and with an iterator I. I
 * must listen to L for change events in order to remain consistent.
 * Therefore I will register itself as a listener to L. When
 * I goes out of scope (as they typically do), it will remain registered
 * as a listener of L. This prevents I from ever being garbage
 * collected! But I can never used again. Because iterators are expected
 * to be used very frequently, this will cause an unacceptable memory leak.
 *
 * 
This problem is solved by WeakReferenceProxy. Instead of adding I
 * as a direct listener of L, add a proxy instead. The proxy will retain
 * a WeakReference to I and forward events to I as
 * long as it is reachable. When I is no longer reachable, the proxy
 * will remove itself from the list of listeners for L and all garbage
 * is available for collection.
 *
 * 
Specifically, the proxy stops listening to L the
 * next time any of the following occurs:
 *
 * 

 *    another ListEventListener is registered with the same EventList
 *   
 another ListEventListener is deregistered with the same EventList
 *   
 another ListEvent is broadcast for the same EventList
 * 
 *
 * @see java.lang.ref.WeakReference
 * @see Bug 21
 *
 * @author Jesse Wilson
 * @author James Lemieux
 */
public final class WeakReferenceProxy implements ListEventListener {

    /** a weak reference the target ListEventListener */
    private final WeakReference> proxyTargetReference;

    /** the list to remove this listener from when done */
    private EventList source;

    /**
     * Creates a new WeakReferenceProxy that listens for events from the
     * specified list and forwards them to the specified listener.
     */
    public WeakReferenceProxy(EventList source, ListEventListener proxyTarget) {
        if (source == null)
            throw new IllegalArgumentException("source may not be null");

        if (proxyTarget == null)
            throw new IllegalArgumentException("proxyTarget may not be null");

        this.source = source;
        this.proxyTargetReference = new WeakReference>(proxyTarget);
    }

    /**
     * Accepts notification for the changes and forwards them to the proxy
     * target if it has not yet been garbage collected.
     */
    public void listChanged(ListEvent listChanges) {
        // if this listener has already been cleaned up, ignore ListEvents
        if (source == null) return;

        // fetch the underlying ListEventListener
        final ListEventListener proxyTarget = getReferent();

        // test to see if the underlying ListEventListener still exists
        if (proxyTarget == null) {
            // it doesn't so clean it up
            source.removeListEventListener(this);
            dispose();

        } else {
            // it does, so notify it of the ListEvent
            proxyTarget.listChanged(listChanges);
        }
    }

    /**
     * Returns the underlying ListEventListener or null if it has
     * been garbage collected.
     */
    public ListEventListener getReferent() {
        return proxyTargetReference.get();
    }

    /**
     * A callback to notify this WeakReferenceProxy that it has been
     * unregistered from the EventList to which it was listening. The
     * WeakReferenceProxy responds by cleaning up internal references to the
     * EventList and ensuring that any future ListEvents it receives are
     * ignored.
     */
    public void dispose() {
        source = null;
    }
}