/*

  * Copyright (c) 1996, 2011, 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 java.beans;

 import java.io.Serializable;

 import java.io.ObjectStreamField;

 import java.io.ObjectOutputStream;

 import java.io.ObjectInputStream;

 import java.io.IOException;

 import java.util.Hashtable;

 import java.util.Map.Entry;

 /**

  * This is a utility class that can be used by beans that support constrained

  * properties.  It manages a list of listeners and dispatches

  * {@link PropertyChangeEvent}s to them.  You can use an instance of this class

  * as a member field of your bean and delegate these types of work to it.

  * The {@link VetoableChangeListener} can be registered for all properties

  * or for a property specified by name.

  * <p>

  * Here is an example of {@code VetoableChangeSupport} usage that follows

  * the rules and recommendations laid out in the JavaBeans™ specification:

  * <pre>

  * public class MyBean {

  *     private final VetoableChangeSupport vcs = new VetoableChangeSupport(this);

  *

  *     public void addVetoableChangeListener(VetoableChangeListener listener) {

  *         this.vcs.addVetoableChangeListener(listener);

  *     }

  *

  *     public void removeVetoableChangeListener(VetoableChangeListener listener) {

  *         this.vcs.removeVetoableChangeListener(listener);

  *     }

  *

  *     private String value;

  *

  *     public String getValue() {

  *         return this.value;

  *     }

  *

  *     public void setValue(String newValue) throws PropertyVetoException {

  *         String oldValue = this.value;

  *         this.vcs.fireVetoableChange("value", oldValue, newValue);

  *         this.value = newValue;

  *     }

  *

  *     [...]

  * }

  * </pre>

  * <p>

  * A {@code VetoableChangeSupport} instance is thread-safe.

  * <p>

  * This class is serializable.  When it is serialized it will save

  * (and restore) any listeners that are themselves serializable.  Any

  * non-serializable listeners will be skipped during serialization.

  *

  * @see PropertyChangeSupport

  */

 public class VetoableChangeSupport implements Serializable {

     private VetoableChangeListenerMap map = new VetoableChangeListenerMap();

     /**

      * Constructs a <code>VetoableChangeSupport</code> object.

      *

      * @param sourceBean  The bean to be given as the source for any events.

      */

     public VetoableChangeSupport(Object sourceBean) {

         if (sourceBean == null) {

             throw new NullPointerException();

         }

         source = sourceBean;

     }

     /**

      * Add a VetoableChangeListener to the listener list.

      * The listener is registered for all properties.

      * The same listener object may be added more than once, and will be called

      * as many times as it is added.

      * If <code>listener</code> is null, no exception is thrown and no action

      * is taken.

      *

      * @param listener  The VetoableChangeListener to be added

      */

     public void addVetoableChangeListener(VetoableChangeListener listener) {

         if (listener == null) {

             return;

         }

         if (listener instanceof VetoableChangeListenerProxy) {

             VetoableChangeListenerProxy proxy =

                     (VetoableChangeListenerProxy)listener;

             // Call two argument add method.

             addVetoableChangeListener(proxy.getPropertyName(),

                                       proxy.getListener());

         } else {

             this.map.add(null, listener);

         }

     }

     /**

      * Remove a VetoableChangeListener from the listener list.

      * This removes a VetoableChangeListener that was registered

      * for all properties.

      * If <code>listener</code> was added more than once to the same event

      * source, it will be notified one less time after being removed.

      * If <code>listener</code> is null, or was never added, no exception is

      * thrown and no action is taken.

      *

      * @param listener  The VetoableChangeListener to be removed

      */

     public void removeVetoableChangeListener(VetoableChangeListener listener) {

         if (listener == null) {

             return;

         }

         if (listener instanceof VetoableChangeListenerProxy) {

             VetoableChangeListenerProxy proxy =

                     (VetoableChangeListenerProxy)listener;

             // Call two argument remove method.

             removeVetoableChangeListener(proxy.getPropertyName(),

                                          proxy.getListener());

         } else {

             this.map.remove(null, listener);

         }

     }

     /**

      * Returns an array of all the listeners that were added to the

      * VetoableChangeSupport object with addVetoableChangeListener().

      * <p>

      * If some listeners have been added with a named property, then

      * the returned array will be a mixture of VetoableChangeListeners

      * and <code>VetoableChangeListenerProxy</code>s. If the calling

      * method is interested in distinguishing the listeners then it must

      * test each element to see if it's a

      * <code>VetoableChangeListenerProxy</code>, perform the cast, and examine

      * the parameter.

      *

      * <pre>

      * VetoableChangeListener[] listeners = bean.getVetoableChangeListeners();

      * for (int i = 0; i < listeners.length; i++) {

      *        if (listeners[i] instanceof VetoableChangeListenerProxy) {

      *     VetoableChangeListenerProxy proxy =

      *                    (VetoableChangeListenerProxy)listeners[i];

      *     if (proxy.getPropertyName().equals("foo")) {

      *       // proxy is a VetoableChangeListener which was associated

      *       // with the property named "foo"

      *     }

      *   }

      * }

      *</pre>

      *

      * @see VetoableChangeListenerProxy

      * @return all of the <code>VetoableChangeListeners</code> added or an

      *         empty array if no listeners have been added

      * @since 1.4

      */

     public VetoableChangeListener[] getVetoableChangeListeners(){

         return this.map.getListeners();

     }

     /**

      * Add a VetoableChangeListener for a specific property.  The listener

      * will be invoked only when a call on fireVetoableChange names that

      * specific property.

      * The same listener object may be added more than once.  For each

      * property,  the listener will be invoked the number of times it was added

      * for that property.

      * If <code>propertyName</code> or <code>listener</code> is null, no

      * exception is thrown and no action is taken.

      *

      * @param propertyName  The name of the property to listen on.

      * @param listener  The VetoableChangeListener to be added

      */

     public void addVetoableChangeListener(

                                 String propertyName,

                 VetoableChangeListener listener) {

         if (listener == null || propertyName == null) {

             return;

         }

         listener = this.map.extract(listener);

         if (listener != null) {

             this.map.add(propertyName, listener);

         }

     }

     /**

      * Remove a VetoableChangeListener for a specific property.

      * If <code>listener</code> was added more than once to the same event

      * source for the specified property, it will be notified one less time

      * after being removed.

      * If <code>propertyName</code> is null, no exception is thrown and no

      * action is taken.

      * If <code>listener</code> is null, or was never added for the specified

      * property, no exception is thrown and no action is taken.

      *

      * @param propertyName  The name of the property that was listened on.

      * @param listener  The VetoableChangeListener to be removed

      */

     public void removeVetoableChangeListener(

                                 String propertyName,

                 VetoableChangeListener listener) {

         if (listener == null || propertyName == null) {

             return;

         }

         listener = this.map.extract(listener);

         if (listener != null) {

             this.map.remove(propertyName, listener);

         }

     }

     /**

      * Returns an array of all the listeners which have been associated

      * with the named property.

      *

      * @param propertyName  The name of the property being listened to

      * @return all the <code>VetoableChangeListeners</code> associated with

      *         the named property.  If no such listeners have been added,

      *         or if <code>propertyName</code> is null, an empty array is

      *         returned.

      * @since 1.4

      */

     public VetoableChangeListener[] getVetoableChangeListeners(String propertyName) {

         return this.map.getListeners(propertyName);

     }

     /**

      * Reports a constrained property update to listeners

      * that have been registered to track updates of

      * all properties or a property with the specified name.

      * <p>

      * Any listener can throw a {@code PropertyVetoException} to veto the update.

      * If one of the listeners vetoes the update, this method passes

      * a new "undo" {@code PropertyChangeEvent} that reverts to the old value

      * to all listeners that already confirmed this update

      * and throws the {@code PropertyVetoException} again.

      * <p>

      * No event is fired if old and new values are equal and non-null.

      * <p>

      * This is merely a convenience wrapper around the more general

      * {@link #fireVetoableChange(PropertyChangeEvent)} method.

      *

      * @param propertyName  the programmatic name of the property that is about to change

      * @param oldValue      the old value of the property

      * @param newValue      the new value of the property

      * @throws PropertyVetoException if one of listeners vetoes the property update

      */

     public void fireVetoableChange(String propertyName, Object oldValue, Object newValue)

             throws PropertyVetoException {

         if (oldValue == null || newValue == null || !oldValue.equals(newValue)) {

             fireVetoableChange(new PropertyChangeEvent(this.source, propertyName, oldValue, newValue));

         }

     }

     /**

      * Reports an integer constrained property update to listeners

      * that have been registered to track updates of

      * all properties or a property with the specified name.

      * <p>

      * Any listener can throw a {@code PropertyVetoException} to veto the update.

      * If one of the listeners vetoes the update, this method passes

      * a new "undo" {@code PropertyChangeEvent} that reverts to the old value

      * to all listeners that already confirmed this update

      * and throws the {@code PropertyVetoException} again.

      * <p>

      * No event is fired if old and new values are equal.

      * <p>

      * This is merely a convenience wrapper around the more general

      * {@link #fireVetoableChange(String, Object, Object)} method.

      *

      * @param propertyName  the programmatic name of the property that is about to change

      * @param oldValue      the old value of the property

      * @param newValue      the new value of the property

      * @throws PropertyVetoException if one of listeners vetoes the property update

      */

     public void fireVetoableChange(String propertyName, int oldValue, int newValue)

             throws PropertyVetoException {

         if (oldValue != newValue) {

             fireVetoableChange(propertyName, Integer.valueOf(oldValue), Integer.valueOf(newValue));

         }

     }

     /**

      * Reports a boolean constrained property update to listeners

      * that have been registered to track updates of

      * all properties or a property with the specified name.

      * <p>

      * Any listener can throw a {@code PropertyVetoException} to veto the update.

      * If one of the listeners vetoes the update, this method passes

      * a new "undo" {@code PropertyChangeEvent} that reverts to the old value

      * to all listeners that already confirmed this update

      * and throws the {@code PropertyVetoException} again.

      * <p>

      * No event is fired if old and new values are equal.

      * <p>

      * This is merely a convenience wrapper around the more general

      * {@link #fireVetoableChange(String, Object, Object)} method.

      *

      * @param propertyName  the programmatic name of the property that is about to change

      * @param oldValue      the old value of the property

      * @param newValue      the new value of the property

      * @throws PropertyVetoException if one of listeners vetoes the property update

      */

     public void fireVetoableChange(String propertyName, boolean oldValue, boolean newValue)

             throws PropertyVetoException {

         if (oldValue != newValue) {

             fireVetoableChange(propertyName, Boolean.valueOf(oldValue), Boolean.valueOf(newValue));

         }

     }

     /**

      * Fires a property change event to listeners

      * that have been registered to track updates of

      * all properties or a property with the specified name.

      * <p>

      * Any listener can throw a {@code PropertyVetoException} to veto the update.

      * If one of the listeners vetoes the update, this method passes

      * a new "undo" {@code PropertyChangeEvent} that reverts to the old value

      * to all listeners that already confirmed this update

      * and throws the {@code PropertyVetoException} again.

      * <p>

      * No event is fired if the given event's old and new values are equal and non-null.

      *

      * @param event  the {@code PropertyChangeEvent} to be fired

      * @throws PropertyVetoException if one of listeners vetoes the property update

      */

     public void fireVetoableChange(PropertyChangeEvent event)

             throws PropertyVetoException {

         Object oldValue = event.getOldValue();

         Object newValue = event.getNewValue();

         if (oldValue == null || newValue == null || !oldValue.equals(newValue)) {

             String name = event.getPropertyName();

             VetoableChangeListener[] common = this.map.get(null);

             VetoableChangeListener[] named = (name != null)

                         ? this.map.get(name)

                         : null;

             VetoableChangeListener[] listeners;

             if (common == null) {

                 listeners = named;

             }

             else if (named == null) {

                 listeners = common;

             }

             else {

                 listeners = new VetoableChangeListener[common.length + named.length];

                 System.arraycopy(common, 0, listeners, 0, common.length);

                 System.arraycopy(named, 0, listeners, common.length, named.length);

             }

             if (listeners != null) {

                 int current = 0;

                 try {

                     while (current < listeners.length) {

                         listeners[current].vetoableChange(event);

                         current++;

                     }

                 }

                 catch (PropertyVetoException veto) {

                     event = new PropertyChangeEvent(this.source, name, newValue, oldValue);

                     for (int i = 0; i < current; i++) {

                         try {

                             listeners[i].vetoableChange(event);

                         }

                         catch (PropertyVetoException exception) {

                             // ignore exceptions that occur during rolling back

                         }

                     }

                     throw veto; // rethrow the veto exception

                 }

             }

         }

     }

     /**

      * Check if there are any listeners for a specific property, including

      * those registered on all properties.  If <code>propertyName</code>

      * is null, only check for listeners registered on all properties.

      *

      * @param propertyName  the property name.

      * @return true if there are one or more listeners for the given property

      */

     public boolean hasListeners(String propertyName) {

         return this.map.hasListeners(propertyName);

     }

     /**

      * @serialData Null terminated list of <code>VetoableChangeListeners</code>.

      * <p>

      * At serialization time we skip non-serializable listeners and

      * only serialize the serializable listeners.

      */

     private void writeObject(ObjectOutputStream s) throws IOException {

         Hashtable<String, VetoableChangeSupport> children = null;

         VetoableChangeListener[] listeners = null;

         synchronized (this.map) {

             for (Entry<String, VetoableChangeListener[]> entry : this.map.getEntries()) {

                 String property = entry.getKey();

                 if (property == null) {

                     listeners = entry.getValue();

                 } else {

                     if (children == null) {

                         children = new Hashtable<String, VetoableChangeSupport>();

                     }

                     VetoableChangeSupport vcs = new VetoableChangeSupport(this.source);

                     vcs.map.set(null, entry.getValue());

                     children.put(property, vcs);

                 }

             }

         }

         ObjectOutputStream.PutField fields = s.putFields();

         fields.put("children", children);

         fields.put("source", this.source);

         fields.put("vetoableChangeSupportSerializedDataVersion", 2);

         s.writeFields();

         if (listeners != null) {

             for (VetoableChangeListener l : listeners) {

                 if (l instanceof Serializable) {

                     s.writeObject(l);

                 }

             }

         }

         s.writeObject(null);

     }

     private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException {

         this.map = new VetoableChangeListenerMap();

         ObjectInputStream.GetField fields = s.readFields();

         Hashtable<String, VetoableChangeSupport> children = (Hashtable<String, VetoableChangeSupport>) fields.get("children", null);

         this.source = fields.get("source", null);

         fields.get("vetoableChangeSupportSerializedDataVersion", 2);

         Object listenerOrNull;

         while (null != (listenerOrNull = s.readObject())) {

             this.map.add(null, (VetoableChangeListener)listenerOrNull);

         }

         if (children != null) {

             for (Entry<String, VetoableChangeSupport> entry : children.entrySet()) {

                 for (VetoableChangeListener listener : entry.getValue().getVetoableChangeListeners()) {

                     this.map.add(entry.getKey(), listener);

                 }

             }

         }

     }

     /**

      * The object to be provided as the "source" for any generated events.

      */

     private Object source;

     /**

      * @serialField children                                   Hashtable

      * @serialField source                                     Object

      * @serialField vetoableChangeSupportSerializedDataVersion int

      */

     private static final ObjectStreamField[] serialPersistentFields = {

             new ObjectStreamField("children", Hashtable.class),

             new ObjectStreamField("source", Object.class),

             new ObjectStreamField("vetoableChangeSupportSerializedDataVersion", Integer.TYPE)

     };

     /**

      * Serialization version ID, so we're compatible with JDK 1.1

      */

     static final long serialVersionUID = -5090210921595982017L;

     /**

      * This is a {@link ChangeListenerMap ChangeListenerMap} implementation

      * that works with {@link VetoableChangeListener VetoableChangeListener} objects.

      */

     private static final class VetoableChangeListenerMap extends ChangeListenerMap<VetoableChangeListener> {

         private static final VetoableChangeListener[] EMPTY = {};

         /**

          * Creates an array of {@link VetoableChangeListener VetoableChangeListener} objects.

          * This method uses the same instance of the empty array

          * when {@code length} equals {@code 0}.

          *

          * @param length  the array length

          * @return        an array with specified length

          */

         @Override

         protected VetoableChangeListener[] newArray(int length) {

             return (0 < length)

                     ? new VetoableChangeListener[length]

                     : EMPTY;

         }

         /**

          * Creates a {@link VetoableChangeListenerProxy VetoableChangeListenerProxy}

          * object for the specified property.

          *

          * @param name      the name of the property to listen on

          * @param listener  the listener to process events

          * @return          a {@code VetoableChangeListenerProxy} object

          */

         @Override

         protected VetoableChangeListener newProxy(String name, VetoableChangeListener listener) {

             return new VetoableChangeListenerProxy(name, listener);

         }

     }

 }