| /* |
| * Copyright (c) 1997, 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 java.beans.beancontext; |
| |
| import java.awt.Component; |
| import java.awt.Container; |
| |
| import java.beans.Beans; |
| import java.beans.AppletInitializer; |
| |
| import java.beans.DesignMode; |
| |
| import java.beans.PropertyChangeEvent; |
| import java.beans.PropertyChangeListener; |
| import java.beans.PropertyChangeSupport; |
| |
| import java.beans.VetoableChangeListener; |
| import java.beans.VetoableChangeSupport; |
| import java.beans.PropertyVetoException; |
| |
| import java.beans.Visibility; |
| |
| import java.io.IOException; |
| import java.io.InputStream; |
| import java.io.ObjectInputStream; |
| import java.io.ObjectOutputStream; |
| import java.io.Serializable; |
| |
| import java.net.URL; |
| |
| import java.util.ArrayList; |
| import java.util.Collection; |
| import java.util.HashMap; |
| import java.util.Iterator; |
| import java.util.Locale; |
| import java.util.Map; |
| |
| |
| /** |
| * This helper class provides a utility implementation of the |
| * java.beans.beancontext.BeanContext interface. |
| * <p> |
| * Since this class directly implements the BeanContext interface, the class |
| * can, and is intended to be used either by subclassing this implementation, |
| * or via ad-hoc delegation of an instance of this class from another. |
| * </p> |
| * |
| * @author Laurence P. G. Cable |
| * @since 1.2 |
| */ |
| public class BeanContextSupport extends BeanContextChildSupport |
| implements BeanContext, |
| Serializable, |
| PropertyChangeListener, |
| VetoableChangeListener { |
| |
| // Fix for bug 4282900 to pass JCK regression test |
| static final long serialVersionUID = -4879613978649577204L; |
| |
| /** |
| * |
| * Construct a BeanContextSupport instance |
| * |
| * |
| * @param peer The peer <tt>BeanContext</tt> we are |
| * supplying an implementation for, |
| * or <tt>null</tt> |
| * if this object is its own peer |
| * @param lcle The current Locale for this BeanContext. If |
| * <tt>lcle</tt> is <tt>null</tt>, the default locale |
| * is assigned to the <tt>BeanContext</tt> instance. |
| * @param dTime The initial state, |
| * <tt>true</tt> if in design mode, |
| * <tt>false</tt> if runtime. |
| * @param visible The initial visibility. |
| * @see java.util.Locale#getDefault() |
| * @see java.util.Locale#setDefault(java.util.Locale) |
| */ |
| public BeanContextSupport(BeanContext peer, Locale lcle, boolean dTime, boolean visible) { |
| super(peer); |
| |
| locale = lcle != null ? lcle : Locale.getDefault(); |
| designTime = dTime; |
| okToUseGui = visible; |
| |
| initialize(); |
| } |
| |
| /** |
| * Create an instance using the specified Locale and design mode. |
| * |
| * @param peer The peer <tt>BeanContext</tt> we |
| * are supplying an implementation for, |
| * or <tt>null</tt> if this object is its own peer |
| * @param lcle The current Locale for this <tt>BeanContext</tt>. If |
| * <tt>lcle</tt> is <tt>null</tt>, the default locale |
| * is assigned to the <tt>BeanContext</tt> instance. |
| * @param dtime The initial state, <tt>true</tt> |
| * if in design mode, |
| * <tt>false</tt> if runtime. |
| * @see java.util.Locale#getDefault() |
| * @see java.util.Locale#setDefault(java.util.Locale) |
| */ |
| public BeanContextSupport(BeanContext peer, Locale lcle, boolean dtime) { |
| this (peer, lcle, dtime, true); |
| } |
| |
| /** |
| * Create an instance using the specified locale |
| * |
| * @param peer The peer BeanContext we are |
| * supplying an implementation for, |
| * or <tt>null</tt> if this object |
| * is its own peer |
| * @param lcle The current Locale for this |
| * <tt>BeanContext</tt>. If |
| * <tt>lcle</tt> is <tt>null</tt>, |
| * the default locale |
| * is assigned to the <tt>BeanContext</tt> |
| * instance. |
| * @see java.util.Locale#getDefault() |
| * @see java.util.Locale#setDefault(java.util.Locale) |
| */ |
| public BeanContextSupport(BeanContext peer, Locale lcle) { |
| this (peer, lcle, false, true); |
| } |
| |
| /** |
| * Create an instance using with a default locale |
| * |
| * @param peer The peer <tt>BeanContext</tt> we are |
| * supplying an implementation for, |
| * or <tt>null</tt> if this object |
| * is its own peer |
| */ |
| public BeanContextSupport(BeanContext peer) { |
| this (peer, null, false, true); |
| } |
| |
| /** |
| * Create an instance that is not a delegate of another object |
| */ |
| |
| public BeanContextSupport() { |
| this (null, null, false, true); |
| } |
| |
| /** |
| * Gets the instance of <tt>BeanContext</tt> that |
| * this object is providing the implementation for. |
| * @return the BeanContext instance |
| */ |
| public BeanContext getBeanContextPeer() { return (BeanContext)getBeanContextChildPeer(); } |
| |
| /** |
| * <p> |
| * The instantiateChild method is a convenience hook |
| * in BeanContext to simplify |
| * the task of instantiating a Bean, nested, |
| * into a <tt>BeanContext</tt>. |
| * </p> |
| * <p> |
| * The semantics of the beanName parameter are defined by java.beans.Beans.instantiate. |
| * </p> |
| * |
| * @param beanName the name of the Bean to instantiate within this BeanContext |
| * @throws IOException if there is an I/O error when the bean is being deserialized |
| * @throws ClassNotFoundException if the class |
| * identified by the beanName parameter is not found |
| * @return the new object |
| */ |
| public Object instantiateChild(String beanName) |
| throws IOException, ClassNotFoundException { |
| BeanContext bc = getBeanContextPeer(); |
| |
| return Beans.instantiate(bc.getClass().getClassLoader(), beanName, bc); |
| } |
| |
| /** |
| * Gets the number of children currently nested in |
| * this BeanContext. |
| * |
| * @return number of children |
| */ |
| public int size() { |
| synchronized(children) { |
| return children.size(); |
| } |
| } |
| |
| /** |
| * Reports whether or not this |
| * <tt>BeanContext</tt> is empty. |
| * A <tt>BeanContext</tt> is considered |
| * empty when it contains zero |
| * nested children. |
| * @return if there are not children |
| */ |
| public boolean isEmpty() { |
| synchronized(children) { |
| return children.isEmpty(); |
| } |
| } |
| |
| /** |
| * Determines whether or not the specified object |
| * is currently a child of this <tt>BeanContext</tt>. |
| * @param o the Object in question |
| * @return if this object is a child |
| */ |
| public boolean contains(Object o) { |
| synchronized(children) { |
| return children.containsKey(o); |
| } |
| } |
| |
| /** |
| * Determines whether or not the specified object |
| * is currently a child of this <tt>BeanContext</tt>. |
| * @param o the Object in question |
| * @return if this object is a child |
| */ |
| public boolean containsKey(Object o) { |
| synchronized(children) { |
| return children.containsKey(o); |
| } |
| } |
| |
| /** |
| * Gets all JavaBean or <tt>BeanContext</tt> instances |
| * currently nested in this <tt>BeanContext</tt>. |
| * @return an <tt>Iterator</tt> of the nested children |
| */ |
| public Iterator iterator() { |
| synchronized(children) { |
| return new BCSIterator(children.keySet().iterator()); |
| } |
| } |
| |
| /** |
| * Gets all JavaBean or <tt>BeanContext</tt> |
| * instances currently nested in this BeanContext. |
| */ |
| public Object[] toArray() { |
| synchronized(children) { |
| return children.keySet().toArray(); |
| } |
| } |
| |
| /** |
| * Gets an array containing all children of |
| * this <tt>BeanContext</tt> that match |
| * the types contained in arry. |
| * @param arry The array of object |
| * types that are of interest. |
| * @return an array of children |
| */ |
| public Object[] toArray(Object[] arry) { |
| synchronized(children) { |
| return children.keySet().toArray(arry); |
| } |
| } |
| |
| |
| /************************************************************************/ |
| |
| /** |
| * protected final subclass that encapsulates an iterator but implements |
| * a noop remove() method. |
| */ |
| |
| protected static final class BCSIterator implements Iterator { |
| BCSIterator(Iterator i) { super(); src = i; } |
| |
| public boolean hasNext() { return src.hasNext(); } |
| public Object next() { return src.next(); } |
| public void remove() { /* do nothing */ } |
| |
| private Iterator src; |
| } |
| |
| /************************************************************************/ |
| |
| /* |
| * protected nested class containing per child information, an instance |
| * of which is associated with each child in the "children" hashtable. |
| * subclasses can extend this class to include their own per-child state. |
| * |
| * Note that this 'value' is serialized with the corresponding child 'key' |
| * when the BeanContextSupport is serialized. |
| */ |
| |
| protected class BCSChild implements Serializable { |
| |
| private static final long serialVersionUID = -5815286101609939109L; |
| |
| BCSChild(Object bcc, Object peer) { |
| super(); |
| |
| child = bcc; |
| proxyPeer = peer; |
| } |
| |
| Object getChild() { return child; } |
| |
| void setRemovePending(boolean v) { removePending = v; } |
| |
| boolean isRemovePending() { return removePending; } |
| |
| boolean isProxyPeer() { return proxyPeer != null; } |
| |
| Object getProxyPeer() { return proxyPeer; } |
| /* |
| * fields |
| */ |
| |
| |
| private Object child; |
| private Object proxyPeer; |
| |
| private transient boolean removePending; |
| } |
| |
| /** |
| * <p> |
| * Subclasses can override this method to insert their own subclass |
| * of Child without having to override add() or the other Collection |
| * methods that add children to the set. |
| * </p> |
| * @param targetChild the child to create the Child on behalf of |
| * @param peer the peer if the tragetChild and the peer are related by an implementation of BeanContextProxy * @return Subtype-specific subclass of Child without overriding collection methods |
| */ |
| |
| protected BCSChild createBCSChild(Object targetChild, Object peer) { |
| return new BCSChild(targetChild, peer); |
| } |
| |
| /************************************************************************/ |
| |
| /** |
| * Adds/nests a child within this <tt>BeanContext</tt>. |
| * <p> |
| * Invoked as a side effect of java.beans.Beans.instantiate(). |
| * If the child object is not valid for adding then this method |
| * throws an IllegalStateException. |
| * </p> |
| * |
| * |
| * @param targetChild The child objects to nest |
| * within this <tt>BeanContext</tt> |
| * @return true if the child was added successfully. |
| * @see #validatePendingAdd |
| */ |
| public boolean add(Object targetChild) { |
| |
| if (targetChild == null) throw new IllegalArgumentException(); |
| |
| // The specification requires that we do nothing if the child |
| // is already nested herein. |
| |
| if (children.containsKey(targetChild)) return false; // test before locking |
| |
| synchronized(BeanContext.globalHierarchyLock) { |
| if (children.containsKey(targetChild)) return false; // check again |
| |
| if (!validatePendingAdd(targetChild)) { |
| throw new IllegalStateException(); |
| } |
| |
| |
| // The specification requires that we invoke setBeanContext() on the |
| // newly added child if it implements the java.beans.beancontext.BeanContextChild interface |
| |
| BeanContextChild cbcc = getChildBeanContextChild(targetChild); |
| BeanContextChild bccp = null; |
| |
| synchronized(targetChild) { |
| |
| if (targetChild instanceof BeanContextProxy) { |
| bccp = ((BeanContextProxy)targetChild).getBeanContextProxy(); |
| |
| if (bccp == null) throw new NullPointerException("BeanContextPeer.getBeanContextProxy()"); |
| } |
| |
| BCSChild bcsc = createBCSChild(targetChild, bccp); |
| BCSChild pbcsc = null; |
| |
| synchronized (children) { |
| children.put(targetChild, bcsc); |
| |
| if (bccp != null) children.put(bccp, pbcsc = createBCSChild(bccp, targetChild)); |
| } |
| |
| if (cbcc != null) synchronized(cbcc) { |
| try { |
| cbcc.setBeanContext(getBeanContextPeer()); |
| } catch (PropertyVetoException pve) { |
| |
| synchronized (children) { |
| children.remove(targetChild); |
| |
| if (bccp != null) children.remove(bccp); |
| } |
| |
| throw new IllegalStateException(); |
| } |
| |
| cbcc.addPropertyChangeListener("beanContext", childPCL); |
| cbcc.addVetoableChangeListener("beanContext", childVCL); |
| } |
| |
| Visibility v = getChildVisibility(targetChild); |
| |
| if (v != null) { |
| if (okToUseGui) |
| v.okToUseGui(); |
| else |
| v.dontUseGui(); |
| } |
| |
| if (getChildSerializable(targetChild) != null) serializable++; |
| |
| childJustAddedHook(targetChild, bcsc); |
| |
| if (bccp != null) { |
| v = getChildVisibility(bccp); |
| |
| if (v != null) { |
| if (okToUseGui) |
| v.okToUseGui(); |
| else |
| v.dontUseGui(); |
| } |
| |
| if (getChildSerializable(bccp) != null) serializable++; |
| |
| childJustAddedHook(bccp, pbcsc); |
| } |
| |
| |
| } |
| |
| // The specification requires that we fire a notification of the change |
| |
| fireChildrenAdded(new BeanContextMembershipEvent(getBeanContextPeer(), bccp == null ? new Object[] { targetChild } : new Object[] { targetChild, bccp } )); |
| |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Removes a child from this BeanContext. If the child object is not |
| * for adding then this method throws an IllegalStateException. |
| * @param targetChild The child objects to remove |
| * @see #validatePendingRemove |
| */ |
| public boolean remove(Object targetChild) { |
| return remove(targetChild, true); |
| } |
| |
| /** |
| * internal remove used when removal caused by |
| * unexpected <tt>setBeanContext</tt> or |
| * by <tt>remove()</tt> invocation. |
| * @param targetChild the JavaBean, BeanContext, or Object to be removed |
| * @param callChildSetBC used to indicate that |
| * the child should be notified that it is no |
| * longer nested in this <tt>BeanContext</tt>. |
| * @return whether or not was present before being removed |
| */ |
| protected boolean remove(Object targetChild, boolean callChildSetBC) { |
| |
| if (targetChild == null) throw new IllegalArgumentException(); |
| |
| synchronized(BeanContext.globalHierarchyLock) { |
| if (!containsKey(targetChild)) return false; |
| |
| if (!validatePendingRemove(targetChild)) { |
| throw new IllegalStateException(); |
| } |
| |
| BCSChild bcsc = (BCSChild)children.get(targetChild); |
| BCSChild pbcsc = null; |
| Object peer = null; |
| |
| // we are required to notify the child that it is no longer nested here if |
| // it implements java.beans.beancontext.BeanContextChild |
| |
| synchronized(targetChild) { |
| if (callChildSetBC) { |
| BeanContextChild cbcc = getChildBeanContextChild(targetChild); |
| if (cbcc != null) synchronized(cbcc) { |
| cbcc.removePropertyChangeListener("beanContext", childPCL); |
| cbcc.removeVetoableChangeListener("beanContext", childVCL); |
| |
| try { |
| cbcc.setBeanContext(null); |
| } catch (PropertyVetoException pve1) { |
| cbcc.addPropertyChangeListener("beanContext", childPCL); |
| cbcc.addVetoableChangeListener("beanContext", childVCL); |
| throw new IllegalStateException(); |
| } |
| |
| } |
| } |
| |
| synchronized (children) { |
| children.remove(targetChild); |
| |
| if (bcsc.isProxyPeer()) { |
| pbcsc = (BCSChild)children.get(peer = bcsc.getProxyPeer()); |
| children.remove(peer); |
| } |
| } |
| |
| if (getChildSerializable(targetChild) != null) serializable--; |
| |
| childJustRemovedHook(targetChild, bcsc); |
| |
| if (peer != null) { |
| if (getChildSerializable(peer) != null) serializable--; |
| |
| childJustRemovedHook(peer, pbcsc); |
| } |
| } |
| |
| fireChildrenRemoved(new BeanContextMembershipEvent(getBeanContextPeer(), peer == null ? new Object[] { targetChild } : new Object[] { targetChild, peer } )); |
| |
| } |
| |
| return true; |
| } |
| |
| /** |
| * Tests to see if all objects in the |
| * specified <tt>Collection</tt> are children of |
| * this <tt>BeanContext</tt>. |
| * @param c the specified <tt>Collection</tt> |
| * |
| * @return <tt>true</tt> if all objects |
| * in the collection are children of |
| * this <tt>BeanContext</tt>, false if not. |
| */ |
| public boolean containsAll(Collection c) { |
| synchronized(children) { |
| Iterator i = c.iterator(); |
| while (i.hasNext()) |
| if(!contains(i.next())) |
| return false; |
| |
| return true; |
| } |
| } |
| |
| /** |
| * add Collection to set of Children (Unsupported) |
| * implementations must synchronized on the hierarchy lock and "children" protected field |
| * @throws UnsupportedOperationException thrown unconditionally by this implementation |
| * @return this implementation unconditionally throws {@code UnsupportedOperationException} |
| */ |
| public boolean addAll(Collection c) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * remove all specified children (Unsupported) |
| * implementations must synchronized on the hierarchy lock and "children" protected field |
| * @throws UnsupportedOperationException thrown unconditionally by this implementation |
| * @return this implementation unconditionally throws {@code UnsupportedOperationException} |
| |
| */ |
| public boolean removeAll(Collection c) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| |
| /** |
| * retain only specified children (Unsupported) |
| * implementations must synchronized on the hierarchy lock and "children" protected field |
| * @throws UnsupportedOperationException thrown unconditionally by this implementation |
| * @return this implementation unconditionally throws {@code UnsupportedOperationException} |
| */ |
| public boolean retainAll(Collection c) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * clear the children (Unsupported) |
| * implementations must synchronized on the hierarchy lock and "children" protected field |
| * @throws UnsupportedOperationException thrown unconditionally by this implementation |
| */ |
| public void clear() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * Adds a BeanContextMembershipListener |
| * |
| * @param bcml the BeanContextMembershipListener to add |
| * @throws NullPointerException if the argument is null |
| */ |
| |
| public void addBeanContextMembershipListener(BeanContextMembershipListener bcml) { |
| if (bcml == null) throw new NullPointerException("listener"); |
| |
| synchronized(bcmListeners) { |
| if (bcmListeners.contains(bcml)) |
| return; |
| else |
| bcmListeners.add(bcml); |
| } |
| } |
| |
| /** |
| * Removes a BeanContextMembershipListener |
| * |
| * @param bcml the BeanContextMembershipListener to remove |
| * @throws NullPointerException if the argument is null |
| */ |
| |
| public void removeBeanContextMembershipListener(BeanContextMembershipListener bcml) { |
| if (bcml == null) throw new NullPointerException("listener"); |
| |
| synchronized(bcmListeners) { |
| if (!bcmListeners.contains(bcml)) |
| return; |
| else |
| bcmListeners.remove(bcml); |
| } |
| } |
| |
| /** |
| * @param name the name of the resource requested. |
| * @param bcc the child object making the request. |
| * |
| * @return the requested resource as an InputStream |
| * @throws NullPointerException if the argument is null |
| */ |
| |
| public InputStream getResourceAsStream(String name, BeanContextChild bcc) { |
| if (name == null) throw new NullPointerException("name"); |
| if (bcc == null) throw new NullPointerException("bcc"); |
| |
| if (containsKey(bcc)) { |
| ClassLoader cl = bcc.getClass().getClassLoader(); |
| |
| return cl != null ? cl.getResourceAsStream(name) |
| : ClassLoader.getSystemResourceAsStream(name); |
| } else throw new IllegalArgumentException("Not a valid child"); |
| } |
| |
| /** |
| * @param name the name of the resource requested. |
| * @param bcc the child object making the request. |
| * |
| * @return the requested resource as an InputStream |
| */ |
| |
| public URL getResource(String name, BeanContextChild bcc) { |
| if (name == null) throw new NullPointerException("name"); |
| if (bcc == null) throw new NullPointerException("bcc"); |
| |
| if (containsKey(bcc)) { |
| ClassLoader cl = bcc.getClass().getClassLoader(); |
| |
| return cl != null ? cl.getResource(name) |
| : ClassLoader.getSystemResource(name); |
| } else throw new IllegalArgumentException("Not a valid child"); |
| } |
| |
| /** |
| * Sets the new design time value for this <tt>BeanContext</tt>. |
| * @param dTime the new designTime value |
| */ |
| public synchronized void setDesignTime(boolean dTime) { |
| if (designTime != dTime) { |
| designTime = dTime; |
| |
| firePropertyChange("designMode", Boolean.valueOf(!dTime), Boolean.valueOf(dTime)); |
| } |
| } |
| |
| |
| /** |
| * Reports whether or not this object is in |
| * currently in design time mode. |
| * @return <tt>true</tt> if in design time mode, |
| * <tt>false</tt> if not |
| */ |
| public synchronized boolean isDesignTime() { return designTime; } |
| |
| /** |
| * Sets the locale of this BeanContext. |
| * @param newLocale the new locale. This method call will have |
| * no effect if newLocale is <CODE>null</CODE>. |
| * @throws PropertyVetoException if the new value is rejected |
| */ |
| public synchronized void setLocale(Locale newLocale) throws PropertyVetoException { |
| |
| if ((locale != null && !locale.equals(newLocale)) && newLocale != null) { |
| Locale old = locale; |
| |
| fireVetoableChange("locale", old, newLocale); // throws |
| |
| locale = newLocale; |
| |
| firePropertyChange("locale", old, newLocale); |
| } |
| } |
| |
| /** |
| * Gets the locale for this <tt>BeanContext</tt>. |
| * |
| * @return the current Locale of the <tt>BeanContext</tt> |
| */ |
| public synchronized Locale getLocale() { return locale; } |
| |
| /** |
| * <p> |
| * This method is typically called from the environment in order to determine |
| * if the implementor "needs" a GUI. |
| * </p> |
| * <p> |
| * The algorithm used herein tests the BeanContextPeer, and its current children |
| * to determine if they are either Containers, Components, or if they implement |
| * Visibility and return needsGui() == true. |
| * </p> |
| * @return <tt>true</tt> if the implementor needs a GUI |
| */ |
| public synchronized boolean needsGui() { |
| BeanContext bc = getBeanContextPeer(); |
| |
| if (bc != this) { |
| if (bc instanceof Visibility) return ((Visibility)bc).needsGui(); |
| |
| if (bc instanceof Container || bc instanceof Component) |
| return true; |
| } |
| |
| synchronized(children) { |
| for (Iterator i = children.keySet().iterator(); i.hasNext();) { |
| Object c = i.next(); |
| |
| try { |
| return ((Visibility)c).needsGui(); |
| } catch (ClassCastException cce) { |
| // do nothing ... |
| } |
| |
| if (c instanceof Container || c instanceof Component) |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * notify this instance that it may no longer render a GUI. |
| */ |
| |
| public synchronized void dontUseGui() { |
| if (okToUseGui) { |
| okToUseGui = false; |
| |
| // lets also tell the Children that can that they may not use their GUI's |
| synchronized(children) { |
| for (Iterator i = children.keySet().iterator(); i.hasNext();) { |
| Visibility v = getChildVisibility(i.next()); |
| |
| if (v != null) v.dontUseGui(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Notify this instance that it may now render a GUI |
| */ |
| |
| public synchronized void okToUseGui() { |
| if (!okToUseGui) { |
| okToUseGui = true; |
| |
| // lets also tell the Children that can that they may use their GUI's |
| synchronized(children) { |
| for (Iterator i = children.keySet().iterator(); i.hasNext();) { |
| Visibility v = getChildVisibility(i.next()); |
| |
| if (v != null) v.okToUseGui(); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Used to determine if the <tt>BeanContext</tt> |
| * child is avoiding using its GUI. |
| * @return is this instance avoiding using its GUI? |
| * @see Visibility |
| */ |
| public boolean avoidingGui() { |
| return !okToUseGui && needsGui(); |
| } |
| |
| /** |
| * Is this <tt>BeanContext</tt> in the |
| * process of being serialized? |
| * @return if this <tt>BeanContext</tt> is |
| * currently being serialized |
| */ |
| public boolean isSerializing() { return serializing; } |
| |
| /** |
| * Returns an iterator of all children |
| * of this <tt>BeanContext</tt>. |
| * @return an iterator for all the current BCSChild values |
| */ |
| protected Iterator bcsChildren() { synchronized(children) { return children.values().iterator(); } } |
| |
| /** |
| * called by writeObject after defaultWriteObject() but prior to |
| * serialization of currently serializable children. |
| * |
| * This method may be overridden by subclasses to perform custom |
| * serialization of their state prior to this superclass serializing |
| * the children. |
| * |
| * This method should not however be used by subclasses to replace their |
| * own implementation (if any) of writeObject(). |
| * @param oos the {@code ObjectOutputStream} to use during serialization |
| * @throws IOException if serialization failed |
| */ |
| |
| protected void bcsPreSerializationHook(ObjectOutputStream oos) throws IOException { |
| } |
| |
| /** |
| * called by readObject after defaultReadObject() but prior to |
| * deserialization of any children. |
| * |
| * This method may be overridden by subclasses to perform custom |
| * deserialization of their state prior to this superclass deserializing |
| * the children. |
| * |
| * This method should not however be used by subclasses to replace their |
| * own implementation (if any) of readObject(). |
| * @param ois the {@code ObjectInputStream} to use during deserialization |
| * @throws IOException if deserialization failed |
| * @throws ClassNotFoundException if needed classes are not found |
| */ |
| |
| protected void bcsPreDeserializationHook(ObjectInputStream ois) throws IOException, ClassNotFoundException { |
| } |
| |
| /** |
| * Called by readObject with the newly deserialized child and BCSChild. |
| * @param child the newly deserialized child |
| * @param bcsc the newly deserialized BCSChild |
| */ |
| protected void childDeserializedHook(Object child, BCSChild bcsc) { |
| synchronized(children) { |
| children.put(child, bcsc); |
| } |
| } |
| |
| /** |
| * Used by writeObject to serialize a Collection. |
| * @param oos the <tt>ObjectOutputStream</tt> |
| * to use during serialization |
| * @param coll the <tt>Collection</tt> to serialize |
| * @throws IOException if serialization failed |
| */ |
| protected final void serialize(ObjectOutputStream oos, Collection coll) throws IOException { |
| int count = 0; |
| Object[] objects = coll.toArray(); |
| |
| for (int i = 0; i < objects.length; i++) { |
| if (objects[i] instanceof Serializable) |
| count++; |
| else |
| objects[i] = null; |
| } |
| |
| oos.writeInt(count); // number of subsequent objects |
| |
| for (int i = 0; count > 0; i++) { |
| Object o = objects[i]; |
| |
| if (o != null) { |
| oos.writeObject(o); |
| count--; |
| } |
| } |
| } |
| |
| /** |
| * used by readObject to deserialize a collection. |
| * @param ois the ObjectInputStream to use |
| * @param coll the Collection |
| * @throws IOException if deserialization failed |
| * @throws ClassNotFoundException if needed classes are not found |
| */ |
| protected final void deserialize(ObjectInputStream ois, Collection coll) throws IOException, ClassNotFoundException { |
| int count = 0; |
| |
| count = ois.readInt(); |
| |
| while (count-- > 0) { |
| coll.add(ois.readObject()); |
| } |
| } |
| |
| /** |
| * Used to serialize all children of |
| * this <tt>BeanContext</tt>. |
| * @param oos the <tt>ObjectOutputStream</tt> |
| * to use during serialization |
| * @throws IOException if serialization failed |
| */ |
| public final void writeChildren(ObjectOutputStream oos) throws IOException { |
| if (serializable <= 0) return; |
| |
| boolean prev = serializing; |
| |
| serializing = true; |
| |
| int count = 0; |
| |
| synchronized(children) { |
| Iterator i = children.entrySet().iterator(); |
| |
| while (i.hasNext() && count < serializable) { |
| Map.Entry entry = (Map.Entry)i.next(); |
| |
| if (entry.getKey() instanceof Serializable) { |
| try { |
| oos.writeObject(entry.getKey()); // child |
| oos.writeObject(entry.getValue()); // BCSChild |
| } catch (IOException ioe) { |
| serializing = prev; |
| throw ioe; |
| } |
| count++; |
| } |
| } |
| } |
| |
| serializing = prev; |
| |
| if (count != serializable) { |
| throw new IOException("wrote different number of children than expected"); |
| } |
| |
| } |
| |
| /** |
| * Serialize the BeanContextSupport, if this instance has a distinct |
| * peer (that is this object is acting as a delegate for another) then |
| * the children of this instance are not serialized here due to a |
| * 'chicken and egg' problem that occurs on deserialization of the |
| * children at the same time as this instance. |
| * |
| * Therefore in situations where there is a distinct peer to this instance |
| * it should always call writeObject() followed by writeChildren() and |
| * readObject() followed by readChildren(). |
| * |
| * @param oos the ObjectOutputStream |
| */ |
| |
| private synchronized void writeObject(ObjectOutputStream oos) throws IOException, ClassNotFoundException { |
| serializing = true; |
| |
| synchronized (BeanContext.globalHierarchyLock) { |
| try { |
| oos.defaultWriteObject(); // serialize the BeanContextSupport object |
| |
| bcsPreSerializationHook(oos); |
| |
| if (serializable > 0 && this.equals(getBeanContextPeer())) |
| writeChildren(oos); |
| |
| serialize(oos, (Collection)bcmListeners); |
| } finally { |
| serializing = false; |
| } |
| } |
| } |
| |
| /** |
| * When an instance of this class is used as a delegate for the |
| * implementation of the BeanContext protocols (and its subprotocols) |
| * there exists a 'chicken and egg' problem during deserialization |
| * @param ois the ObjectInputStream to use |
| * @throws IOException if deserialization failed |
| * @throws ClassNotFoundException if needed classes are not found |
| */ |
| |
| public final void readChildren(ObjectInputStream ois) throws IOException, ClassNotFoundException { |
| int count = serializable; |
| |
| while (count-- > 0) { |
| Object child = null; |
| BeanContextSupport.BCSChild bscc = null; |
| |
| try { |
| child = ois.readObject(); |
| bscc = (BeanContextSupport.BCSChild)ois.readObject(); |
| } catch (IOException ioe) { |
| continue; |
| } catch (ClassNotFoundException cnfe) { |
| continue; |
| } |
| |
| |
| synchronized(child) { |
| BeanContextChild bcc = null; |
| |
| try { |
| bcc = (BeanContextChild)child; |
| } catch (ClassCastException cce) { |
| // do nothing; |
| } |
| |
| if (bcc != null) { |
| try { |
| bcc.setBeanContext(getBeanContextPeer()); |
| |
| bcc.addPropertyChangeListener("beanContext", childPCL); |
| bcc.addVetoableChangeListener("beanContext", childVCL); |
| |
| } catch (PropertyVetoException pve) { |
| continue; |
| } |
| } |
| |
| childDeserializedHook(child, bscc); |
| } |
| } |
| } |
| |
| /** |
| * deserialize contents ... if this instance has a distinct peer the |
| * children are *not* serialized here, the peer's readObject() must call |
| * readChildren() after deserializing this instance. |
| */ |
| |
| private synchronized void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException { |
| |
| synchronized(BeanContext.globalHierarchyLock) { |
| ois.defaultReadObject(); |
| |
| initialize(); |
| |
| bcsPreDeserializationHook(ois); |
| |
| if (serializable > 0 && this.equals(getBeanContextPeer())) |
| readChildren(ois); |
| |
| deserialize(ois, bcmListeners = new ArrayList(1)); |
| } |
| } |
| |
| /** |
| * subclasses may envelope to monitor veto child property changes. |
| */ |
| |
| public void vetoableChange(PropertyChangeEvent pce) throws PropertyVetoException { |
| String propertyName = pce.getPropertyName(); |
| Object source = pce.getSource(); |
| |
| synchronized(children) { |
| if ("beanContext".equals(propertyName) && |
| containsKey(source) && |
| !getBeanContextPeer().equals(pce.getNewValue()) |
| ) { |
| if (!validatePendingRemove(source)) { |
| throw new PropertyVetoException("current BeanContext vetoes setBeanContext()", pce); |
| } else ((BCSChild)children.get(source)).setRemovePending(true); |
| } |
| } |
| } |
| |
| /** |
| * subclasses may envelope to monitor child property changes. |
| */ |
| |
| public void propertyChange(PropertyChangeEvent pce) { |
| String propertyName = pce.getPropertyName(); |
| Object source = pce.getSource(); |
| |
| synchronized(children) { |
| if ("beanContext".equals(propertyName) && |
| containsKey(source) && |
| ((BCSChild)children.get(source)).isRemovePending()) { |
| BeanContext bc = getBeanContextPeer(); |
| |
| if (bc.equals(pce.getOldValue()) && !bc.equals(pce.getNewValue())) { |
| remove(source, false); |
| } else { |
| ((BCSChild)children.get(source)).setRemovePending(false); |
| } |
| } |
| } |
| } |
| |
| /** |
| * <p> |
| * Subclasses of this class may override, or envelope, this method to |
| * add validation behavior for the BeanContext to examine child objects |
| * immediately prior to their being added to the BeanContext. |
| * </p> |
| * |
| * @param targetChild the child to create the Child on behalf of |
| * @return true iff the child may be added to this BeanContext, otherwise false. |
| */ |
| |
| protected boolean validatePendingAdd(Object targetChild) { |
| return true; |
| } |
| |
| /** |
| * <p> |
| * Subclasses of this class may override, or envelope, this method to |
| * add validation behavior for the BeanContext to examine child objects |
| * immediately prior to their being removed from the BeanContext. |
| * </p> |
| * |
| * @param targetChild the child to create the Child on behalf of |
| * @return true iff the child may be removed from this BeanContext, otherwise false. |
| */ |
| |
| protected boolean validatePendingRemove(Object targetChild) { |
| return true; |
| } |
| |
| /** |
| * subclasses may override this method to simply extend add() semantics |
| * after the child has been added and before the event notification has |
| * occurred. The method is called with the child synchronized. |
| * @param child the child |
| * @param bcsc the BCSChild |
| */ |
| |
| protected void childJustAddedHook(Object child, BCSChild bcsc) { |
| } |
| |
| /** |
| * subclasses may override this method to simply extend remove() semantics |
| * after the child has been removed and before the event notification has |
| * occurred. The method is called with the child synchronized. |
| * @param child the child |
| * @param bcsc the BCSChild |
| */ |
| |
| protected void childJustRemovedHook(Object child, BCSChild bcsc) { |
| } |
| |
| /** |
| * Gets the Component (if any) associated with the specified child. |
| * @param child the specified child |
| * @return the Component (if any) associated with the specified child. |
| */ |
| protected static final Visibility getChildVisibility(Object child) { |
| try { |
| return (Visibility)child; |
| } catch (ClassCastException cce) { |
| return null; |
| } |
| } |
| |
| /** |
| * Gets the Serializable (if any) associated with the specified Child |
| * @param child the specified child |
| * @return the Serializable (if any) associated with the specified Child |
| */ |
| protected static final Serializable getChildSerializable(Object child) { |
| try { |
| return (Serializable)child; |
| } catch (ClassCastException cce) { |
| return null; |
| } |
| } |
| |
| /** |
| * Gets the PropertyChangeListener |
| * (if any) of the specified child |
| * @param child the specified child |
| * @return the PropertyChangeListener (if any) of the specified child |
| */ |
| protected static final PropertyChangeListener getChildPropertyChangeListener(Object child) { |
| try { |
| return (PropertyChangeListener)child; |
| } catch (ClassCastException cce) { |
| return null; |
| } |
| } |
| |
| /** |
| * Gets the VetoableChangeListener |
| * (if any) of the specified child |
| * @param child the specified child |
| * @return the VetoableChangeListener (if any) of the specified child |
| */ |
| protected static final VetoableChangeListener getChildVetoableChangeListener(Object child) { |
| try { |
| return (VetoableChangeListener)child; |
| } catch (ClassCastException cce) { |
| return null; |
| } |
| } |
| |
| /** |
| * Gets the BeanContextMembershipListener |
| * (if any) of the specified child |
| * @param child the specified child |
| * @return the BeanContextMembershipListener (if any) of the specified child |
| */ |
| protected static final BeanContextMembershipListener getChildBeanContextMembershipListener(Object child) { |
| try { |
| return (BeanContextMembershipListener)child; |
| } catch (ClassCastException cce) { |
| return null; |
| } |
| } |
| |
| /** |
| * Gets the BeanContextChild (if any) of the specified child |
| * @param child the specified child |
| * @return the BeanContextChild (if any) of the specified child |
| * @throws IllegalArgumentException if child implements both BeanContextChild and BeanContextProxy |
| */ |
| protected static final BeanContextChild getChildBeanContextChild(Object child) { |
| try { |
| BeanContextChild bcc = (BeanContextChild)child; |
| |
| if (child instanceof BeanContextChild && child instanceof BeanContextProxy) |
| throw new IllegalArgumentException("child cannot implement both BeanContextChild and BeanContextProxy"); |
| else |
| return bcc; |
| } catch (ClassCastException cce) { |
| try { |
| return ((BeanContextProxy)child).getBeanContextProxy(); |
| } catch (ClassCastException cce1) { |
| return null; |
| } |
| } |
| } |
| |
| /** |
| * Fire a BeanContextshipEvent on the BeanContextMembershipListener interface |
| * @param bcme the event to fire |
| */ |
| |
| protected final void fireChildrenAdded(BeanContextMembershipEvent bcme) { |
| Object[] copy; |
| |
| synchronized(bcmListeners) { copy = bcmListeners.toArray(); } |
| |
| for (int i = 0; i < copy.length; i++) |
| ((BeanContextMembershipListener)copy[i]).childrenAdded(bcme); |
| } |
| |
| /** |
| * Fire a BeanContextshipEvent on the BeanContextMembershipListener interface |
| * @param bcme the event to fire |
| */ |
| |
| protected final void fireChildrenRemoved(BeanContextMembershipEvent bcme) { |
| Object[] copy; |
| |
| synchronized(bcmListeners) { copy = bcmListeners.toArray(); } |
| |
| for (int i = 0; i < copy.length; i++) |
| ((BeanContextMembershipListener)copy[i]).childrenRemoved(bcme); |
| } |
| |
| /** |
| * protected method called from constructor and readObject to initialize |
| * transient state of BeanContextSupport instance. |
| * |
| * This class uses this method to instantiate inner class listeners used |
| * to monitor PropertyChange and VetoableChange events on children. |
| * |
| * subclasses may envelope this method to add their own initialization |
| * behavior |
| */ |
| |
| protected synchronized void initialize() { |
| children = new HashMap(serializable + 1); |
| bcmListeners = new ArrayList(1); |
| |
| childPCL = new PropertyChangeListener() { |
| |
| /* |
| * this adaptor is used by the BeanContextSupport class to forward |
| * property changes from a child to the BeanContext, avoiding |
| * accidential serialization of the BeanContext by a badly |
| * behaved Serializable child. |
| */ |
| |
| public void propertyChange(PropertyChangeEvent pce) { |
| BeanContextSupport.this.propertyChange(pce); |
| } |
| }; |
| |
| childVCL = new VetoableChangeListener() { |
| |
| /* |
| * this adaptor is used by the BeanContextSupport class to forward |
| * vetoable changes from a child to the BeanContext, avoiding |
| * accidential serialization of the BeanContext by a badly |
| * behaved Serializable child. |
| */ |
| |
| public void vetoableChange(PropertyChangeEvent pce) throws PropertyVetoException { |
| BeanContextSupport.this.vetoableChange(pce); |
| } |
| }; |
| } |
| |
| /** |
| * Gets a copy of the this BeanContext's children. |
| * @return a copy of the current nested children |
| */ |
| protected final Object[] copyChildren() { |
| synchronized(children) { return children.keySet().toArray(); } |
| } |
| |
| /** |
| * Tests to see if two class objects, |
| * or their names are equal. |
| * @param first the first object |
| * @param second the second object |
| * @return true if equal, false if not |
| */ |
| protected static final boolean classEquals(Class first, Class second) { |
| return first.equals(second) || first.getName().equals(second.getName()); |
| } |
| |
| |
| /* |
| * fields |
| */ |
| |
| |
| /** |
| * all accesses to the <code> protected HashMap children </code> field |
| * shall be synchronized on that object. |
| */ |
| protected transient HashMap children; |
| |
| private int serializable = 0; // children serializable |
| |
| /** |
| * all accesses to the <code> protected ArrayList bcmListeners </code> field |
| * shall be synchronized on that object. |
| */ |
| protected transient ArrayList bcmListeners; |
| |
| // |
| |
| /** |
| * The current locale of this BeanContext. |
| */ |
| protected Locale locale; |
| |
| /** |
| * A <tt>boolean</tt> indicating if this |
| * instance may now render a GUI. |
| */ |
| protected boolean okToUseGui; |
| |
| |
| /** |
| * A <tt>boolean</tt> indicating whether or not |
| * this object is currently in design time mode. |
| */ |
| protected boolean designTime; |
| |
| /* |
| * transient |
| */ |
| |
| private transient PropertyChangeListener childPCL; |
| |
| private transient VetoableChangeListener childVCL; |
| |
| private transient boolean serializing; |
| } |
