/*
 * Copyright (c) 2011, 2013, 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 javafx.collections;

import javafx.beans.NamedArg;
import javafx.beans.WeakListener;

import java.lang.ref.WeakReference;

A WeakMapChangeListener can be used, if an ObservableMap should only maintain a weak reference to the listener. This helps to avoid memory leaks, that can occur if observers are not unregistered from observed objects after use. 
 WeakMapChangeListener are created by passing in the original MapChangeListener. The WeakMapChangeListener should then be registered to listen for changes of the observed object. 
 Note: You have to keep a reference to the MapChangeListener, that was passed in as long as it is in use, otherwise it will be garbage collected to soon. 
Type parameters:
<K> – the key element type
<V> – the value element type
See Also:
MapChangeListener
ObservableMap
WeakListener
Since:
JavaFX 2.1/**
 * A {@code WeakMapChangeListener} can be used, if an {@link javafx.collections.ObservableMap}
 * should only maintain a weak reference to the listener. This helps to avoid
 * memory leaks, that can occur if observers are not unregistered from observed
 * objects after use.
 * <p>
 * {@code WeakMapChangeListener} are created by passing in the original
 * {@link javafx.collections.MapChangeListener}. The {@code WeakMapChangeListener} should then be
 * registered to listen for changes of the observed object.
 * <p>
 * Note: You have to keep a reference to the {@code MapChangeListener}, that
 * was passed in as long as it is in use, otherwise it will be garbage collected
 * to soon.
 *
 * @see MapChangeListener
 * @see ObservableMap
 * @see javafx.beans.WeakListener
 *
 * @param <K> the key element type
 * @param <V> the value element type
 *
 * @since JavaFX 2.1
 */
public final class WeakMapChangeListener<K, V> implements MapChangeListener<K, V>, WeakListener {

    private final WeakReference<MapChangeListener<K, V>> ref;

    
The constructor of WeakMapChangeListener. 
Params:
listener – 
           The original listener that should be notified/**
     * The constructor of {@code WeakMapChangeListener}.
     *
     * @param listener
     *            The original listener that should be notified
     */
    public WeakMapChangeListener(@NamedArg("listener") MapChangeListener<K, V> listener) {
        if (listener == null) {
            throw new NullPointerException("Listener must be specified.");
        }
        this.ref = new WeakReference<MapChangeListener<K, V>>(listener);
    }

    
{@inheritDoc}
/**
     * {@inheritDoc}
     */
    @Override
    public boolean wasGarbageCollected() {
        return (ref.get() == null);
    }

    
{@inheritDoc}
/**
     * {@inheritDoc}
     */
    @Override
    public void onChanged(Change<? extends K,? extends V> change) {
        final MapChangeListener<K, V> listener = ref.get();
        if (listener != null) {
            listener.onChanged(change);
        } else {
            // The weakly reference listener has been garbage collected,
            // so this WeakListener will now unhook itself from the
            // source bean
            change.getMap().removeListener(this);
        }
    }
}