| /* |
| * Licensed to the Apache Software Foundation (ASF) under one or more |
| * contributor license agreements. See the NOTICE file distributed with |
| * this work for additional information regarding copyright ownership. |
| * The ASF licenses this file to You under the Apache License, Version 2.0 |
| * (the "License"); you may not use this file except in compliance with |
| * the License. You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package java.beans.beancontext; |
| |
| import java.awt.Component; |
| import java.beans.Beans; |
| import java.beans.PropertyChangeEvent; |
| import java.beans.PropertyChangeListener; |
| import java.beans.PropertyVetoException; |
| import java.beans.VetoableChangeListener; |
| 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 org.apache.harmony.beans.internal.nls.Messages; |
| |
| /** |
| * This support class implements <code>BeanContext</code> interface. |
| * This class can be used directly, or be a super class of your class, |
| * or be a delegate of your implementation that needs to support |
| * <code>BeanContext</code> interface. |
| * |
| */ |
| public class BeanContextSupport extends BeanContextChildSupport implements |
| BeanContext, PropertyChangeListener, VetoableChangeListener, |
| Serializable { |
| |
| /** |
| * Every child of context is companied with a <code>BCSChild</code> |
| * instance. It can hold implementation specific information about |
| * each child. |
| * <p> |
| * This class holds references of the child and its peer if there is one.</p> |
| * |
| */ |
| protected class BCSChild implements Serializable { |
| |
| private static final long serialVersionUID = -5815286101609939109L; |
| |
| Object child; |
| |
| Object proxyPeer; |
| |
| BCSChild(Object child, Object proxyPeer) { |
| this.child = child; |
| this.proxyPeer = proxyPeer; |
| } |
| } |
| |
| /** |
| * This implementation wraps an iterator and override |
| * <code>remove()</code> with a noop method. |
| * |
| */ |
| protected static final class BCSIterator implements Iterator { |
| |
| private Iterator backIter; |
| |
| BCSIterator(Iterator backIter) { |
| this.backIter = backIter; |
| } |
| |
| public boolean hasNext() { |
| return backIter.hasNext(); |
| } |
| |
| public Object next() { |
| return backIter.next(); |
| } |
| |
| public void remove() { |
| // no-op |
| } |
| } |
| |
| private static final long serialVersionUID = -4879613978649577204L; //J2SE 1.4.2 |
| |
| /** |
| * A list of registered membership listeners. |
| * All access to this object should be synchronized on itself. |
| */ |
| @SuppressWarnings("unchecked") |
| transient protected ArrayList bcmListeners; |
| |
| /** |
| * A map of children - key is child instance, value is <code>BCSChild</code> instance. |
| * All access to this object should be synchronized on itself. |
| */ |
| @SuppressWarnings("unchecked") |
| transient protected HashMap children; |
| |
| transient private boolean serializing; |
| |
| transient private boolean inNeedsGui; |
| |
| transient private PropertyChangeListener nonSerPCL; |
| |
| private int serializable; |
| |
| /** |
| * The locale of this context. |
| */ |
| protected Locale locale; |
| |
| /** |
| * A flag indicating whether this context is allowed to use GUI. |
| */ |
| protected boolean okToUseGui; |
| |
| /** |
| * A flag indicating whether this context is in design mode. |
| */ |
| protected boolean designTime; |
| |
| /** |
| * Constructs a standload <code>BeanContextSupport</code>. |
| */ |
| public BeanContextSupport() { |
| this(null, Locale.getDefault(), false, true); |
| } |
| |
| /** |
| * Constructs a <code>BeanContextSupport</code> which is a delegate |
| * of the given peer. |
| * |
| * @param peer the peer of this context |
| */ |
| public BeanContextSupport(BeanContext peer) { |
| this(peer, Locale.getDefault(), false, true); |
| } |
| |
| /** |
| * Constructs a <code>BeanContextSupport</code> which is a delegate |
| * of the given peer. |
| * |
| * @param peer the peer of this context |
| * @param locale the locale of this context |
| */ |
| public BeanContextSupport(BeanContext peer, Locale locale) { |
| this(peer, locale, false, true); |
| } |
| |
| /** |
| * Constructs a <code>BeanContextSupport</code> which is a delegate |
| * of the given peer. |
| * |
| * @param peer the peer of this context |
| * @param locale the locale of this context |
| * @param designTime whether in design mode or not |
| */ |
| public BeanContextSupport(BeanContext peer, Locale locale, |
| boolean designTime) { |
| this(peer, locale, designTime, true); |
| } |
| |
| /** |
| * Constructs a <code>BeanContextSupport</code> which is a delegate |
| * of the given peer. |
| * |
| * @param peer the peer of this context |
| * @param locale the locale of this context |
| * @param designTime whether in design mode or not |
| * @param okToUseGui whether GUI is usable or not |
| */ |
| public BeanContextSupport(BeanContext peer, Locale locale, |
| boolean designTime, boolean okToUseGui) { |
| super(peer); |
| if (locale == null) { |
| locale = Locale.getDefault(); |
| } |
| this.locale = locale; |
| this.designTime = designTime; |
| this.okToUseGui = okToUseGui; |
| |
| initialize(); |
| } |
| |
| /** |
| * Add a child to this context. |
| * <p> |
| * If the child already exists in this context, simply returns false. |
| * Otherwise, it is validated by calling <code>validatePendingAdd()</code>. |
| * If the add is valid, the child and its proxy (if the child implements |
| * <code>BeanContextProxy</code>) is then added, and <code>setBeanContext()</code> |
| * is called on it (if the child implements <code>BeanContextChild</code> |
| * or it has a proxy). Last, the <code>childJustAddedHook()</code> is |
| * called and all registered <code>BeanContextMembershipListener</code>s |
| * are notified.</p> |
| * |
| * @param child the child to add |
| * @return true if the child is added to this context; otherwise false |
| * @throws IllegalStateException if the child is not valid to add |
| * @see java.util.Collection#add(java.lang.Object) |
| */ |
| @SuppressWarnings("unchecked") |
| public boolean add(Object child) { |
| if (child == null) { |
| throw new IllegalArgumentException(Messages.getString("beans.67")); |
| } |
| |
| BeanContextChild proxy = null; |
| |
| synchronized (globalHierarchyLock) { |
| // check existence |
| if (contains(child)) { |
| return false; |
| } |
| |
| // check serializing state |
| if (serializing) { |
| throw new IllegalStateException( |
| Messages.getString("beans.68")); |
| } |
| |
| // validate |
| boolean valid = validatePendingAdd(child); |
| if (!valid) { |
| throw new IllegalStateException( |
| Messages.getString("beans.69")); |
| } |
| |
| // find the proxy, if there's one |
| if (child instanceof BeanContextProxy) { |
| proxy = ((BeanContextProxy) child).getBeanContextProxy(); |
| if (proxy == null) { |
| throw new NullPointerException( |
| Messages.getString("beans.6A")); |
| } |
| } |
| BeanContextChild beanContextChild = getChildBeanContextChild(child); |
| |
| // add to children |
| BCSChild childBCSC = null, proxyBCSC = null; |
| synchronized (children) { |
| childBCSC = createBCSChild(child, proxy); |
| children.put(child, childBCSC); |
| if (proxy != null) { |
| proxyBCSC = createBCSChild(proxy, child); |
| children.put(proxy, proxyBCSC); |
| } |
| } |
| |
| // set child's beanContext property |
| if (beanContextChild != null) { |
| try { |
| beanContextChild.setBeanContext(getBeanContextPeer()); |
| } catch (PropertyVetoException e) { |
| synchronized (children) { |
| children.remove(child); |
| if (proxy != null) { |
| children.remove(proxy); |
| } |
| } |
| throw new IllegalStateException( |
| Messages.getString("beans.6B")); |
| } |
| // ensure no duplicate listener |
| beanContextChild.removePropertyChangeListener("beanContext", |
| nonSerPCL); |
| // listen to child's beanContext change |
| beanContextChild.addPropertyChangeListener("beanContext", |
| nonSerPCL); |
| } |
| |
| // trigger hook |
| synchronized (child) { |
| addSerializable(childBCSC); |
| childJustAddedHook(child, childBCSC); |
| } |
| if (proxy != null) { |
| synchronized (proxy) { |
| addSerializable(proxyBCSC); |
| childJustAddedHook(proxy, proxyBCSC); |
| } |
| } |
| } |
| |
| // notify listeners |
| fireChildrenAdded(new BeanContextMembershipEvent(getBeanContextPeer(), |
| proxy == null ? new Object[] { child } : new Object[] { child, |
| proxy })); |
| return true; |
| } |
| |
| /** |
| * This method is unsupported, throws <code>UnsupportedOperationException</code>. |
| * |
| * @see java.util.Collection#addAll(java.util.Collection) |
| */ |
| public boolean addAll(Collection collection) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.beancontext.BeanContext#addBeanContextMembershipListener(java.beans.beancontext.BeanContextMembershipListener) |
| */ |
| public void addBeanContextMembershipListener( |
| BeanContextMembershipListener listener) { |
| if (listener == null) { |
| throw new NullPointerException(); |
| } |
| synchronized (bcmListeners) { |
| if (!bcmListeners.contains(listener)) { |
| bcmListeners.add(listener); |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.Visibility#avoidingGui() |
| */ |
| public boolean avoidingGui() { |
| // Avoiding GUI means that |
| // GUI is needed but not allowed to use at this time |
| return (needsGui() && !this.okToUseGui); |
| } |
| |
| /** |
| * Returns an iterator of all <code>BCSChild</code> instances, |
| * with <code>remove()</code> disabled. |
| * |
| * @return an iterator of all <code>BCSChild</code> instances |
| */ |
| protected Iterator bcsChildren() { |
| synchronized (children) { |
| return new BCSIterator(children.values().iterator()); |
| } |
| } |
| |
| /** |
| * This method is called by <code>readObject()</code> after |
| * <code>defaultReadObject()</code> and before deserializing any |
| * children or listeners. Subclass can insert its specific |
| * deserialization behavior by overrideing this method. |
| * <p> |
| * The default implementation does nothing.</p> |
| * |
| * @param ois the object input stream |
| * @throws IOException |
| * @throws ClassNotFoundException |
| */ |
| protected void bcsPreDeserializationHook(ObjectInputStream ois) |
| throws IOException, ClassNotFoundException { |
| // to be overridden |
| } |
| |
| /** |
| * This method is called by <code>writeObject()</code> after |
| * <code>defaultWriteObject()</code> and before serializing any |
| * children or listeners. Subclass can insert its specific |
| * serialization behavior by overrideing this method. |
| * <p> |
| * The default implementation does nothing.</p> |
| * |
| * @param oos the object output stream |
| * @throws IOException |
| */ |
| protected void bcsPreSerializationHook(ObjectOutputStream oos) |
| throws IOException { |
| // to be overridden |
| } |
| |
| /** |
| * This method is called during deserialization everytime a child is read. |
| * <p> |
| * The default implementation does nothing.</p> |
| * |
| * @param child the child just deserialized |
| * @param bcsChild the <code>BCSChild</code> just deserialized |
| */ |
| protected void childDeserializedHook(Object child, BCSChild bcsChild) { |
| // to be overridden |
| } |
| |
| /** |
| * This method is called everytime a child is added to this context. |
| * This method is called with child synchronized. |
| * <p> |
| * The default implementation does nothing.</p> |
| * |
| * @param child the child just added |
| * @param bcsChild the <code>BCSChild</code> just added |
| */ |
| protected void childJustAddedHook(Object child, BCSChild bcsChild) { |
| // to be overridden |
| } |
| |
| /** |
| * This method is called everytime a child is removed from this context. |
| * This method is called with child synchronized. |
| * <p> |
| * The default implementation does nothing.</p> |
| * |
| * @param child the child just removed |
| * @param bcsChild the <code>BCSChild</code> just removed |
| */ |
| protected void childJustRemovedHook(Object child, BCSChild bcsChild) { |
| // to be overridden |
| } |
| |
| /** |
| * Compares if two classes are equal or their class names are equal. |
| * |
| * @param clz1 a class |
| * @param clz2 another class |
| * @return true if two class objects are equal or their class names are equal. |
| */ |
| protected static final boolean classEquals(Class clz1, Class clz2) { |
| if (clz1 == null || clz2 == null) { |
| throw new NullPointerException(); |
| } |
| return clz1 == clz2 || clz1.getName().equals(clz2.getName()); |
| } |
| |
| /** |
| * This method is unsupported, throws <code>UnsupportedOperationException</code>. |
| * |
| * @see java.util.Collection#clear() |
| */ |
| public void clear() { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * Returns true if the given object is a child of this context. |
| * |
| * @param child the object to test |
| * @return true if the given object is a child of this context |
| * @see java.util.Collection#contains(java.lang.Object) |
| */ |
| public boolean contains(Object child) { |
| synchronized (children) { |
| return children.containsKey(child); |
| } |
| } |
| |
| /** |
| * Returns true if given objects are children of this context. |
| * |
| * @param collection a collection of objects |
| * @return true if given objects are children of this context |
| * @see java.util.Collection#containsAll(java.util.Collection) |
| */ |
| @SuppressWarnings("unchecked") |
| public boolean containsAll(Collection collection) { |
| synchronized (children) { |
| return children.keySet().containsAll(collection); |
| } |
| } |
| |
| /** |
| * Returns true if the given object is a child of this context. |
| * |
| * @param child the object to test |
| * @return true if the given object is a child of this context |
| */ |
| public boolean containsKey(Object child) { |
| synchronized (children) { |
| return children.containsKey(child); |
| } |
| } |
| |
| /** |
| * Returns an array containing all children of this context. |
| * |
| * @return an array containing all children of this context |
| */ |
| protected final Object[] copyChildren() { |
| synchronized (children) { |
| return children.keySet().toArray(); |
| } |
| } |
| |
| /** |
| * Creates a <code>BCSChild</code> object to company the given child. |
| * |
| * @param child the child |
| * @param proxyPeer the proxy peer of the child if there is one |
| * @return a <code>BCSChild</code> object to company the given child |
| */ |
| protected BCSChild createBCSChild(Object child, Object proxyPeer) { |
| return new BCSChild(child, proxyPeer); |
| } |
| |
| /** |
| * Deserialize a collection. |
| * <p> |
| * First read a <code>int</code> indicating of number of rest objects, |
| * then read the objects one by one.</p> |
| * |
| * @param ois the stream where the collection is read from |
| * @param collection the collection to hold read objects |
| * @throws IOException if I/O exception occurs |
| * @throws ClassNotFoundException if class of any read object is not found |
| */ |
| @SuppressWarnings("unchecked") |
| protected final void deserialize(ObjectInputStream ois, |
| Collection collection) throws IOException, ClassNotFoundException { |
| int size = ois.readInt(); |
| for (int i = 0; i < size; i++) { |
| collection.add(ois.readObject()); |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.Visibility#dontUseGui() |
| */ |
| public void dontUseGui() { |
| okToUseGui = false; |
| } |
| |
| /** |
| * Notifies registered <code>BeanContextMembershipListener</code>s that |
| * a new child has been added. |
| * |
| * @param event the <code>BeanContextMembershipEvent</code> |
| */ |
| protected final void fireChildrenAdded(BeanContextMembershipEvent event) { |
| Object listeners[]; |
| synchronized (bcmListeners) { |
| listeners = bcmListeners.toArray(); |
| } |
| for (int i = 0; i < listeners.length; i++) { |
| BeanContextMembershipListener l = (BeanContextMembershipListener) listeners[i]; |
| l.childrenAdded(event); |
| } |
| } |
| |
| /** |
| * Notifies registered <code>BeanContextMembershipListener</code>s that |
| * a child has been removed. |
| * |
| * @param event the <code>BeanContextMembershipEvent</code> |
| */ |
| protected final void fireChildrenRemoved(BeanContextMembershipEvent event) { |
| Object listeners[]; |
| synchronized (bcmListeners) { |
| listeners = bcmListeners.toArray(); |
| } |
| for (int i = 0; i < listeners.length; i++) { |
| BeanContextMembershipListener l = (BeanContextMembershipListener) listeners[i]; |
| l.childrenRemoved(event); |
| } |
| } |
| |
| /** |
| * Returns the peer of this context casted as <code>BeanContext</code>. |
| * |
| * @return the peer of this context casted as <code>BeanContext</code> |
| */ |
| public BeanContext getBeanContextPeer() { |
| return (BeanContext) beanContextChildPeer; |
| } |
| |
| /** |
| * Returns the <code>BeanContextChild</code> related with the given child. |
| * <p> |
| * If the child implements <code>BeanContextChild</code>, it is returned. |
| * If the child implements <code>BeanContextProxy</code>, the proxy is returned. |
| * Otherwise, null is returned.</p> |
| * |
| * @param child a child |
| * @return the <code>BeanContextChild</code> related with the given child |
| * @throws IllegalStateException if the child implements both <code>BeanContextChild</code> and <code>BeanContextProxy</code> |
| */ |
| protected static final BeanContextChild getChildBeanContextChild( |
| Object child) { |
| if (child instanceof BeanContextChild) { |
| if (child instanceof BeanContextProxy) { |
| throw new IllegalArgumentException( |
| Messages.getString("beans.6C")); |
| } |
| return (BeanContextChild) child; |
| } |
| if (child instanceof BeanContextProxy) { |
| if (child instanceof BeanContextChild) { |
| throw new IllegalArgumentException( |
| Messages.getString("beans.6C")); |
| } |
| return ((BeanContextProxy) child).getBeanContextProxy(); |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the given child casted to <code>BeanContextMembershipListener</code>, |
| * or null if it does not implements the interface. |
| * |
| * @param child a child |
| * @return the given child casted to <code>BeanContextMembershipListener</code>, |
| * or null if it does not implements the interface |
| */ |
| protected static final BeanContextMembershipListener getChildBeanContextMembershipListener( |
| Object child) { |
| if (child instanceof BeanContextMembershipListener) { |
| return (BeanContextMembershipListener) child; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the given child casted to <code>PropertyChangeListener</code>, |
| * or null if it does not implements the interface. |
| * |
| * @param child a child |
| * @return the given child casted to <code>PropertyChangeListener</code>, |
| * or null if it does not implements the interface |
| */ |
| protected static final PropertyChangeListener getChildPropertyChangeListener( |
| Object child) { |
| if (child instanceof PropertyChangeListener) { |
| return (PropertyChangeListener) child; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the given child casted to <code>Serializable</code>, |
| * or null if it does not implements the interface. |
| * |
| * @param child a child |
| * @return the given child casted to <code>Serializable</code>, |
| * or null if it does not implements the interface |
| */ |
| protected static final Serializable getChildSerializable(Object child) { |
| if (child instanceof Serializable) { |
| return (Serializable) child; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the given child casted to <code>VetoableChangeListener</code>, |
| * or null if it does not implements the interface. |
| * |
| * @param child a child |
| * @return the given child casted to <code>VetoableChangeListener</code>, |
| * or null if it does not implements the interface |
| */ |
| protected static final VetoableChangeListener getChildVetoableChangeListener( |
| Object child) { |
| if (child instanceof VetoableChangeListener) { |
| return (VetoableChangeListener) child; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the given child casted to <code>Visibility</code>, |
| * or null if it does not implements the interface. |
| * |
| * @param child a child |
| * @return the given child casted to <code>Visibility</code>, |
| * or null if it does not implements the interface |
| */ |
| protected static final Visibility getChildVisibility(Object child) { |
| if (child instanceof Visibility) { |
| return (Visibility) child; |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Returns the locale of this context. |
| * |
| * @return the locale of this context |
| */ |
| public Locale getLocale() { |
| return locale; |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.beancontext.BeanContext#getResource(java.lang.String, java.beans.beancontext.BeanContextChild) |
| */ |
| public URL getResource(String resourceName, BeanContextChild child) { |
| if (resourceName == null || child == null) { |
| throw new NullPointerException(); |
| } |
| if (!contains(child)) { |
| throw new IllegalArgumentException(Messages.getString("beans.6D")); |
| } |
| |
| return ClassLoader.getSystemResource(resourceName); |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.beancontext.BeanContext#getResourceAsStream(java.lang.String, java.beans.beancontext.BeanContextChild) |
| */ |
| public InputStream getResourceAsStream(String resourceName, |
| BeanContextChild child) throws IllegalArgumentException { |
| if (resourceName == null || child == null) { |
| throw new NullPointerException(); |
| } |
| if (!contains(child)) { |
| throw new IllegalArgumentException(Messages.getString("beans.6D")); |
| } |
| |
| return ClassLoader.getSystemResourceAsStream(resourceName); |
| } |
| |
| /** |
| * Initializes all transient fields of this instance, called by |
| * constructors and <code>readObject()</code>. |
| */ |
| protected void initialize() { |
| // init transient fields |
| bcmListeners = new ArrayList<BeanContextMembershipListener>(); |
| children = new HashMap(); |
| serializing = false; |
| inNeedsGui = false; |
| nonSerPCL = new PropertyChangeListener() { |
| public void propertyChange(PropertyChangeEvent event) { |
| BeanContextSupport.this.propertyChange(event); |
| } |
| }; |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.beancontext.BeanContext#instantiateChild(java.lang.String) |
| */ |
| public Object instantiateChild(String beanName) throws IOException, |
| ClassNotFoundException { |
| return Beans.instantiate(getClass().getClassLoader(), beanName, |
| getBeanContextPeer()); |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.DesignMode#isDesignTime() |
| */ |
| public boolean isDesignTime() { |
| return designTime; |
| } |
| |
| /* (non-Javadoc) |
| * @see java.util.Collection#isEmpty() |
| */ |
| public boolean isEmpty() { |
| synchronized (children) { |
| return children.isEmpty(); |
| } |
| } |
| |
| /** |
| * Returns true if this context is currently being serialized |
| * (by another thread). |
| * |
| * @return true if this context is currently being serialized |
| * (by another thread) |
| */ |
| public boolean isSerializing() { |
| return serializing; |
| } |
| |
| /** |
| * Returns an iterator of children of this context, |
| * with <code>remove()</code> disabled. |
| * |
| * @see java.util.Collection#iterator() |
| */ |
| public Iterator iterator() { |
| synchronized (children) { |
| return new BCSIterator(children.keySet().iterator()); |
| } |
| } |
| |
| /** |
| * Returns true if this context or its children needs GUI to work properly. |
| * <p> |
| * The implementation checks the peer and all the children that implement |
| * <code>Visibility</code> to see if any of their <code>needsGui()</code> |
| * returns true, and if any of the children extends |
| * <code>java.awt.Component</code>.</p> |
| * |
| * @see java.beans.Visibility#needsGui() |
| */ |
| public boolean needsGui() { |
| if (inNeedsGui) { |
| return false; |
| } |
| inNeedsGui = true; |
| |
| try { |
| if (getBeanContextPeer() != this) { |
| if (getBeanContextPeer().needsGui()) { |
| return true; |
| } |
| } |
| Object childs[] = copyChildren(); |
| for (int i = 0; i < childs.length; i++) { |
| if (childs[i] instanceof Component) { |
| return true; |
| } |
| Visibility v = getChildVisibility(childs[i]); |
| if (v != null && v.needsGui()) { |
| return true; |
| } |
| } |
| return false; |
| } finally { |
| inNeedsGui = false; |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.Visibility#okToUseGui() |
| */ |
| public void okToUseGui() { |
| okToUseGui = true; |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.PropertyChangeListener#propertyChange(java.beans.PropertyChangeEvent) |
| */ |
| public void propertyChange(PropertyChangeEvent event) { |
| if (contains(event.getSource()) |
| && "beanContext".equals(event.getPropertyName()) |
| && event.getOldValue() == getBeanContextPeer()) { |
| remove(event.getSource(), false); |
| } |
| } |
| |
| /** |
| * Deserializes children from the given object input stream. |
| * <p> |
| * The implementation reads pairs of child object and <code>BCSChild</code> |
| * object according to <code>serializable</code> property. For each pair, |
| * it is added to the <code>children</code> map and the |
| * <code>childDeserializedHook()</code> is called. If the child implements |
| * <code>BeanContextChild</code>, its <code>setBeanContext()</code> is |
| * also called. |
| * </p> |
| * <p> |
| * This method is called by <code>readObject()</code> if the context works |
| * standalone. Or if this support object is a delegate of another |
| * <code>BeanContext</code> implementation, then this method should be |
| * called by the peer. Doing this means that derialization can proceed |
| * without any circular dependency problems. |
| * |
| * @param ois |
| * the object input stream |
| * @throws IOException |
| * if I/O exception occurs |
| * @throws ClassNotFoundException |
| * if class of read object is not found |
| */ |
| @SuppressWarnings("unchecked") |
| public final void readChildren(ObjectInputStream ois) throws IOException, |
| ClassNotFoundException { |
| synchronized (children) { |
| for (int i = 0; i < serializable; i++) { |
| Object child = ois.readObject(); |
| BCSChild childBCSC = (BCSChild) ois.readObject(); |
| children.put(child, childBCSC); |
| |
| childDeserializedHook(child, childBCSC); |
| |
| // set child's beanContext property |
| BeanContextChild beanContextChild = getChildBeanContextChild(child); |
| if (beanContextChild != null) { |
| try { |
| beanContextChild.setBeanContext(getBeanContextPeer()); |
| } catch (PropertyVetoException e) { |
| throw new IOException( |
| Messages.getString("beans.6B")); |
| } |
| // ensure no duplicate listener |
| beanContextChild.removePropertyChangeListener( |
| "beanContext", nonSerPCL); |
| // listen to child's beanContext change |
| beanContextChild.addPropertyChangeListener("beanContext", |
| nonSerPCL); |
| } |
| } |
| } |
| } |
| |
| /** |
| * Removes the given child from this context. |
| * <p> |
| * Delegates to <code>remove(child, true)</code>.</p> |
| * |
| * @param child a child of this context |
| * @return true if the child is removed; or false if it is not a child of this context |
| * @throws IllegalArgumentException if the child is null |
| * @throws IllegalStateException if the child is not valid to remove |
| * @see java.util.Collection#remove(java.lang.Object) |
| */ |
| public boolean remove(Object child) { |
| return remove(child, true); |
| } |
| |
| /** |
| * Removes the given child from this context. |
| * <p> |
| * If the given child is not a child of this context, simply returns false. |
| * Otherwise, <code>validatePendingRemove()</code> is called. If the |
| * removal is valid, the child's <code>beanContext</code> property is |
| * updated (if required) and the child and its proxy peer (if there is one) |
| * is removed. Last, <code>childJustRemovedHook()</code> is called and |
| * listeners are notified.</p> |
| * |
| * @param child a child of this context |
| * @param setChildBC whether to call <code>setBeanContext()</code> on the child or not |
| * @return true if the child is removed; or false if it is not a child of this context |
| * @throws IllegalArgumentException if the child is null |
| * @throws IllegalStateException if the child is not valid to remove |
| */ |
| protected boolean remove(Object child, boolean setChildBC) { |
| if (child == null) { |
| throw new IllegalArgumentException(Messages.getString("beans.67")); |
| } |
| |
| Object peer = null; |
| |
| synchronized (globalHierarchyLock) { |
| // check existence |
| if (!contains(child)) { |
| return false; |
| } |
| |
| // check serializing state |
| if (serializing) { |
| throw new IllegalStateException( |
| Messages.getString("beans.68")); |
| } |
| |
| // validate |
| boolean valid = validatePendingRemove(child); |
| if (!valid) { |
| throw new IllegalStateException( |
| Messages.getString("beans.6E")); |
| } |
| |
| // set child's beanContext property |
| BeanContextChild beanContextChild = getChildBeanContextChild(child); |
| if (beanContextChild != null && setChildBC) { |
| // remove listener, first |
| beanContextChild.removePropertyChangeListener("beanContext", |
| nonSerPCL); |
| try { |
| beanContextChild.setBeanContext(null); |
| } catch (PropertyVetoException e) { |
| // rollback the listener change |
| beanContextChild.addPropertyChangeListener("beanContext", |
| nonSerPCL); |
| throw new IllegalStateException( |
| Messages.getString("beans.6B")); |
| } |
| } |
| |
| // remove from children |
| BCSChild childBCSC = null, peerBCSC = null; |
| synchronized (children) { |
| childBCSC = (BCSChild) children.remove(child); |
| peer = childBCSC.proxyPeer; |
| if (peer != null) { |
| peerBCSC = (BCSChild) children.remove(peer); |
| } |
| } |
| |
| // trigger hook |
| synchronized (child) { |
| removeSerializable(childBCSC); |
| childJustRemovedHook(child, childBCSC); |
| } |
| if (peer != null) { |
| synchronized (peer) { |
| removeSerializable(peerBCSC); |
| childJustRemovedHook(peer, peerBCSC); |
| } |
| } |
| } |
| |
| // notify listeners |
| fireChildrenRemoved(new BeanContextMembershipEvent( |
| getBeanContextPeer(), peer == null ? new Object[] { child } |
| : new Object[] { child, peer })); |
| return true; |
| } |
| |
| /** |
| * This method is unsupported, throws <code>UnsupportedOperationException</code>. |
| * |
| * @see java.util.Collection#removeAll(java.util.Collection) |
| */ |
| public boolean removeAll(Collection collection) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.beancontext.BeanContext#removeBeanContextMembershipListener(java.beans.beancontext.BeanContextMembershipListener) |
| */ |
| public void removeBeanContextMembershipListener( |
| BeanContextMembershipListener listener) { |
| if (listener == null) { |
| throw new NullPointerException(); |
| } |
| synchronized (bcmListeners) { |
| bcmListeners.remove(listener); |
| } |
| } |
| |
| /** |
| * This method is unsupported, throws <code>UnsupportedOperationException</code>. |
| * |
| * @see java.util.Collection#retainAll(java.util.Collection) |
| */ |
| public boolean retainAll(Collection collection) { |
| throw new UnsupportedOperationException(); |
| } |
| |
| /** |
| * Serializes the given collection. |
| * <p> |
| * First writes a <code>int</code> indicating the number of all |
| * serializable elements (implements <code>Serializable</code>, then |
| * objects are writtern one by one.</p> |
| * |
| * @param oos the stream where the collection is writtern to |
| * @param collection the collection to serialize |
| * @throws IOException if I/O exception occurs |
| */ |
| protected final void serialize(ObjectOutputStream oos, Collection collection) |
| throws IOException { |
| Object array[] = collection.toArray(); |
| int serCount = 0; |
| for (int i = 0; i < array.length; i++) { |
| if (array[i] instanceof Serializable) { |
| serCount++; |
| } |
| } |
| |
| oos.writeInt(serCount); |
| for (int i = 0; i < array.length; i++) { |
| if (array[i] instanceof Serializable) { |
| oos.writeObject(array[i]); |
| } |
| } |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.DesignMode#setDesignTime(boolean) |
| */ |
| public void setDesignTime(boolean designTime) { |
| this.designTime = designTime; |
| } |
| |
| /** |
| * Sets the locale of this context. <code>VetoableChangeListener</code>s |
| * and <code>PropertyChangeListener</code>s are notified. |
| * |
| * @param newLocale the new locale to set |
| * @throws PropertyVetoException if any <code>VetoableChangeListener</code> vetos this change |
| */ |
| public void setLocale(Locale newLocale) throws PropertyVetoException { |
| if (newLocale == null || newLocale == locale) { |
| return; // ignore null locale |
| } |
| |
| PropertyChangeEvent event = new PropertyChangeEvent( |
| beanContextChildPeer, "locale", locale, newLocale); |
| |
| // apply change |
| Locale oldLocale = locale; |
| locale = newLocale; |
| |
| try { |
| // notify vetoable listeners |
| vcSupport.fireVetoableChange(event); |
| } catch (PropertyVetoException e) { |
| // rollback change |
| locale = oldLocale; |
| throw e; |
| } |
| // Notify BeanContext about this change |
| this.pcSupport.firePropertyChange(event); |
| } |
| |
| /** |
| * Returns the number children of this context. |
| * |
| * @return the number children of this context |
| * @see java.util.Collection#size() |
| */ |
| public int size() { |
| synchronized (children) { |
| return children.size(); |
| } |
| } |
| |
| /** |
| * Returns an array of children of this context. |
| * |
| * @return an array of children of this context |
| * @see java.util.Collection#toArray() |
| */ |
| public Object[] toArray() { |
| synchronized (children) { |
| return children.keySet().toArray(); |
| } |
| } |
| |
| /** |
| * Returns an array of children of this context. |
| * |
| * @return an array of children of this context |
| * @see java.util.Collection#toArray(java.lang.Object[]) |
| */ |
| @SuppressWarnings("unchecked") |
| public Object[] toArray(Object[] array) { |
| synchronized (children) { |
| return children.keySet().toArray(array); |
| } |
| } |
| |
| /** |
| * Validates the pending add of child. |
| * <p> |
| * Default implementation always returns true.</p> |
| * |
| * @param child the child to be added |
| * @return true if it is valid to add the child |
| */ |
| protected boolean validatePendingAdd(Object child) { |
| // to be overridden |
| return true; |
| } |
| |
| /** |
| * Validates the pending removal of child. |
| * <p> |
| * Default implementation always returns true.</p> |
| * |
| * @param child the child to be removed |
| * @return true if it is valid to remove the child |
| */ |
| protected boolean validatePendingRemove(Object child) { |
| // to be overridden |
| return true; |
| } |
| |
| /* (non-Javadoc) |
| * @see java.beans.VetoableChangeListener#vetoableChange(java.beans.PropertyChangeEvent) |
| */ |
| public void vetoableChange(PropertyChangeEvent pce) |
| throws PropertyVetoException { |
| if (pce == null) { |
| throw new NullPointerException(Messages.getString("beans.1C")); //$NON-NLS-1$ |
| } |
| } |
| |
| /** |
| * Serializes children to the given object input stream. |
| * <p> |
| * The implementation iterates through all children and writes out pairs |
| * of child object and <code>BCSChild</code> object if the child is |
| * serializable (implements <code>Serialization</code>.</p> |
| * <p> |
| * This method is called by <code>writeObject()</code> if the context |
| * works standalone. Or if this support object is a delegate of another |
| * <code>BeanContext</code> implementation, then this method should be |
| * called by the peer to avoid the 'chicken and egg' problem during |
| * deserialization.</p> |
| * |
| * @param oos the stream to write |
| * @throws IOException if I/O exception occurs |
| */ |
| public final void writeChildren(ObjectOutputStream oos) throws IOException { |
| boolean origSer = serializing; |
| serializing = true; |
| |
| try { |
| int count = 0; |
| synchronized (children) { |
| for (Iterator iter = children.values().iterator(); iter |
| .hasNext();) { |
| BCSChild bcsc = (BCSChild) iter.next(); |
| if (bcsc.child instanceof Serializable |
| && (bcsc.proxyPeer == null || bcsc.proxyPeer instanceof Serializable)) { |
| oos.writeObject(bcsc.child); |
| oos.writeObject(bcsc); |
| count++; |
| } |
| } |
| } |
| |
| // what if count not equals to serializable? |
| if (count != serializable) { |
| throw new IOException(Messages.getString("beans.6F")); |
| } |
| } finally { |
| serializing = origSer; |
| } |
| } |
| |
| /** |
| * The implementation goes through following steps: |
| * <p> |
| * <ol> |
| * <li>Writes out non-transient properties by calling |
| * <code>defaultWriteObject()</code>, especially the |
| * <code>serializable</code> indicating the number of serializable |
| * children.</li> |
| * <li>Calls <code>bcsPreSerializationHook()</code>.</li> |
| * <li>Writes out children by calling <code>writeChildren()</code> if |
| * this context works standalone. Otherwise it is the peer's |
| * responsibility to call <code>writeChildren()</code> after this object |
| * is serialized.</li> |
| * <li>Writes out serializable membership listeners.</li> |
| * </ol> |
| * </p> |
| * |
| * @param oos the object output stream |
| * @throws IOException if I/O exception occurs |
| */ |
| private void writeObject(ObjectOutputStream oos) throws IOException { |
| boolean origSer = serializing; |
| serializing = true; |
| |
| try { |
| oos.defaultWriteObject(); |
| |
| bcsPreSerializationHook(oos); |
| |
| if (this == getBeanContextPeer()) { |
| writeChildren(oos); |
| } |
| |
| synchronized (bcmListeners) { |
| serialize(oos, bcmListeners); |
| } |
| } finally { |
| serializing = origSer; |
| } |
| } |
| |
| /** |
| * The implementation goes through following steps: |
| * <p> |
| * <ol> |
| * <li>Reads non-transient properties by calling |
| * <code>defaultReadObject()</code>.</li> |
| * <li>Calls <code>bcsPreDeserializationHook()</code>.</li> |
| * <li>Reads children by calling <code>readChildren()</code> if |
| * this context works standalone. Otherwise it is the peer's |
| * responsibility to call <code>readChildren()</code> after this object |
| * is deserialized.</li> |
| * <li>Reads serializable membership listeners.</li> |
| * </ol> |
| * </p> |
| * |
| * @param ois the object input stream |
| * @throws IOException if I/O error occurs |
| * @throws ClassNotFoundException if class of read object is not found |
| */ |
| private void readObject(ObjectInputStream ois) throws IOException, |
| ClassNotFoundException { |
| |
| ois.defaultReadObject(); |
| |
| initialize(); // init transient fields |
| |
| bcsPreDeserializationHook(ois); |
| |
| if (this == getBeanContextPeer()) { |
| readChildren(ois); |
| } |
| |
| deserialize(ois, bcmListeners); |
| } |
| |
| /* |
| * Increase variable serializable if child and proxyPeer fields of the given |
| * BCSChild object are serializable |
| */ |
| private void addSerializable(BCSChild bcsc) { |
| if (bcsc.child instanceof Serializable |
| && (bcsc.proxyPeer == null || bcsc.proxyPeer instanceof Serializable)) { |
| serializable++; |
| } |
| } |
| |
| /* |
| * Decrease variable serializable if child and proxyPeer fields of the given |
| * BCSChild object are serializable |
| */ |
| private void removeSerializable(BCSChild bcsc) { |
| if (serializable > 0 |
| && bcsc.child instanceof Serializable |
| && (bcsc.proxyPeer == null || bcsc.proxyPeer instanceof Serializable)) { |
| serializable--; |
| } |
| } |
| |
| } |
| |
| |
