plan9-archive/inferno-java

java/pkg/java/beans/AppletInitializer.class+0−0

Binary file not shown.

java/pkg/java/beans/AppletInitializer.java+91−0

@@ -0,0 +1,91 @@
	1	/*
	2	* Copyright (c) 1997, 2000, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.applet.Applet;
	29
	30	import java.beans.beancontext.BeanContext;
	31
	32	/**
	33	* <p>
	34	* This interface is designed to work in collusion with java.beans.Beans.instantiate.
	35	* The interafce is intended to provide mechanism to allow the proper
	36	* initialization of JavaBeans that are also Applets, during their
	37	* instantiation by java.beans.Beans.instantiate().
	38	* </p>
	39	*
	40	* @see java.beans.Beans#instantiate
	41	*
	42	* @since 1.2
	43	*
	44	*/
	45
	46
	47	public interface AppletInitializer {
	48
	49	/**
	50	* <p>
	51	* If passed to the appropriate variant of java.beans.Beans.instantiate
	52	* this method will be called in order to associate the newly instantiated
	53	* Applet (JavaBean) with its AppletContext, AppletStub, and Container.
	54	* </p>
	55	* <p>
	56	* Conformant implementations shall:
	57	* <ol>
	58	* <li> Associate the newly instantiated Applet with the appropriate
	59	* AppletContext.
	60	*
	61	* <li> Instantiate an AppletStub() and associate that AppletStub with
	62	* the Applet via an invocation of setStub().
	63	*
	64	* <li> If BeanContext parameter is null, then it shall associate the
	65	* Applet with its appropriate Container by adding that Applet to its
	66	* Container via an invocation of add(). If the BeanContext parameter is
	67	* non-null, then it is the responsibility of the BeanContext to associate
	68	* the Applet with its Container during the subsequent invocation of its
	69	* addChildren() method.
	70	* </ol>
	71	* </p>
	72	*
	73	* @param newAppletBean The newly instantiated JavaBean
	74	* @param bCtxt The BeanContext intended for this Applet, or
	75	* null.
	76	*/
	77
	78	void initialize(Applet newAppletBean, BeanContext bCtxt);
	79
	80	/**
	81	* <p>
	82	* Activate, and/or mark Applet active. Implementors of this interface
	83	* shall mark this Applet as active, and optionally invoke its start()
	84	* method.
	85	* </p>
	86	*
	87	* @param newApplet The newly instantiated JavaBean
	88	*/
	89
	90	void activate(Applet newApplet);
	91	}

java/pkg/java/beans/ArrayPersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/BeanDescriptor.class+0−0

Binary file not shown.

java/pkg/java/beans/BeanDescriptor.java+109−0

@@ -0,0 +1,109 @@
	1	/*
	2	* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.lang.ref.Reference;
	29
	30	/**
	31	* A BeanDescriptor provides global information about a "bean",
	32	* including its Java class, its displayName, etc.
	33	* <p>
	34	* This is one of the kinds of descriptor returned by a BeanInfo object,
	35	* which also returns descriptors for properties, method, and events.
	36	*/
	37
	38	public class BeanDescriptor extends FeatureDescriptor {
	39
	40	private Reference<Class> beanClassRef;
	41	private Reference<Class> customizerClassRef;
	42
	43	/**
	44	* Create a BeanDescriptor for a bean that doesn't have a customizer.
	45	*
	46	* @param beanClass The Class object of the Java class that implements
	47	* the bean. For example sun.beans.OurButton.class.
	48	*/
	49	public BeanDescriptor(Class<?> beanClass) {
	50	this(beanClass, null);
	51	}
	52
	53	/**
	54	* Create a BeanDescriptor for a bean that has a customizer.
	55	*
	56	* @param beanClass The Class object of the Java class that implements
	57	* the bean. For example sun.beans.OurButton.class.
	58	* @param customizerClass The Class object of the Java class that implements
	59	* the bean's Customizer. For example sun.beans.OurButtonCustomizer.class.
	60	*/
	61	public BeanDescriptor(Class<?> beanClass, Class<?> customizerClass) {
	62	this.beanClassRef = getWeakReference((Class)beanClass);
	63	this.customizerClassRef = getWeakReference((Class)customizerClass);
	64
	65	String name = beanClass.getName();
	66	while (name.indexOf('.') >= 0) {
	67	name = name.substring(name.indexOf('.')+1);
	68	}
	69	setName(name);
	70	}
	71
	72	/**
	73	* Gets the bean's Class object.
	74	*
	75	* @return The Class object for the bean.
	76	*/
	77	public Class<?> getBeanClass() {
	78	return (this.beanClassRef != null)
	79	? this.beanClassRef.get()
	80	: null;
	81	}
	82
	83	/**
	84	* Gets the Class object for the bean's customizer.
	85	*
	86	* @return The Class object for the bean's customizer. This may
	87	* be null if the bean doesn't have a customizer.
	88	*/
	89	public Class<?> getCustomizerClass() {
	90	return (this.customizerClassRef != null)
	91	? this.customizerClassRef.get()
	92	: null;
	93	}
	94
	95	/*
	96	* Package-private dup constructor
	97	* This must isolate the new object from any changes to the old object.
	98	*/
	99	BeanDescriptor(BeanDescriptor old) {
	100	super(old);
	101	beanClassRef = old.beanClassRef;
	102	customizerClassRef = old.customizerClassRef;
	103	}
	104
	105	void appendTo(StringBuilder sb) {
	106	appendTo(sb, "beanClass", this.beanClassRef);
	107	appendTo(sb, "customizerClass", this.customizerClassRef);
	108	}
	109	}

java/pkg/java/beans/BeanInfo.class+0−0

Binary file not shown.

java/pkg/java/beans/BeanInfo.java+176−0

@@ -0,0 +1,176 @@
	1	/*
	2	* Copyright (c) 1996, 1999, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* A bean implementor who wishes to provide explicit information about
	30	* their bean may provide a BeanInfo class that implements this BeanInfo
	31	* interface and provides explicit information about the methods,
	32	* properties, events, etc, of their bean.
	33	* <p>
	34	* A bean implementor doesn't need to provide a complete set of
	35	* explicit information. You can pick and choose which information
	36	* you want to provide and the rest will be obtained by automatic
	37	* analysis using low-level reflection of the bean classes' methods
	38	* and applying standard design patterns.
	39	* <p>
	40	* You get the opportunity to provide lots and lots of different
	41	* information as part of the various XyZDescriptor classes. But
	42	* don't panic, you only really need to provide the minimal core
	43	* information required by the various constructors.
	44	* <P>
	45	* See also the SimpleBeanInfo class which provides a convenient
	46	* "noop" base class for BeanInfo classes, which you can override
	47	* for those specific places where you want to return explicit info.
	48	* <P>
	49	* To learn about all the behaviour of a bean see the Introspector class.
	50	*/
	51
	52	public interface BeanInfo {
	53
	54	/**
	55	* Gets the beans <code>BeanDescriptor</code>.
	56	*
	57	* @return A BeanDescriptor providing overall information about
	58	* the bean, such as its displayName, its customizer, etc. May
	59	* return null if the information should be obtained by automatic
	60	* analysis.
	61	*/
	62	BeanDescriptor getBeanDescriptor();
	63
	64	/**
	65	* Gets the beans <code>EventSetDescriptor</code>s.
	66	*
	67	* @return An array of EventSetDescriptors describing the kinds of
	68	* events fired by this bean. May return null if the information
	69	* should be obtained by automatic analysis.
	70	*/
	71	EventSetDescriptor[] getEventSetDescriptors();
	72
	73	/**
	74	* A bean may have a "default" event that is the event that will
	75	* mostly commonly be used by humans when using the bean.
	76	* @return Index of default event in the EventSetDescriptor array
	77	* returned by getEventSetDescriptors.
	78	* <P> Returns -1 if there is no default event.
	79	*/
	80	int getDefaultEventIndex();
	81
	82	/**
	83	* Returns descriptors for all properties of the bean.
	84	* May return {@code null} if the information
	85	* should be obtained by automatic analysis.
	86	* <p>
	87	* If a property is indexed, then its entry in the result array
	88	* will belong to the {@link IndexedPropertyDescriptor} subclass
	89	* of the {@link PropertyDescriptor} class.
	90	* A client of the {@code getPropertyDescriptors} method
	91	* can use "{@code instanceof}" to check
	92	* whether a given {@code PropertyDescriptor}
	93	* is an {@code IndexedPropertyDescriptor}.
	94	*
	95	* @return an array of {@code PropertyDescriptor}s
	96	* describing all properties supported by the bean
	97	* or {@code null}
	98	*/
	99	PropertyDescriptor[] getPropertyDescriptors();
	100
	101	/**
	102	* A bean may have a "default" property that is the property that will
	103	* mostly commonly be initially chosen for update by human's who are
	104	* customizing the bean.
	105	* @return Index of default property in the PropertyDescriptor array
	106	* returned by getPropertyDescriptors.
	107	* <P> Returns -1 if there is no default property.
	108	*/
	109	int getDefaultPropertyIndex();
	110
	111	/**
	112	* Gets the beans <code>MethodDescriptor</code>s.
	113	*
	114	* @return An array of MethodDescriptors describing the externally
	115	* visible methods supported by this bean. May return null if
	116	* the information should be obtained by automatic analysis.
	117	*/
	118	MethodDescriptor[] getMethodDescriptors();
	119
	120	/**
	121	* This method allows a BeanInfo object to return an arbitrary collection
	122	* of other BeanInfo objects that provide additional information on the
	123	* current bean.
	124	* <P>
	125	* If there are conflicts or overlaps between the information provided
	126	* by different BeanInfo objects, then the current BeanInfo takes precedence
	127	* over the getAdditionalBeanInfo objects, and later elements in the array
	128	* take precedence over earlier ones.
	129	*
	130	* @return an array of BeanInfo objects. May return null.
	131	*/
	132	BeanInfo[] getAdditionalBeanInfo();
	133
	134	/**
	135	* This method returns an image object that can be used to
	136	* represent the bean in toolboxes, toolbars, etc. Icon images
	137	* will typically be GIFs, but may in future include other formats.
	138	* <p>
	139	* Beans aren't required to provide icons and may return null from
	140	* this method.
	141	* <p>
	142	* There are four possible flavors of icons (16x16 color,
	143	* 32x32 color, 16x16 mono, 32x32 mono). If a bean choses to only
	144	* support a single icon we recommend supporting 16x16 color.
	145	* <p>
	146	* We recommend that icons have a "transparent" background
	147	* so they can be rendered onto an existing background.
	148	*
	149	* @param iconKind The kind of icon requested. This should be
	150	* one of the constant values ICON_COLOR_16x16, ICON_COLOR_32x32,
	151	* ICON_MONO_16x16, or ICON_MONO_32x32.
	152	* @return An image object representing the requested icon. May
	153	* return null if no suitable icon is available.
	154	*/
	155	java.awt.Image getIcon(int iconKind);
	156
	157	/**
	158	* Constant to indicate a 16 x 16 color icon.
	159	*/
	160	final static int ICON_COLOR_16x16 = 1;
	161
	162	/**
	163	* Constant to indicate a 32 x 32 color icon.
	164	*/
	165	final static int ICON_COLOR_32x32 = 2;
	166
	167	/**
	168	* Constant to indicate a 16 x 16 monochrome icon.
	169	*/
	170	final static int ICON_MONO_16x16 = 3;
	171
	172	/**
	173	* Constant to indicate a 32 x 32 monochrome icon.
	174	*/
	175	final static int ICON_MONO_32x32 = 4;
	176	}

java/pkg/java/beans/Beans$1.class+0−0

Binary file not shown.

java/pkg/java/beans/Beans$2.class+0−0

Binary file not shown.

java/pkg/java/beans/Beans.class+0−0

Binary file not shown.

java/pkg/java/beans/Beans.java+637−0

@@ -0,0 +1,637 @@
	1	/*
	2	* Copyright (c) 1996, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import com.sun.beans.finder.ClassFinder;
	29
	30	import java.applet.Applet;
	31	import java.applet.AppletContext;
	32	import java.applet.AppletStub;
	33	import java.applet.AudioClip;
	34
	35	import java.awt.GraphicsEnvironment;
	36	import java.awt.Image;
	37
	38	import java.beans.beancontext.BeanContext;
	39
	40	import java.io.IOException;
	41	import java.io.InputStream;
	42	import java.io.ObjectInputStream;
	43	import java.io.ObjectStreamClass;
	44	import java.io.StreamCorruptedException;
	45
	46	import java.net.URL;
	47
	48	import java.security.AccessController;
	49	import java.security.PrivilegedAction;
	50
	51	import java.util.Enumeration;
	52	import java.util.Hashtable;
	53	import java.util.Iterator;
	54	import java.util.Vector;
	55
	56	import sun.awt.AppContext;
	57
	58	/**
	59	* This class provides some general purpose beans control methods.
	60	*/
	61
	62	public class Beans {
	63	private static final Object DESIGN_TIME = new Object();
	64	private static final Object GUI_AVAILABLE = new Object();
	65
	66	/**
	67	* <p>
	68	* Instantiate a JavaBean.
	69	* </p>
	70	*
	71	* @param cls the class-loader from which we should create
	72	* the bean. If this is null, then the system
	73	* class-loader is used.
	74	* @param beanName the name of the bean within the class-loader.
	75	* For example "sun.beanbox.foobah"
	76	*
	77	* @exception ClassNotFoundException if the class of a serialized
	78	* object could not be found.
	79	* @exception IOException if an I/O error occurs.
	80	*/
	81
	82	public static Object instantiate(ClassLoader cls, String beanName) throws IOException, ClassNotFoundException {
	83	return Beans.instantiate(cls, beanName, null, null);
	84	}
	85
	86	/**
	87	* <p>
	88	* Instantiate a JavaBean.
	89	* </p>
	90	*
	91	* @param cls the class-loader from which we should create
	92	* the bean. If this is null, then the system
	93	* class-loader is used.
	94	* @param beanName the name of the bean within the class-loader.
	95	* For example "sun.beanbox.foobah"
	96	* @param beanContext The BeanContext in which to nest the new bean
	97	*
	98	* @exception ClassNotFoundException if the class of a serialized
	99	* object could not be found.
	100	* @exception IOException if an I/O error occurs.
	101	*/
	102
	103	public static Object instantiate(ClassLoader cls, String beanName, BeanContext beanContext) throws IOException, ClassNotFoundException {
	104	return Beans.instantiate(cls, beanName, beanContext, null);
	105	}
	106
	107	/**
	108	* Instantiate a bean.
	109	* <p>
	110	* The bean is created based on a name relative to a class-loader.
	111	* This name should be a dot-separated name such as "a.b.c".
	112	* <p>
	113	* In Beans 1.0 the given name can indicate either a serialized object
	114	* or a class. Other mechanisms may be added in the future. In
	115	* beans 1.0 we first try to treat the beanName as a serialized object
	116	* name then as a class name.
	117	* <p>
	118	* When using the beanName as a serialized object name we convert the
	119	* given beanName to a resource pathname and add a trailing ".ser" suffix.
	120	* We then try to load a serialized object from that resource.
	121	* <p>
	122	* For example, given a beanName of "x.y", Beans.instantiate would first
	123	* try to read a serialized object from the resource "x/y.ser" and if
	124	* that failed it would try to load the class "x.y" and create an
	125	* instance of that class.
	126	* <p>
	127	* If the bean is a subtype of java.applet.Applet, then it is given
	128	* some special initialization. First, it is supplied with a default
	129	* AppletStub and AppletContext. Second, if it was instantiated from
	130	* a classname the applet's "init" method is called. (If the bean was
	131	* deserialized this step is skipped.)
	132	* <p>
	133	* Note that for beans which are applets, it is the caller's responsiblity
	134	* to call "start" on the applet. For correct behaviour, this should be done
	135	* after the applet has been added into a visible AWT container.
	136	* <p>
	137	* Note that applets created via beans.instantiate run in a slightly
	138	* different environment than applets running inside browsers. In
	139	* particular, bean applets have no access to "parameters", so they may
	140	* wish to provide property get/set methods to set parameter values. We
	141	* advise bean-applet developers to test their bean-applets against both
	142	* the JDK appletviewer (for a reference browser environment) and the
	143	* BDK BeanBox (for a reference bean container).
	144	*
	145	* @param cls the class-loader from which we should create
	146	* the bean. If this is null, then the system
	147	* class-loader is used.
	148	* @param beanName the name of the bean within the class-loader.
	149	* For example "sun.beanbox.foobah"
	150	* @param beanContext The BeanContext in which to nest the new bean
	151	* @param initializer The AppletInitializer for the new bean
	152	*
	153	* @exception ClassNotFoundException if the class of a serialized
	154	* object could not be found.
	155	* @exception IOException if an I/O error occurs.
	156	*/
	157
	158	public static Object instantiate(ClassLoader cls, String beanName, BeanContext beanContext, AppletInitializer initializer)
	159	throws IOException, ClassNotFoundException {
	160
	161	InputStream ins;
	162	ObjectInputStream oins = null;
	163	Object result = null;
	164	boolean serialized = false;
	165	IOException serex = null;
	166
	167	// If the given classloader is null, we check if an
	168	// system classloader is available and (if so)
	169	// use that instead.
	170	// Note that calls on the system class loader will
	171	// look in the bootstrap class loader first.
	172	if (cls == null) {
	173	try {
	174	cls = ClassLoader.getSystemClassLoader();
	175	} catch (SecurityException ex) {
	176	// We're not allowed to access the system class loader.
	177	// Drop through.
	178	}
	179	}
	180
	181	// Try to find a serialized object with this name
	182	final String serName = beanName.replace('.','/').concat(".ser");
	183	final ClassLoader loader = cls;
	184	ins = (InputStream)AccessController.doPrivileged
	185	(new PrivilegedAction() {
	186	public Object run() {
	187	if (loader == null)
	188	return ClassLoader.getSystemResourceAsStream(serName);
	189	else
	190	return loader.getResourceAsStream(serName);
	191	}
	192	});
	193	if (ins != null) {
	194	try {
	195	if (cls == null) {
	196	oins = new ObjectInputStream(ins);
	197	} else {
	198	oins = new ObjectInputStreamWithLoader(ins, cls);
	199	}
	200	result = oins.readObject();
	201	serialized = true;
	202	oins.close();
	203	} catch (IOException ex) {
	204	ins.close();
	205	// Drop through and try opening the class. But remember
	206	// the exception in case we can't find the class either.
	207	serex = ex;
	208	} catch (ClassNotFoundException ex) {
	209	ins.close();
	210	throw ex;
	211	}
	212	}
	213
	214	if (result == null) {
	215	// No serialized object, try just instantiating the class
	216	Class cl;
	217
	218	try {
	219	cl = ClassFinder.findClass(beanName, cls);
	220	} catch (ClassNotFoundException ex) {
	221	// There is no appropriate class. If we earlier tried to
	222	// deserialize an object and got an IO exception, throw that,
	223	// otherwise rethrow the ClassNotFoundException.
	224	if (serex != null) {
	225	throw serex;
	226	}
	227	throw ex;
	228	}
	229
	230	/*
	231	* Try to instantiate the class.
	232	*/
	233
	234	try {
	235	result = cl.newInstance();
	236	} catch (Exception ex) {
	237	// We have to remap the exception to one in our signature.
	238	// But we pass extra information in the detail message.
	239	throw new ClassNotFoundException("" + cl + " : " + ex, ex);
	240	}
	241	}
	242
	243	if (result != null) {
	244
	245	// Ok, if the result is an applet initialize it.
	246
	247	AppletStub stub = null;
	248
	249	if (result instanceof Applet) {
	250	Applet applet = (Applet) result;
	251	boolean needDummies = initializer == null;
	252
	253	if (needDummies) {
	254
	255	// Figure our the codebase and docbase URLs. We do this
	256	// by locating the URL for a known resource, and then
	257	// massaging the URL.
	258
	259	// First find the "resource name" corresponding to the bean
	260	// itself. So a serialzied bean "a.b.c" would imply a
	261	// resource name of "a/b/c.ser" and a classname of "x.y"
	262	// would imply a resource name of "x/y.class".
	263
	264	final String resourceName;
	265
	266	if (serialized) {
	267	// Serialized bean
	268	resourceName = beanName.replace('.','/').concat(".ser");
	269	} else {
	270	// Regular class
	271	resourceName = beanName.replace('.','/').concat(".class");
	272	}
	273
	274	URL objectUrl = null;
	275	URL codeBase = null;
	276	URL docBase = null;
	277
	278	// Now get the URL correponding to the resource name.
	279
	280	final ClassLoader cloader = cls;
	281	objectUrl = (URL)
	282	AccessController.doPrivileged
	283	(new PrivilegedAction() {
	284	public Object run() {
	285	if (cloader == null)
	286	return ClassLoader.getSystemResource
	287	(resourceName);
	288	else
	289	return cloader.getResource(resourceName);
	290	}
	291	});
	292
	293	// If we found a URL, we try to locate the docbase by taking
	294	// of the final path name component, and the code base by taking
	295	// of the complete resourceName.
	296	// So if we had a resourceName of "a/b/c.class" and we got an
	297	// objectURL of "file://bert/classes/a/b/c.class" then we would
	298	// want to set the codebase to "file://bert/classes/" and the
	299	// docbase to "file://bert/classes/a/b/"
	300
	301	if (objectUrl != null) {
	302	String s = objectUrl.toExternalForm();
	303
	304	if (s.endsWith(resourceName)) {
	305	int ix = s.length() - resourceName.length();
	306	codeBase = new URL(s.substring(0,ix));
	307	docBase = codeBase;
	308
	309	ix = s.lastIndexOf('/');
	310
	311	if (ix >= 0) {
	312	docBase = new URL(s.substring(0,ix+1));
	313	}
	314	}
	315	}
	316
	317	// Setup a default context and stub.
	318	BeansAppletContext context = new BeansAppletContext(applet);
	319
	320	stub = (AppletStub)new BeansAppletStub(applet, context, codeBase, docBase);
	321	applet.setStub(stub);
	322	} else {
	323	initializer.initialize(applet, beanContext);
	324	}
	325
	326	// now, if there is a BeanContext, add the bean, if applicable.
	327
	328	if (beanContext != null) {
	329	beanContext.add(result);
	330	}
	331
	332	// If it was deserialized then it was already init-ed.
	333	// Otherwise we need to initialize it.
	334
	335	if (!serialized) {
	336	// We need to set a reasonable initial size, as many
	337	// applets are unhappy if they are started without
	338	// having been explicitly sized.
	339	applet.setSize(100,100);
	340	applet.init();
	341	}
	342
	343	if (needDummies) {
	344	((BeansAppletStub)stub).active = true;
	345	} else initializer.activate(applet);
	346
	347	} else if (beanContext != null) beanContext.add(result);
	348	}
	349
	350	return result;
	351	}
	352
	353
	354	/**
	355	* From a given bean, obtain an object representing a specified
	356	* type view of that source object.
	357	* <p>
	358	* The result may be the same object or a different object. If
	359	* the requested target view isn't available then the given
	360	* bean is returned.
	361	* <p>
	362	* This method is provided in Beans 1.0 as a hook to allow the
	363	* addition of more flexible bean behaviour in the future.
	364	*
	365	* @param bean Object from which we want to obtain a view.
	366	* @param targetType The type of view we'd like to get.
	367	*
	368	*/
	369	public static Object getInstanceOf(Object bean, Class<?> targetType) {
	370	return bean;
	371	}
	372
	373	/**
	374	* Check if a bean can be viewed as a given target type.
	375	* The result will be true if the Beans.getInstanceof method
	376	* can be used on the given bean to obtain an object that
	377	* represents the specified targetType type view.
	378	*
	379	* @param bean Bean from which we want to obtain a view.
	380	* @param targetType The type of view we'd like to get.
	381	* @return "true" if the given bean supports the given targetType.
	382	*
	383	*/
	384	public static boolean isInstanceOf(Object bean, Class<?> targetType) {
	385	return Introspector.isSubclass(bean.getClass(), targetType);
	386	}
	387
	388
	389	/**
	390	* Test if we are in design-mode.
	391	*
	392	* @return True if we are running in an application construction
	393	* environment.
	394	*
	395	* @see DesignMode
	396	*/
	397	public static boolean isDesignTime() {
	398	Object value = AppContext.getAppContext().get(DESIGN_TIME);
	399	return (value instanceof Boolean) && (Boolean) value;
	400	}
	401
	402	/**
	403	* Determines whether beans can assume a GUI is available.
	404	*
	405	* @return True if we are running in an environment where beans
	406	* can assume that an interactive GUI is available, so they
	407	* can pop up dialog boxes, etc. This will normally return
	408	* true in a windowing environment, and will normally return
	409	* false in a server environment or if an application is
	410	* running as part of a batch job.
	411	*
	412	* @see Visibility
	413	*
	414	*/
	415	public static boolean isGuiAvailable() {
	416	Object value = AppContext.getAppContext().get(GUI_AVAILABLE);
	417	return (value instanceof Boolean) ? (Boolean) value : !GraphicsEnvironment.isHeadless();
	418	}
	419
	420	/**
	421	* Used to indicate whether of not we are running in an application
	422	* builder environment.
	423	*
	424	* <p>Note that this method is security checked
	425	* and is not available to (for example) untrusted applets.
	426	* More specifically, if there is a security manager,
	427	* its <code>checkPropertiesAccess</code>
	428	* method is called. This could result in a SecurityException.
	429	*
	430	* @param isDesignTime True if we're in an application builder tool.
	431	* @exception SecurityException if a security manager exists and its
	432	* <code>checkPropertiesAccess</code> method doesn't allow setting
	433	* of system properties.
	434	* @see SecurityManager#checkPropertiesAccess
	435	*/
	436
	437	public static void setDesignTime(boolean isDesignTime)
	438	throws SecurityException {
	439	SecurityManager sm = System.getSecurityManager();
	440	if (sm != null) {
	441	sm.checkPropertiesAccess();
	442	}
	443	AppContext.getAppContext().put(DESIGN_TIME, Boolean.valueOf(isDesignTime));
	444	}
	445
	446	/**
	447	* Used to indicate whether of not we are running in an environment
	448	* where GUI interaction is available.
	449	*
	450	* <p>Note that this method is security checked
	451	* and is not available to (for example) untrusted applets.
	452	* More specifically, if there is a security manager,
	453	* its <code>checkPropertiesAccess</code>
	454	* method is called. This could result in a SecurityException.
	455	*
	456	* @param isGuiAvailable True if GUI interaction is available.
	457	* @exception SecurityException if a security manager exists and its
	458	* <code>checkPropertiesAccess</code> method doesn't allow setting
	459	* of system properties.
	460	* @see SecurityManager#checkPropertiesAccess
	461	*/
	462
	463	public static void setGuiAvailable(boolean isGuiAvailable)
	464	throws SecurityException {
	465	SecurityManager sm = System.getSecurityManager();
	466	if (sm != null) {
	467	sm.checkPropertiesAccess();
	468	}
	469	AppContext.getAppContext().put(GUI_AVAILABLE, Boolean.valueOf(isGuiAvailable));
	470	}
	471	}
	472
	473	/**
	474	* This subclass of ObjectInputStream delegates loading of classes to
	475	* an existing ClassLoader.
	476	*/
	477
	478	class ObjectInputStreamWithLoader extends ObjectInputStream
	479	{
	480	private ClassLoader loader;
	481
	482	/**
	483	* Loader must be non-null;
	484	*/
	485
	486	public ObjectInputStreamWithLoader(InputStream in, ClassLoader loader)
	487	throws IOException, StreamCorruptedException {
	488
	489	super(in);
	490	if (loader == null) {
	491	throw new IllegalArgumentException("Illegal null argument to ObjectInputStreamWithLoader");
	492	}
	493	this.loader = loader;
	494	}
	495
	496	/**
	497	* Use the given ClassLoader rather than using the system class
	498	*/
	499	protected Class resolveClass(ObjectStreamClass classDesc)
	500	throws IOException, ClassNotFoundException {
	501
	502	String cname = classDesc.getName();
	503	return ClassFinder.resolveClass(cname, this.loader);
	504	}
	505	}
	506
	507	/**
	508	* Package private support class. This provides a default AppletContext
	509	* for beans which are applets.
	510	*/
	511
	512	class BeansAppletContext implements AppletContext {
	513	Applet target;
	514	Hashtable imageCache = new Hashtable();
	515
	516	BeansAppletContext(Applet target) {
	517	this.target = target;
	518	}
	519
	520	public AudioClip getAudioClip(URL url) {
	521	// We don't currently support audio clips in the Beans.instantiate
	522	// applet context, unless by some luck there exists a URL content
	523	// class that can generate an AudioClip from the audio URL.
	524	try {
	525	return (AudioClip) url.getContent();
	526	} catch (Exception ex) {
	527	return null;
	528	}
	529	}
	530
	531	public synchronized Image getImage(URL url) {
	532	Object o = imageCache.get(url);
	533	if (o != null) {
	534	return (Image)o;
	535	}
	536	try {
	537	o = url.getContent();
	538	if (o == null) {
	539	return null;
	540	}
	541	if (o instanceof Image) {
	542	imageCache.put(url, o);
	543	return (Image) o;
	544	}
	545	// Otherwise it must be an ImageProducer.
	546	Image img = target.createImage((java.awt.image.ImageProducer)o);
	547	imageCache.put(url, img);
	548	return img;
	549
	550	} catch (Exception ex) {
	551	return null;
	552	}
	553	}
	554
	555	public Applet getApplet(String name) {
	556	return null;
	557	}
	558
	559	public Enumeration getApplets() {
	560	Vector applets = new Vector();
	561	applets.addElement(target);
	562	return applets.elements();
	563	}
	564
	565	public void showDocument(URL url) {
	566	// We do nothing.
	567	}
	568
	569	public void showDocument(URL url, String target) {
	570	// We do nothing.
	571	}
	572
	573	public void showStatus(String status) {
	574	// We do nothing.
	575	}
	576
	577	public void setStream(String key, InputStream stream)throws IOException{
	578	// We do nothing.
	579	}
	580
	581	public InputStream getStream(String key){
	582	// We do nothing.
	583	return null;
	584	}
	585
	586	public Iterator getStreamKeys(){
	587	// We do nothing.
	588	return null;
	589	}
	590	}
	591
	592	/**
	593	* Package private support class. This provides an AppletStub
	594	* for beans which are applets.
	595	*/
	596	class BeansAppletStub implements AppletStub {
	597	transient boolean active;
	598	transient Applet target;
	599	transient AppletContext context;
	600	transient URL codeBase;
	601	transient URL docBase;
	602
	603	BeansAppletStub(Applet target,
	604	AppletContext context, URL codeBase,
	605	URL docBase) {
	606	this.target = target;
	607	this.context = context;
	608	this.codeBase = codeBase;
	609	this.docBase = docBase;
	610	}
	611
	612	public boolean isActive() {
	613	return active;
	614	}
	615
	616	public URL getDocumentBase() {
	617	// use the root directory of the applet's class-loader
	618	return docBase;
	619	}
	620
	621	public URL getCodeBase() {
	622	// use the directory where we found the class or serialized object.
	623	return codeBase;
	624	}
	625
	626	public String getParameter(String name) {
	627	return null;
	628	}
	629
	630	public AppletContext getAppletContext() {
	631	return context;
	632	}
	633
	634	public void appletResize(int width, int height) {
	635	// we do nothing.
	636	}
	637	}

java/pkg/java/beans/BeansAppletContext.class+0−0

Binary file not shown.

java/pkg/java/beans/BeansAppletStub.class+0−0

Binary file not shown.

java/pkg/java/beans/ChangeListenerMap.class+0−0

Binary file not shown.

java/pkg/java/beans/ChangeListenerMap.java+247−0

@@ -0,0 +1,247 @@
	1	/*
	2	* Copyright (c) 2007, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import java.util.ArrayList;
	28	import java.util.Collections;
	29	import java.util.EventListener;
	30	import java.util.EventListenerProxy;
	31	import java.util.HashMap;
	32	import java.util.List;
	33	import java.util.Map;
	34	import java.util.Map.Entry;
	35	import java.util.Set;
	36
	37	/**
	38	* This is an abstract class that provides base functionality
	39	* for the {@link PropertyChangeSupport PropertyChangeSupport} class
	40	* and the {@link VetoableChangeSupport VetoableChangeSupport} class.
	41	*
	42	* @see PropertyChangeListenerMap
	43	* @see VetoableChangeListenerMap
	44	*
	45	* @author Sergey A. Malenkov
	46	*/
	47	abstract class ChangeListenerMap<L extends EventListener> {
	48	private Map<String, L[]> map;
	49
	50	/**
	51	* Creates an array of listeners.
	52	* This method can be optimized by using
	53	* the same instance of the empty array
	54	* when {@code length} is equal to {@code 0}.
	55	*
	56	* @param length the array length
	57	* @return an array with specified length
	58	*/
	59	protected abstract L[] newArray(int length);
	60
	61	/**
	62	* Creates a proxy listener for the specified property.
	63	*
	64	* @param name the name of the property to listen on
	65	* @param listener the listener to process events
	66	* @return a proxy listener
	67	*/
	68	protected abstract L newProxy(String name, L listener);
	69
	70	/**
	71	* Adds a listener to the list of listeners for the specified property.
	72	* This listener is called as many times as it was added.
	73	*
	74	* @param name the name of the property to listen on
	75	* @param listener the listener to process events
	76	*/
	77	public final synchronized void add(String name, L listener) {
	78	if (this.map == null) {
	79	this.map = new HashMap<String, L[]>();
	80	}
	81	L[] array = this.map.get(name);
	82	int size = (array != null)
	83	? array.length
	84	: 0;
	85
	86	L[] clone = newArray(size + 1);
	87	clone[size] = listener;
	88	if (array != null) {
	89	System.arraycopy(array, 0, clone, 0, size);
	90	}
	91	this.map.put(name, clone);
	92	}
	93
	94	/**
	95	* Removes a listener from the list of listeners for the specified property.
	96	* If the listener was added more than once to the same event source,
	97	* this listener will be notified one less time after being removed.
	98	*
	99	* @param name the name of the property to listen on
	100	* @param listener the listener to process events
	101	*/
	102	public final synchronized void remove(String name, L listener) {
	103	if (this.map != null) {
	104	L[] array = this.map.get(name);
	105	if (array != null) {
	106	for (int i = 0; i < array.length; i++) {
	107	if (listener.equals(array[i])) {
	108	int size = array.length - 1;
	109	if (size > 0) {
	110	L[] clone = newArray(size);
	111	System.arraycopy(array, 0, clone, 0, i);
	112	System.arraycopy(array, i + 1, clone, i, size - i);
	113	this.map.put(name, clone);
	114	}
	115	else {
	116	this.map.remove(name);
	117	if (this.map.isEmpty()) {
	118	this.map = null;
	119	}
	120	}
	121	break;
	122	}
	123	}
	124	}
	125	}
	126	}
	127
	128	/**
	129	* Returns the list of listeners for the specified property.
	130	*
	131	* @param name the name of the property
	132	* @return the corresponding list of listeners
	133	*/
	134	public final synchronized L[] get(String name) {
	135	return (this.map != null)
	136	? this.map.get(name)
	137	: null;
	138	}
	139
	140	/**
	141	* Sets new list of listeners for the specified property.
	142	*
	143	* @param name the name of the property
	144	* @param listeners new list of listeners
	145	*/
	146	public final void set(String name, L[] listeners) {
	147	if (listeners != null) {
	148	if (this.map == null) {
	149	this.map = new HashMap<String, L[]>();
	150	}
	151	this.map.put(name, listeners);
	152	}
	153	else if (this.map != null) {
	154	this.map.remove(name);
	155	if (this.map.isEmpty()) {
	156	this.map = null;
	157	}
	158	}
	159	}
	160
	161	/**
	162	* Returns all listeners in the map.
	163	*
	164	* @return an array of all listeners
	165	*/
	166	public final synchronized L[] getListeners() {
	167	if (this.map == null) {
	168	return newArray(0);
	169	}
	170	List<L> list = new ArrayList<L>();
	171
	172	L[] listeners = this.map.get(null);
	173	if (listeners != null) {
	174	for (L listener : listeners) {
	175	list.add(listener);
	176	}
	177	}
	178	for (Entry<String, L[]> entry : this.map.entrySet()) {
	179	String name = entry.getKey();
	180	if (name != null) {
	181	for (L listener : entry.getValue()) {
	182	list.add(newProxy(name, listener));
	183	}
	184	}
	185	}
	186	return list.toArray(newArray(list.size()));
	187	}
	188
	189	/**
	190	* Returns listeners that have been associated with the named property.
	191	*
	192	* @param name the name of the property
	193	* @return an array of listeners for the named property
	194	*/
	195	public final L[] getListeners(String name) {
	196	if (name != null) {
	197	L[] listeners = get(name);
	198	if (listeners != null) {
	199	return listeners.clone();
	200	}
	201	}
	202	return newArray(0);
	203	}
	204
	205	/**
	206	* Indicates whether the map contains
	207	* at least one listener to be notified.
	208	*
	209	* @param name the name of the property
	210	* @return {@code true} if at least one listener exists or
	211	* {@code false} otherwise
	212	*/
	213	public final synchronized boolean hasListeners(String name) {
	214	if (this.map == null) {
	215	return false;
	216	}
	217	L[] array = this.map.get(null);
	218	return (array != null) \|\| ((name != null) && (null != this.map.get(name)));
	219	}
	220
	221	/**
	222	* Returns a set of entries from the map.
	223	* Each entry is a pair consisted of the property name
	224	* and the corresponding list of listeners.
	225	*
	226	* @return a set of entries from the map
	227	*/
	228	public final Set<Entry<String, L[]>> getEntries() {
	229	return (this.map != null)
	230	? this.map.entrySet()
	231	: Collections.<Entry<String, L[]>>emptySet();
	232	}
	233
	234	/**
	235	* Extracts a real listener from the proxy listener.
	236	* It is necessary because default proxy class is not serializable.
	237	*
	238	* @return a real listener
	239	*/
	240	public final L extract(L listener) {
	241	while (listener instanceof EventListenerProxy) {
	242	EventListenerProxy<L> proxy = (EventListenerProxy<L>) listener;
	243	listener = proxy.getListener();
	244	}
	245	return listener;
	246	}
	247	}

java/pkg/java/beans/ConstructorProperties.class+0−0

Binary file not shown.

java/pkg/java/beans/ConstructorProperties.java+76−0

@@ -0,0 +1,76 @@
	1	/*
	2	* Copyright (c) 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.lang.annotation.*;
	29	import static java.lang.annotation.ElementType.*;
	30	import static java.lang.annotation.RetentionPolicy.*;
	31
	32	/**
	33	<p>An annotation on a constructor that shows how the parameters of
	34	that constructor correspond to the constructed object's getter
	35	methods. For example:
	36
	37	<blockquote>
	38	<pre>
	39	public class Point {
	40	@ConstructorProperties({"x", "y"})
	41	public Point(int x, int y) {
	42	this.x = x;
	43	this.y = y;
	44	}
	45
	46	public int getX() {
	47	return x;
	48	}
	49
	50	public int getY() {
	51	return y;
	52	}
	53
	54	private final int x, y;
	55	}
	56	</pre>
	57	</blockquote>
	58
	59	The annotation shows that the first parameter of the constructor
	60	can be retrieved with the {@code getX()} method and the second with
	61	the {@code getY()} method. Since parameter names are not in
	62	general available at runtime, without the annotation there would be
	63	no way to know whether the parameters correspond to {@code getX()}
	64	and {@code getY()} or the other way around.</p>
	65
	66	@since 1.6
	67	*/
	68	@Documented @Target(CONSTRUCTOR) @Retention(RUNTIME)
	69	public @interface ConstructorProperties {
	70	/**
	71	<p>The getter names.</p>
	72	@return the getter names corresponding to the parameters in the
	73	annotated constructor.
	74	*/
	75	String[] value();
	76	}

java/pkg/java/beans/Customizer.class+0−0

Binary file not shown.

java/pkg/java/beans/Customizer.java+65−0

@@ -0,0 +1,65 @@
	1	/*
	2	* Copyright (c) 1996, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* A customizer class provides a complete custom GUI for customizing
	30	* a target Java Bean.
	31	* <P>
	32	* Each customizer should inherit from the java.awt.Component class so
	33	* it can be instantiated inside an AWT dialog or panel.
	34	* <P>
	35	* Each customizer should have a null constructor.
	36	*/
	37
	38	public interface Customizer {
	39
	40	/**
	41	* Set the object to be customized. This method should be called only
	42	* once, before the Customizer has been added to any parent AWT container.
	43	* @param bean The object to be customized.
	44	*/
	45	void setObject(Object bean);
	46
	47	/**
	48	* Register a listener for the PropertyChange event. The customizer
	49	* should fire a PropertyChange event whenever it changes the target
	50	* bean in a way that might require the displayed properties to be
	51	* refreshed.
	52	*
	53	* @param listener An object to be invoked when a PropertyChange
	54	* event is fired.
	55	*/
	56	void addPropertyChangeListener(PropertyChangeListener listener);
	57
	58	/**
	59	* Remove a listener for the PropertyChange event.
	60	*
	61	* @param listener The PropertyChange listener to be removed.
	62	*/
	63	void removePropertyChangeListener(PropertyChangeListener listener);
	64
	65	}

java/pkg/java/beans/DefaultPersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/DefaultPersistenceDelegate.java+414−0

@@ -0,0 +1,414 @@
	1	/*
	2	* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import java.util.*;
	28	import java.lang.reflect.*;
	29	import java.util.Objects;
	30	import sun.reflect.misc.*;
	31
	32
	33	/**
	34	* The <code>DefaultPersistenceDelegate</code> is a concrete implementation of
	35	* the abstract <code>PersistenceDelegate</code> class and
	36	* is the delegate used by default for classes about
	37	* which no information is available. The <code>DefaultPersistenceDelegate</code>
	38	* provides, version resilient, public API-based persistence for
	39	* classes that follow the JavaBeans™ conventions without any class specific
	40	* configuration.
	41	* <p>
	42	* The key assumptions are that the class has a nullary constructor
	43	* and that its state is accurately represented by matching pairs
	44	* of "setter" and "getter" methods in the order they are returned
	45	* by the Introspector.
	46	* In addition to providing code-free persistence for JavaBeans,
	47	* the <code>DefaultPersistenceDelegate</code> provides a convenient means
	48	* to effect persistent storage for classes that have a constructor
	49	* that, while not nullary, simply requires some property values
	50	* as arguments.
	51	*
	52	* @see #DefaultPersistenceDelegate(String[])
	53	* @see java.beans.Introspector
	54	*
	55	* @since 1.4
	56	*
	57	* @author Philip Milne
	58	*/
	59
	60	public class DefaultPersistenceDelegate extends PersistenceDelegate {
	61	private String[] constructor;
	62	private Boolean definesEquals;
	63
	64	/**
	65	* Creates a persistence delegate for a class with a nullary constructor.
	66	*
	67	* @see #DefaultPersistenceDelegate(java.lang.String[])
	68	*/
	69	public DefaultPersistenceDelegate() {
	70	this(new String[0]);
	71	}
	72
	73	/**
	74	* Creates a default persistence delegate for a class with a
	75	* constructor whose arguments are the values of the property
	76	* names as specified by <code>constructorPropertyNames</code>.
	77	* The constructor arguments are created by
	78	* evaluating the property names in the order they are supplied.
	79	* To use this class to specify a single preferred constructor for use
	80	* in the serialization of a particular type, we state the
	81	* names of the properties that make up the constructor's
	82	* arguments. For example, the <code>Font</code> class which
	83	* does not define a nullary constructor can be handled
	84	* with the following persistence delegate:
	85	*
	86	* <pre>
	87	* new DefaultPersistenceDelegate(new String[]{"name", "style", "size"});
	88	* </pre>
	89	*
	90	* @param constructorPropertyNames The property names for the arguments of this constructor.
	91	*
	92	* @see #instantiate
	93	*/
	94	public DefaultPersistenceDelegate(String[] constructorPropertyNames) {
	95	this.constructor = constructorPropertyNames;
	96	}
	97
	98	private static boolean definesEquals(Class type) {
	99	try {
	100	return type == type.getMethod("equals", Object.class).getDeclaringClass();
	101	}
	102	catch(NoSuchMethodException e) {
	103	return false;
	104	}
	105	}
	106
	107	private boolean definesEquals(Object instance) {
	108	if (definesEquals != null) {
	109	return (definesEquals == Boolean.TRUE);
	110	}
	111	else {
	112	boolean result = definesEquals(instance.getClass());
	113	definesEquals = result ? Boolean.TRUE : Boolean.FALSE;
	114	return result;
	115	}
	116	}
	117
	118	/**
	119	* If the number of arguments in the specified constructor is non-zero and
	120	* the class of <code>oldInstance</code> explicitly declares an "equals" method
	121	* this method returns the value of <code>oldInstance.equals(newInstance)</code>.
	122	* Otherwise, this method uses the superclass's definition which returns true if the
	123	* classes of the two instances are equal.
	124	*
	125	* @param oldInstance The instance to be copied.
	126	* @param newInstance The instance that is to be modified.
	127	* @return True if an equivalent copy of <code>newInstance</code> may be
	128	* created by applying a series of mutations to <code>oldInstance</code>.
	129	*
	130	* @see #DefaultPersistenceDelegate(String[])
	131	*/
	132	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	133	// Assume the instance is either mutable or a singleton
	134	// if it has a nullary constructor.
	135	return (constructor.length == 0) \|\| !definesEquals(oldInstance) ?
	136	super.mutatesTo(oldInstance, newInstance) :
	137	oldInstance.equals(newInstance);
	138	}
	139
	140	/**
	141	* This default implementation of the <code>instantiate</code> method returns
	142	* an expression containing the predefined method name "new" which denotes a
	143	* call to a constructor with the arguments as specified in
	144	* the <code>DefaultPersistenceDelegate</code>'s constructor.
	145	*
	146	* @param oldInstance The instance to be instantiated.
	147	* @param out The code output stream.
	148	* @return An expression whose value is <code>oldInstance</code>.
	149	*
	150	* @throws NullPointerException if {@code out} is {@code null}
	151	*
	152	* @see #DefaultPersistenceDelegate(String[])
	153	*/
	154	protected Expression instantiate(Object oldInstance, Encoder out) {
	155	int nArgs = constructor.length;
	156	Class type = oldInstance.getClass();
	157	Object[] constructorArgs = new Object[nArgs];
	158	for(int i = 0; i < nArgs; i++) {
	159	try {
	160	Method method = findMethod(type, this.constructor[i]);
	161	constructorArgs[i] = MethodUtil.invoke(method, oldInstance, new Object[0]);
	162	}
	163	catch (Exception e) {
	164	out.getExceptionListener().exceptionThrown(e);
	165	}
	166	}
	167	return new Expression(oldInstance, oldInstance.getClass(), "new", constructorArgs);
	168	}
	169
	170	private Method findMethod(Class type, String property) {
	171	if (property == null) {
	172	throw new IllegalArgumentException("Property name is null");
	173	}
	174	PropertyDescriptor pd = getPropertyDescriptor(type, property);
	175	if (pd == null) {
	176	throw new IllegalStateException("Could not find property by the name " + property);
	177	}
	178	Method method = pd.getReadMethod();
	179	if (method == null) {
	180	throw new IllegalStateException("Could not find getter for the property " + property);
	181	}
	182	return method;
	183	}
	184
	185	private void doProperty(Class type, PropertyDescriptor pd, Object oldInstance, Object newInstance, Encoder out) throws Exception {
	186	Method getter = pd.getReadMethod();
	187	Method setter = pd.getWriteMethod();
	188
	189	if (getter != null && setter != null) {
	190	Expression oldGetExp = new Expression(oldInstance, getter.getName(), new Object[]{});
	191	Expression newGetExp = new Expression(newInstance, getter.getName(), new Object[]{});
	192	Object oldValue = oldGetExp.getValue();
	193	Object newValue = newGetExp.getValue();
	194	out.writeExpression(oldGetExp);
	195	if (!Objects.equals(newValue, out.get(oldValue))) {
	196	// Search for a static constant with this value;
	197	Object e = (Object[])pd.getValue("enumerationValues");
	198	if (e instanceof Object[] && Array.getLength(e) % 3 == 0) {
	199	Object[] a = (Object[])e;
	200	for(int i = 0; i < a.length; i = i + 3) {
	201	try {
	202	Field f = type.getField((String)a[i]);
	203	if (f.get(null).equals(oldValue)) {
	204	out.remove(oldValue);
	205	out.writeExpression(new Expression(oldValue, f, "get", new Object[]{null}));
	206	}
	207	}
	208	catch (Exception ex) {}
	209	}
	210	}
	211	invokeStatement(oldInstance, setter.getName(), new Object[]{oldValue}, out);
	212	}
	213	}
	214	}
	215
	216	static void invokeStatement(Object instance, String methodName, Object[] args, Encoder out) {
	217	out.writeStatement(new Statement(instance, methodName, args));
	218	}
	219
	220	// Write out the properties of this instance.
	221	private void initBean(Class type, Object oldInstance, Object newInstance, Encoder out) {
	222	for (Field field : type.getFields()) {
	223	int mod = field.getModifiers();
	224	if (Modifier.isFinal(mod) \|\| Modifier.isStatic(mod) \|\| Modifier.isTransient(mod)) {
	225	continue;
	226	}
	227	try {
	228	Expression oldGetExp = new Expression(field, "get", new Object[] { oldInstance });
	229	Expression newGetExp = new Expression(field, "get", new Object[] { newInstance });
	230	Object oldValue = oldGetExp.getValue();
	231	Object newValue = newGetExp.getValue();
	232	out.writeExpression(oldGetExp);
	233	if (!Objects.equals(newValue, out.get(oldValue))) {
	234	out.writeStatement(new Statement(field, "set", new Object[] { oldInstance, oldValue }));
	235	}
	236	}
	237	catch (Exception exception) {
	238	out.getExceptionListener().exceptionThrown(exception);
	239	}
	240	}
	241	BeanInfo info;
	242	try {
	243	info = Introspector.getBeanInfo(type);
	244	} catch (IntrospectionException exception) {
	245	return;
	246	}
	247	// Properties
	248	for (PropertyDescriptor d : info.getPropertyDescriptors()) {
	249	if (d.isTransient()) {
	250	continue;
	251	}
	252	try {
	253	doProperty(type, d, oldInstance, newInstance, out);
	254	}
	255	catch (Exception e) {
	256	out.getExceptionListener().exceptionThrown(e);
	257	}
	258	}
	259
	260	// Listeners
	261	/*
	262	Pending(milne). There is a general problem with the archival of
	263	listeners which is unresolved as of 1.4. Many of the methods
	264	which install one object inside another (typically "add" methods
	265	or setters) automatically install a listener on the "child" object
	266	so that its "parent" may respond to changes that are made to it.
	267	For example the JTable:setModel() method automatically adds a
	268	TableModelListener (the JTable itself in this case) to the supplied
	269	table model.
	270
	271	We do not need to explictly add these listeners to the model in an
	272	archive as they will be added automatically by, in the above case,
	273	the JTable's "setModel" method. In some cases, we must specifically
	274	avoid trying to do this since the listener may be an inner class
	275	that cannot be instantiated using public API.
	276
	277	No general mechanism currently
	278	exists for differentiating between these kind of listeners and
	279	those which were added explicitly by the user. A mechanism must
	280	be created to provide a general means to differentiate these
	281	special cases so as to provide reliable persistence of listeners
	282	for the general case.
	283	*/
	284	if (!java.awt.Component.class.isAssignableFrom(type)) {
	285	return; // Just handle the listeners of Components for now.
	286	}
	287	for (EventSetDescriptor d : info.getEventSetDescriptors()) {
	288	if (d.isTransient()) {
	289	continue;
	290	}
	291	Class listenerType = d.getListenerType();
	292
	293
	294	// The ComponentListener is added automatically, when
	295	// Contatiner:add is called on the parent.
	296	if (listenerType == java.awt.event.ComponentListener.class) {
	297	continue;
	298	}
	299
	300	// JMenuItems have a change listener added to them in
	301	// their "add" methods to enable accessibility support -
	302	// see the add method in JMenuItem for details. We cannot
	303	// instantiate this instance as it is a private inner class
	304	// and do not need to do this anyway since it will be created
	305	// and installed by the "add" method. Special case this for now,
	306	// ignoring all change listeners on JMenuItems.
	307	if (listenerType == javax.swing.event.ChangeListener.class &&
	308	type == javax.swing.JMenuItem.class) {
	309	continue;
	310	}
	311
	312	EventListener[] oldL = new EventListener[0];
	313	EventListener[] newL = new EventListener[0];
	314	try {
	315	Method m = d.getGetListenerMethod();
	316	oldL = (EventListener[])MethodUtil.invoke(m, oldInstance, new Object[]{});
	317	newL = (EventListener[])MethodUtil.invoke(m, newInstance, new Object[]{});
	318	}
	319	catch (Exception e2) {
	320	try {
	321	Method m = type.getMethod("getListeners", new Class[]{Class.class});
	322	oldL = (EventListener[])MethodUtil.invoke(m, oldInstance, new Object[]{listenerType});
	323	newL = (EventListener[])MethodUtil.invoke(m, newInstance, new Object[]{listenerType});
	324	}
	325	catch (Exception e3) {
	326	return;
	327	}
	328	}
	329
	330	// Asssume the listeners are in the same order and that there are no gaps.
	331	// Eventually, this may need to do true differencing.
	332	String addListenerMethodName = d.getAddListenerMethod().getName();
	333	for (int i = newL.length; i < oldL.length; i++) {
	334	// System.out.println("Adding listener: " + addListenerMethodName + oldL[i]);
	335	invokeStatement(oldInstance, addListenerMethodName, new Object[]{oldL[i]}, out);
	336	}
	337
	338	String removeListenerMethodName = d.getRemoveListenerMethod().getName();
	339	for (int i = oldL.length; i < newL.length; i++) {
	340	invokeStatement(oldInstance, removeListenerMethodName, new Object[]{newL[i]}, out);
	341	}
	342	}
	343	}
	344
	345	/**
	346	* This default implementation of the <code>initialize</code> method assumes
	347	* all state held in objects of this type is exposed via the
	348	* matching pairs of "setter" and "getter" methods in the order
	349	* they are returned by the Introspector. If a property descriptor
	350	* defines a "transient" attribute with a value equal to
	351	* <code>Boolean.TRUE</code> the property is ignored by this
	352	* default implementation. Note that this use of the word
	353	* "transient" is quite independent of the field modifier
	354	* that is used by the <code>ObjectOutputStream</code>.
	355	* <p>
	356	* For each non-transient property, an expression is created
	357	* in which the nullary "getter" method is applied
	358	* to the <code>oldInstance</code>. The value of this
	359	* expression is the value of the property in the instance that is
	360	* being serialized. If the value of this expression
	361	* in the cloned environment <code>mutatesTo</code> the
	362	* target value, the new value is initialized to make it
	363	* equivalent to the old value. In this case, because
	364	* the property value has not changed there is no need to
	365	* call the corresponding "setter" method and no statement
	366	* is emitted. If not however, the expression for this value
	367	* is replaced with another expression (normally a constructor)
	368	* and the corresponding "setter" method is called to install
	369	* the new property value in the object. This scheme removes
	370	* default information from the output produced by streams
	371	* using this delegate.
	372	* <p>
	373	* In passing these statements to the output stream, where they
	374	* will be executed, side effects are made to the <code>newInstance</code>.
	375	* In most cases this allows the problem of properties
	376	* whose values depend on each other to actually help the
	377	* serialization process by making the number of statements
	378	* that need to be written to the output smaller. In general,
	379	* the problem of handling interdependent properties is reduced to
	380	* that of finding an order for the properties in
	381	* a class such that no property value depends on the value of
	382	* a subsequent property.
	383	*
	384	* @param oldInstance The instance to be copied.
	385	* @param newInstance The instance that is to be modified.
	386	* @param out The stream to which any initialization statements should be written.
	387	*
	388	* @throws NullPointerException if {@code out} is {@code null}
	389	*
	390	* @see java.beans.Introspector#getBeanInfo
	391	* @see java.beans.PropertyDescriptor
	392	*/
	393	protected void initialize(Class<?> type,
	394	Object oldInstance, Object newInstance,
	395	Encoder out)
	396	{
	397	// System.out.println("DefulatPD:initialize" + type);
	398	super.initialize(type, oldInstance, newInstance, out);
	399	if (oldInstance.getClass() == type) { // !type.isInterface()) {
	400	initBean(type, oldInstance, newInstance, out);
	401	}
	402	}
	403
	404	private static PropertyDescriptor getPropertyDescriptor(Class type, String property) {
	405	try {
	406	for (PropertyDescriptor pd : Introspector.getBeanInfo(type).getPropertyDescriptors()) {
	407	if (property.equals(pd.getName()))
	408	return pd;
	409	}
	410	} catch (IntrospectionException exception) {
	411	}
	412	return null;
	413	}
	414	}

java/pkg/java/beans/DesignMode.class+0−0

Binary file not shown.

java/pkg/java/beans/DesignMode.java+89−0

@@ -0,0 +1,89 @@
	1	/*
	2	* Copyright (c) 1997, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* <p>
	30	* This interface is intended to be implemented by, or delegated from, instances
	31	* of java.beans.beancontext.BeanContext, in order to propagate to its nested hierarchy
	32	* of java.beans.beancontext.BeanContextChild instances, the current "designTime" property.
	33	* <p>
	34	* The JavaBeans™ specification defines the notion of design time as is a
	35	* mode in which JavaBeans instances should function during their composition
	36	* and customization in a interactive design, composition or construction tool,
	37	* as opposed to runtime when the JavaBean is part of an applet, application,
	38	* or other live Java executable abstraction.
	39	*
	40	* @author Laurence P. G. Cable
	41	* @since 1.2
	42	*
	43	* @see java.beans.beancontext.BeanContext
	44	* @see java.beans.beancontext.BeanContextChild
	45	* @see java.beans.beancontext.BeanContextMembershipListener
	46	* @see java.beans.PropertyChangeEvent
	47	*/
	48
	49	public interface DesignMode {
	50
	51	/**
	52	* The standard value of the propertyName as fired from a BeanContext or
	53	* other source of PropertyChangeEvents.
	54	*/
	55
	56	static String PROPERTYNAME = "designTime";
	57
	58	/**
	59	* Sets the "value" of the "designTime" property.
	60	* <p>
	61	* If the implementing object is an instance of java.beans.beancontext.BeanContext,
	62	* or a subinterface thereof, then that BeanContext should fire a
	63	* PropertyChangeEvent, to its registered BeanContextMembershipListeners, with
	64	* parameters:
	65	* <ul>
	66	* <li><code>propertyName</code> - <code>java.beans.DesignMode.PROPERTYNAME</code>
	67	* <li><code>oldValue</code> - previous value of "designTime"
	68	* <li><code>newValue</code> - current value of "designTime"
	69	* </ul>
	70	* Note it is illegal for a BeanContextChild to invoke this method
	71	* associated with a BeanContext that it is nested within.
	72	*
	73	* @param designTime the current "value" of the "designTime" property
	74	* @see java.beans.beancontext.BeanContext
	75	* @see java.beans.beancontext.BeanContextMembershipListener
	76	* @see java.beans.PropertyChangeEvent
	77	*/
	78
	79	void setDesignTime(boolean designTime);
	80
	81	/**
	82	* A value of true denotes that JavaBeans should behave in design time
	83	* mode, a value of false denotes runtime behavior.
	84	*
	85	* @return the current "value" of the "designTime" property.
	86	*/
	87
	88	boolean isDesignTime();
	89	}

java/pkg/java/beans/Encoder.class+0−0

Binary file not shown.

java/pkg/java/beans/Encoder.java+345−0

@@ -0,0 +1,345 @@
	1	/*
	2	* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import com.sun.beans.finder.PersistenceDelegateFinder;
	28
	29	import java.util.HashMap;
	30	import java.util.IdentityHashMap;
	31	import java.util.Map;
	32
	33	/**
	34	* An <code>Encoder</code> is a class which can be used to create
	35	* files or streams that encode the state of a collection of
	36	* JavaBeans in terms of their public APIs. The <code>Encoder</code>,
	37	* in conjunction with its persistence delegates, is responsible for
	38	* breaking the object graph down into a series of <code>Statements</code>s
	39	* and <code>Expression</code>s which can be used to create it.
	40	* A subclass typically provides a syntax for these expressions
	41	* using some human readable form - like Java source code or XML.
	42	*
	43	* @since 1.4
	44	*
	45	* @author Philip Milne
	46	*/
	47
	48	public class Encoder {
	49	private final PersistenceDelegateFinder finder = new PersistenceDelegateFinder();
	50	private Map bindings = new IdentityHashMap();
	51	private ExceptionListener exceptionListener;
	52	boolean executeStatements = true;
	53	private Map attributes;
	54
	55	/**
	56	* Write the specified object to the output stream.
	57	* The serialized form will denote a series of
	58	* expressions, the combined effect of which will create
	59	* an equivalent object when the input stream is read.
	60	* By default, the object is assumed to be a <em>JavaBean</em>
	61	* with a nullary constructor, whose state is defined by
	62	* the matching pairs of "setter" and "getter" methods
	63	* returned by the Introspector.
	64	*
	65	* @param o The object to be written to the stream.
	66	*
	67	* @see XMLDecoder#readObject
	68	*/
	69	protected void writeObject(Object o) {
	70	if (o == this) {
	71	return;
	72	}
	73	PersistenceDelegate info = getPersistenceDelegate(o == null ? null : o.getClass());
	74	info.writeObject(o, this);
	75	}
	76
	77	/**
	78	* Sets the exception handler for this stream to <code>exceptionListener</code>.
	79	* The exception handler is notified when this stream catches recoverable
	80	* exceptions.
	81	*
	82	* @param exceptionListener The exception handler for this stream;
	83	* if <code>null</code> the default exception listener will be used.
	84	*
	85	* @see #getExceptionListener
	86	*/
	87	public void setExceptionListener(ExceptionListener exceptionListener) {
	88	this.exceptionListener = exceptionListener;
	89	}
	90
	91	/**
	92	* Gets the exception handler for this stream.
	93	*
	94	* @return The exception handler for this stream;
	95	* Will return the default exception listener if this has not explicitly been set.
	96	*
	97	* @see #setExceptionListener
	98	*/
	99	public ExceptionListener getExceptionListener() {
	100	return (exceptionListener != null) ? exceptionListener : Statement.defaultExceptionListener;
	101	}
	102
	103	Object getValue(Expression exp) {
	104	try {
	105	return (exp == null) ? null : exp.getValue();
	106	}
	107	catch (Exception e) {
	108	getExceptionListener().exceptionThrown(e);
	109	throw new RuntimeException("failed to evaluate: " + exp.toString());
	110	}
	111	}
	112
	113	/**
	114	* Returns the persistence delegate for the given type.
	115	* The persistence delegate is calculated by applying
	116	* the following rules in order:
	117	* <ol>
	118	* <li>
	119	* If a persistence delegate is associated with the given type
	120	* by using the {@link #setPersistenceDelegate} method
	121	* it is returned.
	122	* <li>
	123	* A persistence delegate is then looked up by the name
	124	* composed of the the fully qualified name of the given type
	125	* and the "PersistenceDelegate" postfix.
	126	* For example, a persistence delegate for the {@code Bean} class
	127	* should be named {@code BeanPersistenceDelegate}
	128	* and located in the same package.
	129	* <pre>
	130	* public class Bean { ... }
	131	* public class BeanPersistenceDelegate { ... }</pre>
	132	* The instance of the {@code BeanPersistenceDelegate} class
	133	* is returned for the {@code Bean} class.
	134	* <li>
	135	* If the type is {@code null},
	136	* a shared internal persistence delegate is returned
	137	* that encodes {@code null} value.
	138	* <li>
	139	* If the type is a {@code enum} declaration,
	140	* a shared internal persistence delegate is returned
	141	* that encodes constants of this enumeration
	142	* by their names.
	143	* <li>
	144	* If the type is a primitive type or the corresponding wrapper,
	145	* a shared internal persistence delegate is returned
	146	* that encodes values of the given type.
	147	* <li>
	148	* If the type is an array,
	149	* a shared internal persistence delegate is returned
	150	* that encodes an array of the appropriate type and length,
	151	* and each of its elements as if they are properties.
	152	* <li>
	153	* If the type is a proxy,
	154	* a shared internal persistence delegate is returned
	155	* that encodes a proxy instance by using
	156	* the {@link java.lang.reflect.Proxy#newProxyInstance} method.
	157	* <li>
	158	* If the {@link BeanInfo} for this type has a {@link BeanDescriptor}
	159	* which defined a "persistenceDelegate" attribute,
	160	* the value of this named attribute is returned.
	161	* <li>
	162	* In all other cases the default persistence delegate is returned.
	163	* The default persistence delegate assumes the type is a <em>JavaBean</em>,
	164	* implying that it has a default constructor and that its state
	165	* may be characterized by the matching pairs of "setter" and "getter"
	166	* methods returned by the {@link Introspector} class.
	167	* The default constructor is the constructor with the greatest number
	168	* of parameters that has the {@link ConstructorProperties} annotation.
	169	* If none of the constructors has the {@code ConstructorProperties} annotation,
	170	* then the nullary constructor (constructor with no parameters) will be used.
	171	* For example, in the following code fragment, the nullary constructor
	172	* for the {@code Foo} class will be used,
	173	* while the two-parameter constructor
	174	* for the {@code Bar} class will be used.
	175	* <pre>
	176	* public class Foo {
	177	* public Foo() { ... }
	178	* public Foo(int x) { ... }
	179	* }
	180	* public class Bar {
	181	* public Bar() { ... }
	182	* @ConstructorProperties({"x"})
	183	* public Bar(int x) { ... }
	184	* @ConstructorProperties({"x", "y"})
	185	* public Bar(int x, int y) { ... }
	186	* }</pre>
	187	* </ol>
	188	*
	189	* @param type the class of the objects
	190	* @return the persistence delegate for the given type
	191	*
	192	* @see #setPersistenceDelegate
	193	* @see java.beans.Introspector#getBeanInfo
	194	* @see java.beans.BeanInfo#getBeanDescriptor
	195	*/
	196	public PersistenceDelegate getPersistenceDelegate(Class<?> type) {
	197	PersistenceDelegate pd = this.finder.find(type);
	198	return (pd != null) ? pd : MetaData.getPersistenceDelegate(type);
	199	}
	200
	201	/**
	202	* Associates the specified persistence delegate with the given type.
	203	*
	204	* @param type the class of objects that the specified persistence delegate applies to
	205	* @param delegate the persistence delegate for instances of the given type
	206	*
	207	* @see #getPersistenceDelegate
	208	* @see java.beans.Introspector#getBeanInfo
	209	* @see java.beans.BeanInfo#getBeanDescriptor
	210	*/
	211	public void setPersistenceDelegate(Class<?> type, PersistenceDelegate delegate) {
	212	this.finder.register(type, delegate);
	213	}
	214
	215	/**
	216	* Removes the entry for this instance, returning the old entry.
	217	*
	218	* @param oldInstance The entry that should be removed.
	219	* @return The entry that was removed.
	220	*
	221	* @see #get
	222	*/
	223	public Object remove(Object oldInstance) {
	224	Expression exp = (Expression)bindings.remove(oldInstance);
	225	return getValue(exp);
	226	}
	227
	228	/**
	229	* Returns a tentative value for <code>oldInstance</code> in
	230	* the environment created by this stream. A persistence
	231	* delegate can use its <code>mutatesTo</code> method to
	232	* determine whether this value may be initialized to
	233	* form the equivalent object at the output or whether
	234	* a new object must be instantiated afresh. If the
	235	* stream has not yet seen this value, null is returned.
	236	*
	237	* @param oldInstance The instance to be looked up.
	238	* @return The object, null if the object has not been seen before.
	239	*/
	240	public Object get(Object oldInstance) {
	241	if (oldInstance == null \|\| oldInstance == this \|\|
	242	oldInstance.getClass() == String.class) {
	243	return oldInstance;
	244	}
	245	Expression exp = (Expression)bindings.get(oldInstance);
	246	return getValue(exp);
	247	}
	248
	249	private Object writeObject1(Object oldInstance) {
	250	Object o = get(oldInstance);
	251	if (o == null) {
	252	writeObject(oldInstance);
	253	o = get(oldInstance);
	254	}
	255	return o;
	256	}
	257
	258	private Statement cloneStatement(Statement oldExp) {
	259	Object oldTarget = oldExp.getTarget();
	260	Object newTarget = writeObject1(oldTarget);
	261
	262	Object[] oldArgs = oldExp.getArguments();
	263	Object[] newArgs = new Object[oldArgs.length];
	264	for (int i = 0; i < oldArgs.length; i++) {
	265	newArgs[i] = writeObject1(oldArgs[i]);
	266	}
	267	Statement newExp = Statement.class.equals(oldExp.getClass())
	268	? new Statement(newTarget, oldExp.getMethodName(), newArgs)
	269	: new Expression(newTarget, oldExp.getMethodName(), newArgs);
	270	newExp.loader = oldExp.loader;
	271	return newExp;
	272	}
	273
	274	/**
	275	* Writes statement <code>oldStm</code> to the stream.
	276	* The <code>oldStm</code> should be written entirely
	277	* in terms of the callers environment, i.e. the
	278	* target and all arguments should be part of the
	279	* object graph being written. These expressions
	280	* represent a series of "what happened" expressions
	281	* which tell the output stream how to produce an
	282	* object graph like the original.
	283	* <p>
	284	* The implementation of this method will produce
	285	* a second expression to represent the same expression in
	286	* an environment that will exist when the stream is read.
	287	* This is achieved simply by calling <code>writeObject</code>
	288	* on the target and all the arguments and building a new
	289	* expression with the results.
	290	*
	291	* @param oldStm The expression to be written to the stream.
	292	*/
	293	public void writeStatement(Statement oldStm) {
	294	// System.out.println("writeStatement: " + oldExp);
	295	Statement newStm = cloneStatement(oldStm);
	296	if (oldStm.getTarget() != this && executeStatements) {
	297	try {
	298	newStm.execute();
	299	} catch (Exception e) {
	300	getExceptionListener().exceptionThrown(new Exception("Encoder: discarding statement "
	301	+ newStm, e));
	302	}
	303	}
	304	}
	305
	306	/**
	307	* The implementation first checks to see if an
	308	* expression with this value has already been written.
	309	* If not, the expression is cloned, using
	310	* the same procedure as <code>writeStatement</code>,
	311	* and the value of this expression is reconciled
	312	* with the value of the cloned expression
	313	* by calling <code>writeObject</code>.
	314	*
	315	* @param oldExp The expression to be written to the stream.
	316	*/
	317	public void writeExpression(Expression oldExp) {
	318	// System.out.println("Encoder::writeExpression: " + oldExp);
	319	Object oldValue = getValue(oldExp);
	320	if (get(oldValue) != null) {
	321	return;
	322	}
	323	bindings.put(oldValue, (Expression)cloneStatement(oldExp));
	324	writeObject(oldValue);
	325	}
	326
	327	void clear() {
	328	bindings.clear();
	329	}
	330
	331	// Package private method for setting an attributes table for the encoder
	332	void setAttribute(Object key, Object value) {
	333	if (attributes == null) {
	334	attributes = new HashMap();
	335	}
	336	attributes.put(key, value);
	337	}
	338
	339	Object getAttribute(Object key) {
	340	if (attributes == null) {
	341	return null;
	342	}
	343	return attributes.get(key);
	344	}
	345	}

java/pkg/java/beans/EnumPersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/EventHandler$1.class+0−0

Binary file not shown.

java/pkg/java/beans/EventHandler.class+0−0

Binary file not shown.

java/pkg/java/beans/EventHandler.java+694−0

@@ -0,0 +1,694 @@
	1	/*
	2	* Copyright (c) 2000, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import java.lang.reflect.InvocationHandler;
	28	import java.lang.reflect.InvocationTargetException;
	29	import java.lang.reflect.Proxy;
	30	import java.lang.reflect.Method;
	31	import java.security.AccessControlContext;
	32	import java.security.AccessController;
	33	import java.security.PrivilegedAction;
	34
	35	import sun.reflect.misc.MethodUtil;
	36
	37	/**
	38	* The <code>EventHandler</code> class provides
	39	* support for dynamically generating event listeners whose methods
	40	* execute a simple statement involving an incoming event object
	41	* and a target object.
	42	* <p>
	43	* The <code>EventHandler</code> class is intended to be used by interactive tools, such as
	44	* application builders, that allow developers to make connections between
	45	* beans. Typically connections are made from a user interface bean
	46	* (the event <em>source</em>)
	47	* to an application logic bean (the <em>target</em>). The most effective
	48	* connections of this kind isolate the application logic from the user
	49	* interface. For example, the <code>EventHandler</code> for a
	50	* connection from a <code>JCheckBox</code> to a method
	51	* that accepts a boolean value can deal with extracting the state
	52	* of the check box and passing it directly to the method so that
	53	* the method is isolated from the user interface layer.
	54	* <p>
	55	* Inner classes are another, more general way to handle events from
	56	* user interfaces. The <code>EventHandler</code> class
	57	* handles only a subset of what is possible using inner
	58	* classes. However, <code>EventHandler</code> works better
	59	* with the long-term persistence scheme than inner classes.
	60	* Also, using <code>EventHandler</code> in large applications in
	61	* which the same interface is implemented many times can
	62	* reduce the disk and memory footprint of the application.
	63	* <p>
	64	* The reason that listeners created with <code>EventHandler</code>
	65	* have such a small
	66	* footprint is that the <code>Proxy</code> class, on which
	67	* the <code>EventHandler</code> relies, shares implementations
	68	* of identical
	69	* interfaces. For example, if you use
	70	* the <code>EventHandler</code> <code>create</code> methods to make
	71	* all the <code>ActionListener</code>s in an application,
	72	* all the action listeners will be instances of a single class
	73	* (one created by the <code>Proxy</code> class).
	74	* In general, listeners based on
	75	* the <code>Proxy</code> class require one listener class
	76	* to be created per <em>listener type</em> (interface),
	77	* whereas the inner class
	78	* approach requires one class to be created per <em>listener</em>
	79	* (object that implements the interface).
	80	*
	81	* <p>
	82	* You don't generally deal directly with <code>EventHandler</code>
	83	* instances.
	84	* Instead, you use one of the <code>EventHandler</code>
	85	* <code>create</code> methods to create
	86	* an object that implements a given listener interface.
	87	* This listener object uses an <code>EventHandler</code> object
	88	* behind the scenes to encapsulate information about the
	89	* event, the object to be sent a message when the event occurs,
	90	* the message (method) to be sent, and any argument
	91	* to the method.
	92	* The following section gives examples of how to create listener
	93	* objects using the <code>create</code> methods.
	94	*
	95	* <h2>Examples of Using EventHandler</h2>
	96	*
	97	* The simplest use of <code>EventHandler</code> is to install
	98	* a listener that calls a method on the target object with no arguments.
	99	* In the following example we create an <code>ActionListener</code>
	100	* that invokes the <code>toFront</code> method on an instance
	101	* of <code>javax.swing.JFrame</code>.
	102	*
	103	* <blockquote>
	104	*<pre>
	105	*myButton.addActionListener(
	106	* (ActionListener)EventHandler.create(ActionListener.class, frame, "toFront"));
	107	*</pre>
	108	* </blockquote>
	109	*
	110	* When <code>myButton</code> is pressed, the statement
	111	* <code>frame.toFront()</code> will be executed. One could get
	112	* the same effect, with some additional compile-time type safety,
	113	* by defining a new implementation of the <code>ActionListener</code>
	114	* interface and adding an instance of it to the button:
	115	*
	116	* <blockquote>
	117	*<pre>
	118	//Equivalent code using an inner class instead of EventHandler.
	119	*myButton.addActionListener(new ActionListener() {
	120	* public void actionPerformed(ActionEvent e) {
	121	* frame.toFront();
	122	* }
	123	*});
	124	*</pre>
	125	* </blockquote>
	126	*
	127	* The next simplest use of <code>EventHandler</code> is
	128	* to extract a property value from the first argument
	129	* of the method in the listener interface (typically an event object)
	130	* and use it to set the value of a property in the target object.
	131	* In the following example we create an <code>ActionListener</code> that
	132	* sets the <code>nextFocusableComponent</code> property of the target
	133	* (myButton) object to the value of the "source" property of the event.
	134	*
	135	* <blockquote>
	136	*<pre>
	137	*EventHandler.create(ActionListener.class, myButton, "nextFocusableComponent", "source")
	138	*</pre>
	139	* </blockquote>
	140	*
	141	* This would correspond to the following inner class implementation:
	142	*
	143	* <blockquote>
	144	*<pre>
	145	//Equivalent code using an inner class instead of EventHandler.
	146	*new ActionListener() {
	147	* public void actionPerformed(ActionEvent e) {
	148	* myButton.setNextFocusableComponent((Component)e.getSource());
	149	* }
	150	*}
	151	*</pre>
	152	* </blockquote>
	153	*
	154	* It's also possible to create an <code>EventHandler</code> that
	155	* just passes the incoming event object to the target's action.
	156	* If the fourth <code>EventHandler.create</code> argument is
	157	* an empty string, then the event is just passed along:
	158	*
	159	* <blockquote>
	160	*<pre>
	161	*EventHandler.create(ActionListener.class, target, "doActionEvent", "")
	162	*</pre>
	163	* </blockquote>
	164	*
	165	* This would correspond to the following inner class implementation:
	166	*
	167	* <blockquote>
	168	*<pre>
	169	//Equivalent code using an inner class instead of EventHandler.
	170	*new ActionListener() {
	171	* public void actionPerformed(ActionEvent e) {
	172	* target.doActionEvent(e);
	173	* }
	174	*}
	175	*</pre>
	176	* </blockquote>
	177	*
	178	* Probably the most common use of <code>EventHandler</code>
	179	* is to extract a property value from the
	180	* <em>source</em> of the event object and set this value as
	181	* the value of a property of the target object.
	182	* In the following example we create an <code>ActionListener</code> that
	183	* sets the "label" property of the target
	184	* object to the value of the "text" property of the
	185	* source (the value of the "source" property) of the event.
	186	*
	187	* <blockquote>
	188	*<pre>
	189	*EventHandler.create(ActionListener.class, myButton, "label", "source.text")
	190	*</pre>
	191	* </blockquote>
	192	*
	193	* This would correspond to the following inner class implementation:
	194	*
	195	* <blockquote>
	196	*<pre>
	197	//Equivalent code using an inner class instead of EventHandler.
	198	*new ActionListener {
	199	* public void actionPerformed(ActionEvent e) {
	200	* myButton.setLabel(((JTextField)e.getSource()).getText());
	201	* }
	202	*}
	203	*</pre>
	204	* </blockquote>
	205	*
	206	* The event property may be "qualified" with an arbitrary number
	207	* of property prefixes delimited with the "." character. The "qualifying"
	208	* names that appear before the "." characters are taken as the names of
	209	* properties that should be applied, left-most first, to
	210	* the event object.
	211	* <p>
	212	* For example, the following action listener
	213	*
	214	* <blockquote>
	215	*<pre>
	216	*EventHandler.create(ActionListener.class, target, "a", "b.c.d")
	217	*</pre>
	218	* </blockquote>
	219	*
	220	* might be written as the following inner class
	221	* (assuming all the properties had canonical getter methods and
	222	* returned the appropriate types):
	223	*
	224	* <blockquote>
	225	*<pre>
	226	//Equivalent code using an inner class instead of EventHandler.
	227	*new ActionListener {
	228	* public void actionPerformed(ActionEvent e) {
	229	* target.setA(e.getB().getC().isD());
	230	* }
	231	*}
	232	*</pre>
	233	* </blockquote>
	234	* The target property may also be "qualified" with an arbitrary number
	235	* of property prefixs delimited with the "." character. For example, the
	236	* following action listener:
	237	* <pre>
	238	* EventHandler.create(ActionListener.class, target, "a.b", "c.d")
	239	* </pre>
	240	* might be written as the following inner class
	241	* (assuming all the properties had canonical getter methods and
	242	* returned the appropriate types):
	243	* <pre>
	244	* //Equivalent code using an inner class instead of EventHandler.
	245	* new ActionListener {
	246	* public void actionPerformed(ActionEvent e) {
	247	* target.getA().setB(e.getC().isD());
	248	* }
	249	*}
	250	*</pre>
	251	* <p>
	252	* As <code>EventHandler</code> ultimately relies on reflection to invoke
	253	* a method we recommend against targeting an overloaded method. For example,
	254	* if the target is an instance of the class <code>MyTarget</code> which is
	255	* defined as:
	256	* <pre>
	257	* public class MyTarget {
	258	* public void doIt(String);
	259	* public void doIt(Object);
	260	* }
	261	* </pre>
	262	* Then the method <code>doIt</code> is overloaded. EventHandler will invoke
	263	* the method that is appropriate based on the source. If the source is
	264	* null, then either method is appropriate and the one that is invoked is
	265	* undefined. For that reason we recommend against targeting overloaded
	266	* methods.
	267	*
	268	* @see java.lang.reflect.Proxy
	269	* @see java.util.EventObject
	270	*
	271	* @since 1.4
	272	*
	273	* @author Mark Davidson
	274	* @author Philip Milne
	275	* @author Hans Muller
	276	*
	277	*/
	278	public class EventHandler implements InvocationHandler {
	279	private Object target;
	280	private String action;
	281	private final String eventPropertyName;
	282	private final String listenerMethodName;
	283	private final AccessControlContext acc = AccessController.getContext();
	284
	285	/**
	286	* Creates a new <code>EventHandler</code> object;
	287	* you generally use one of the <code>create</code> methods
	288	* instead of invoking this constructor directly. Refer to
	289	* {@link java.beans.EventHandler#create(Class, Object, String, String)
	290	* the general version of create} for a complete description of
	291	* the <code>eventPropertyName</code> and <code>listenerMethodName</code>
	292	* parameter.
	293	*
	294	* @param target the object that will perform the action
	295	* @param action the name of a (possibly qualified) property or method on
	296	* the target
	297	* @param eventPropertyName the (possibly qualified) name of a readable property of the incoming event
	298	* @param listenerMethodName the name of the method in the listener interface that should trigger the action
	299	*
	300	* @throws NullPointerException if <code>target</code> is null
	301	* @throws NullPointerException if <code>action</code> is null
	302	*
	303	* @see EventHandler
	304	* @see #create(Class, Object, String, String, String)
	305	* @see #getTarget
	306	* @see #getAction
	307	* @see #getEventPropertyName
	308	* @see #getListenerMethodName
	309	*/
	310	@ConstructorProperties({"target", "action", "eventPropertyName", "listenerMethodName"})
	311	public EventHandler(Object target, String action, String eventPropertyName, String listenerMethodName) {
	312	this.target = target;
	313	this.action = action;
	314	if (target == null) {
	315	throw new NullPointerException("target must be non-null");
	316	}
	317	if (action == null) {
	318	throw new NullPointerException("action must be non-null");
	319	}
	320	this.eventPropertyName = eventPropertyName;
	321	this.listenerMethodName = listenerMethodName;
	322	}
	323
	324	/**
	325	* Returns the object to which this event handler will send a message.
	326	*
	327	* @return the target of this event handler
	328	* @see #EventHandler(Object, String, String, String)
	329	*/
	330	public Object getTarget() {
	331	return target;
	332	}
	333
	334	/**
	335	* Returns the name of the target's writable property
	336	* that this event handler will set,
	337	* or the name of the method that this event handler
	338	* will invoke on the target.
	339	*
	340	* @return the action of this event handler
	341	* @see #EventHandler(Object, String, String, String)
	342	*/
	343	public String getAction() {
	344	return action;
	345	}
	346
	347	/**
	348	* Returns the property of the event that should be
	349	* used in the action applied to the target.
	350	*
	351	* @return the property of the event
	352	*
	353	* @see #EventHandler(Object, String, String, String)
	354	*/
	355	public String getEventPropertyName() {
	356	return eventPropertyName;
	357	}
	358
	359	/**
	360	* Returns the name of the method that will trigger the action.
	361	* A return value of <code>null</code> signifies that all methods in the
	362	* listener interface trigger the action.
	363	*
	364	* @return the name of the method that will trigger the action
	365	*
	366	* @see #EventHandler(Object, String, String, String)
	367	*/
	368	public String getListenerMethodName() {
	369	return listenerMethodName;
	370	}
	371
	372	private Object applyGetters(Object target, String getters) {
	373	if (getters == null \|\| getters.equals("")) {
	374	return target;
	375	}
	376	int firstDot = getters.indexOf('.');
	377	if (firstDot == -1) {
	378	firstDot = getters.length();
	379	}
	380	String first = getters.substring(0, firstDot);
	381	String rest = getters.substring(Math.min(firstDot + 1, getters.length()));
	382
	383	try {
	384	Method getter = null;
	385	if (target != null) {
	386	getter = Statement.getMethod(target.getClass(),
	387	"get" + NameGenerator.capitalize(first),
	388	new Class[]{});
	389	if (getter == null) {
	390	getter = Statement.getMethod(target.getClass(),
	391	"is" + NameGenerator.capitalize(first),
	392	new Class[]{});
	393	}
	394	if (getter == null) {
	395	getter = Statement.getMethod(target.getClass(), first, new Class[]{});
	396	}
	397	}
	398	if (getter == null) {
	399	throw new RuntimeException("No method called: " + first +
	400	" defined on " + target);
	401	}
	402	Object newTarget = MethodUtil.invoke(getter, target, new Object[]{});
	403	return applyGetters(newTarget, rest);
	404	}
	405	catch (Exception e) {
	406	throw new RuntimeException("Failed to call method: " + first +
	407	" on " + target, e);
	408	}
	409	}
	410
	411	/**
	412	* Extract the appropriate property value from the event and
	413	* pass it to the action associated with
	414	* this <code>EventHandler</code>.
	415	*
	416	* @param proxy the proxy object
	417	* @param method the method in the listener interface
	418	* @return the result of applying the action to the target
	419	*
	420	* @see EventHandler
	421	*/
	422	public Object invoke(final Object proxy, final Method method, final Object[] arguments) {
	423	AccessControlContext acc = this.acc;
	424	if ((acc == null) && (System.getSecurityManager() != null)) {
	425	throw new SecurityException("AccessControlContext is not set");
	426	}
	427	return AccessController.doPrivileged(new PrivilegedAction<Object>() {
	428	public Object run() {
	429	return invokeInternal(proxy, method, arguments);
	430	}
	431	}, acc);
	432	}
	433
	434	private Object invokeInternal(Object proxy, Method method, Object[] arguments) {
	435	String methodName = method.getName();
	436	if (method.getDeclaringClass() == Object.class) {
	437	// Handle the Object public methods.
	438	if (methodName.equals("hashCode")) {
	439	return new Integer(System.identityHashCode(proxy));
	440	} else if (methodName.equals("equals")) {
	441	return (proxy == arguments[0] ? Boolean.TRUE : Boolean.FALSE);
	442	} else if (methodName.equals("toString")) {
	443	return proxy.getClass().getName() + '@' + Integer.toHexString(proxy.hashCode());
	444	}
	445	}
	446
	447	if (listenerMethodName == null \|\| listenerMethodName.equals(methodName)) {
	448	Class[] argTypes = null;
	449	Object[] newArgs = null;
	450
	451	if (eventPropertyName == null) { // Nullary method.
	452	newArgs = new Object[]{};
	453	argTypes = new Class[]{};
	454	}
	455	else {
	456	Object input = applyGetters(arguments[0], getEventPropertyName());
	457	newArgs = new Object[]{input};
	458	argTypes = new Class[]{input == null ? null :
	459	input.getClass()};
	460	}
	461	try {
	462	int lastDot = action.lastIndexOf('.');
	463	if (lastDot != -1) {
	464	target = applyGetters(target, action.substring(0, lastDot));
	465	action = action.substring(lastDot + 1);
	466	}
	467	Method targetMethod = Statement.getMethod(
	468	target.getClass(), action, argTypes);
	469	if (targetMethod == null) {
	470	targetMethod = Statement.getMethod(target.getClass(),
	471	"set" + NameGenerator.capitalize(action), argTypes);
	472	}
	473	if (targetMethod == null) {
	474	String argTypeString = (argTypes.length == 0)
	475	? " with no arguments"
	476	: " with argument " + argTypes[0];
	477	throw new RuntimeException(
	478	"No method called " + action + " on " +
	479	target.getClass() + argTypeString);
	480	}
	481	return MethodUtil.invoke(targetMethod, target, newArgs);
	482	}
	483	catch (IllegalAccessException ex) {
	484	throw new RuntimeException(ex);
	485	}
	486	catch (InvocationTargetException ex) {
	487	Throwable th = ex.getTargetException();
	488	throw (th instanceof RuntimeException)
	489	? (RuntimeException) th
	490	: new RuntimeException(th);
	491	}
	492	}
	493	return null;
	494	}
	495
	496	/**
	497	* Creates an implementation of <code>listenerInterface</code> in which
	498	* <em>all</em> of the methods in the listener interface apply
	499	* the handler's <code>action</code> to the <code>target</code>. This
	500	* method is implemented by calling the other, more general,
	501	* implementation of the <code>create</code> method with both
	502	* the <code>eventPropertyName</code> and the <code>listenerMethodName</code>
	503	* taking the value <code>null</code>. Refer to
	504	* {@link java.beans.EventHandler#create(Class, Object, String, String)
	505	* the general version of create} for a complete description of
	506	* the <code>action</code> parameter.
	507	* <p>
	508	* To create an <code>ActionListener</code> that shows a
	509	* <code>JDialog</code> with <code>dialog.show()</code>,
	510	* one can write:
	511	*
	512	*<blockquote>
	513	*<pre>
	514	*EventHandler.create(ActionListener.class, dialog, "show")
	515	*</pre>
	516	*</blockquote>
	517	*
	518	* @param listenerInterface the listener interface to create a proxy for
	519	* @param target the object that will perform the action
	520	* @param action the name of a (possibly qualified) property or method on
	521	* the target
	522	* @return an object that implements <code>listenerInterface</code>
	523	*
	524	* @throws NullPointerException if <code>listenerInterface</code> is null
	525	* @throws NullPointerException if <code>target</code> is null
	526	* @throws NullPointerException if <code>action</code> is null
	527	*
	528	* @see #create(Class, Object, String, String)
	529	*/
	530	public static <T> T create(Class<T> listenerInterface,
	531	Object target, String action)
	532	{
	533	return create(listenerInterface, target, action, null, null);
	534	}
	535
	536	/**
	537	/**
	538	* Creates an implementation of <code>listenerInterface</code> in which
	539	* <em>all</em> of the methods pass the value of the event
	540	* expression, <code>eventPropertyName</code>, to the final method in the
	541	* statement, <code>action</code>, which is applied to the <code>target</code>.
	542	* This method is implemented by calling the
	543	* more general, implementation of the <code>create</code> method with
	544	* the <code>listenerMethodName</code> taking the value <code>null</code>.
	545	* Refer to
	546	* {@link java.beans.EventHandler#create(Class, Object, String, String)
	547	* the general version of create} for a complete description of
	548	* the <code>action</code> and <code>eventPropertyName</code> parameters.
	549	* <p>
	550	* To create an <code>ActionListener</code> that sets the
	551	* the text of a <code>JLabel</code> to the text value of
	552	* the <code>JTextField</code> source of the incoming event,
	553	* you can use the following code:
	554	*
	555	*<blockquote>
	556	*<pre>
	557	*EventHandler.create(ActionListener.class, label, "text", "source.text");
	558	*</pre>
	559	*</blockquote>
	560	*
	561	* This is equivalent to the following code:
	562	*<blockquote>
	563	*<pre>
	564	//Equivalent code using an inner class instead of EventHandler.
	565	*new ActionListener() {
	566	* public void actionPerformed(ActionEvent event) {
	567	* label.setText(((JTextField)(event.getSource())).getText());
	568	* }
	569	*};
	570	*</pre>
	571	*</blockquote>
	572	*
	573	* @param listenerInterface the listener interface to create a proxy for
	574	* @param target the object that will perform the action
	575	* @param action the name of a (possibly qualified) property or method on
	576	* the target
	577	* @param eventPropertyName the (possibly qualified) name of a readable property of the incoming event
	578	*
	579	* @return an object that implements <code>listenerInterface</code>
	580	*
	581	* @throws NullPointerException if <code>listenerInterface</code> is null
	582	* @throws NullPointerException if <code>target</code> is null
	583	* @throws NullPointerException if <code>action</code> is null
	584	*
	585	* @see #create(Class, Object, String, String, String)
	586	*/
	587	public static <T> T create(Class<T> listenerInterface,
	588	Object target, String action,
	589	String eventPropertyName)
	590	{
	591	return create(listenerInterface, target, action, eventPropertyName, null);
	592	}
	593
	594	/**
	595	* Creates an implementation of <code>listenerInterface</code> in which
	596	* the method named <code>listenerMethodName</code>
	597	* passes the value of the event expression, <code>eventPropertyName</code>,
	598	* to the final method in the statement, <code>action</code>, which
	599	* is applied to the <code>target</code>. All of the other listener
	600	* methods do nothing.
	601	* <p>
	602	* The <code>eventPropertyName</code> string is used to extract a value
	603	* from the incoming event object that is passed to the target
	604	* method. The common case is the target method takes no arguments, in
	605	* which case a value of null should be used for the
	606	* <code>eventPropertyName</code>. Alternatively if you want
	607	* the incoming event object passed directly to the target method use
	608	* the empty string.
	609	* The format of the <code>eventPropertyName</code> string is a sequence of
	610	* methods or properties where each method or
	611	* property is applied to the value returned by the preceeding method
	612	* starting from the incoming event object.
	613	* The syntax is: <code>propertyName{.propertyName}*</code>
	614	* where <code>propertyName</code> matches a method or
	615	* property. For example, to extract the <code>point</code>
	616	* property from a <code>MouseEvent</code>, you could use either
	617	* <code>"point"</code> or <code>"getPoint"</code> as the
	618	* <code>eventPropertyName</code>. To extract the "text" property from
	619	* a <code>MouseEvent</code> with a <code>JLabel</code> source use any
	620	* of the following as <code>eventPropertyName</code>:
	621	* <code>"source.text"</code>,
	622	* <code>"getSource.text"</code> <code>"getSource.getText"</code> or
	623	* <code>"source.getText"</code>. If a method can not be found, or an
	624	* exception is generated as part of invoking a method a
	625	* <code>RuntimeException</code> will be thrown at dispatch time. For
	626	* example, if the incoming event object is null, and
	627	* <code>eventPropertyName</code> is non-null and not empty, a
	628	* <code>RuntimeException</code> will be thrown.
	629	* <p>
	630	* The <code>action</code> argument is of the same format as the
	631	* <code>eventPropertyName</code> argument where the last property name
	632	* identifies either a method name or writable property.
	633	* <p>
	634	* If the <code>listenerMethodName</code> is <code>null</code>
	635	* <em>all</em> methods in the interface trigger the <code>action</code> to be
	636	* executed on the <code>target</code>.
	637	* <p>
	638	* For example, to create a <code>MouseListener</code> that sets the target
	639	* object's <code>origin</code> property to the incoming <code>MouseEvent</code>'s
	640	* location (that's the value of <code>mouseEvent.getPoint()</code>) each
	641	* time a mouse button is pressed, one would write:
	642	*<blockquote>
	643	*<pre>
	644	*EventHandler.create(MouseListener.class, target, "origin", "point", "mousePressed");
	645	*</pre>
	646	*</blockquote>
	647	*
	648	* This is comparable to writing a <code>MouseListener</code> in which all
	649	* of the methods except <code>mousePressed</code> are no-ops:
	650	*
	651	*<blockquote>
	652	*<pre>
	653	//Equivalent code using an inner class instead of EventHandler.
	654	*new MouseAdapter() {
	655	* public void mousePressed(MouseEvent e) {
	656	* target.setOrigin(e.getPoint());
	657	* }
	658	*};
	659	* </pre>
	660	*</blockquote>
	661	*
	662	* @param listenerInterface the listener interface to create a proxy for
	663	* @param target the object that will perform the action
	664	* @param action the name of a (possibly qualified) property or method on
	665	* the target
	666	* @param eventPropertyName the (possibly qualified) name of a readable property of the incoming event
	667	* @param listenerMethodName the name of the method in the listener interface that should trigger the action
	668	*
	669	* @return an object that implements <code>listenerInterface</code>
	670	*
	671	* @throws NullPointerException if <code>listenerInterface</code> is null
	672	* @throws NullPointerException if <code>target</code> is null
	673	* @throws NullPointerException if <code>action</code> is null
	674	*
	675	* @see EventHandler
	676	*/
	677	public static <T> T create(Class<T> listenerInterface,
	678	Object target, String action,
	679	String eventPropertyName,
	680	String listenerMethodName)
	681	{
	682	// Create this first to verify target/action are non-null
	683	EventHandler eventHandler = new EventHandler(target, action,
	684	eventPropertyName,
	685	listenerMethodName);
	686	if (listenerInterface == null) {
	687	throw new NullPointerException(
	688	"listenerInterface must be non-null");
	689	}
	690	return (T)Proxy.newProxyInstance(target.getClass().getClassLoader(),
	691	new Class[] {listenerInterface},
	692	eventHandler);
	693	}
	694	}

java/pkg/java/beans/EventSetDescriptor.class+0−0

Binary file not shown.

java/pkg/java/beans/EventSetDescriptor.java+536−0

@@ -0,0 +1,536 @@
	1	/*
	2	* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.lang.ref.Reference;
	29	import java.lang.reflect.Method;
	30	import java.lang.reflect.Modifier;
	31
	32	/**
	33	* An EventSetDescriptor describes a group of events that a given Java
	34	* bean fires.
	35	* <P>
	36	* The given group of events are all delivered as method calls on a single
	37	* event listener interface, and an event listener object can be registered
	38	* via a call on a registration method supplied by the event source.
	39	*/
	40	public class EventSetDescriptor extends FeatureDescriptor {
	41
	42	private MethodDescriptor[] listenerMethodDescriptors;
	43	private MethodDescriptor addMethodDescriptor;
	44	private MethodDescriptor removeMethodDescriptor;
	45	private MethodDescriptor getMethodDescriptor;
	46
	47	private Reference<Method[]> listenerMethodsRef;
	48	private Reference<Class> listenerTypeRef;
	49
	50	private boolean unicast;
	51	private boolean inDefaultEventSet = true;
	52
	53	/**
	54	* Creates an <TT>EventSetDescriptor</TT> assuming that you are
	55	* following the most simple standard design pattern where a named
	56	* event "fred" is (1) delivered as a call on the single method of
	57	* interface FredListener, (2) has a single argument of type FredEvent,
	58	* and (3) where the FredListener may be registered with a call on an
	59	* addFredListener method of the source component and removed with a
	60	* call on a removeFredListener method.
	61	*
	62	* @param sourceClass The class firing the event.
	63	* @param eventSetName The programmatic name of the event. E.g. "fred".
	64	* Note that this should normally start with a lower-case character.
	65	* @param listenerType The target interface that events
	66	* will get delivered to.
	67	* @param listenerMethodName The method that will get called when the event gets
	68	* delivered to its target listener interface.
	69	* @exception IntrospectionException if an exception occurs during
	70	* introspection.
	71	*/
	72	public EventSetDescriptor(Class<?> sourceClass, String eventSetName,
	73	Class<?> listenerType, String listenerMethodName)
	74	throws IntrospectionException {
	75	this(sourceClass, eventSetName, listenerType,
	76	new String[] { listenerMethodName },
	77	Introspector.ADD_PREFIX + getListenerClassName(listenerType),
	78	Introspector.REMOVE_PREFIX + getListenerClassName(listenerType),
	79	Introspector.GET_PREFIX + getListenerClassName(listenerType) + "s");
	80
	81	String eventName = NameGenerator.capitalize(eventSetName) + "Event";
	82	Method[] listenerMethods = getListenerMethods();
	83	if (listenerMethods.length > 0) {
	84	Class[] args = getParameterTypes(getClass0(), listenerMethods[0]);
	85	// Check for EventSet compliance. Special case for vetoableChange. See 4529996
	86	if (!"vetoableChange".equals(eventSetName) && !args[0].getName().endsWith(eventName)) {
	87	throw new IntrospectionException("Method \"" + listenerMethodName +
	88	"\" should have argument \"" +
	89	eventName + "\"");
	90	}
	91	}
	92	}
	93
	94	private static String getListenerClassName(Class cls) {
	95	String className = cls.getName();
	96	return className.substring(className.lastIndexOf('.') + 1);
	97	}
	98
	99	/**
	100	* Creates an <TT>EventSetDescriptor</TT> from scratch using
	101	* string names.
	102	*
	103	* @param sourceClass The class firing the event.
	104	* @param eventSetName The programmatic name of the event set.
	105	* Note that this should normally start with a lower-case character.
	106	* @param listenerType The Class of the target interface that events
	107	* will get delivered to.
	108	* @param listenerMethodNames The names of the methods that will get called
	109	* when the event gets delivered to its target listener interface.
	110	* @param addListenerMethodName The name of the method on the event source
	111	* that can be used to register an event listener object.
	112	* @param removeListenerMethodName The name of the method on the event source
	113	* that can be used to de-register an event listener object.
	114	* @exception IntrospectionException if an exception occurs during
	115	* introspection.
	116	*/
	117	public EventSetDescriptor(Class<?> sourceClass,
	118	String eventSetName,
	119	Class<?> listenerType,
	120	String listenerMethodNames[],
	121	String addListenerMethodName,
	122	String removeListenerMethodName)
	123	throws IntrospectionException {
	124	this(sourceClass, eventSetName, listenerType,
	125	listenerMethodNames, addListenerMethodName,
	126	removeListenerMethodName, null);
	127	}
	128
	129	/**
	130	* This constructor creates an EventSetDescriptor from scratch using
	131	* string names.
	132	*
	133	* @param sourceClass The class firing the event.
	134	* @param eventSetName The programmatic name of the event set.
	135	* Note that this should normally start with a lower-case character.
	136	* @param listenerType The Class of the target interface that events
	137	* will get delivered to.
	138	* @param listenerMethodNames The names of the methods that will get called
	139	* when the event gets delivered to its target listener interface.
	140	* @param addListenerMethodName The name of the method on the event source
	141	* that can be used to register an event listener object.
	142	* @param removeListenerMethodName The name of the method on the event source
	143	* that can be used to de-register an event listener object.
	144	* @param getListenerMethodName The method on the event source that
	145	* can be used to access the array of event listener objects.
	146	* @exception IntrospectionException if an exception occurs during
	147	* introspection.
	148	* @since 1.4
	149	*/
	150	public EventSetDescriptor(Class<?> sourceClass,
	151	String eventSetName,
	152	Class<?> listenerType,
	153	String listenerMethodNames[],
	154	String addListenerMethodName,
	155	String removeListenerMethodName,
	156	String getListenerMethodName)
	157	throws IntrospectionException {
	158	if (sourceClass == null \|\| eventSetName == null \|\| listenerType == null) {
	159	throw new NullPointerException();
	160	}
	161	setName(eventSetName);
	162	setClass0(sourceClass);
	163	setListenerType(listenerType);
	164
	165	Method[] listenerMethods = new Method[listenerMethodNames.length];
	166	for (int i = 0; i < listenerMethodNames.length; i++) {
	167	// Check for null names
	168	if (listenerMethodNames[i] == null) {
	169	throw new NullPointerException();
	170	}
	171	listenerMethods[i] = getMethod(listenerType, listenerMethodNames[i], 1);
	172	}
	173	setListenerMethods(listenerMethods);
	174
	175	setAddListenerMethod(getMethod(sourceClass, addListenerMethodName, 1));
	176	setRemoveListenerMethod(getMethod(sourceClass, removeListenerMethodName, 1));
	177
	178	// Be more forgiving of not finding the getListener method.
	179	Method method = Introspector.findMethod(sourceClass, getListenerMethodName, 0);
	180	if (method != null) {
	181	setGetListenerMethod(method);
	182	}
	183	}
	184
	185	private static Method getMethod(Class cls, String name, int args)
	186	throws IntrospectionException {
	187	if (name == null) {
	188	return null;
	189	}
	190	Method method = Introspector.findMethod(cls, name, args);
	191	if ((method == null) \|\| Modifier.isStatic(method.getModifiers())) {
	192	throw new IntrospectionException("Method not found: " + name +
	193	" on class " + cls.getName());
	194	}
	195	return method;
	196	}
	197
	198	/**
	199	* Creates an <TT>EventSetDescriptor</TT> from scratch using
	200	* <TT>java.lang.reflect.Method</TT> and <TT>java.lang.Class</TT> objects.
	201	*
	202	* @param eventSetName The programmatic name of the event set.
	203	* @param listenerType The Class for the listener interface.
	204	* @param listenerMethods An array of Method objects describing each
	205	* of the event handling methods in the target listener.
	206	* @param addListenerMethod The method on the event source
	207	* that can be used to register an event listener object.
	208	* @param removeListenerMethod The method on the event source
	209	* that can be used to de-register an event listener object.
	210	* @exception IntrospectionException if an exception occurs during
	211	* introspection.
	212	*/
	213	public EventSetDescriptor(String eventSetName,
	214	Class<?> listenerType,
	215	Method listenerMethods[],
	216	Method addListenerMethod,
	217	Method removeListenerMethod)
	218	throws IntrospectionException {
	219	this(eventSetName, listenerType, listenerMethods,
	220	addListenerMethod, removeListenerMethod, null);
	221	}
	222
	223	/**
	224	* This constructor creates an EventSetDescriptor from scratch using
	225	* java.lang.reflect.Method and java.lang.Class objects.
	226	*
	227	* @param eventSetName The programmatic name of the event set.
	228	* @param listenerType The Class for the listener interface.
	229	* @param listenerMethods An array of Method objects describing each
	230	* of the event handling methods in the target listener.
	231	* @param addListenerMethod The method on the event source
	232	* that can be used to register an event listener object.
	233	* @param removeListenerMethod The method on the event source
	234	* that can be used to de-register an event listener object.
	235	* @param getListenerMethod The method on the event source
	236	* that can be used to access the array of event listener objects.
	237	* @exception IntrospectionException if an exception occurs during
	238	* introspection.
	239	* @since 1.4
	240	*/
	241	public EventSetDescriptor(String eventSetName,
	242	Class<?> listenerType,
	243	Method listenerMethods[],
	244	Method addListenerMethod,
	245	Method removeListenerMethod,
	246	Method getListenerMethod)
	247	throws IntrospectionException {
	248	setName(eventSetName);
	249	setListenerMethods(listenerMethods);
	250	setAddListenerMethod(addListenerMethod);
	251	setRemoveListenerMethod( removeListenerMethod);
	252	setGetListenerMethod(getListenerMethod);
	253	setListenerType(listenerType);
	254	}
	255
	256	/**
	257	* Creates an <TT>EventSetDescriptor</TT> from scratch using
	258	* <TT>java.lang.reflect.MethodDescriptor</TT> and <TT>java.lang.Class</TT>
	259	* objects.
	260	*
	261	* @param eventSetName The programmatic name of the event set.
	262	* @param listenerType The Class for the listener interface.
	263	* @param listenerMethodDescriptors An array of MethodDescriptor objects
	264	* describing each of the event handling methods in the
	265	* target listener.
	266	* @param addListenerMethod The method on the event source
	267	* that can be used to register an event listener object.
	268	* @param removeListenerMethod The method on the event source
	269	* that can be used to de-register an event listener object.
	270	* @exception IntrospectionException if an exception occurs during
	271	* introspection.
	272	*/
	273	public EventSetDescriptor(String eventSetName,
	274	Class<?> listenerType,
	275	MethodDescriptor listenerMethodDescriptors[],
	276	Method addListenerMethod,
	277	Method removeListenerMethod)
	278	throws IntrospectionException {
	279	setName(eventSetName);
	280	this.listenerMethodDescriptors = listenerMethodDescriptors;
	281	setAddListenerMethod(addListenerMethod);
	282	setRemoveListenerMethod(removeListenerMethod);
	283	setListenerType(listenerType);
	284	}
	285
	286	/**
	287	* Gets the <TT>Class</TT> object for the target interface.
	288	*
	289	* @return The Class object for the target interface that will
	290	* get invoked when the event is fired.
	291	*/
	292	public Class<?> getListenerType() {
	293	return (this.listenerTypeRef != null)
	294	? this.listenerTypeRef.get()
	295	: null;
	296	}
	297
	298	private void setListenerType(Class cls) {
	299	this.listenerTypeRef = getWeakReference(cls);
	300	}
	301
	302	/**
	303	* Gets the methods of the target listener interface.
	304	*
	305	* @return An array of <TT>Method</TT> objects for the target methods
	306	* within the target listener interface that will get called when
	307	* events are fired.
	308	*/
	309	public synchronized Method[] getListenerMethods() {
	310	Method[] methods = getListenerMethods0();
	311	if (methods == null) {
	312	if (listenerMethodDescriptors != null) {
	313	methods = new Method[listenerMethodDescriptors.length];
	314	for (int i = 0; i < methods.length; i++) {
	315	methods[i] = listenerMethodDescriptors[i].getMethod();
	316	}
	317	}
	318	setListenerMethods(methods);
	319	}
	320	return methods;
	321	}
	322
	323	private void setListenerMethods(Method[] methods) {
	324	if (methods == null) {
	325	return;
	326	}
	327	if (listenerMethodDescriptors == null) {
	328	listenerMethodDescriptors = new MethodDescriptor[methods.length];
	329	for (int i = 0; i < methods.length; i++) {
	330	listenerMethodDescriptors[i] = new MethodDescriptor(methods[i]);
	331	}
	332	}
	333	this.listenerMethodsRef = getSoftReference(methods);
	334	}
	335
	336	private Method[] getListenerMethods0() {
	337	return (this.listenerMethodsRef != null)
	338	? this.listenerMethodsRef.get()
	339	: null;
	340	}
	341
	342	/**
	343	* Gets the <code>MethodDescriptor</code>s of the target listener interface.
	344	*
	345	* @return An array of <code>MethodDescriptor</code> objects for the target methods
	346	* within the target listener interface that will get called when
	347	* events are fired.
	348	*/
	349	public synchronized MethodDescriptor[] getListenerMethodDescriptors() {
	350	return listenerMethodDescriptors;
	351	}
	352
	353	/**
	354	* Gets the method used to add event listeners.
	355	*
	356	* @return The method used to register a listener at the event source.
	357	*/
	358	public synchronized Method getAddListenerMethod() {
	359	return getMethod(this.addMethodDescriptor);
	360	}
	361
	362	private synchronized void setAddListenerMethod(Method method) {
	363	if (method == null) {
	364	return;
	365	}
	366	if (getClass0() == null) {
	367	setClass0(method.getDeclaringClass());
	368	}
	369	addMethodDescriptor = new MethodDescriptor(method);
	370	setTransient(method.getAnnotation(Transient.class));
	371	}
	372
	373	/**
	374	* Gets the method used to remove event listeners.
	375	*
	376	* @return The method used to remove a listener at the event source.
	377	*/
	378	public synchronized Method getRemoveListenerMethod() {
	379	return getMethod(this.removeMethodDescriptor);
	380	}
	381
	382	private synchronized void setRemoveListenerMethod(Method method) {
	383	if (method == null) {
	384	return;
	385	}
	386	if (getClass0() == null) {
	387	setClass0(method.getDeclaringClass());
	388	}
	389	removeMethodDescriptor = new MethodDescriptor(method);
	390	setTransient(method.getAnnotation(Transient.class));
	391	}
	392
	393	/**
	394	* Gets the method used to access the registered event listeners.
	395	*
	396	* @return The method used to access the array of listeners at the event
	397	* source or null if it doesn't exist.
	398	* @since 1.4
	399	*/
	400	public synchronized Method getGetListenerMethod() {
	401	return getMethod(this.getMethodDescriptor);
	402	}
	403
	404	private synchronized void setGetListenerMethod(Method method) {
	405	if (method == null) {
	406	return;
	407	}
	408	if (getClass0() == null) {
	409	setClass0(method.getDeclaringClass());
	410	}
	411	getMethodDescriptor = new MethodDescriptor(method);
	412	setTransient(method.getAnnotation(Transient.class));
	413	}
	414
	415	/**
	416	* Mark an event set as unicast (or not).
	417	*
	418	* @param unicast True if the event set is unicast.
	419	*/
	420	public void setUnicast(boolean unicast) {
	421	this.unicast = unicast;
	422	}
	423
	424	/**
	425	* Normally event sources are multicast. However there are some
	426	* exceptions that are strictly unicast.
	427	*
	428	* @return <TT>true</TT> if the event set is unicast.
	429	* Defaults to <TT>false</TT>.
	430	*/
	431	public boolean isUnicast() {
	432	return unicast;
	433	}
	434
	435	/**
	436	* Marks an event set as being in the "default" set (or not).
	437	* By default this is <TT>true</TT>.
	438	*
	439	* @param inDefaultEventSet <code>true</code> if the event set is in
	440	* the "default" set,
	441	* <code>false</code> if not
	442	*/
	443	public void setInDefaultEventSet(boolean inDefaultEventSet) {
	444	this.inDefaultEventSet = inDefaultEventSet;
	445	}
	446
	447	/**
	448	* Reports if an event set is in the "default" set.
	449	*
	450	* @return <TT>true</TT> if the event set is in
	451	* the "default" set. Defaults to <TT>true</TT>.
	452	*/
	453	public boolean isInDefaultEventSet() {
	454	return inDefaultEventSet;
	455	}
	456
	457	/*
	458	* Package-private constructor
	459	* Merge two event set descriptors. Where they conflict, give the
	460	* second argument (y) priority over the first argument (x).
	461	*
	462	* @param x The first (lower priority) EventSetDescriptor
	463	* @param y The second (higher priority) EventSetDescriptor
	464	*/
	465	EventSetDescriptor(EventSetDescriptor x, EventSetDescriptor y) {
	466	super(x,y);
	467	listenerMethodDescriptors = x.listenerMethodDescriptors;
	468	if (y.listenerMethodDescriptors != null) {
	469	listenerMethodDescriptors = y.listenerMethodDescriptors;
	470	}
	471
	472	listenerTypeRef = x.listenerTypeRef;
	473	if (y.listenerTypeRef != null) {
	474	listenerTypeRef = y.listenerTypeRef;
	475	}
	476
	477	addMethodDescriptor = x.addMethodDescriptor;
	478	if (y.addMethodDescriptor != null) {
	479	addMethodDescriptor = y.addMethodDescriptor;
	480	}
	481
	482	removeMethodDescriptor = x.removeMethodDescriptor;
	483	if (y.removeMethodDescriptor != null) {
	484	removeMethodDescriptor = y.removeMethodDescriptor;
	485	}
	486
	487	getMethodDescriptor = x.getMethodDescriptor;
	488	if (y.getMethodDescriptor != null) {
	489	getMethodDescriptor = y.getMethodDescriptor;
	490	}
	491
	492	unicast = y.unicast;
	493	if (!x.inDefaultEventSet \|\| !y.inDefaultEventSet) {
	494	inDefaultEventSet = false;
	495	}
	496	}
	497
	498	/*
	499	* Package-private dup constructor
	500	* This must isolate the new object from any changes to the old object.
	501	*/
	502	EventSetDescriptor(EventSetDescriptor old) {
	503	super(old);
	504	if (old.listenerMethodDescriptors != null) {
	505	int len = old.listenerMethodDescriptors.length;
	506	listenerMethodDescriptors = new MethodDescriptor[len];
	507	for (int i = 0; i < len; i++) {
	508	listenerMethodDescriptors[i] = new MethodDescriptor(
	509	old.listenerMethodDescriptors[i]);
	510	}
	511	}
	512	listenerTypeRef = old.listenerTypeRef;
	513
	514	addMethodDescriptor = old.addMethodDescriptor;
	515	removeMethodDescriptor = old.removeMethodDescriptor;
	516	getMethodDescriptor = old.getMethodDescriptor;
	517
	518	unicast = old.unicast;
	519	inDefaultEventSet = old.inDefaultEventSet;
	520	}
	521
	522	void appendTo(StringBuilder sb) {
	523	appendTo(sb, "unicast", this.unicast);
	524	appendTo(sb, "inDefaultEventSet", this.inDefaultEventSet);
	525	appendTo(sb, "listenerType", this.listenerTypeRef);
	526	appendTo(sb, "getListenerMethod", getMethod(this.getMethodDescriptor));
	527	appendTo(sb, "addListenerMethod", getMethod(this.addMethodDescriptor));
	528	appendTo(sb, "removeListenerMethod", getMethod(this.removeMethodDescriptor));
	529	}
	530
	531	private static Method getMethod(MethodDescriptor descriptor) {
	532	return (descriptor != null)
	533	? descriptor.getMethod()
	534	: null;
	535	}
	536	}

java/pkg/java/beans/ExceptionListener.class+0−0

Binary file not shown.

java/pkg/java/beans/ExceptionListener.java+43−0

@@ -0,0 +1,43 @@
	1	/*
	2	* Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	/**
	28	* An ExceptionListener is notified of internal exceptions.
	29	*
	30	* @since 1.4
	31	*
	32	* @author Philip Milne
	33	*/
	34	public interface ExceptionListener {
	35	/**
	36	* This method is called when a recoverable exception has
	37	* been caught.
	38	*
	39	* @param e The exception that was caught.
	40	*
	41	*/
	42	public void exceptionThrown(Exception e);
	43	}

java/pkg/java/beans/Expression.class+0−0

Binary file not shown.

java/pkg/java/beans/Expression.java+182−0

@@ -0,0 +1,182 @@
	1	/*
	2	* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* An <code>Expression</code> object represents a primitive expression
	30	* in which a single method is applied to a target and a set of
	31	* arguments to return a result - as in <code>"a.getFoo()"</code>.
	32	* <p>
	33	* In addition to the properties of the super class, the
	34	* <code>Expression</code> object provides a <em>value</em> which
	35	* is the object returned when this expression is evaluated.
	36	* The return value is typically not provided by the caller and
	37	* is instead computed by dynamically finding the method and invoking
	38	* it when the first call to <code>getValue</code> is made.
	39	*
	40	* @see #getValue
	41	* @see #setValue
	42	*
	43	* @since 1.4
	44	*
	45	* @author Philip Milne
	46	*/
	47	public class Expression extends Statement {
	48
	49	private static Object unbound = new Object();
	50
	51	private Object value = unbound;
	52
	53	/**
	54	* Creates a new {@link Expression} object
	55	* for the specified target object to invoke the method
	56	* specified by the name and by the array of arguments.
	57	* <p>
	58	* The {@code target} and the {@code methodName} values should not be {@code null}.
	59	* Otherwise an attempt to execute this {@code Expression}
	60	* will result in a {@code NullPointerException}.
	61	* If the {@code arguments} value is {@code null},
	62	* an empty array is used as the value of the {@code arguments} property.
	63	*
	64	* @param target the target object of this expression
	65	* @param methodName the name of the method to invoke on the specified target
	66	* @param arguments the array of arguments to invoke the specified method
	67	*
	68	* @see #getValue
	69	*/
	70	@ConstructorProperties({"target", "methodName", "arguments"})
	71	public Expression(Object target, String methodName, Object[] arguments) {
	72	super(target, methodName, arguments);
	73	}
	74
	75	/**
	76	* Creates a new {@link Expression} object with the specified value
	77	* for the specified target object to invoke the method
	78	* specified by the name and by the array of arguments.
	79	* The {@code value} value is used as the value of the {@code value} property,
	80	* so the {@link #getValue} method will return it
	81	* without executing this {@code Expression}.
	82	* <p>
	83	* The {@code target} and the {@code methodName} values should not be {@code null}.
	84	* Otherwise an attempt to execute this {@code Expression}
	85	* will result in a {@code NullPointerException}.
	86	* If the {@code arguments} value is {@code null},
	87	* an empty array is used as the value of the {@code arguments} property.
	88	*
	89	* @param value the value of this expression
	90	* @param target the target object of this expression
	91	* @param methodName the name of the method to invoke on the specified target
	92	* @param arguments the array of arguments to invoke the specified method
	93	*
	94	* @see #setValue
	95	*/
	96	public Expression(Object value, Object target, String methodName, Object[] arguments) {
	97	this(target, methodName, arguments);
	98	setValue(value);
	99	}
	100
	101	/**
	102	* {@inheritDoc}
	103	* <p>
	104	* If the invoked method completes normally,
	105	* the value it returns is copied in the {@code value} property.
	106	* Note that the {@code value} property is set to {@code null},
	107	* if the return type of the underlying method is {@code void}.
	108	*
	109	* @throws NullPointerException if the value of the {@code target} or
	110	* {@code methodName} property is {@code null}
	111	* @throws NoSuchMethodException if a matching method is not found
	112	* @throws SecurityException if a security manager exists and
	113	* it denies the method invocation
	114	* @throws Exception that is thrown by the invoked method
	115	*
	116	* @see java.lang.reflect.Method
	117	* @since 1.7
	118	*/
	119	@Override
	120	public void execute() throws Exception {
	121	setValue(invoke());
	122	}
	123
	124	/**
	125	* If the value property of this instance is not already set,
	126	* this method dynamically finds the method with the specified
	127	* methodName on this target with these arguments and calls it.
	128	* The result of the method invocation is first copied
	129	* into the value property of this expression and then returned
	130	* as the result of <code>getValue</code>. If the value property
	131	* was already set, either by a call to <code>setValue</code>
	132	* or a previous call to <code>getValue</code> then the value
	133	* property is returned without either looking up or calling the method.
	134	* <p>
	135	* The value property of an <code>Expression</code> is set to
	136	* a unique private (non-<code>null</code>) value by default and
	137	* this value is used as an internal indication that the method
	138	* has not yet been called. A return value of <code>null</code>
	139	* replaces this default value in the same way that any other value
	140	* would, ensuring that expressions are never evaluated more than once.
	141	* <p>
	142	* See the <code>excecute</code> method for details on how
	143	* methods are chosen using the dynamic types of the target
	144	* and arguments.
	145	*
	146	* @see Statement#execute
	147	* @see #setValue
	148	*
	149	* @return The result of applying this method to these arguments.
	150	*/
	151	public Object getValue() throws Exception {
	152	if (value == unbound) {
	153	setValue(invoke());
	154	}
	155	return value;
	156	}
	157
	158	/**
	159	* Sets the value of this expression to <code>value</code>.
	160	* This value will be returned by the getValue method
	161	* without calling the method associated with this
	162	* expression.
	163	*
	164	* @param value The value of this expression.
	165	*
	166	* @see #getValue
	167	*/
	168	public void setValue(Object value) {
	169	this.value = value;
	170	}
	171
	172	/pp/ String instanceName(Object instance) {
	173	return instance == unbound ? "<unbound>" : super.instanceName(instance);
	174	}
	175
	176	/**
	177	* Prints the value of this expression using a Java-style syntax.
	178	*/
	179	public String toString() {
	180	return instanceName(value) + "=" + super.toString();
	181	}
	182	}

java/pkg/java/beans/FeatureDescriptor.class+0−0

Binary file not shown.

java/pkg/java/beans/FeatureDescriptor.java+445−0

@@ -0,0 +1,445 @@
	1	/*
	2	* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import com.sun.beans.TypeResolver;
	29
	30	import java.lang.ref.Reference;
	31	import java.lang.ref.WeakReference;
	32	import java.lang.ref.SoftReference;
	33
	34	import java.lang.reflect.Method;
	35
	36	import java.util.Enumeration;
	37	import java.util.Hashtable;
	38	import java.util.Map.Entry;
	39
	40	/**
	41	* The FeatureDescriptor class is the common baseclass for PropertyDescriptor,
	42	* EventSetDescriptor, and MethodDescriptor, etc.
	43	* <p>
	44	* It supports some common information that can be set and retrieved for
	45	* any of the introspection descriptors.
	46	* <p>
	47	* In addition it provides an extension mechanism so that arbitrary
	48	* attribute/value pairs can be associated with a design feature.
	49	*/
	50
	51	public class FeatureDescriptor {
	52	private static final String TRANSIENT = "transient";
	53
	54	private Reference<Class> classRef;
	55
	56	/**
	57	* Constructs a <code>FeatureDescriptor</code>.
	58	*/
	59	public FeatureDescriptor() {
	60	}
	61
	62	/**
	63	* Gets the programmatic name of this feature.
	64	*
	65	* @return The programmatic name of the property/method/event
	66	*/
	67	public String getName() {
	68	return name;
	69	}
	70
	71	/**
	72	* Sets the programmatic name of this feature.
	73	*
	74	* @param name The programmatic name of the property/method/event
	75	*/
	76	public void setName(String name) {
	77	this.name = name;
	78	}
	79
	80	/**
	81	* Gets the localized display name of this feature.
	82	*
	83	* @return The localized display name for the property/method/event.
	84	* This defaults to the same as its programmatic name from getName.
	85	*/
	86	public String getDisplayName() {
	87	if (displayName == null) {
	88	return getName();
	89	}
	90	return displayName;
	91	}
	92
	93	/**
	94	* Sets the localized display name of this feature.
	95	*
	96	* @param displayName The localized display name for the
	97	* property/method/event.
	98	*/
	99	public void setDisplayName(String displayName) {
	100	this.displayName = displayName;
	101	}
	102
	103	/**
	104	* The "expert" flag is used to distinguish between those features that are
	105	* intended for expert users from those that are intended for normal users.
	106	*
	107	* @return True if this feature is intended for use by experts only.
	108	*/
	109	public boolean isExpert() {
	110	return expert;
	111	}
	112
	113	/**
	114	* The "expert" flag is used to distinguish between features that are
	115	* intended for expert users from those that are intended for normal users.
	116	*
	117	* @param expert True if this feature is intended for use by experts only.
	118	*/
	119	public void setExpert(boolean expert) {
	120	this.expert = expert;
	121	}
	122
	123	/**
	124	* The "hidden" flag is used to identify features that are intended only
	125	* for tool use, and which should not be exposed to humans.
	126	*
	127	* @return True if this feature should be hidden from human users.
	128	*/
	129	public boolean isHidden() {
	130	return hidden;
	131	}
	132
	133	/**
	134	* The "hidden" flag is used to identify features that are intended only
	135	* for tool use, and which should not be exposed to humans.
	136	*
	137	* @param hidden True if this feature should be hidden from human users.
	138	*/
	139	public void setHidden(boolean hidden) {
	140	this.hidden = hidden;
	141	}
	142
	143	/**
	144	* The "preferred" flag is used to identify features that are particularly
	145	* important for presenting to humans.
	146	*
	147	* @return True if this feature should be preferentially shown to human users.
	148	*/
	149	public boolean isPreferred() {
	150	return preferred;
	151	}
	152
	153	/**
	154	* The "preferred" flag is used to identify features that are particularly
	155	* important for presenting to humans.
	156	*
	157	* @param preferred True if this feature should be preferentially shown
	158	* to human users.
	159	*/
	160	public void setPreferred(boolean preferred) {
	161	this.preferred = preferred;
	162	}
	163
	164	/**
	165	* Gets the short description of this feature.
	166	*
	167	* @return A localized short description associated with this
	168	* property/method/event. This defaults to be the display name.
	169	*/
	170	public String getShortDescription() {
	171	if (shortDescription == null) {
	172	return getDisplayName();
	173	}
	174	return shortDescription;
	175	}
	176
	177	/**
	178	* You can associate a short descriptive string with a feature. Normally
	179	* these descriptive strings should be less than about 40 characters.
	180	* @param text A (localized) short description to be associated with
	181	* this property/method/event.
	182	*/
	183	public void setShortDescription(String text) {
	184	shortDescription = text;
	185	}
	186
	187	/**
	188	* Associate a named attribute with this feature.
	189	*
	190	* @param attributeName The locale-independent name of the attribute
	191	* @param value The value.
	192	*/
	193	public void setValue(String attributeName, Object value) {
	194	getTable().put(attributeName, value);
	195	}
	196
	197	/**
	198	* Retrieve a named attribute with this feature.
	199	*
	200	* @param attributeName The locale-independent name of the attribute
	201	* @return The value of the attribute. May be null if
	202	* the attribute is unknown.
	203	*/
	204	public Object getValue(String attributeName) {
	205	return (this.table != null)
	206	? this.table.get(attributeName)
	207	: null;
	208	}
	209
	210	/**
	211	* Gets an enumeration of the locale-independent names of this
	212	* feature.
	213	*
	214	* @return An enumeration of the locale-independent names of any
	215	* attributes that have been registered with setValue.
	216	*/
	217	public Enumeration<String> attributeNames() {
	218	return getTable().keys();
	219	}
	220
	221	/**
	222	* Package-private constructor,
	223	* Merge information from two FeatureDescriptors.
	224	* The merged hidden and expert flags are formed by or-ing the values.
	225	* In the event of other conflicts, the second argument (y) is
	226	* given priority over the first argument (x).
	227	*
	228	* @param x The first (lower priority) MethodDescriptor
	229	* @param y The second (higher priority) MethodDescriptor
	230	*/
	231	FeatureDescriptor(FeatureDescriptor x, FeatureDescriptor y) {
	232	expert = x.expert \| y.expert;
	233	hidden = x.hidden \| y.hidden;
	234	preferred = x.preferred \| y.preferred;
	235	name = y.name;
	236	shortDescription = x.shortDescription;
	237	if (y.shortDescription != null) {
	238	shortDescription = y.shortDescription;
	239	}
	240	displayName = x.displayName;
	241	if (y.displayName != null) {
	242	displayName = y.displayName;
	243	}
	244	classRef = x.classRef;
	245	if (y.classRef != null) {
	246	classRef = y.classRef;
	247	}
	248	addTable(x.table);
	249	addTable(y.table);
	250	}
	251
	252	/*
	253	* Package-private dup constructor
	254	* This must isolate the new object from any changes to the old object.
	255	*/
	256	FeatureDescriptor(FeatureDescriptor old) {
	257	expert = old.expert;
	258	hidden = old.hidden;
	259	preferred = old.preferred;
	260	name = old.name;
	261	shortDescription = old.shortDescription;
	262	displayName = old.displayName;
	263	classRef = old.classRef;
	264
	265	addTable(old.table);
	266	}
	267
	268	/**
	269	* Copies all values from the specified attribute table.
	270	* If some attribute is exist its value should be overridden.
	271	*
	272	* @param table the attribute table with new values
	273	*/
	274	private void addTable(Hashtable<String, Object> table) {
	275	if ((table != null) && !table.isEmpty()) {
	276	getTable().putAll(table);
	277	}
	278	}
	279
	280	/**
	281	* Returns the initialized attribute table.
	282	*
	283	* @return the initialized attribute table
	284	*/
	285	private Hashtable<String, Object> getTable() {
	286	if (this.table == null) {
	287	this.table = new Hashtable<String, Object>();
	288	}
	289	return this.table;
	290	}
	291
	292	/**
	293	* Sets the "transient" attribute according to the annotation.
	294	* If the "transient" attribute is already set
	295	* it should not be changed.
	296	*
	297	* @param annotation the annotation of the element of the feature
	298	*/
	299	void setTransient(Transient annotation) {
	300	if ((annotation != null) && (null == getValue(TRANSIENT))) {
	301	setValue(TRANSIENT, annotation.value());
	302	}
	303	}
	304
	305	/**
	306	* Indicates whether the feature is transient.
	307	*
	308	* @return {@code true} if the feature is transient,
	309	* {@code false} otherwise
	310	*/
	311	boolean isTransient() {
	312	Object value = getValue(TRANSIENT);
	313	return (value instanceof Boolean)
	314	? (Boolean) value
	315	: false;
	316	}
	317
	318	// Package private methods for recreating the weak/soft referent
	319
	320	void setClass0(Class cls) {
	321	this.classRef = getWeakReference(cls);
	322	}
	323
	324	Class getClass0() {
	325	return (this.classRef != null)
	326	? this.classRef.get()
	327	: null;
	328	}
	329
	330	/**
	331	* Creates a new soft reference that refers to the given object.
	332	*
	333	* @return a new soft reference or <code>null</code> if object is <code>null</code>
	334	*
	335	* @see SoftReference
	336	*/
	337	static <T> Reference<T> getSoftReference(T object) {
	338	return (object != null)
	339	? new SoftReference<T>(object)
	340	: null;
	341	}
	342
	343	/**
	344	* Creates a new weak reference that refers to the given object.
	345	*
	346	* @return a new weak reference or <code>null</code> if object is <code>null</code>
	347	*
	348	* @see WeakReference
	349	*/
	350	static <T> Reference<T> getWeakReference(T object) {
	351	return (object != null)
	352	? new WeakReference<T>(object)
	353	: null;
	354	}
	355
	356	/**
	357	* Resolves the return type of the method.
	358	*
	359	* @param base the class that contains the method in the hierarchy
	360	* @param method the object that represents the method
	361	* @return a class identifying the return type of the method
	362	*
	363	* @see Method#getGenericReturnType
	364	* @see Method#getReturnType
	365	*/
	366	static Class getReturnType(Class base, Method method) {
	367	if (base == null) {
	368	base = method.getDeclaringClass();
	369	}
	370	return TypeResolver.erase(TypeResolver.resolveInClass(base, method.getGenericReturnType()));
	371	}
	372
	373	/**
	374	* Resolves the parameter types of the method.
	375	*
	376	* @param base the class that contains the method in the hierarchy
	377	* @param method the object that represents the method
	378	* @return an array of classes identifying the parameter types of the method
	379	*
	380	* @see Method#getGenericParameterTypes
	381	* @see Method#getParameterTypes
	382	*/
	383	static Class[] getParameterTypes(Class base, Method method) {
	384	if (base == null) {
	385	base = method.getDeclaringClass();
	386	}
	387	return TypeResolver.erase(TypeResolver.resolveInClass(base, method.getGenericParameterTypes()));
	388	}
	389
	390	private boolean expert;
	391	private boolean hidden;
	392	private boolean preferred;
	393	private String shortDescription;
	394	private String name;
	395	private String displayName;
	396	private Hashtable<String, Object> table;
	397
	398	/**
	399	* Returns a string representation of the object.
	400	*
	401	* @return a string representation of the object
	402	*
	403	* @since 1.7
	404	*/
	405	public String toString() {
	406	StringBuilder sb = new StringBuilder(getClass().getName());
	407	sb.append("[name=").append(this.name);
	408	appendTo(sb, "displayName", this.displayName);
	409	appendTo(sb, "shortDescription", this.shortDescription);
	410	appendTo(sb, "preferred", this.preferred);
	411	appendTo(sb, "hidden", this.hidden);
	412	appendTo(sb, "expert", this.expert);
	413	if ((this.table != null) && !this.table.isEmpty()) {
	414	sb.append("; values={");
	415	for (Entry<String, Object> entry : this.table.entrySet()) {
	416	sb.append(entry.getKey()).append("=").append(entry.getValue()).append("; ");
	417	}
	418	sb.setLength(sb.length() - 2);
	419	sb.append("}");
	420	}
	421	appendTo(sb);
	422	return sb.append("]").toString();
	423	}
	424
	425	void appendTo(StringBuilder sb) {
	426	}
	427
	428	static void appendTo(StringBuilder sb, String name, Reference reference) {
	429	if (reference != null) {
	430	appendTo(sb, name, reference.get());
	431	}
	432	}
	433
	434	static void appendTo(StringBuilder sb, String name, Object value) {
	435	if (value != null) {
	436	sb.append("; ").append(name).append("=").append(value);
	437	}
	438	}
	439
	440	static void appendTo(StringBuilder sb, String name, boolean value) {
	441	if (value) {
	442	sb.append("; ").append(name);
	443	}
	444	}
	445	}

java/pkg/java/beans/GenericBeanInfo.class+0−0

Binary file not shown.

java/pkg/java/beans/IndexedPropertyChangeEvent.class+0−0

Binary file not shown.

java/pkg/java/beans/IndexedPropertyChangeEvent.java+78−0

@@ -0,0 +1,78 @@
	1	/*
	2	* Copyright (c) 2003, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	/**
	28	* An "IndexedPropertyChange" event gets delivered whenever a component that
	29	* conforms to the JavaBeans™ specification (a "bean") changes a bound
	30	* indexed property. This class is an extension of <code>PropertyChangeEvent</code>
	31	* but contains the index of the property that has changed.
	32	* <P>
	33	* Null values may be provided for the old and the new values if their
	34	* true values are not known.
	35	* <P>
	36	* An event source may send a null object as the name to indicate that an
	37	* arbitrary set of if its properties have changed. In this case the
	38	* old and new values should also be null.
	39	*
	40	* @since 1.5
	41	* @author Mark Davidson
	42	*/
	43	public class IndexedPropertyChangeEvent extends PropertyChangeEvent {
	44	private static final long serialVersionUID = -320227448495806870L;
	45
	46	private int index;
	47
	48	/**
	49	* Constructs a new <code>IndexedPropertyChangeEvent</code> object.
	50	*
	51	* @param source The bean that fired the event.
	52	* @param propertyName The programmatic name of the property that
	53	* was changed.
	54	* @param oldValue The old value of the property.
	55	* @param newValue The new value of the property.
	56	* @param index index of the property element that was changed.
	57	*/
	58	public IndexedPropertyChangeEvent(Object source, String propertyName,
	59	Object oldValue, Object newValue,
	60	int index) {
	61	super (source, propertyName, oldValue, newValue);
	62	this.index = index;
	63	}
	64
	65	/**
	66	* Gets the index of the property that was changed.
	67	*
	68	* @return The index specifying the property element that was
	69	* changed.
	70	*/
	71	public int getIndex() {
	72	return index;
	73	}
	74
	75	void appendTo(StringBuilder sb) {
	76	sb.append("; index=").append(getIndex());
	77	}
	78	}

java/pkg/java/beans/IndexedPropertyDescriptor.class+0−0

Binary file not shown.

java/pkg/java/beans/IndexedPropertyDescriptor.java+523−0

@@ -0,0 +1,523 @@
	1	/*
	2	* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.lang.ref.Reference;
	29	import java.lang.reflect.Method;
	30
	31	/**
	32	* An IndexedPropertyDescriptor describes a property that acts like an
	33	* array and has an indexed read and/or indexed write method to access
	34	* specific elements of the array.
	35	* <p>
	36	* An indexed property may also provide simple non-indexed read and write
	37	* methods. If these are present, they read and write arrays of the type
	38	* returned by the indexed read method.
	39	*/
	40
	41	public class IndexedPropertyDescriptor extends PropertyDescriptor {
	42
	43	private Reference<Class> indexedPropertyTypeRef;
	44	private Reference<Method> indexedReadMethodRef;
	45	private Reference<Method> indexedWriteMethodRef;
	46
	47	private String indexedReadMethodName;
	48	private String indexedWriteMethodName;
	49
	50	/**
	51	* This constructor constructs an IndexedPropertyDescriptor for a property
	52	* that follows the standard Java conventions by having getFoo and setFoo
	53	* accessor methods, for both indexed access and array access.
	54	* <p>
	55	* Thus if the argument name is "fred", it will assume that there
	56	* is an indexed reader method "getFred", a non-indexed (array) reader
	57	* method also called "getFred", an indexed writer method "setFred",
	58	* and finally a non-indexed writer method "setFred".
	59	*
	60	* @param propertyName The programmatic name of the property.
	61	* @param beanClass The Class object for the target bean.
	62	* @exception IntrospectionException if an exception occurs during
	63	* introspection.
	64	*/
	65	public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass)
	66	throws IntrospectionException {
	67	this(propertyName, beanClass,
	68	Introspector.GET_PREFIX + NameGenerator.capitalize(propertyName),
	69	Introspector.SET_PREFIX + NameGenerator.capitalize(propertyName),
	70	Introspector.GET_PREFIX + NameGenerator.capitalize(propertyName),
	71	Introspector.SET_PREFIX + NameGenerator.capitalize(propertyName));
	72	}
	73
	74	/**
	75	* This constructor takes the name of a simple property, and method
	76	* names for reading and writing the property, both indexed
	77	* and non-indexed.
	78	*
	79	* @param propertyName The programmatic name of the property.
	80	* @param beanClass The Class object for the target bean.
	81	* @param readMethodName The name of the method used for reading the property
	82	* values as an array. May be null if the property is write-only
	83	* or must be indexed.
	84	* @param writeMethodName The name of the method used for writing the property
	85	* values as an array. May be null if the property is read-only
	86	* or must be indexed.
	87	* @param indexedReadMethodName The name of the method used for reading
	88	* an indexed property value.
	89	* May be null if the property is write-only.
	90	* @param indexedWriteMethodName The name of the method used for writing
	91	* an indexed property value.
	92	* May be null if the property is read-only.
	93	* @exception IntrospectionException if an exception occurs during
	94	* introspection.
	95	*/
	96	public IndexedPropertyDescriptor(String propertyName, Class<?> beanClass,
	97	String readMethodName, String writeMethodName,
	98	String indexedReadMethodName, String indexedWriteMethodName)
	99	throws IntrospectionException {
	100	super(propertyName, beanClass, readMethodName, writeMethodName);
	101
	102	this.indexedReadMethodName = indexedReadMethodName;
	103	if (indexedReadMethodName != null && getIndexedReadMethod() == null) {
	104	throw new IntrospectionException("Method not found: " + indexedReadMethodName);
	105	}
	106
	107	this.indexedWriteMethodName = indexedWriteMethodName;
	108	if (indexedWriteMethodName != null && getIndexedWriteMethod() == null) {
	109	throw new IntrospectionException("Method not found: " + indexedWriteMethodName);
	110	}
	111	// Implemented only for type checking.
	112	findIndexedPropertyType(getIndexedReadMethod(), getIndexedWriteMethod());
	113	}
	114
	115	/**
	116	* This constructor takes the name of a simple property, and Method
	117	* objects for reading and writing the property.
	118	*
	119	* @param propertyName The programmatic name of the property.
	120	* @param readMethod The method used for reading the property values as an array.
	121	* May be null if the property is write-only or must be indexed.
	122	* @param writeMethod The method used for writing the property values as an array.
	123	* May be null if the property is read-only or must be indexed.
	124	* @param indexedReadMethod The method used for reading an indexed property value.
	125	* May be null if the property is write-only.
	126	* @param indexedWriteMethod The method used for writing an indexed property value.
	127	* May be null if the property is read-only.
	128	* @exception IntrospectionException if an exception occurs during
	129	* introspection.
	130	*/
	131	public IndexedPropertyDescriptor(String propertyName, Method readMethod, Method writeMethod,
	132	Method indexedReadMethod, Method indexedWriteMethod)
	133	throws IntrospectionException {
	134	super(propertyName, readMethod, writeMethod);
	135
	136	setIndexedReadMethod0(indexedReadMethod);
	137	setIndexedWriteMethod0(indexedWriteMethod);
	138
	139	// Type checking
	140	setIndexedPropertyType(findIndexedPropertyType(indexedReadMethod, indexedWriteMethod));
	141	}
	142
	143	/**
	144	* Creates <code>PropertyDescriptor</code> for the specified bean
	145	* with the specified name and methods to read/write the property value.
	146	*
	147	* @param bean the type of the target bean
	148	* @param base the base name of the property (the rest of the method name)
	149	* @param read the method used for reading the property value
	150	* @param write the method used for writing the property value
	151	* @param readIndexed the method used for reading an indexed property value
	152	* @param writeIndexed the method used for writing an indexed property value
	153	* @exception IntrospectionException if an exception occurs during introspection
	154	*
	155	* @since 1.7
	156	*/
	157	IndexedPropertyDescriptor(Class<?> bean, String base, Method read, Method write, Method readIndexed, Method writeIndexed) throws IntrospectionException {
	158	super(bean, base, read, write);
	159
	160	setIndexedReadMethod0(readIndexed);
	161	setIndexedWriteMethod0(writeIndexed);
	162
	163	// Type checking
	164	setIndexedPropertyType(findIndexedPropertyType(readIndexed, writeIndexed));
	165	}
	166
	167	/**
	168	* Gets the method that should be used to read an indexed
	169	* property value.
	170	*
	171	* @return The method that should be used to read an indexed
	172	* property value.
	173	* May return null if the property isn't indexed or is write-only.
	174	*/
	175	public synchronized Method getIndexedReadMethod() {
	176	Method indexedReadMethod = getIndexedReadMethod0();
	177	if (indexedReadMethod == null) {
	178	Class cls = getClass0();
	179	if (cls == null \|\|
	180	(indexedReadMethodName == null && indexedReadMethodRef == null)) {
	181	// the Indexed readMethod was explicitly set to null.
	182	return null;
	183	}
	184	if (indexedReadMethodName == null) {
	185	Class type = getIndexedPropertyType0();
	186	if (type == boolean.class \|\| type == null) {
	187	indexedReadMethodName = Introspector.IS_PREFIX + getBaseName();
	188	} else {
	189	indexedReadMethodName = Introspector.GET_PREFIX + getBaseName();
	190	}
	191	}
	192
	193	Class[] args = { int.class };
	194	indexedReadMethod = Introspector.findMethod(cls, indexedReadMethodName, 1, args);
	195	if (indexedReadMethod == null) {
	196	// no "is" method, so look for a "get" method.
	197	indexedReadMethodName = Introspector.GET_PREFIX + getBaseName();
	198	indexedReadMethod = Introspector.findMethod(cls, indexedReadMethodName, 1, args);
	199	}
	200	setIndexedReadMethod0(indexedReadMethod);
	201	}
	202	return indexedReadMethod;
	203	}
	204
	205	/**
	206	* Sets the method that should be used to read an indexed property value.
	207	*
	208	* @param readMethod The new indexed read method.
	209	*/
	210	public synchronized void setIndexedReadMethod(Method readMethod)
	211	throws IntrospectionException {
	212
	213	// the indexed property type is set by the reader.
	214	setIndexedPropertyType(findIndexedPropertyType(readMethod,
	215	getIndexedWriteMethod0()));
	216	setIndexedReadMethod0(readMethod);
	217	}
	218
	219	private void setIndexedReadMethod0(Method readMethod) {
	220	if (readMethod == null) {
	221	indexedReadMethodName = null;
	222	indexedReadMethodRef = null;
	223	return;
	224	}
	225	setClass0(readMethod.getDeclaringClass());
	226
	227	indexedReadMethodName = readMethod.getName();
	228	this.indexedReadMethodRef = getSoftReference(readMethod);
	229	setTransient(readMethod.getAnnotation(Transient.class));
	230	}
	231
	232
	233	/**
	234	* Gets the method that should be used to write an indexed property value.
	235	*
	236	* @return The method that should be used to write an indexed
	237	* property value.
	238	* May return null if the property isn't indexed or is read-only.
	239	*/
	240	public synchronized Method getIndexedWriteMethod() {
	241	Method indexedWriteMethod = getIndexedWriteMethod0();
	242	if (indexedWriteMethod == null) {
	243	Class cls = getClass0();
	244	if (cls == null \|\|
	245	(indexedWriteMethodName == null && indexedWriteMethodRef == null)) {
	246	// the Indexed writeMethod was explicitly set to null.
	247	return null;
	248	}
	249
	250	// We need the indexed type to ensure that we get the correct method.
	251	// Cannot use the getIndexedPropertyType method since that could
	252	// result in an infinite loop.
	253	Class type = getIndexedPropertyType0();
	254	if (type == null) {
	255	try {
	256	type = findIndexedPropertyType(getIndexedReadMethod(), null);
	257	setIndexedPropertyType(type);
	258	} catch (IntrospectionException ex) {
	259	// Set iprop type to be the classic type
	260	Class propType = getPropertyType();
	261	if (propType.isArray()) {
	262	type = propType.getComponentType();
	263	}
	264	}
	265	}
	266
	267	if (indexedWriteMethodName == null) {
	268	indexedWriteMethodName = Introspector.SET_PREFIX + getBaseName();
	269	}
	270
	271	Class[] args = (type == null) ? null : new Class[] { int.class, type };
	272	indexedWriteMethod = Introspector.findMethod(cls, indexedWriteMethodName, 2, args);
	273	if (indexedWriteMethod != null) {
	274	if (!indexedWriteMethod.getReturnType().equals(void.class)) {
	275	indexedWriteMethod = null;
	276	}
	277	}
	278	setIndexedWriteMethod0(indexedWriteMethod);
	279	}
	280	return indexedWriteMethod;
	281	}
	282
	283	/**
	284	* Sets the method that should be used to write an indexed property value.
	285	*
	286	* @param writeMethod The new indexed write method.
	287	*/
	288	public synchronized void setIndexedWriteMethod(Method writeMethod)
	289	throws IntrospectionException {
	290
	291	// If the indexed property type has not been set, then set it.
	292	Class type = findIndexedPropertyType(getIndexedReadMethod(),
	293	writeMethod);
	294	setIndexedPropertyType(type);
	295	setIndexedWriteMethod0(writeMethod);
	296	}
	297
	298	private void setIndexedWriteMethod0(Method writeMethod) {
	299	if (writeMethod == null) {
	300	indexedWriteMethodName = null;
	301	indexedWriteMethodRef = null;
	302	return;
	303	}
	304	setClass0(writeMethod.getDeclaringClass());
	305
	306	indexedWriteMethodName = writeMethod.getName();
	307	this.indexedWriteMethodRef = getSoftReference(writeMethod);
	308	setTransient(writeMethod.getAnnotation(Transient.class));
	309	}
	310
	311	/**
	312	* Returns the Java type info for the indexed property.
	313	* Note that the {@code Class} object may describe
	314	* primitive Java types such as {@code int}.
	315	* This type is returned by the indexed read method
	316	* or is used as the parameter type of the indexed write method.
	317	*
	318	* @return the {@code Class} object that represents the Java type info,
	319	* or {@code null} if the type cannot be determined
	320	*/
	321	public synchronized Class<?> getIndexedPropertyType() {
	322	Class type = getIndexedPropertyType0();
	323	if (type == null) {
	324	try {
	325	type = findIndexedPropertyType(getIndexedReadMethod(),
	326	getIndexedWriteMethod());
	327	setIndexedPropertyType(type);
	328	} catch (IntrospectionException ex) {
	329	// fall
	330	}
	331	}
	332	return type;
	333	}
	334
	335	// Private methods which set get/set the Reference objects
	336
	337	private void setIndexedPropertyType(Class type) {
	338	this.indexedPropertyTypeRef = getWeakReference(type);
	339	}
	340
	341	private Class getIndexedPropertyType0() {
	342	return (this.indexedPropertyTypeRef != null)
	343	? this.indexedPropertyTypeRef.get()
	344	: null;
	345	}
	346
	347	private Method getIndexedReadMethod0() {
	348	return (this.indexedReadMethodRef != null)
	349	? this.indexedReadMethodRef.get()
	350	: null;
	351	}
	352
	353	private Method getIndexedWriteMethod0() {
	354	return (this.indexedWriteMethodRef != null)
	355	? this.indexedWriteMethodRef.get()
	356	: null;
	357	}
	358
	359	private Class findIndexedPropertyType(Method indexedReadMethod,
	360	Method indexedWriteMethod)
	361	throws IntrospectionException {
	362	Class indexedPropertyType = null;
	363
	364	if (indexedReadMethod != null) {
	365	Class params[] = getParameterTypes(getClass0(), indexedReadMethod);
	366	if (params.length != 1) {
	367	throw new IntrospectionException("bad indexed read method arg count");
	368	}
	369	if (params[0] != Integer.TYPE) {
	370	throw new IntrospectionException("non int index to indexed read method");
	371	}
	372	indexedPropertyType = getReturnType(getClass0(), indexedReadMethod);
	373	if (indexedPropertyType == Void.TYPE) {
	374	throw new IntrospectionException("indexed read method returns void");
	375	}
	376	}
	377	if (indexedWriteMethod != null) {
	378	Class params[] = getParameterTypes(getClass0(), indexedWriteMethod);
	379	if (params.length != 2) {
	380	throw new IntrospectionException("bad indexed write method arg count");
	381	}
	382	if (params[0] != Integer.TYPE) {
	383	throw new IntrospectionException("non int index to indexed write method");
	384	}
	385	if (indexedPropertyType != null && indexedPropertyType != params[1]) {
	386	throw new IntrospectionException(
	387	"type mismatch between indexed read and indexed write methods: "
	388	+ getName());
	389	}
	390	indexedPropertyType = params[1];
	391	}
	392	Class propertyType = getPropertyType();
	393	if (propertyType != null && (!propertyType.isArray() \|\|
	394	propertyType.getComponentType() != indexedPropertyType)) {
	395	throw new IntrospectionException("type mismatch between indexed and non-indexed methods: "
	396	+ getName());
	397	}
	398	return indexedPropertyType;
	399	}
	400
	401	/**
	402	* Compares this <code>PropertyDescriptor</code> against the specified object.
	403	* Returns true if the objects are the same. Two <code>PropertyDescriptor</code>s
	404	* are the same if the read, write, property types, property editor and
	405	* flags are equivalent.
	406	*
	407	* @since 1.4
	408	*/
	409	public boolean equals(Object obj) {
	410	// Note: This would be identical to PropertyDescriptor but they don't
	411	// share the same fields.
	412	if (this == obj) {
	413	return true;
	414	}
	415
	416	if (obj != null && obj instanceof IndexedPropertyDescriptor) {
	417	IndexedPropertyDescriptor other = (IndexedPropertyDescriptor)obj;
	418	Method otherIndexedReadMethod = other.getIndexedReadMethod();
	419	Method otherIndexedWriteMethod = other.getIndexedWriteMethod();
	420
	421	if (!compareMethods(getIndexedReadMethod(), otherIndexedReadMethod)) {
	422	return false;
	423	}
	424
	425	if (!compareMethods(getIndexedWriteMethod(), otherIndexedWriteMethod)) {
	426	return false;
	427	}
	428
	429	if (getIndexedPropertyType() != other.getIndexedPropertyType()) {
	430	return false;
	431	}
	432	return super.equals(obj);
	433	}
	434	return false;
	435	}
	436
	437	/**
	438	* Package-private constructor.
	439	* Merge two property descriptors. Where they conflict, give the
	440	* second argument (y) priority over the first argumnnt (x).
	441	*
	442	* @param x The first (lower priority) PropertyDescriptor
	443	* @param y The second (higher priority) PropertyDescriptor
	444	*/
	445
	446	IndexedPropertyDescriptor(PropertyDescriptor x, PropertyDescriptor y) {
	447	super(x,y);
	448	if (x instanceof IndexedPropertyDescriptor) {
	449	IndexedPropertyDescriptor ix = (IndexedPropertyDescriptor)x;
	450	try {
	451	Method xr = ix.getIndexedReadMethod();
	452	if (xr != null) {
	453	setIndexedReadMethod(xr);
	454	}
	455
	456	Method xw = ix.getIndexedWriteMethod();
	457	if (xw != null) {
	458	setIndexedWriteMethod(xw);
	459	}
	460	} catch (IntrospectionException ex) {
	461	// Should not happen
	462	throw new AssertionError(ex);
	463	}
	464	}
	465	if (y instanceof IndexedPropertyDescriptor) {
	466	IndexedPropertyDescriptor iy = (IndexedPropertyDescriptor)y;
	467	try {
	468	Method yr = iy.getIndexedReadMethod();
	469	if (yr != null && yr.getDeclaringClass() == getClass0()) {
	470	setIndexedReadMethod(yr);
	471	}
	472
	473	Method yw = iy.getIndexedWriteMethod();
	474	if (yw != null && yw.getDeclaringClass() == getClass0()) {
	475	setIndexedWriteMethod(yw);
	476	}
	477	} catch (IntrospectionException ex) {
	478	// Should not happen
	479	throw new AssertionError(ex);
	480	}
	481	}
	482	}
	483
	484	/*
	485	* Package-private dup constructor
	486	* This must isolate the new object from any changes to the old object.
	487	*/
	488	IndexedPropertyDescriptor(IndexedPropertyDescriptor old) {
	489	super(old);
	490	indexedReadMethodRef = old.indexedReadMethodRef;
	491	indexedWriteMethodRef = old.indexedWriteMethodRef;
	492	indexedPropertyTypeRef = old.indexedPropertyTypeRef;
	493	indexedWriteMethodName = old.indexedWriteMethodName;
	494	indexedReadMethodName = old.indexedReadMethodName;
	495	}
	496
	497	/**
	498	* Returns a hash code value for the object.
	499	* See {@link java.lang.Object#hashCode} for a complete description.
	500	*
	501	* @return a hash code value for this object.
	502	* @since 1.5
	503	*/
	504	public int hashCode() {
	505	int result = super.hashCode();
	506
	507	result = 37 * result + ((indexedWriteMethodName == null) ? 0 :
	508	indexedWriteMethodName.hashCode());
	509	result = 37 * result + ((indexedReadMethodName == null) ? 0 :
	510	indexedReadMethodName.hashCode());
	511	result = 37 * result + ((getIndexedPropertyType() == null) ? 0 :
	512	getIndexedPropertyType().hashCode());
	513
	514	return result;
	515	}
	516
	517	void appendTo(StringBuilder sb) {
	518	super.appendTo(sb);
	519	appendTo(sb, "indexedPropertyType", this.indexedPropertyTypeRef);
	520	appendTo(sb, "indexedReadMethod", this.indexedReadMethodRef);
	521	appendTo(sb, "indexedWriteMethod", this.indexedWriteMethodRef);
	522	}
	523	}

java/pkg/java/beans/IntrospectionException.class+0−0

Binary file not shown.

java/pkg/java/beans/IntrospectionException.java+50−0

@@ -0,0 +1,50 @@
	1	/*
	2	* Copyright (c) 1996, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* Thrown when an exception happens during Introspection.
	30	* <p>
	31	* Typical causes include not being able to map a string class name
	32	* to a Class object, not being able to resolve a string method name,
	33	* or specifying a method name that has the wrong type signature for
	34	* its intended use.
	35	*/
	36
	37	public
	38	class IntrospectionException extends Exception {
	39	private static final long serialVersionUID = -3728150539969542619L;
	40
	41	/**
	42	* Constructs an <code>IntrospectionException</code> with a
	43	* detailed message.
	44	*
	45	* @param mess Descriptive message
	46	*/
	47	public IntrospectionException(String mess) {
	48	super(mess);
	49	}
	50	}

java/pkg/java/beans/Introspector.class+0−0

Binary file not shown.

java/pkg/java/beans/Introspector.java+1558−0

@@ -0,0 +1,1558 @@
	1	/*
	2	* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import com.sun.beans.WeakCache;
	29	import com.sun.beans.finder.BeanInfoFinder;
	30	import com.sun.beans.finder.ClassFinder;
	31
	32	import java.awt.Component;
	33
	34	import java.lang.ref.Reference;
	35	import java.lang.ref.SoftReference;
	36	import java.lang.reflect.Method;
	37	import java.lang.reflect.Modifier;
	38
	39	import java.util.Map;
	40	import java.util.ArrayList;
	41	import java.util.HashMap;
	42	import java.util.Iterator;
	43	import java.util.EventListener;
	44	import java.util.EventObject;
	45	import java.util.List;
	46	import java.util.TreeMap;
	47	import java.util.WeakHashMap;
	48
	49	import sun.awt.AppContext;
	50	import sun.reflect.misc.ReflectUtil;
	51
	52	/**
	53	* The Introspector class provides a standard way for tools to learn about
	54	* the properties, events, and methods supported by a target Java Bean.
	55	* <p>
	56	* For each of those three kinds of information, the Introspector will
	57	* separately analyze the bean's class and superclasses looking for
	58	* either explicit or implicit information and use that information to
	59	* build a BeanInfo object that comprehensively describes the target bean.
	60	* <p>
	61	* For each class "Foo", explicit information may be available if there exists
	62	* a corresponding "FooBeanInfo" class that provides a non-null value when
	63	* queried for the information. We first look for the BeanInfo class by
	64	* taking the full package-qualified name of the target bean class and
	65	* appending "BeanInfo" to form a new class name. If this fails, then
	66	* we take the final classname component of this name, and look for that
	67	* class in each of the packages specified in the BeanInfo package search
	68	* path.
	69	* <p>
	70	* Thus for a class such as "sun.xyz.OurButton" we would first look for a
	71	* BeanInfo class called "sun.xyz.OurButtonBeanInfo" and if that failed we'd
	72	* look in each package in the BeanInfo search path for an OurButtonBeanInfo
	73	* class. With the default search path, this would mean looking for
	74	* "sun.beans.infos.OurButtonBeanInfo".
	75	* <p>
	76	* If a class provides explicit BeanInfo about itself then we add that to
	77	* the BeanInfo information we obtained from analyzing any derived classes,
	78	* but we regard the explicit information as being definitive for the current
	79	* class and its base classes, and do not proceed any further up the superclass
	80	* chain.
	81	* <p>
	82	* If we don't find explicit BeanInfo on a class, we use low-level
	83	* reflection to study the methods of the class and apply standard design
	84	* patterns to identify property accessors, event sources, or public
	85	* methods. We then proceed to analyze the class's superclass and add
	86	* in the information from it (and possibly on up the superclass chain).
	87	* <p>
	88	* For more information about introspection and design patterns, please
	89	* consult the
	90	* <a href="http://java.sun.com/products/javabeans/docs/index.html">JavaBeans™ specification</a>.
	91	*/
	92
	93	public class Introspector {
	94
	95	// Flags that can be used to control getBeanInfo:
	96	public final static int USE_ALL_BEANINFO = 1;
	97	public final static int IGNORE_IMMEDIATE_BEANINFO = 2;
	98	public final static int IGNORE_ALL_BEANINFO = 3;
	99
	100	// Static Caches to speed up introspection.
	101	private static WeakCache<Class<?>, Method[]> declaredMethodCache =
	102	new WeakCache<Class<?>, Method[]>();
	103
	104	private static final Object BEANINFO_CACHE = new Object();
	105
	106	private Class beanClass;
	107	private BeanInfo explicitBeanInfo;
	108	private BeanInfo superBeanInfo;
	109	private BeanInfo additionalBeanInfo[];
	110
	111	private boolean propertyChangeSource = false;
	112	private static Class eventListenerType = EventListener.class;
	113
	114	// These should be removed.
	115	private String defaultEventName;
	116	private String defaultPropertyName;
	117	private int defaultEventIndex = -1;
	118	private int defaultPropertyIndex = -1;
	119
	120	// Methods maps from Method objects to MethodDescriptors
	121	private Map methods;
	122
	123	// properties maps from String names to PropertyDescriptors
	124	private Map properties;
	125
	126	// events maps from String names to EventSetDescriptors
	127	private Map events;
	128
	129	private final static EventSetDescriptor[] EMPTY_EVENTSETDESCRIPTORS = new EventSetDescriptor[0];
	130
	131	static final String ADD_PREFIX = "add";
	132	static final String REMOVE_PREFIX = "remove";
	133	static final String GET_PREFIX = "get";
	134	static final String SET_PREFIX = "set";
	135	static final String IS_PREFIX = "is";
	136
	137	private static final Object FINDER_KEY = new Object();
	138
	139	//======================================================================
	140	// Public methods
	141	//======================================================================
	142
	143	/**
	144	* Introspect on a Java Bean and learn about all its properties, exposed
	145	* methods, and events.
	146	* <p>
	147	* If the BeanInfo class for a Java Bean has been previously Introspected
	148	* then the BeanInfo class is retrieved from the BeanInfo cache.
	149	*
	150	* @param beanClass The bean class to be analyzed.
	151	* @return A BeanInfo object describing the target bean.
	152	* @exception IntrospectionException if an exception occurs during
	153	* introspection.
	154	* @see #flushCaches
	155	* @see #flushFromCaches
	156	*/
	157	public static BeanInfo getBeanInfo(Class<?> beanClass)
	158	throws IntrospectionException
	159	{
	160	if (!ReflectUtil.isPackageAccessible(beanClass)) {
	161	return (new Introspector(beanClass, null, USE_ALL_BEANINFO)).getBeanInfo();
	162	}
	163	Map<Class<?>, BeanInfo> beanInfoCache;
	164	BeanInfo beanInfo;
	165	synchronized (BEANINFO_CACHE) {
	166	beanInfoCache = (Map<Class<?>, BeanInfo>) AppContext.getAppContext().get(BEANINFO_CACHE);
	167	if (beanInfoCache == null) {
	168	beanInfoCache = new WeakHashMap<Class<?>, BeanInfo>();
	169	AppContext.getAppContext().put(BEANINFO_CACHE, beanInfoCache);
	170	}
	171	beanInfo = beanInfoCache.get(beanClass);
	172	}
	173	if (beanInfo == null) {
	174	beanInfo = new Introspector(beanClass, null, USE_ALL_BEANINFO).getBeanInfo();
	175	synchronized (BEANINFO_CACHE) {
	176	beanInfoCache.put(beanClass, beanInfo);
	177	}
	178	}
	179	return beanInfo;
	180	}
	181
	182	/**
	183	* Introspect on a Java bean and learn about all its properties, exposed
	184	* methods, and events, subject to some control flags.
	185	* <p>
	186	* If the BeanInfo class for a Java Bean has been previously Introspected
	187	* based on the same arguments then the BeanInfo class is retrieved
	188	* from the BeanInfo cache.
	189	*
	190	* @param beanClass The bean class to be analyzed.
	191	* @param flags Flags to control the introspection.
	192	* If flags == USE_ALL_BEANINFO then we use all of the BeanInfo
	193	* classes we can discover.
	194	* If flags == IGNORE_IMMEDIATE_BEANINFO then we ignore any
	195	* BeanInfo associated with the specified beanClass.
	196	* If flags == IGNORE_ALL_BEANINFO then we ignore all BeanInfo
	197	* associated with the specified beanClass or any of its
	198	* parent classes.
	199	* @return A BeanInfo object describing the target bean.
	200	* @exception IntrospectionException if an exception occurs during
	201	* introspection.
	202	*/
	203	public static BeanInfo getBeanInfo(Class<?> beanClass, int flags)
	204	throws IntrospectionException {
	205	return getBeanInfo(beanClass, null, flags);
	206	}
	207
	208	/**
	209	* Introspect on a Java bean and learn all about its properties, exposed
	210	* methods, below a given "stop" point.
	211	* <p>
	212	* If the BeanInfo class for a Java Bean has been previously Introspected
	213	* based on the same arguments, then the BeanInfo class is retrieved
	214	* from the BeanInfo cache.
	215	*
	216	* @param beanClass The bean class to be analyzed.
	217	* @param stopClass The baseclass at which to stop the analysis. Any
	218	* methods/properties/events in the stopClass or in its baseclasses
	219	* will be ignored in the analysis.
	220	* @exception IntrospectionException if an exception occurs during
	221	* introspection.
	222	*/
	223	public static BeanInfo getBeanInfo(Class<?> beanClass, Class<?> stopClass)
	224	throws IntrospectionException {
	225	return getBeanInfo(beanClass, stopClass, USE_ALL_BEANINFO);
	226	}
	227
	228	/**
	229	* Introspect on a Java Bean and learn about all its properties,
	230	* exposed methods and events, below a given {@code stopClass} point
	231	* subject to some control {@code flags}.
	232	* <dl>
	233	* <dt>USE_ALL_BEANINFO</dt>
	234	* <dd>Any BeanInfo that can be discovered will be used.</dd>
	235	* <dt>IGNORE_IMMEDIATE_BEANINFO</dt>
	236	* <dd>Any BeanInfo associated with the specified {@code beanClass} will be ignored.</dd>
	237	* <dt>IGNORE_ALL_BEANINFO</dt>
	238	* <dd>Any BeanInfo associated with the specified {@code beanClass}
	239	* or any of its parent classes will be ignored.</dd>
	240	* </dl>
	241	* Any methods/properties/events in the {@code stopClass}
	242	* or in its parent classes will be ignored in the analysis.
	243	* <p>
	244	* If the BeanInfo class for a Java Bean has been
	245	* previously introspected based on the same arguments then
	246	* the BeanInfo class is retrieved from the BeanInfo cache.
	247	*
	248	* @param beanClass the bean class to be analyzed
	249	* @param stopClass the parent class at which to stop the analysis
	250	* @param flags flags to control the introspection
	251	* @return a BeanInfo object describing the target bean
	252	* @exception IntrospectionException if an exception occurs during introspection
	253	*
	254	* @since 1.7
	255	*/
	256	public static BeanInfo getBeanInfo(Class<?> beanClass, Class<?> stopClass,
	257	int flags) throws IntrospectionException {
	258	BeanInfo bi;
	259	if (stopClass == null && flags == USE_ALL_BEANINFO) {
	260	// Same parameters to take advantage of caching.
	261	bi = getBeanInfo(beanClass);
	262	} else {
	263	bi = (new Introspector(beanClass, stopClass, flags)).getBeanInfo();
	264	}
	265	return bi;
	266
	267	// Old behaviour: Make an independent copy of the BeanInfo.
	268	//return new GenericBeanInfo(bi);
	269	}
	270
	271
	272	/**
	273	* Utility method to take a string and convert it to normal Java variable
	274	* name capitalization. This normally means converting the first
	275	* character from upper case to lower case, but in the (unusual) special
	276	* case when there is more than one character and both the first and
	277	* second characters are upper case, we leave it alone.
	278	* <p>
	279	* Thus "FooBah" becomes "fooBah" and "X" becomes "x", but "URL" stays
	280	* as "URL".
	281	*
	282	* @param name The string to be decapitalized.
	283	* @return The decapitalized version of the string.
	284	*/
	285	public static String decapitalize(String name) {
	286	if (name == null \|\| name.length() == 0) {
	287	return name;
	288	}
	289	if (name.length() > 1 && Character.isUpperCase(name.charAt(1)) &&
	290	Character.isUpperCase(name.charAt(0))){
	291	return name;
	292	}
	293	char chars[] = name.toCharArray();
	294	chars[0] = Character.toLowerCase(chars[0]);
	295	return new String(chars);
	296	}
	297
	298	/**
	299	* Gets the list of package names that will be used for
	300	* finding BeanInfo classes.
	301	*
	302	* @return The array of package names that will be searched in
	303	* order to find BeanInfo classes. The default value
	304	* for this array is implementation-dependent; e.g.
	305	* Sun implementation initially sets to {"sun.beans.infos"}.
	306	*/
	307
	308	public static String[] getBeanInfoSearchPath() {
	309	return getFinder().getPackages();
	310	}
	311
	312	/**
	313	* Change the list of package names that will be used for
	314	* finding BeanInfo classes. The behaviour of
	315	* this method is undefined if parameter path
	316	* is null.
	317	*
	318	* <p>First, if there is a security manager, its <code>checkPropertiesAccess</code>
	319	* method is called. This could result in a SecurityException.
	320	*
	321	* @param path Array of package names.
	322	* @exception SecurityException if a security manager exists and its
	323	* <code>checkPropertiesAccess</code> method doesn't allow setting
	324	* of system properties.
	325	* @see SecurityManager#checkPropertiesAccess
	326	*/
	327
	328	public static void setBeanInfoSearchPath(String[] path) {
	329	SecurityManager sm = System.getSecurityManager();
	330	if (sm != null) {
	331	sm.checkPropertiesAccess();
	332	}
	333	getFinder().setPackages(path);
	334	}
	335
	336
	337	/**
	338	* Flush all of the Introspector's internal caches. This method is
	339	* not normally required. It is normally only needed by advanced
	340	* tools that update existing "Class" objects in-place and need
	341	* to make the Introspector re-analyze existing Class objects.
	342	*/
	343
	344	public static void flushCaches() {
	345	synchronized (BEANINFO_CACHE) {
	346	Map beanInfoCache = (Map) AppContext.getAppContext().get(BEANINFO_CACHE);
	347	if (beanInfoCache != null) {
	348	beanInfoCache.clear();
	349	}
	350	declaredMethodCache.clear();
	351	}
	352	}
	353
	354	/**
	355	* Flush the Introspector's internal cached information for a given class.
	356	* This method is not normally required. It is normally only needed
	357	* by advanced tools that update existing "Class" objects in-place
	358	* and need to make the Introspector re-analyze an existing Class object.
	359	*
	360	* Note that only the direct state associated with the target Class
	361	* object is flushed. We do not flush state for other Class objects
	362	* with the same name, nor do we flush state for any related Class
	363	* objects (such as subclasses), even though their state may include
	364	* information indirectly obtained from the target Class object.
	365	*
	366	* @param clz Class object to be flushed.
	367	* @throws NullPointerException If the Class object is null.
	368	*/
	369	public static void flushFromCaches(Class<?> clz) {
	370	if (clz == null) {
	371	throw new NullPointerException();
	372	}
	373	synchronized (BEANINFO_CACHE) {
	374	Map beanInfoCache = (Map) AppContext.getAppContext().get(BEANINFO_CACHE);
	375	if (beanInfoCache != null) {
	376	beanInfoCache.put(clz, null);
	377	}
	378	declaredMethodCache.put(clz, null);
	379	}
	380	}
	381
	382	//======================================================================
	383	// Private implementation methods
	384	//======================================================================
	385
	386	private Introspector(Class beanClass, Class stopClass, int flags)
	387	throws IntrospectionException {
	388	this.beanClass = beanClass;
	389
	390	// Check stopClass is a superClass of startClass.
	391	if (stopClass != null) {
	392	boolean isSuper = false;
	393	for (Class c = beanClass.getSuperclass(); c != null; c = c.getSuperclass()) {
	394	if (c == stopClass) {
	395	isSuper = true;
	396	}
	397	}
	398	if (!isSuper) {
	399	throw new IntrospectionException(stopClass.getName() + " not superclass of " +
	400	beanClass.getName());
	401	}
	402	}
	403
	404	if (flags == USE_ALL_BEANINFO) {
	405	explicitBeanInfo = findExplicitBeanInfo(beanClass);
	406	}
	407
	408	Class superClass = beanClass.getSuperclass();
	409	if (superClass != stopClass) {
	410	int newFlags = flags;
	411	if (newFlags == IGNORE_IMMEDIATE_BEANINFO) {
	412	newFlags = USE_ALL_BEANINFO;
	413	}
	414	superBeanInfo = getBeanInfo(superClass, stopClass, newFlags);
	415	}
	416	if (explicitBeanInfo != null) {
	417	additionalBeanInfo = explicitBeanInfo.getAdditionalBeanInfo();
	418	}
	419	if (additionalBeanInfo == null) {
	420	additionalBeanInfo = new BeanInfo[0];
	421	}
	422	}
	423
	424	/**
	425	* Constructs a GenericBeanInfo class from the state of the Introspector
	426	*/
	427	private BeanInfo getBeanInfo() throws IntrospectionException {
	428
	429	// the evaluation order here is import, as we evaluate the
	430	// event sets and locate PropertyChangeListeners before we
	431	// look for properties.
	432	BeanDescriptor bd = getTargetBeanDescriptor();
	433	MethodDescriptor mds[] = getTargetMethodInfo();
	434	EventSetDescriptor esds[] = getTargetEventInfo();
	435	PropertyDescriptor pds[] = getTargetPropertyInfo();
	436
	437	int defaultEvent = getTargetDefaultEventIndex();
	438	int defaultProperty = getTargetDefaultPropertyIndex();
	439
	440	return new GenericBeanInfo(bd, esds, defaultEvent, pds,
	441	defaultProperty, mds, explicitBeanInfo);
	442
	443	}
	444
	445	/**
	446	* Looks for an explicit BeanInfo class that corresponds to the Class.
	447	* First it looks in the existing package that the Class is defined in,
	448	* then it checks to see if the class is its own BeanInfo. Finally,
	449	* the BeanInfo search path is prepended to the class and searched.
	450	*
	451	* @param beanClass the class type of the bean
	452	* @return Instance of an explicit BeanInfo class or null if one isn't found.
	453	*/
	454	private static BeanInfo findExplicitBeanInfo(Class beanClass) {
	455	return getFinder().find(beanClass);
	456	}
	457
	458	/**
	459	* @return An array of PropertyDescriptors describing the editable
	460	* properties supported by the target bean.
	461	*/
	462
	463	private PropertyDescriptor[] getTargetPropertyInfo() {
	464
	465	// Check if the bean has its own BeanInfo that will provide
	466	// explicit information.
	467	PropertyDescriptor[] explicitProperties = null;
	468	if (explicitBeanInfo != null) {
	469	explicitProperties = getPropertyDescriptors(this.explicitBeanInfo);
	470	}
	471
	472	if (explicitProperties == null && superBeanInfo != null) {
	473	// We have no explicit BeanInfo properties. Check with our parent.
	474	addPropertyDescriptors(getPropertyDescriptors(this.superBeanInfo));
	475	}
	476
	477	for (int i = 0; i < additionalBeanInfo.length; i++) {
	478	addPropertyDescriptors(additionalBeanInfo[i].getPropertyDescriptors());
	479	}
	480
	481	if (explicitProperties != null) {
	482	// Add the explicit BeanInfo data to our results.
	483	addPropertyDescriptors(explicitProperties);
	484
	485	} else {
	486
	487	// Apply some reflection to the current class.
	488
	489	// First get an array of all the public methods at this level
	490	Method methodList[] = getPublicDeclaredMethods(beanClass);
	491
	492	// Now analyze each method.
	493	for (int i = 0; i < methodList.length; i++) {
	494	Method method = methodList[i];
	495	if (method == null \|\| method.isSynthetic()) {
	496	continue;
	497	}
	498	// skip static methods.
	499	int mods = method.getModifiers();
	500	if (Modifier.isStatic(mods)) {
	501	continue;
	502	}
	503	String name = method.getName();
	504	Class argTypes[] = method.getParameterTypes();
	505	Class resultType = method.getReturnType();
	506	int argCount = argTypes.length;
	507	PropertyDescriptor pd = null;
	508
	509	if (name.length() <= 3 && !name.startsWith(IS_PREFIX)) {
	510	// Optimization. Don't bother with invalid propertyNames.
	511	continue;
	512	}
	513
	514	try {
	515
	516	if (argCount == 0) {
	517	if (name.startsWith(GET_PREFIX)) {
	518	// Simple getter
	519	pd = new PropertyDescriptor(this.beanClass, name.substring(3), method, null);
	520	} else if (resultType == boolean.class && name.startsWith(IS_PREFIX)) {
	521	// Boolean getter
	522	pd = new PropertyDescriptor(this.beanClass, name.substring(2), method, null);
	523	}
	524	} else if (argCount == 1) {
	525	if (int.class.equals(argTypes[0]) && name.startsWith(GET_PREFIX)) {
	526	pd = new IndexedPropertyDescriptor(this.beanClass, name.substring(3), null, null, method, null);
	527	} else if (void.class.equals(resultType) && name.startsWith(SET_PREFIX)) {
	528	// Simple setter
	529	pd = new PropertyDescriptor(this.beanClass, name.substring(3), null, method);
	530	if (throwsException(method, PropertyVetoException.class)) {
	531	pd.setConstrained(true);
	532	}
	533	}
	534	} else if (argCount == 2) {
	535	if (void.class.equals(resultType) && int.class.equals(argTypes[0]) && name.startsWith(SET_PREFIX)) {
	536	pd = new IndexedPropertyDescriptor(this.beanClass, name.substring(3), null, null, null, method);
	537	if (throwsException(method, PropertyVetoException.class)) {
	538	pd.setConstrained(true);
	539	}
	540	}
	541	}
	542	} catch (IntrospectionException ex) {
	543	// This happens if a PropertyDescriptor or IndexedPropertyDescriptor
	544	// constructor fins that the method violates details of the deisgn
	545	// pattern, e.g. by having an empty name, or a getter returning
	546	// void , or whatever.
	547	pd = null;
	548	}
	549
	550	if (pd != null) {
	551	// If this class or one of its base classes is a PropertyChange
	552	// source, then we assume that any properties we discover are "bound".
	553	if (propertyChangeSource) {
	554	pd.setBound(true);
	555	}
	556	addPropertyDescriptor(pd);
	557	}
	558	}
	559	}
	560	processPropertyDescriptors();
	561
	562	// Allocate and populate the result array.
	563	PropertyDescriptor result[] = new PropertyDescriptor[properties.size()];
	564	result = (PropertyDescriptor[])properties.values().toArray(result);
	565
	566	// Set the default index.
	567	if (defaultPropertyName != null) {
	568	for (int i = 0; i < result.length; i++) {
	569	if (defaultPropertyName.equals(result[i].getName())) {
	570	defaultPropertyIndex = i;
	571	}
	572	}
	573	}
	574
	575	return result;
	576	}
	577
	578	private HashMap pdStore = new HashMap();
	579
	580	/**
	581	* Adds the property descriptor to the list store.
	582	*/
	583	private void addPropertyDescriptor(PropertyDescriptor pd) {
	584	String propName = pd.getName();
	585	List list = (List)pdStore.get(propName);
	586	if (list == null) {
	587	list = new ArrayList();
	588	pdStore.put(propName, list);
	589	}
	590	if (this.beanClass != pd.getClass0()) {
	591	// replace existing property descriptor
	592	// only if we have types to resolve
	593	// in the context of this.beanClass
	594	try {
	595	String name = pd.getName();
	596	Method read = pd.getReadMethod();
	597	Method write = pd.getWriteMethod();
	598	boolean cls = true;
	599	if (read != null) cls = cls && read.getGenericReturnType() instanceof Class;
	600	if (write != null) cls = cls && write.getGenericParameterTypes()[0] instanceof Class;
	601	if (pd instanceof IndexedPropertyDescriptor) {
	602	IndexedPropertyDescriptor ipd = (IndexedPropertyDescriptor)pd;
	603	Method readI = ipd.getIndexedReadMethod();
	604	Method writeI = ipd.getIndexedWriteMethod();
	605	if (readI != null) cls = cls && readI.getGenericReturnType() instanceof Class;
	606	if (writeI != null) cls = cls && writeI.getGenericParameterTypes()[1] instanceof Class;
	607	if (!cls) {
	608	pd = new IndexedPropertyDescriptor(this.beanClass, name, read, write, readI, writeI);
	609	}
	610	} else if (!cls) {
	611	pd = new PropertyDescriptor(this.beanClass, name, read, write);
	612	}
	613	} catch ( IntrospectionException e ) {
	614	}
	615	}
	616	list.add(pd);
	617	}
	618
	619	private void addPropertyDescriptors(PropertyDescriptor[] descriptors) {
	620	if (descriptors != null) {
	621	for (PropertyDescriptor descriptor : descriptors) {
	622	addPropertyDescriptor(descriptor);
	623	}
	624	}
	625	}
	626
	627	private PropertyDescriptor[] getPropertyDescriptors(BeanInfo info) {
	628	PropertyDescriptor[] descriptors = info.getPropertyDescriptors();
	629	int index = info.getDefaultPropertyIndex();
	630	if ((0 <= index) && (index < descriptors.length)) {
	631	this.defaultPropertyName = descriptors[index].getName();
	632	}
	633	return descriptors;
	634	}
	635
	636	/**
	637	* Populates the property descriptor table by merging the
	638	* lists of Property descriptors.
	639	*/
	640	private void processPropertyDescriptors() {
	641	if (properties == null) {
	642	properties = new TreeMap();
	643	}
	644
	645	List list;
	646
	647	PropertyDescriptor pd, gpd, spd;
	648	IndexedPropertyDescriptor ipd, igpd, ispd;
	649
	650	Iterator it = pdStore.values().iterator();
	651	while (it.hasNext()) {
	652	pd = null; gpd = null; spd = null;
	653	ipd = null; igpd = null; ispd = null;
	654
	655	list = (List)it.next();
	656
	657	// First pass. Find the latest getter method. Merge properties
	658	// of previous getter methods.
	659	for (int i = 0; i < list.size(); i++) {
	660	pd = (PropertyDescriptor)list.get(i);
	661	if (pd instanceof IndexedPropertyDescriptor) {
	662	ipd = (IndexedPropertyDescriptor)pd;
	663	if (ipd.getIndexedReadMethod() != null) {
	664	if (igpd != null) {
	665	igpd = new IndexedPropertyDescriptor(igpd, ipd);
	666	} else {
	667	igpd = ipd;
	668	}
	669	}
	670	} else {
	671	if (pd.getReadMethod() != null) {
	672	if (gpd != null) {
	673	// Don't replace the existing read
	674	// method if it starts with "is"
	675	Method method = gpd.getReadMethod();
	676	if (!method.getName().startsWith(IS_PREFIX)) {
	677	gpd = new PropertyDescriptor(gpd, pd);
	678	}
	679	} else {
	680	gpd = pd;
	681	}
	682	}
	683	}
	684	}
	685
	686	// Second pass. Find the latest setter method which
	687	// has the same type as the getter method.
	688	for (int i = 0; i < list.size(); i++) {
	689	pd = (PropertyDescriptor)list.get(i);
	690	if (pd instanceof IndexedPropertyDescriptor) {
	691	ipd = (IndexedPropertyDescriptor)pd;
	692	if (ipd.getIndexedWriteMethod() != null) {
	693	if (igpd != null) {
	694	if (igpd.getIndexedPropertyType()
	695	== ipd.getIndexedPropertyType()) {
	696	if (ispd != null) {
	697	ispd = new IndexedPropertyDescriptor(ispd, ipd);
	698	} else {
	699	ispd = ipd;
	700	}
	701	}
	702	} else {
	703	if (ispd != null) {
	704	ispd = new IndexedPropertyDescriptor(ispd, ipd);
	705	} else {
	706	ispd = ipd;
	707	}
	708	}
	709	}
	710	} else {
	711	if (pd.getWriteMethod() != null) {
	712	if (gpd != null) {
	713	if (gpd.getPropertyType() == pd.getPropertyType()) {
	714	if (spd != null) {
	715	spd = new PropertyDescriptor(spd, pd);
	716	} else {
	717	spd = pd;
	718	}
	719	}
	720	} else {
	721	if (spd != null) {
	722	spd = new PropertyDescriptor(spd, pd);
	723	} else {
	724	spd = pd;
	725	}
	726	}
	727	}
	728	}
	729	}
	730
	731	// At this stage we should have either PDs or IPDs for the
	732	// representative getters and setters. The order at which the
	733	// property descriptors are determined represent the
	734	// precedence of the property ordering.
	735	pd = null; ipd = null;
	736
	737	if (igpd != null && ispd != null) {
	738	// Complete indexed properties set
	739	// Merge any classic property descriptors
	740	if (gpd != null) {
	741	PropertyDescriptor tpd = mergePropertyDescriptor(igpd, gpd);
	742	if (tpd instanceof IndexedPropertyDescriptor) {
	743	igpd = (IndexedPropertyDescriptor)tpd;
	744	}
	745	}
	746	if (spd != null) {
	747	PropertyDescriptor tpd = mergePropertyDescriptor(ispd, spd);
	748	if (tpd instanceof IndexedPropertyDescriptor) {
	749	ispd = (IndexedPropertyDescriptor)tpd;
	750	}
	751	}
	752	if (igpd == ispd) {
	753	pd = igpd;
	754	} else {
	755	pd = mergePropertyDescriptor(igpd, ispd);
	756	}
	757	} else if (gpd != null && spd != null) {
	758	// Complete simple properties set
	759	if (gpd == spd) {
	760	pd = gpd;
	761	} else {
	762	pd = mergePropertyDescriptor(gpd, spd);
	763	}
	764	} else if (ispd != null) {
	765	// indexed setter
	766	pd = ispd;
	767	// Merge any classic property descriptors
	768	if (spd != null) {
	769	pd = mergePropertyDescriptor(ispd, spd);
	770	}
	771	if (gpd != null) {
	772	pd = mergePropertyDescriptor(ispd, gpd);
	773	}
	774	} else if (igpd != null) {
	775	// indexed getter
	776	pd = igpd;
	777	// Merge any classic property descriptors
	778	if (gpd != null) {
	779	pd = mergePropertyDescriptor(igpd, gpd);
	780	}
	781	if (spd != null) {
	782	pd = mergePropertyDescriptor(igpd, spd);
	783	}
	784	} else if (spd != null) {
	785	// simple setter
	786	pd = spd;
	787	} else if (gpd != null) {
	788	// simple getter
	789	pd = gpd;
	790	}
	791
	792	// Very special case to ensure that an IndexedPropertyDescriptor
	793	// doesn't contain less information than the enclosed
	794	// PropertyDescriptor. If it does, then recreate as a
	795	// PropertyDescriptor. See 4168833
	796	if (pd instanceof IndexedPropertyDescriptor) {
	797	ipd = (IndexedPropertyDescriptor)pd;
	798	if (ipd.getIndexedReadMethod() == null && ipd.getIndexedWriteMethod() == null) {
	799	pd = new PropertyDescriptor(ipd);
	800	}
	801	}
	802
	803	// Find the first property descriptor
	804	// which does not have getter and setter methods.
	805	// See regression bug 4984912.
	806	if ( (pd == null) && (list.size() > 0) ) {
	807	pd = (PropertyDescriptor) list.get(0);
	808	}
	809
	810	if (pd != null) {
	811	properties.put(pd.getName(), pd);
	812	}
	813	}
	814	}
	815
	816	/**
	817	* Adds the property descriptor to the indexedproperty descriptor only if the
	818	* types are the same.
	819	*
	820	* The most specific property descriptor will take precedence.
	821	*/
	822	private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd,
	823	PropertyDescriptor pd) {
	824	PropertyDescriptor result = null;
	825
	826	Class propType = pd.getPropertyType();
	827	Class ipropType = ipd.getIndexedPropertyType();
	828
	829	if (propType.isArray() && propType.getComponentType() == ipropType) {
	830	if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
	831	result = new IndexedPropertyDescriptor(pd, ipd);
	832	} else {
	833	result = new IndexedPropertyDescriptor(ipd, pd);
	834	}
	835	} else {
	836	// Cannot merge the pd because of type mismatch
	837	// Return the most specific pd
	838	if (pd.getClass0().isAssignableFrom(ipd.getClass0())) {
	839	result = ipd;
	840	} else {
	841	result = pd;
	842	// Try to add methods which may have been lost in the type change
	843	// See 4168833
	844	Method write = result.getWriteMethod();
	845	Method read = result.getReadMethod();
	846
	847	if (read == null && write != null) {
	848	read = findMethod(result.getClass0(),
	849	GET_PREFIX + NameGenerator.capitalize(result.getName()), 0);
	850	if (read != null) {
	851	try {
	852	result.setReadMethod(read);
	853	} catch (IntrospectionException ex) {
	854	// no consequences for failure.
	855	}
	856	}
	857	}
	858	if (write == null && read != null) {
	859	write = findMethod(result.getClass0(),
	860	SET_PREFIX + NameGenerator.capitalize(result.getName()), 1,
	861	new Class[] { FeatureDescriptor.getReturnType(result.getClass0(), read) });
	862	if (write != null) {
	863	try {
	864	result.setWriteMethod(write);
	865	} catch (IntrospectionException ex) {
	866	// no consequences for failure.
	867	}
	868	}
	869	}
	870	}
	871	}
	872	return result;
	873	}
	874
	875	// Handle regular pd merge
	876	private PropertyDescriptor mergePropertyDescriptor(PropertyDescriptor pd1,
	877	PropertyDescriptor pd2) {
	878	if (pd1.getClass0().isAssignableFrom(pd2.getClass0())) {
	879	return new PropertyDescriptor(pd1, pd2);
	880	} else {
	881	return new PropertyDescriptor(pd2, pd1);
	882	}
	883	}
	884
	885	// Handle regular ipd merge
	886	private PropertyDescriptor mergePropertyDescriptor(IndexedPropertyDescriptor ipd1,
	887	IndexedPropertyDescriptor ipd2) {
	888	if (ipd1.getClass0().isAssignableFrom(ipd2.getClass0())) {
	889	return new IndexedPropertyDescriptor(ipd1, ipd2);
	890	} else {
	891	return new IndexedPropertyDescriptor(ipd2, ipd1);
	892	}
	893	}
	894
	895	/**
	896	* @return An array of EventSetDescriptors describing the kinds of
	897	* events fired by the target bean.
	898	*/
	899	private EventSetDescriptor[] getTargetEventInfo() throws IntrospectionException {
	900	if (events == null) {
	901	events = new HashMap();
	902	}
	903
	904	// Check if the bean has its own BeanInfo that will provide
	905	// explicit information.
	906	EventSetDescriptor[] explicitEvents = null;
	907	if (explicitBeanInfo != null) {
	908	explicitEvents = explicitBeanInfo.getEventSetDescriptors();
	909	int ix = explicitBeanInfo.getDefaultEventIndex();
	910	if (ix >= 0 && ix < explicitEvents.length) {
	911	defaultEventName = explicitEvents[ix].getName();
	912	}
	913	}
	914
	915	if (explicitEvents == null && superBeanInfo != null) {
	916	// We have no explicit BeanInfo events. Check with our parent.
	917	EventSetDescriptor supers[] = superBeanInfo.getEventSetDescriptors();
	918	for (int i = 0 ; i < supers.length; i++) {
	919	addEvent(supers[i]);
	920	}
	921	int ix = superBeanInfo.getDefaultEventIndex();
	922	if (ix >= 0 && ix < supers.length) {
	923	defaultEventName = supers[ix].getName();
	924	}
	925	}
	926
	927	for (int i = 0; i < additionalBeanInfo.length; i++) {
	928	EventSetDescriptor additional[] = additionalBeanInfo[i].getEventSetDescriptors();
	929	if (additional != null) {
	930	for (int j = 0 ; j < additional.length; j++) {
	931	addEvent(additional[j]);
	932	}
	933	}
	934	}
	935
	936	if (explicitEvents != null) {
	937	// Add the explicit explicitBeanInfo data to our results.
	938	for (int i = 0 ; i < explicitEvents.length; i++) {
	939	addEvent(explicitEvents[i]);
	940	}
	941
	942	} else {
	943
	944	// Apply some reflection to the current class.
	945
	946	// Get an array of all the public beans methods at this level
	947	Method methodList[] = getPublicDeclaredMethods(beanClass);
	948
	949	// Find all suitable "add", "remove" and "get" Listener methods
	950	// The name of the listener type is the key for these hashtables
	951	// i.e, ActionListener
	952	Map adds = null;
	953	Map removes = null;
	954	Map gets = null;
	955
	956	for (int i = 0; i < methodList.length; i++) {
	957	Method method = methodList[i];
	958	if (method == null) {
	959	continue;
	960	}
	961	// skip static methods.
	962	int mods = method.getModifiers();
	963	if (Modifier.isStatic(mods)) {
	964	continue;
	965	}
	966	String name = method.getName();
	967	// Optimization avoid getParameterTypes
	968	if (!name.startsWith(ADD_PREFIX) && !name.startsWith(REMOVE_PREFIX)
	969	&& !name.startsWith(GET_PREFIX)) {
	970	continue;
	971	}
	972
	973	Class argTypes[] = FeatureDescriptor.getParameterTypes(beanClass, method);
	974	Class resultType = FeatureDescriptor.getReturnType(beanClass, method);
	975
	976	if (name.startsWith(ADD_PREFIX) && argTypes.length == 1 &&
	977	resultType == Void.TYPE &&
	978	Introspector.isSubclass(argTypes[0], eventListenerType)) {
	979	String listenerName = name.substring(3);
	980	if (listenerName.length() > 0 &&
	981	argTypes[0].getName().endsWith(listenerName)) {
	982	if (adds == null) {
	983	adds = new HashMap();
	984	}
	985	adds.put(listenerName, method);
	986	}
	987	}
	988	else if (name.startsWith(REMOVE_PREFIX) && argTypes.length == 1 &&
	989	resultType == Void.TYPE &&
	990	Introspector.isSubclass(argTypes[0], eventListenerType)) {
	991	String listenerName = name.substring(6);
	992	if (listenerName.length() > 0 &&
	993	argTypes[0].getName().endsWith(listenerName)) {
	994	if (removes == null) {
	995	removes = new HashMap();
	996	}
	997	removes.put(listenerName, method);
	998	}
	999	}
	1000	else if (name.startsWith(GET_PREFIX) && argTypes.length == 0 &&
	1001	resultType.isArray() &&
	1002	Introspector.isSubclass(resultType.getComponentType(),
	1003	eventListenerType)) {
	1004	String listenerName = name.substring(3, name.length() - 1);
	1005	if (listenerName.length() > 0 &&
	1006	resultType.getComponentType().getName().endsWith(listenerName)) {
	1007	if (gets == null) {
	1008	gets = new HashMap();
	1009	}
	1010	gets.put(listenerName, method);
	1011	}
	1012	}
	1013	}
	1014
	1015	if (adds != null && removes != null) {
	1016	// Now look for matching addFooListener+removeFooListener pairs.
	1017	// Bonus if there is a matching getFooListeners method as well.
	1018	Iterator keys = adds.keySet().iterator();
	1019	while (keys.hasNext()) {
	1020	String listenerName = (String) keys.next();
	1021	// Skip any "add" which doesn't have a matching "remove" or
	1022	// a listener name that doesn't end with Listener
	1023	if (removes.get(listenerName) == null \|\| !listenerName.endsWith("Listener")) {
	1024	continue;
	1025	}
	1026	String eventName = decapitalize(listenerName.substring(0, listenerName.length()-8));
	1027	Method addMethod = (Method)adds.get(listenerName);
	1028	Method removeMethod = (Method)removes.get(listenerName);
	1029	Method getMethod = null;
	1030	if (gets != null) {
	1031	getMethod = (Method)gets.get(listenerName);
	1032	}
	1033	Class argType = FeatureDescriptor.getParameterTypes(beanClass, addMethod)[0];
	1034
	1035	// generate a list of Method objects for each of the target methods:
	1036	Method allMethods[] = getPublicDeclaredMethods(argType);
	1037	List validMethods = new ArrayList(allMethods.length);
	1038	for (int i = 0; i < allMethods.length; i++) {
	1039	if (allMethods[i] == null) {
	1040	continue;
	1041	}
	1042
	1043	if (isEventHandler(allMethods[i])) {
	1044	validMethods.add(allMethods[i]);
	1045	}
	1046	}
	1047	Method[] methods = (Method[])validMethods.toArray(new Method[validMethods.size()]);
	1048
	1049	EventSetDescriptor esd = new EventSetDescriptor(eventName, argType,
	1050	methods, addMethod,
	1051	removeMethod,
	1052	getMethod);
	1053
	1054	// If the adder method throws the TooManyListenersException then it
	1055	// is a Unicast event source.
	1056	if (throwsException(addMethod,
	1057	java.util.TooManyListenersException.class)) {
	1058	esd.setUnicast(true);
	1059	}
	1060	addEvent(esd);
	1061	}
	1062	} // if (adds != null ...
	1063	}
	1064	EventSetDescriptor[] result;
	1065	if (events.size() == 0) {
	1066	result = EMPTY_EVENTSETDESCRIPTORS;
	1067	} else {
	1068	// Allocate and populate the result array.
	1069	result = new EventSetDescriptor[events.size()];
	1070	result = (EventSetDescriptor[])events.values().toArray(result);
	1071
	1072	// Set the default index.
	1073	if (defaultEventName != null) {
	1074	for (int i = 0; i < result.length; i++) {
	1075	if (defaultEventName.equals(result[i].getName())) {
	1076	defaultEventIndex = i;
	1077	}
	1078	}
	1079	}
	1080	}
	1081	return result;
	1082	}
	1083
	1084	private void addEvent(EventSetDescriptor esd) {
	1085	String key = esd.getName();
	1086	if (esd.getName().equals("propertyChange")) {
	1087	propertyChangeSource = true;
	1088	}
	1089	EventSetDescriptor old = (EventSetDescriptor)events.get(key);
	1090	if (old == null) {
	1091	events.put(key, esd);
	1092	return;
	1093	}
	1094	EventSetDescriptor composite = new EventSetDescriptor(old, esd);
	1095	events.put(key, composite);
	1096	}
	1097
	1098	/**
	1099	* @return An array of MethodDescriptors describing the private
	1100	* methods supported by the target bean.
	1101	*/
	1102	private MethodDescriptor[] getTargetMethodInfo() {
	1103	if (methods == null) {
	1104	methods = new HashMap(100);
	1105	}
	1106
	1107	// Check if the bean has its own BeanInfo that will provide
	1108	// explicit information.
	1109	MethodDescriptor[] explicitMethods = null;
	1110	if (explicitBeanInfo != null) {
	1111	explicitMethods = explicitBeanInfo.getMethodDescriptors();
	1112	}
	1113
	1114	if (explicitMethods == null && superBeanInfo != null) {
	1115	// We have no explicit BeanInfo methods. Check with our parent.
	1116	MethodDescriptor supers[] = superBeanInfo.getMethodDescriptors();
	1117	for (int i = 0 ; i < supers.length; i++) {
	1118	addMethod(supers[i]);
	1119	}
	1120	}
	1121
	1122	for (int i = 0; i < additionalBeanInfo.length; i++) {
	1123	MethodDescriptor additional[] = additionalBeanInfo[i].getMethodDescriptors();
	1124	if (additional != null) {
	1125	for (int j = 0 ; j < additional.length; j++) {
	1126	addMethod(additional[j]);
	1127	}
	1128	}
	1129	}
	1130
	1131	if (explicitMethods != null) {
	1132	// Add the explicit explicitBeanInfo data to our results.
	1133	for (int i = 0 ; i < explicitMethods.length; i++) {
	1134	addMethod(explicitMethods[i]);
	1135	}
	1136
	1137	} else {
	1138
	1139	// Apply some reflection to the current class.
	1140
	1141	// First get an array of all the beans methods at this level
	1142	Method methodList[] = getPublicDeclaredMethods(beanClass);
	1143
	1144	// Now analyze each method.
	1145	for (int i = 0; i < methodList.length; i++) {
	1146	Method method = methodList[i];
	1147	if (method == null) {
	1148	continue;
	1149	}
	1150	MethodDescriptor md = new MethodDescriptor(method);
	1151	addMethod(md);
	1152	}
	1153	}
	1154
	1155	// Allocate and populate the result array.
	1156	MethodDescriptor result[] = new MethodDescriptor[methods.size()];
	1157	result = (MethodDescriptor[])methods.values().toArray(result);
	1158
	1159	return result;
	1160	}
	1161
	1162	private void addMethod(MethodDescriptor md) {
	1163	// We have to be careful here to distinguish method by both name
	1164	// and argument lists.
	1165	// This method gets called a *lot, so we try to be efficient.
	1166	String name = md.getName();
	1167
	1168	MethodDescriptor old = (MethodDescriptor)methods.get(name);
	1169	if (old == null) {
	1170	// This is the common case.
	1171	methods.put(name, md);
	1172	return;
	1173	}
	1174
	1175	// We have a collision on method names. This is rare.
	1176
	1177	// Check if old and md have the same type.
	1178	String[] p1 = md.getParamNames();
	1179	String[] p2 = old.getParamNames();
	1180
	1181	boolean match = false;
	1182	if (p1.length == p2.length) {
	1183	match = true;
	1184	for (int i = 0; i < p1.length; i++) {
	1185	if (p1[i] != p2[i]) {
	1186	match = false;
	1187	break;
	1188	}
	1189	}
	1190	}
	1191	if (match) {
	1192	MethodDescriptor composite = new MethodDescriptor(old, md);
	1193	methods.put(name, composite);
	1194	return;
	1195	}
	1196
	1197	// We have a collision on method names with different type signatures.
	1198	// This is very rare.
	1199
	1200	String longKey = makeQualifiedMethodName(name, p1);
	1201	old = (MethodDescriptor)methods.get(longKey);
	1202	if (old == null) {
	1203	methods.put(longKey, md);
	1204	return;
	1205	}
	1206	MethodDescriptor composite = new MethodDescriptor(old, md);
	1207	methods.put(longKey, composite);
	1208	}
	1209
	1210	/**
	1211	* Creates a key for a method in a method cache.
	1212	*/
	1213	private static String makeQualifiedMethodName(String name, String[] params) {
	1214	StringBuffer sb = new StringBuffer(name);
	1215	sb.append('=');
	1216	for (int i = 0; i < params.length; i++) {
	1217	sb.append(':');
	1218	sb.append(params[i]);
	1219	}
	1220	return sb.toString();
	1221	}
	1222
	1223	private int getTargetDefaultEventIndex() {
	1224	return defaultEventIndex;
	1225	}
	1226
	1227	private int getTargetDefaultPropertyIndex() {
	1228	return defaultPropertyIndex;
	1229	}
	1230
	1231	private BeanDescriptor getTargetBeanDescriptor() {
	1232	// Use explicit info, if available,
	1233	if (explicitBeanInfo != null) {
	1234	BeanDescriptor bd = explicitBeanInfo.getBeanDescriptor();
	1235	if (bd != null) {
	1236	return (bd);
	1237	}
	1238	}
	1239	// OK, fabricate a default BeanDescriptor.
	1240	return new BeanDescriptor(this.beanClass, findCustomizerClass(this.beanClass));
	1241	}
	1242
	1243	private static Class<?> findCustomizerClass(Class<?> type) {
	1244	String name = type.getName() + "Customizer";
	1245	try {
	1246	type = ClassFinder.findClass(name, type.getClassLoader());
	1247	// Each customizer should inherit java.awt.Component and implement java.beans.Customizer
	1248	// according to the section 9.3 of JavaBeans™ specification
	1249	if (Component.class.isAssignableFrom(type) && Customizer.class.isAssignableFrom(type)) {
	1250	return type;
	1251	}
	1252	}
	1253	catch (Exception exception) {
	1254	// ignore any exceptions
	1255	}
	1256	return null;
	1257	}
	1258
	1259	private boolean isEventHandler(Method m) {
	1260	// We assume that a method is an event handler if it has a single
	1261	// argument, whose type inherit from java.util.Event.
	1262	Class argTypes[] = FeatureDescriptor.getParameterTypes(beanClass, m);
	1263	if (argTypes.length != 1) {
	1264	return false;
	1265	}
	1266	return isSubclass(argTypes[0], EventObject.class);
	1267	}
	1268
	1269	/*
	1270	* Internal method to return public methods within a class.
	1271	*/
	1272	private static Method[] getPublicDeclaredMethods(Class clz) {
	1273	// Looking up Class.getDeclaredMethods is relatively expensive,
	1274	// so we cache the results.
	1275	if (!ReflectUtil.isPackageAccessible(clz)) {
	1276	return new Method[0];
	1277	}
	1278	synchronized (BEANINFO_CACHE) {
	1279	Method[] result = declaredMethodCache.get(clz);
	1280	if (result == null) {
	1281	result = clz.getMethods();
	1282	for (int i = 0; i < result.length; i++) {
	1283	Method method = result[i];
	1284	if (!method.getDeclaringClass().equals(clz)) {
	1285	result[i] = null;
	1286	}
	1287	}
	1288	declaredMethodCache.put(clz, result);
	1289	}
	1290	return result;
	1291	}
	1292	}
	1293
	1294	//======================================================================
	1295	// Package private support methods.
	1296	//======================================================================
	1297
	1298	/**
	1299	* Internal support for finding a target methodName with a given
	1300	* parameter list on a given class.
	1301	*/
	1302	private static Method internalFindMethod(Class start, String methodName,
	1303	int argCount, Class args[]) {
	1304	// For overriden methods we need to find the most derived version.
	1305	// So we start with the given class and walk up the superclass chain.
	1306
	1307	Method method = null;
	1308
	1309	for (Class cl = start; cl != null; cl = cl.getSuperclass()) {
	1310	Method methods[] = getPublicDeclaredMethods(cl);
	1311	for (int i = 0; i < methods.length; i++) {
	1312	method = methods[i];
	1313	if (method == null) {
	1314	continue;
	1315	}
	1316
	1317	// make sure method signature matches.
	1318	Class params[] = FeatureDescriptor.getParameterTypes(start, method);
	1319	if (method.getName().equals(methodName) &&
	1320	params.length == argCount) {
	1321	if (args != null) {
	1322	boolean different = false;
	1323	if (argCount > 0) {
	1324	for (int j = 0; j < argCount; j++) {
	1325	if (params[j] != args[j]) {
	1326	different = true;
	1327	continue;
	1328	}
	1329	}
	1330	if (different) {
	1331	continue;
	1332	}
	1333	}
	1334	}
	1335	return method;
	1336	}
	1337	}
	1338	}
	1339	method = null;
	1340
	1341	// Now check any inherited interfaces. This is necessary both when
	1342	// the argument class is itself an interface, and when the argument
	1343	// class is an abstract class.
	1344	Class ifcs[] = start.getInterfaces();
	1345	for (int i = 0 ; i < ifcs.length; i++) {
	1346	// Note: The original implementation had both methods calling
	1347	// the 3 arg method. This is preserved but perhaps it should
	1348	// pass the args array instead of null.
	1349	method = internalFindMethod(ifcs[i], methodName, argCount, null);
	1350	if (method != null) {
	1351	break;
	1352	}
	1353	}
	1354	return method;
	1355	}
	1356
	1357	/**
	1358	* Find a target methodName on a given class.
	1359	*/
	1360	static Method findMethod(Class cls, String methodName, int argCount) {
	1361	return findMethod(cls, methodName, argCount, null);
	1362	}
	1363
	1364	/**
	1365	* Find a target methodName with specific parameter list on a given class.
	1366	* <p>
	1367	* Used in the contructors of the EventSetDescriptor,
	1368	* PropertyDescriptor and the IndexedPropertyDescriptor.
	1369	* <p>
	1370	* @param cls The Class object on which to retrieve the method.
	1371	* @param methodName Name of the method.
	1372	* @param argCount Number of arguments for the desired method.
	1373	* @param args Array of argument types for the method.
	1374	* @return the method or null if not found
	1375	*/
	1376	static Method findMethod(Class cls, String methodName, int argCount,
	1377	Class args[]) {
	1378	if (methodName == null) {
	1379	return null;
	1380	}
	1381	return internalFindMethod(cls, methodName, argCount, args);
	1382	}
	1383
	1384	/**
	1385	* Return true if class a is either equivalent to class b, or
	1386	* if class a is a subclass of class b, i.e. if a either "extends"
	1387	* or "implements" b.
	1388	* Note tht either or both "Class" objects may represent interfaces.
	1389	*/
	1390	static boolean isSubclass(Class a, Class b) {
	1391	// We rely on the fact that for any given java class or
	1392	// primtitive type there is a unqiue Class object, so
	1393	// we can use object equivalence in the comparisons.
	1394	if (a == b) {
	1395	return true;
	1396	}
	1397	if (a == null \|\| b == null) {
	1398	return false;
	1399	}
	1400	for (Class x = a; x != null; x = x.getSuperclass()) {
	1401	if (x == b) {
	1402	return true;
	1403	}
	1404	if (b.isInterface()) {
	1405	Class interfaces[] = x.getInterfaces();
	1406	for (int i = 0; i < interfaces.length; i++) {
	1407	if (isSubclass(interfaces[i], b)) {
	1408	return true;
	1409	}
	1410	}
	1411	}
	1412	}
	1413	return false;
	1414	}
	1415
	1416	/**
	1417	* Return true iff the given method throws the given exception.
	1418	*/
	1419	private boolean throwsException(Method method, Class exception) {
	1420	Class exs[] = method.getExceptionTypes();
	1421	for (int i = 0; i < exs.length; i++) {
	1422	if (exs[i] == exception) {
	1423	return true;
	1424	}
	1425	}
	1426	return false;
	1427	}
	1428
	1429	private static BeanInfoFinder getFinder() {
	1430	AppContext context = AppContext.getAppContext();
	1431	Object object = context.get(FINDER_KEY);
	1432	if (object instanceof BeanInfoFinder) {
	1433	return (BeanInfoFinder) object;
	1434	}
	1435	BeanInfoFinder finder = new BeanInfoFinder();
	1436	context.put(FINDER_KEY, finder);
	1437	return finder;
	1438	}
	1439
	1440	/**
	1441	* Try to create an instance of a named class.
	1442	* First try the classloader of "sibling", then try the system
	1443	* classloader then the class loader of the current Thread.
	1444	*/
	1445	static Object instantiate(Class sibling, String className)
	1446	throws InstantiationException, IllegalAccessException,
	1447	ClassNotFoundException {
	1448	// First check with sibling's classloader (if any).
	1449	ClassLoader cl = sibling.getClassLoader();
	1450	Class cls = ClassFinder.findClass(className, cl);
	1451	return cls.newInstance();
	1452	}
	1453
	1454	} // end class Introspector
	1455
	1456	//===========================================================================
	1457
	1458	/**
	1459	* Package private implementation support class for Introspector's
	1460	* internal use.
	1461	* <p>
	1462	* Mostly this is used as a placeholder for the descriptors.
	1463	*/
	1464
	1465	class GenericBeanInfo extends SimpleBeanInfo {
	1466
	1467	private BeanDescriptor beanDescriptor;
	1468	private EventSetDescriptor[] events;
	1469	private int defaultEvent;
	1470	private PropertyDescriptor[] properties;
	1471	private int defaultProperty;
	1472	private MethodDescriptor[] methods;
	1473	private final Reference<BeanInfo> targetBeanInfoRef;
	1474
	1475	public GenericBeanInfo(BeanDescriptor beanDescriptor,
	1476	EventSetDescriptor[] events, int defaultEvent,
	1477	PropertyDescriptor[] properties, int defaultProperty,
	1478	MethodDescriptor[] methods, BeanInfo targetBeanInfo) {
	1479	this.beanDescriptor = beanDescriptor;
	1480	this.events = events;
	1481	this.defaultEvent = defaultEvent;
	1482	this.properties = properties;
	1483	this.defaultProperty = defaultProperty;
	1484	this.methods = methods;
	1485	this.targetBeanInfoRef = new SoftReference<BeanInfo>(targetBeanInfo);
	1486	}
	1487
	1488	/**
	1489	* Package-private dup constructor
	1490	* This must isolate the new object from any changes to the old object.
	1491	*/
	1492	GenericBeanInfo(GenericBeanInfo old) {
	1493
	1494	beanDescriptor = new BeanDescriptor(old.beanDescriptor);
	1495	if (old.events != null) {
	1496	int len = old.events.length;
	1497	events = new EventSetDescriptor[len];
	1498	for (int i = 0; i < len; i++) {
	1499	events[i] = new EventSetDescriptor(old.events[i]);
	1500	}
	1501	}
	1502	defaultEvent = old.defaultEvent;
	1503	if (old.properties != null) {
	1504	int len = old.properties.length;
	1505	properties = new PropertyDescriptor[len];
	1506	for (int i = 0; i < len; i++) {
	1507	PropertyDescriptor oldp = old.properties[i];
	1508	if (oldp instanceof IndexedPropertyDescriptor) {
	1509	properties[i] = new IndexedPropertyDescriptor(
	1510	(IndexedPropertyDescriptor) oldp);
	1511	} else {
	1512	properties[i] = new PropertyDescriptor(oldp);
	1513	}
	1514	}
	1515	}
	1516	defaultProperty = old.defaultProperty;
	1517	if (old.methods != null) {
	1518	int len = old.methods.length;
	1519	methods = new MethodDescriptor[len];
	1520	for (int i = 0; i < len; i++) {
	1521	methods[i] = new MethodDescriptor(old.methods[i]);
	1522	}
	1523	}
	1524	this.targetBeanInfoRef = old.targetBeanInfoRef;
	1525	}
	1526
	1527	public PropertyDescriptor[] getPropertyDescriptors() {
	1528	return properties;
	1529	}
	1530
	1531	public int getDefaultPropertyIndex() {
	1532	return defaultProperty;
	1533	}
	1534
	1535	public EventSetDescriptor[] getEventSetDescriptors() {
	1536	return events;
	1537	}
	1538
	1539	public int getDefaultEventIndex() {
	1540	return defaultEvent;
	1541	}
	1542
	1543	public MethodDescriptor[] getMethodDescriptors() {
	1544	return methods;
	1545	}
	1546
	1547	public BeanDescriptor getBeanDescriptor() {
	1548	return beanDescriptor;
	1549	}
	1550
	1551	public java.awt.Image getIcon(int iconKind) {
	1552	BeanInfo targetBeanInfo = this.targetBeanInfoRef.get();
	1553	if (targetBeanInfo != null) {
	1554	return targetBeanInfo.getIcon(iconKind);
	1555	}
	1556	return super.getIcon(iconKind);
	1557	}
	1558	}

java/pkg/java/beans/MetaData$1.class+0−0

Binary file not shown.

java/pkg/java/beans/MetaData.class+0−0

Binary file not shown.

java/pkg/java/beans/MetaData.java+1443−0

@@ -0,0 +1,1443 @@
	1	/*
	2	* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import com.sun.beans.finder.PrimitiveWrapperMap;
	28
	29	import java.awt.AWTKeyStroke;
	30	import java.awt.BorderLayout;
	31	import java.awt.Dimension;
	32	import java.awt.Color;
	33	import java.awt.Font;
	34	import java.awt.GridBagConstraints;
	35	import java.awt.Insets;
	36	import java.awt.Point;
	37	import java.awt.Rectangle;
	38	import java.awt.event.KeyEvent;
	39	import java.awt.font.TextAttribute;
	40
	41	import java.lang.reflect.Array;
	42	import java.lang.reflect.Constructor;
	43	import java.lang.reflect.Field;
	44	import java.lang.reflect.Method;
	45	import java.lang.reflect.InvocationTargetException;
	46
	47	import java.security.AccessController;
	48	import java.security.PrivilegedAction;
	49
	50	import java.util.*;
	51
	52	import javax.swing.Box;
	53	import javax.swing.JLayeredPane;
	54	import javax.swing.border.MatteBorder;
	55	import javax.swing.plaf.ColorUIResource;
	56
	57	import sun.swing.PrintColorUIResource;
	58
	59	import java.util.Objects;
	60
	61	/*
	62	* Like the <code>Intropector</code>, the <code>MetaData</code> class
	63	* contains <em>meta</em> objects that describe the way
	64	* classes should express their state in terms of their
	65	* own public APIs.
	66	*
	67	* @see java.beans.Intropector
	68	*
	69	* @author Philip Milne
	70	* @author Steve Langley
	71	*/
	72
	73	class NullPersistenceDelegate extends PersistenceDelegate {
	74	// Note this will be called by all classes when they reach the
	75	// top of their superclass chain.
	76	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	77	}
	78	protected Expression instantiate(Object oldInstance, Encoder out) { return null; }
	79
	80	public void writeObject(Object oldInstance, Encoder out) {
	81	// System.out.println("NullPersistenceDelegate:writeObject " + oldInstance);
	82	}
	83	}
	84
	85	/**
	86	* The persistence delegate for <CODE>enum</CODE> classes.
	87	*
	88	* @author Sergey A. Malenkov
	89	*/
	90	class EnumPersistenceDelegate extends PersistenceDelegate {
	91	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	92	return oldInstance == newInstance;
	93	}
	94
	95	protected Expression instantiate(Object oldInstance, Encoder out) {
	96	Enum e = (Enum) oldInstance;
	97	return new Expression(e, Enum.class, "valueOf", new Object[]{e.getDeclaringClass(), e.name()});
	98	}
	99	}
	100
	101	class PrimitivePersistenceDelegate extends PersistenceDelegate {
	102	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	103	return oldInstance.equals(newInstance);
	104	}
	105
	106	protected Expression instantiate(Object oldInstance, Encoder out) {
	107	return new Expression(oldInstance, oldInstance.getClass(),
	108	"new", new Object[]{oldInstance.toString()});
	109	}
	110	}
	111
	112	class ArrayPersistenceDelegate extends PersistenceDelegate {
	113	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	114	return (newInstance != null &&
	115	oldInstance.getClass() == newInstance.getClass() && // Also ensures the subtype is correct.
	116	Array.getLength(oldInstance) == Array.getLength(newInstance));
	117	}
	118
	119	protected Expression instantiate(Object oldInstance, Encoder out) {
	120	// System.out.println("instantiate: " + type + " " + oldInstance);
	121	Class oldClass = oldInstance.getClass();
	122	return new Expression(oldInstance, Array.class, "newInstance",
	123	new Object[]{oldClass.getComponentType(),
	124	new Integer(Array.getLength(oldInstance))});
	125	}
	126
	127	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	128	int n = Array.getLength(oldInstance);
	129	for (int i = 0; i < n; i++) {
	130	Object index = new Integer(i);
	131	// Expression oldGetExp = new Expression(Array.class, "get", new Object[]{oldInstance, index});
	132	// Expression newGetExp = new Expression(Array.class, "get", new Object[]{newInstance, index});
	133	Expression oldGetExp = new Expression(oldInstance, "get", new Object[]{index});
	134	Expression newGetExp = new Expression(newInstance, "get", new Object[]{index});
	135	try {
	136	Object oldValue = oldGetExp.getValue();
	137	Object newValue = newGetExp.getValue();
	138	out.writeExpression(oldGetExp);
	139	if (!Objects.equals(newValue, out.get(oldValue))) {
	140	// System.out.println("Not equal: " + newGetExp + " != " + actualGetExp);
	141	// invokeStatement(Array.class, "set", new Object[]{oldInstance, index, oldValue}, out);
	142	DefaultPersistenceDelegate.invokeStatement(oldInstance, "set", new Object[]{index, oldValue}, out);
	143	}
	144	}
	145	catch (Exception e) {
	146	// System.err.println("Warning:: failed to write: " + oldGetExp);
	147	out.getExceptionListener().exceptionThrown(e);
	148	}
	149	}
	150	}
	151	}
	152
	153	class ProxyPersistenceDelegate extends PersistenceDelegate {
	154	protected Expression instantiate(Object oldInstance, Encoder out) {
	155	Class type = oldInstance.getClass();
	156	java.lang.reflect.Proxy p = (java.lang.reflect.Proxy)oldInstance;
	157	// This unappealing hack is not required but makes the
	158	// representation of EventHandlers much more concise.
	159	java.lang.reflect.InvocationHandler ih = java.lang.reflect.Proxy.getInvocationHandler(p);
	160	if (ih instanceof EventHandler) {
	161	EventHandler eh = (EventHandler)ih;
	162	Vector args = new Vector();
	163	args.add(type.getInterfaces()[0]);
	164	args.add(eh.getTarget());
	165	args.add(eh.getAction());
	166	if (eh.getEventPropertyName() != null) {
	167	args.add(eh.getEventPropertyName());
	168	}
	169	if (eh.getListenerMethodName() != null) {
	170	args.setSize(4);
	171	args.add(eh.getListenerMethodName());
	172	}
	173	return new Expression(oldInstance,
	174	EventHandler.class,
	175	"create",
	176	args.toArray());
	177	}
	178	return new Expression(oldInstance,
	179	java.lang.reflect.Proxy.class,
	180	"newProxyInstance",
	181	new Object[]{type.getClassLoader(),
	182	type.getInterfaces(),
	183	ih});
	184	}
	185	}
	186
	187	// Strings
	188	class java_lang_String_PersistenceDelegate extends PersistenceDelegate {
	189	protected Expression instantiate(Object oldInstance, Encoder out) { return null; }
	190
	191	public void writeObject(Object oldInstance, Encoder out) {
	192	// System.out.println("NullPersistenceDelegate:writeObject " + oldInstance);
	193	}
	194	}
	195
	196	// Classes
	197	class java_lang_Class_PersistenceDelegate extends PersistenceDelegate {
	198	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	199	return oldInstance.equals(newInstance);
	200	}
	201
	202	protected Expression instantiate(Object oldInstance, Encoder out) {
	203	Class c = (Class)oldInstance;
	204	// As of 1.3 it is not possible to call Class.forName("int"),
	205	// so we have to generate different code for primitive types.
	206	// This is needed for arrays whose subtype may be primitive.
	207	if (c.isPrimitive()) {
	208	Field field = null;
	209	try {
	210	field = PrimitiveWrapperMap.getType(c.getName()).getDeclaredField("TYPE");
	211	} catch (NoSuchFieldException ex) {
	212	System.err.println("Unknown primitive type: " + c);
	213	}
	214	return new Expression(oldInstance, field, "get", new Object[]{null});
	215	}
	216	else if (oldInstance == String.class) {
	217	return new Expression(oldInstance, "", "getClass", new Object[]{});
	218	}
	219	else if (oldInstance == Class.class) {
	220	return new Expression(oldInstance, String.class, "getClass", new Object[]{});
	221	}
	222	else {
	223	Expression newInstance = new Expression(oldInstance, Class.class, "forName", new Object[] { c.getName() });
	224	newInstance.loader = c.getClassLoader();
	225	return newInstance;
	226	}
	227	}
	228	}
	229
	230	// Fields
	231	class java_lang_reflect_Field_PersistenceDelegate extends PersistenceDelegate {
	232	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	233	return oldInstance.equals(newInstance);
	234	}
	235
	236	protected Expression instantiate(Object oldInstance, Encoder out) {
	237	Field f = (Field)oldInstance;
	238	return new Expression(oldInstance,
	239	f.getDeclaringClass(),
	240	"getField",
	241	new Object[]{f.getName()});
	242	}
	243	}
	244
	245	// Methods
	246	class java_lang_reflect_Method_PersistenceDelegate extends PersistenceDelegate {
	247	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	248	return oldInstance.equals(newInstance);
	249	}
	250
	251	protected Expression instantiate(Object oldInstance, Encoder out) {
	252	Method m = (Method)oldInstance;
	253	return new Expression(oldInstance,
	254	m.getDeclaringClass(),
	255	"getMethod",
	256	new Object[]{m.getName(), m.getParameterTypes()});
	257	}
	258	}
	259
	260	// Dates
	261
	262	/**
	263	* The persistence delegate for <CODE>java.util.Date</CODE> classes.
	264	* Do not extend DefaultPersistenceDelegate to improve performance and
	265	* to avoid problems with <CODE>java.sql.Date</CODE>,
	266	* <CODE>java.sql.Time</CODE> and <CODE>java.sql.Timestamp</CODE>.
	267	*
	268	* @author Sergey A. Malenkov
	269	*/
	270	class java_util_Date_PersistenceDelegate extends PersistenceDelegate {
	271	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	272	if (!super.mutatesTo(oldInstance, newInstance)) {
	273	return false;
	274	}
	275	Date oldDate = (Date)oldInstance;
	276	Date newDate = (Date)newInstance;
	277
	278	return oldDate.getTime() == newDate.getTime();
	279	}
	280
	281	protected Expression instantiate(Object oldInstance, Encoder out) {
	282	Date date = (Date)oldInstance;
	283	return new Expression(date, date.getClass(), "new", new Object[] {date.getTime()});
	284	}
	285	}
	286
	287	/**
	288	* The persistence delegate for <CODE>java.sql.Timestamp</CODE> classes.
	289	* It supports nanoseconds.
	290	*
	291	* @author Sergey A. Malenkov
	292	*/
	293	final class java_sql_Timestamp_PersistenceDelegate extends java_util_Date_PersistenceDelegate {
	294	private static final Method getNanosMethod = getNanosMethod();
	295
	296	private static Method getNanosMethod() {
	297	try {
	298	Class<?> c = Class.forName("java.sql.Timestamp", true, null);
	299	return c.getMethod("getNanos");
	300	} catch (ClassNotFoundException e) {
	301	return null;
	302	} catch (NoSuchMethodException e) {
	303	throw new AssertionError(e);
	304	}
	305	}
	306
	307	/**
	308	* Invoke Timstamp getNanos.
	309	*/
	310	private static int getNanos(Object obj) {
	311	if (getNanosMethod == null)
	312	throw new AssertionError("Should not get here");
	313	try {
	314	return (Integer)getNanosMethod.invoke(obj);
	315	} catch (InvocationTargetException e) {
	316	Throwable cause = e.getCause();
	317	if (cause instanceof RuntimeException)
	318	throw (RuntimeException)cause;
	319	if (cause instanceof Error)
	320	throw (Error)cause;
	321	throw new AssertionError(e);
	322	} catch (IllegalAccessException iae) {
	323	throw new AssertionError(iae);
	324	}
	325	}
	326
	327	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	328	// assumes oldInstance and newInstance are Timestamps
	329	int nanos = getNanos(oldInstance);
	330	if (nanos != getNanos(newInstance)) {
	331	out.writeStatement(new Statement(oldInstance, "setNanos", new Object[] {nanos}));
	332	}
	333	}
	334	}
	335
	336	// Collections
	337
	338	/*
	339	The Hashtable and AbstractMap classes have no common ancestor yet may
	340	be handled with a single persistence delegate: one which uses the methods
	341	of the Map insterface exclusively. Attatching the persistence delegates
	342	to the interfaces themselves is fraught however since, in the case of
	343	the Map, both the AbstractMap and HashMap classes are declared to
	344	implement the Map interface, leaving the obvious implementation prone
	345	to repeating their initialization. These issues and questions around
	346	the ordering of delegates attached to interfaces have lead us to
	347	ignore any delegates attached to interfaces and force all persistence
	348	delegates to be registered with concrete classes.
	349	*/
	350
	351	/**
	352	* The base class for persistence delegates for inner classes
	353	* that can be created using {@link Collections}.
	354	*
	355	* @author Sergey A. Malenkov
	356	*/
	357	abstract class java_util_Collections extends PersistenceDelegate {
	358	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	359	if (!super.mutatesTo(oldInstance, newInstance)) {
	360	return false;
	361	}
	362	if ((oldInstance instanceof List) \|\| (oldInstance instanceof Set) \|\| (oldInstance instanceof Map)) {
	363	return oldInstance.equals(newInstance);
	364	}
	365	Collection oldC = (Collection) oldInstance;
	366	Collection newC = (Collection) newInstance;
	367	return (oldC.size() == newC.size()) && oldC.containsAll(newC);
	368	}
	369
	370	static final class EmptyList_PersistenceDelegate extends java_util_Collections {
	371	protected Expression instantiate(Object oldInstance, Encoder out) {
	372	return new Expression(oldInstance, Collections.class, "emptyList", null);
	373	}
	374	}
	375
	376	static final class EmptySet_PersistenceDelegate extends java_util_Collections {
	377	protected Expression instantiate(Object oldInstance, Encoder out) {
	378	return new Expression(oldInstance, Collections.class, "emptySet", null);
	379	}
	380	}
	381
	382	static final class EmptyMap_PersistenceDelegate extends java_util_Collections {
	383	protected Expression instantiate(Object oldInstance, Encoder out) {
	384	return new Expression(oldInstance, Collections.class, "emptyMap", null);
	385	}
	386	}
	387
	388	static final class SingletonList_PersistenceDelegate extends java_util_Collections {
	389	protected Expression instantiate(Object oldInstance, Encoder out) {
	390	List list = (List) oldInstance;
	391	return new Expression(oldInstance, Collections.class, "singletonList", new Object[]{list.get(0)});
	392	}
	393	}
	394
	395	static final class SingletonSet_PersistenceDelegate extends java_util_Collections {
	396	protected Expression instantiate(Object oldInstance, Encoder out) {
	397	Set set = (Set) oldInstance;
	398	return new Expression(oldInstance, Collections.class, "singleton", new Object[]{set.iterator().next()});
	399	}
	400	}
	401
	402	static final class SingletonMap_PersistenceDelegate extends java_util_Collections {
	403	protected Expression instantiate(Object oldInstance, Encoder out) {
	404	Map map = (Map) oldInstance;
	405	Object key = map.keySet().iterator().next();
	406	return new Expression(oldInstance, Collections.class, "singletonMap", new Object[]{key, map.get(key)});
	407	}
	408	}
	409
	410	static final class UnmodifiableCollection_PersistenceDelegate extends java_util_Collections {
	411	protected Expression instantiate(Object oldInstance, Encoder out) {
	412	List list = new ArrayList((Collection) oldInstance);
	413	return new Expression(oldInstance, Collections.class, "unmodifiableCollection", new Object[]{list});
	414	}
	415	}
	416
	417	static final class UnmodifiableList_PersistenceDelegate extends java_util_Collections {
	418	protected Expression instantiate(Object oldInstance, Encoder out) {
	419	List list = new LinkedList((Collection) oldInstance);
	420	return new Expression(oldInstance, Collections.class, "unmodifiableList", new Object[]{list});
	421	}
	422	}
	423
	424	static final class UnmodifiableRandomAccessList_PersistenceDelegate extends java_util_Collections {
	425	protected Expression instantiate(Object oldInstance, Encoder out) {
	426	List list = new ArrayList((Collection) oldInstance);
	427	return new Expression(oldInstance, Collections.class, "unmodifiableList", new Object[]{list});
	428	}
	429	}
	430
	431	static final class UnmodifiableSet_PersistenceDelegate extends java_util_Collections {
	432	protected Expression instantiate(Object oldInstance, Encoder out) {
	433	Set set = new HashSet((Set) oldInstance);
	434	return new Expression(oldInstance, Collections.class, "unmodifiableSet", new Object[]{set});
	435	}
	436	}
	437
	438	static final class UnmodifiableSortedSet_PersistenceDelegate extends java_util_Collections {
	439	protected Expression instantiate(Object oldInstance, Encoder out) {
	440	SortedSet set = new TreeSet((SortedSet) oldInstance);
	441	return new Expression(oldInstance, Collections.class, "unmodifiableSortedSet", new Object[]{set});
	442	}
	443	}
	444
	445	static final class UnmodifiableMap_PersistenceDelegate extends java_util_Collections {
	446	protected Expression instantiate(Object oldInstance, Encoder out) {
	447	Map map = new HashMap((Map) oldInstance);
	448	return new Expression(oldInstance, Collections.class, "unmodifiableMap", new Object[]{map});
	449	}
	450	}
	451
	452	static final class UnmodifiableSortedMap_PersistenceDelegate extends java_util_Collections {
	453	protected Expression instantiate(Object oldInstance, Encoder out) {
	454	SortedMap map = new TreeMap((SortedMap) oldInstance);
	455	return new Expression(oldInstance, Collections.class, "unmodifiableSortedMap", new Object[]{map});
	456	}
	457	}
	458
	459	static final class SynchronizedCollection_PersistenceDelegate extends java_util_Collections {
	460	protected Expression instantiate(Object oldInstance, Encoder out) {
	461	List list = new ArrayList((Collection) oldInstance);
	462	return new Expression(oldInstance, Collections.class, "synchronizedCollection", new Object[]{list});
	463	}
	464	}
	465
	466	static final class SynchronizedList_PersistenceDelegate extends java_util_Collections {
	467	protected Expression instantiate(Object oldInstance, Encoder out) {
	468	List list = new LinkedList((Collection) oldInstance);
	469	return new Expression(oldInstance, Collections.class, "synchronizedList", new Object[]{list});
	470	}
	471	}
	472
	473	static final class SynchronizedRandomAccessList_PersistenceDelegate extends java_util_Collections {
	474	protected Expression instantiate(Object oldInstance, Encoder out) {
	475	List list = new ArrayList((Collection) oldInstance);
	476	return new Expression(oldInstance, Collections.class, "synchronizedList", new Object[]{list});
	477	}
	478	}
	479
	480	static final class SynchronizedSet_PersistenceDelegate extends java_util_Collections {
	481	protected Expression instantiate(Object oldInstance, Encoder out) {
	482	Set set = new HashSet((Set) oldInstance);
	483	return new Expression(oldInstance, Collections.class, "synchronizedSet", new Object[]{set});
	484	}
	485	}
	486
	487	static final class SynchronizedSortedSet_PersistenceDelegate extends java_util_Collections {
	488	protected Expression instantiate(Object oldInstance, Encoder out) {
	489	SortedSet set = new TreeSet((SortedSet) oldInstance);
	490	return new Expression(oldInstance, Collections.class, "synchronizedSortedSet", new Object[]{set});
	491	}
	492	}
	493
	494	static final class SynchronizedMap_PersistenceDelegate extends java_util_Collections {
	495	protected Expression instantiate(Object oldInstance, Encoder out) {
	496	Map map = new HashMap((Map) oldInstance);
	497	return new Expression(oldInstance, Collections.class, "synchronizedMap", new Object[]{map});
	498	}
	499	}
	500
	501	static final class SynchronizedSortedMap_PersistenceDelegate extends java_util_Collections {
	502	protected Expression instantiate(Object oldInstance, Encoder out) {
	503	SortedMap map = new TreeMap((SortedMap) oldInstance);
	504	return new Expression(oldInstance, Collections.class, "synchronizedSortedMap", new Object[]{map});
	505	}
	506	}
	507
	508	static final class CheckedCollection_PersistenceDelegate extends java_util_Collections {
	509	protected Expression instantiate(Object oldInstance, Encoder out) {
	510	Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");
	511	List list = new ArrayList((Collection) oldInstance);
	512	return new Expression(oldInstance, Collections.class, "checkedCollection", new Object[]{list, type});
	513	}
	514	}
	515
	516	static final class CheckedList_PersistenceDelegate extends java_util_Collections {
	517	protected Expression instantiate(Object oldInstance, Encoder out) {
	518	Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");
	519	List list = new LinkedList((Collection) oldInstance);
	520	return new Expression(oldInstance, Collections.class, "checkedList", new Object[]{list, type});
	521	}
	522	}
	523
	524	static final class CheckedRandomAccessList_PersistenceDelegate extends java_util_Collections {
	525	protected Expression instantiate(Object oldInstance, Encoder out) {
	526	Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");
	527	List list = new ArrayList((Collection) oldInstance);
	528	return new Expression(oldInstance, Collections.class, "checkedList", new Object[]{list, type});
	529	}
	530	}
	531
	532	static final class CheckedSet_PersistenceDelegate extends java_util_Collections {
	533	protected Expression instantiate(Object oldInstance, Encoder out) {
	534	Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");
	535	Set set = new HashSet((Set) oldInstance);
	536	return new Expression(oldInstance, Collections.class, "checkedSet", new Object[]{set, type});
	537	}
	538	}
	539
	540	static final class CheckedSortedSet_PersistenceDelegate extends java_util_Collections {
	541	protected Expression instantiate(Object oldInstance, Encoder out) {
	542	Object type = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedCollection.type");
	543	SortedSet set = new TreeSet((SortedSet) oldInstance);
	544	return new Expression(oldInstance, Collections.class, "checkedSortedSet", new Object[]{set, type});
	545	}
	546	}
	547
	548	static final class CheckedMap_PersistenceDelegate extends java_util_Collections {
	549	protected Expression instantiate(Object oldInstance, Encoder out) {
	550	Object keyType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.keyType");
	551	Object valueType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.valueType");
	552	Map map = new HashMap((Map) oldInstance);
	553	return new Expression(oldInstance, Collections.class, "checkedMap", new Object[]{map, keyType, valueType});
	554	}
	555	}
	556
	557	static final class CheckedSortedMap_PersistenceDelegate extends java_util_Collections {
	558	protected Expression instantiate(Object oldInstance, Encoder out) {
	559	Object keyType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.keyType");
	560	Object valueType = MetaData.getPrivateFieldValue(oldInstance, "java.util.Collections$CheckedMap.valueType");
	561	SortedMap map = new TreeMap((SortedMap) oldInstance);
	562	return new Expression(oldInstance, Collections.class, "checkedSortedMap", new Object[]{map, keyType, valueType});
	563	}
	564	}
	565	}
	566
	567	/**
	568	* The persistence delegate for <CODE>java.util.EnumMap</CODE> classes.
	569	*
	570	* @author Sergey A. Malenkov
	571	*/
	572	class java_util_EnumMap_PersistenceDelegate extends PersistenceDelegate {
	573	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	574	return super.mutatesTo(oldInstance, newInstance) && (getType(oldInstance) == getType(newInstance));
	575	}
	576
	577	protected Expression instantiate(Object oldInstance, Encoder out) {
	578	return new Expression(oldInstance, EnumMap.class, "new", new Object[] {getType(oldInstance)});
	579	}
	580
	581	private static Object getType(Object instance) {
	582	return MetaData.getPrivateFieldValue(instance, "java.util.EnumMap.keyType");
	583	}
	584	}
	585
	586	/**
	587	* The persistence delegate for <CODE>java.util.EnumSet</CODE> classes.
	588	*
	589	* @author Sergey A. Malenkov
	590	*/
	591	class java_util_EnumSet_PersistenceDelegate extends PersistenceDelegate {
	592	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	593	return super.mutatesTo(oldInstance, newInstance) && (getType(oldInstance) == getType(newInstance));
	594	}
	595
	596	protected Expression instantiate(Object oldInstance, Encoder out) {
	597	return new Expression(oldInstance, EnumSet.class, "noneOf", new Object[] {getType(oldInstance)});
	598	}
	599
	600	private static Object getType(Object instance) {
	601	return MetaData.getPrivateFieldValue(instance, "java.util.EnumSet.elementType");
	602	}
	603	}
	604
	605	// Collection
	606	class java_util_Collection_PersistenceDelegate extends DefaultPersistenceDelegate {
	607	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	608	java.util.Collection oldO = (java.util.Collection)oldInstance;
	609	java.util.Collection newO = (java.util.Collection)newInstance;
	610
	611	if (newO.size() != 0) {
	612	invokeStatement(oldInstance, "clear", new Object[]{}, out);
	613	}
	614	for (Iterator i = oldO.iterator(); i.hasNext();) {
	615	invokeStatement(oldInstance, "add", new Object[]{i.next()}, out);
	616	}
	617	}
	618	}
	619
	620	// List
	621	class java_util_List_PersistenceDelegate extends DefaultPersistenceDelegate {
	622	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	623	java.util.List oldO = (java.util.List)oldInstance;
	624	java.util.List newO = (java.util.List)newInstance;
	625	int oldSize = oldO.size();
	626	int newSize = (newO == null) ? 0 : newO.size();
	627	if (oldSize < newSize) {
	628	invokeStatement(oldInstance, "clear", new Object[]{}, out);
	629	newSize = 0;
	630	}
	631	for (int i = 0; i < newSize; i++) {
	632	Object index = new Integer(i);
	633
	634	Expression oldGetExp = new Expression(oldInstance, "get", new Object[]{index});
	635	Expression newGetExp = new Expression(newInstance, "get", new Object[]{index});
	636	try {
	637	Object oldValue = oldGetExp.getValue();
	638	Object newValue = newGetExp.getValue();
	639	out.writeExpression(oldGetExp);
	640	if (!Objects.equals(newValue, out.get(oldValue))) {
	641	invokeStatement(oldInstance, "set", new Object[]{index, oldValue}, out);
	642	}
	643	}
	644	catch (Exception e) {
	645	out.getExceptionListener().exceptionThrown(e);
	646	}
	647	}
	648	for (int i = newSize; i < oldSize; i++) {
	649	invokeStatement(oldInstance, "add", new Object[]{oldO.get(i)}, out);
	650	}
	651	}
	652	}
	653
	654
	655	// Map
	656	class java_util_Map_PersistenceDelegate extends DefaultPersistenceDelegate {
	657	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	658	// System.out.println("Initializing: " + newInstance);
	659	java.util.Map oldMap = (java.util.Map)oldInstance;
	660	java.util.Map newMap = (java.util.Map)newInstance;
	661	// Remove the new elements.
	662	// Do this first otherwise we undo the adding work.
	663	if (newMap != null) {
	664	for (Object newKey : newMap.keySet().toArray()) {
	665	// PENDING: This "key" is not in the right environment.
	666	if (!oldMap.containsKey(newKey)) {
	667	invokeStatement(oldInstance, "remove", new Object[]{newKey}, out);
	668	}
	669	}
	670	}
	671	// Add the new elements.
	672	for ( Object oldKey : oldMap.keySet() ) {
	673	Expression oldGetExp = new Expression(oldInstance, "get", new Object[]{oldKey});
	674	// Pending: should use newKey.
	675	Expression newGetExp = new Expression(newInstance, "get", new Object[]{oldKey});
	676	try {
	677	Object oldValue = oldGetExp.getValue();
	678	Object newValue = newGetExp.getValue();
	679	out.writeExpression(oldGetExp);
	680	if (!Objects.equals(newValue, out.get(oldValue))) {
	681	invokeStatement(oldInstance, "put", new Object[]{oldKey, oldValue}, out);
	682	} else if ((newValue == null) && !newMap.containsKey(oldKey)) {
	683	// put oldValue(=null?) if oldKey is absent in newMap
	684	invokeStatement(oldInstance, "put", new Object[]{oldKey, oldValue}, out);
	685	}
	686	}
	687	catch (Exception e) {
	688	out.getExceptionListener().exceptionThrown(e);
	689	}
	690	}
	691	}
	692	}
	693
	694	class java_util_AbstractCollection_PersistenceDelegate extends java_util_Collection_PersistenceDelegate {}
	695	class java_util_AbstractList_PersistenceDelegate extends java_util_List_PersistenceDelegate {}
	696	class java_util_AbstractMap_PersistenceDelegate extends java_util_Map_PersistenceDelegate {}
	697	class java_util_Hashtable_PersistenceDelegate extends java_util_Map_PersistenceDelegate {}
	698
	699
	700	// Beans
	701	class java_beans_beancontext_BeanContextSupport_PersistenceDelegate extends java_util_Collection_PersistenceDelegate {}
	702
	703	// AWT
	704
	705	/**
	706	* The persistence delegate for {@link Insets}.
	707	* It is impossible to use {@link DefaultPersistenceDelegate}
	708	* because this class does not have any properties.
	709	*
	710	* @author Sergey A. Malenkov
	711	*/
	712	final class java_awt_Insets_PersistenceDelegate extends PersistenceDelegate {
	713	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	714	return oldInstance.equals(newInstance);
	715	}
	716
	717	protected Expression instantiate(Object oldInstance, Encoder out) {
	718	Insets insets = (Insets) oldInstance;
	719	Object[] args = new Object[] {
	720	insets.top,
	721	insets.left,
	722	insets.bottom,
	723	insets.right,
	724	};
	725	return new Expression(insets, insets.getClass(), "new", args);
	726	}
	727	}
	728
	729	/**
	730	* The persistence delegate for {@link Font}.
	731	* It is impossible to use {@link DefaultPersistenceDelegate}
	732	* because size of the font can be float value.
	733	*
	734	* @author Sergey A. Malenkov
	735	*/
	736	final class java_awt_Font_PersistenceDelegate extends PersistenceDelegate {
	737	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	738	return oldInstance.equals(newInstance);
	739	}
	740
	741	protected Expression instantiate(Object oldInstance, Encoder out) {
	742	Font font = (Font) oldInstance;
	743
	744	int count = 0;
	745	String family = null;
	746	int style = Font.PLAIN;
	747	int size = 12;
	748
	749	Map basic = font.getAttributes();
	750	Map clone = new HashMap(basic.size());
	751	for (Object key : basic.keySet()) {
	752	Object value = basic.get(key);
	753	if (value != null) {
	754	clone.put(key, value);
	755	}
	756	if (key == TextAttribute.FAMILY) {
	757	if (value instanceof String) {
	758	count++;
	759	family = (String) value;
	760	}
	761	}
	762	else if (key == TextAttribute.WEIGHT) {
	763	if (TextAttribute.WEIGHT_REGULAR.equals(value)) {
	764	count++;
	765	} else if (TextAttribute.WEIGHT_BOLD.equals(value)) {
	766	count++;
	767	style \|= Font.BOLD;
	768	}
	769	}
	770	else if (key == TextAttribute.POSTURE) {
	771	if (TextAttribute.POSTURE_REGULAR.equals(value)) {
	772	count++;
	773	} else if (TextAttribute.POSTURE_OBLIQUE.equals(value)) {
	774	count++;
	775	style \|= Font.ITALIC;
	776	}
	777	} else if (key == TextAttribute.SIZE) {
	778	if (value instanceof Number) {
	779	Number number = (Number) value;
	780	size = number.intValue();
	781	if (size == number.floatValue()) {
	782	count++;
	783	}
	784	}
	785	}
	786	}
	787	Class type = font.getClass();
	788	if (count == clone.size()) {
	789	return new Expression(font, type, "new", new Object[]{family, style, size});
	790	}
	791	if (type == Font.class) {
	792	return new Expression(font, type, "getFont", new Object[]{clone});
	793	}
	794	return new Expression(font, type, "new", new Object[]{Font.getFont(clone)});
	795	}
	796	}
	797
	798	/**
	799	* The persistence delegate for {@link AWTKeyStroke}.
	800	* It is impossible to use {@link DefaultPersistenceDelegate}
	801	* because this class have no public constructor.
	802	*
	803	* @author Sergey A. Malenkov
	804	*/
	805	final class java_awt_AWTKeyStroke_PersistenceDelegate extends PersistenceDelegate {
	806	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	807	return oldInstance.equals(newInstance);
	808	}
	809
	810	protected Expression instantiate(Object oldInstance, Encoder out) {
	811	AWTKeyStroke key = (AWTKeyStroke) oldInstance;
	812
	813	char ch = key.getKeyChar();
	814	int code = key.getKeyCode();
	815	int mask = key.getModifiers();
	816	boolean onKeyRelease = key.isOnKeyRelease();
	817
	818	Object[] args = null;
	819	if (ch == KeyEvent.CHAR_UNDEFINED) {
	820	args = !onKeyRelease
	821	? new Object[]{code, mask}
	822	: new Object[]{code, mask, onKeyRelease};
	823	} else if (code == KeyEvent.VK_UNDEFINED) {
	824	if (!onKeyRelease) {
	825	args = (mask == 0)
	826	? new Object[]{ch}
	827	: new Object[]{ch, mask};
	828	} else if (mask == 0) {
	829	args = new Object[]{ch, onKeyRelease};
	830	}
	831	}
	832	if (args == null) {
	833	throw new IllegalStateException("Unsupported KeyStroke: " + key);
	834	}
	835	Class type = key.getClass();
	836	String name = type.getName();
	837	// get short name of the class
	838	int index = name.lastIndexOf('.') + 1;
	839	if (index > 0) {
	840	name = name.substring(index);
	841	}
	842	return new Expression( key, type, "get" + name, args );
	843	}
	844	}
	845
	846	class StaticFieldsPersistenceDelegate extends PersistenceDelegate {
	847	protected void installFields(Encoder out, Class<?> cls) {
	848	Field fields[] = cls.getFields();
	849	for(int i = 0; i < fields.length; i++) {
	850	Field field = fields[i];
	851	// Don't install primitives, their identity will not be preserved
	852	// by wrapping.
	853	if (Object.class.isAssignableFrom(field.getType())) {
	854	out.writeExpression(new Expression(field, "get", new Object[]{null}));
	855	}
	856	}
	857	}
	858
	859	protected Expression instantiate(Object oldInstance, Encoder out) {
	860	throw new RuntimeException("Unrecognized instance: " + oldInstance);
	861	}
	862
	863	public void writeObject(Object oldInstance, Encoder out) {
	864	if (out.getAttribute(this) == null) {
	865	out.setAttribute(this, Boolean.TRUE);
	866	installFields(out, oldInstance.getClass());
	867	}
	868	super.writeObject(oldInstance, out);
	869	}
	870	}
	871
	872	// SystemColor
	873	class java_awt_SystemColor_PersistenceDelegate extends StaticFieldsPersistenceDelegate {}
	874
	875	// TextAttribute
	876	class java_awt_font_TextAttribute_PersistenceDelegate extends StaticFieldsPersistenceDelegate {}
	877
	878	// MenuShortcut
	879	class java_awt_MenuShortcut_PersistenceDelegate extends PersistenceDelegate {
	880	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	881	return oldInstance.equals(newInstance);
	882	}
	883
	884	protected Expression instantiate(Object oldInstance, Encoder out) {
	885	java.awt.MenuShortcut m = (java.awt.MenuShortcut)oldInstance;
	886	return new Expression(oldInstance, m.getClass(), "new",
	887	new Object[]{new Integer(m.getKey()), Boolean.valueOf(m.usesShiftModifier())});
	888	}
	889	}
	890
	891	// Component
	892	class java_awt_Component_PersistenceDelegate extends DefaultPersistenceDelegate {
	893	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	894	super.initialize(type, oldInstance, newInstance, out);
	895	java.awt.Component c = (java.awt.Component)oldInstance;
	896	java.awt.Component c2 = (java.awt.Component)newInstance;
	897	// The "background", "foreground" and "font" properties.
	898	// The foreground and font properties of Windows change from
	899	// null to defined values after the Windows are made visible -
	900	// special case them for now.
	901	if (!(oldInstance instanceof java.awt.Window)) {
	902	Object oldBackground = c.isBackgroundSet() ? c.getBackground() : null;
	903	Object newBackground = c2.isBackgroundSet() ? c2.getBackground() : null;
	904	if (!Objects.equals(oldBackground, newBackground)) {
	905	invokeStatement(oldInstance, "setBackground", new Object[] { oldBackground }, out);
	906	}
	907	Object oldForeground = c.isForegroundSet() ? c.getForeground() : null;
	908	Object newForeground = c2.isForegroundSet() ? c2.getForeground() : null;
	909	if (!Objects.equals(oldForeground, newForeground)) {
	910	invokeStatement(oldInstance, "setForeground", new Object[] { oldForeground }, out);
	911	}
	912	Object oldFont = c.isFontSet() ? c.getFont() : null;
	913	Object newFont = c2.isFontSet() ? c2.getFont() : null;
	914	if (!Objects.equals(oldFont, newFont)) {
	915	invokeStatement(oldInstance, "setFont", new Object[] { oldFont }, out);
	916	}
	917	}
	918
	919	// Bounds
	920	java.awt.Container p = c.getParent();
	921	if (p == null \|\| p.getLayout() == null) {
	922	// Use the most concise construct.
	923	boolean locationCorrect = c.getLocation().equals(c2.getLocation());
	924	boolean sizeCorrect = c.getSize().equals(c2.getSize());
	925	if (!locationCorrect && !sizeCorrect) {
	926	invokeStatement(oldInstance, "setBounds", new Object[]{c.getBounds()}, out);
	927	}
	928	else if (!locationCorrect) {
	929	invokeStatement(oldInstance, "setLocation", new Object[]{c.getLocation()}, out);
	930	}
	931	else if (!sizeCorrect) {
	932	invokeStatement(oldInstance, "setSize", new Object[]{c.getSize()}, out);
	933	}
	934	}
	935	}
	936	}
	937
	938	// Container
	939	class java_awt_Container_PersistenceDelegate extends DefaultPersistenceDelegate {
	940	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	941	super.initialize(type, oldInstance, newInstance, out);
	942	// Ignore the children of a JScrollPane.
	943	// Pending(milne) find a better way to do this.
	944	if (oldInstance instanceof javax.swing.JScrollPane) {
	945	return;
	946	}
	947	java.awt.Container oldC = (java.awt.Container)oldInstance;
	948	java.awt.Component[] oldChildren = oldC.getComponents();
	949	java.awt.Container newC = (java.awt.Container)newInstance;
	950	java.awt.Component[] newChildren = (newC == null) ? new java.awt.Component[0] : newC.getComponents();
	951
	952	BorderLayout layout = ( oldC.getLayout() instanceof BorderLayout )
	953	? ( BorderLayout )oldC.getLayout()
	954	: null;
	955
	956	JLayeredPane oldLayeredPane = (oldInstance instanceof JLayeredPane)
	957	? (JLayeredPane) oldInstance
	958	: null;
	959
	960	// Pending. Assume all the new children are unaltered.
	961	for(int i = newChildren.length; i < oldChildren.length; i++) {
	962	Object[] args = ( layout != null )
	963	? new Object[] {oldChildren[i], layout.getConstraints( oldChildren[i] )}
	964	: (oldLayeredPane != null)
	965	? new Object[] {oldChildren[i], oldLayeredPane.getLayer(oldChildren[i]), Integer.valueOf(-1)}
	966	: new Object[] {oldChildren[i]};
	967
	968	invokeStatement(oldInstance, "add", args, out);
	969	}
	970	}
	971	}
	972
	973	// Choice
	974	class java_awt_Choice_PersistenceDelegate extends DefaultPersistenceDelegate {
	975	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	976	super.initialize(type, oldInstance, newInstance, out);
	977	java.awt.Choice m = (java.awt.Choice)oldInstance;
	978	java.awt.Choice n = (java.awt.Choice)newInstance;
	979	for (int i = n.getItemCount(); i < m.getItemCount(); i++) {
	980	invokeStatement(oldInstance, "add", new Object[]{m.getItem(i)}, out);
	981	}
	982	}
	983	}
	984
	985	// Menu
	986	class java_awt_Menu_PersistenceDelegate extends DefaultPersistenceDelegate {
	987	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	988	super.initialize(type, oldInstance, newInstance, out);
	989	java.awt.Menu m = (java.awt.Menu)oldInstance;
	990	java.awt.Menu n = (java.awt.Menu)newInstance;
	991	for (int i = n.getItemCount(); i < m.getItemCount(); i++) {
	992	invokeStatement(oldInstance, "add", new Object[]{m.getItem(i)}, out);
	993	}
	994	}
	995	}
	996
	997	// MenuBar
	998	class java_awt_MenuBar_PersistenceDelegate extends DefaultPersistenceDelegate {
	999	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	1000	super.initialize(type, oldInstance, newInstance, out);
	1001	java.awt.MenuBar m = (java.awt.MenuBar)oldInstance;
	1002	java.awt.MenuBar n = (java.awt.MenuBar)newInstance;
	1003	for (int i = n.getMenuCount(); i < m.getMenuCount(); i++) {
	1004	invokeStatement(oldInstance, "add", new Object[]{m.getMenu(i)}, out);
	1005	}
	1006	}
	1007	}
	1008
	1009	// List
	1010	class java_awt_List_PersistenceDelegate extends DefaultPersistenceDelegate {
	1011	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	1012	super.initialize(type, oldInstance, newInstance, out);
	1013	java.awt.List m = (java.awt.List)oldInstance;
	1014	java.awt.List n = (java.awt.List)newInstance;
	1015	for (int i = n.getItemCount(); i < m.getItemCount(); i++) {
	1016	invokeStatement(oldInstance, "add", new Object[]{m.getItem(i)}, out);
	1017	}
	1018	}
	1019	}
	1020
	1021
	1022	// LayoutManagers
	1023
	1024	// BorderLayout
	1025	class java_awt_BorderLayout_PersistenceDelegate extends DefaultPersistenceDelegate {
	1026	private static final String[] CONSTRAINTS = {
	1027	BorderLayout.NORTH,
	1028	BorderLayout.SOUTH,
	1029	BorderLayout.EAST,
	1030	BorderLayout.WEST,
	1031	BorderLayout.CENTER,
	1032	BorderLayout.PAGE_START,
	1033	BorderLayout.PAGE_END,
	1034	BorderLayout.LINE_START,
	1035	BorderLayout.LINE_END,
	1036	};
	1037	@Override
	1038	protected void initialize(Class<?> type, Object oldInstance,
	1039	Object newInstance, Encoder out) {
	1040	super.initialize(type, oldInstance, newInstance, out);
	1041	BorderLayout oldLayout = (BorderLayout) oldInstance;
	1042	BorderLayout newLayout = (BorderLayout) newInstance;
	1043	for (String constraints : CONSTRAINTS) {
	1044	Object oldC = oldLayout.getLayoutComponent(constraints);
	1045	Object newC = newLayout.getLayoutComponent(constraints);
	1046	// Pending, assume any existing elements are OK.
	1047	if (oldC != null && newC == null) {
	1048	invokeStatement(oldInstance, "addLayoutComponent",
	1049	new Object[] { oldC, constraints }, out);
	1050	}
	1051	}
	1052	}
	1053	}
	1054
	1055	// CardLayout
	1056	class java_awt_CardLayout_PersistenceDelegate extends DefaultPersistenceDelegate {
	1057	protected void initialize(Class<?> type, Object oldInstance,
	1058	Object newInstance, Encoder out) {
	1059	super.initialize(type, oldInstance, newInstance, out);
	1060	Hashtable tab = (Hashtable)ReflectionUtils.getPrivateField(oldInstance,
	1061	java.awt.CardLayout.class,
	1062	"tab",
	1063	out.getExceptionListener());
	1064	if (tab != null) {
	1065	for(Enumeration e = tab.keys(); e.hasMoreElements();) {
	1066	Object child = e.nextElement();
	1067	invokeStatement(oldInstance, "addLayoutComponent",
	1068	new Object[]{child, (String)tab.get(child)}, out);
	1069	}
	1070	}
	1071	}
	1072	}
	1073
	1074	// GridBagLayout
	1075	class java_awt_GridBagLayout_PersistenceDelegate extends DefaultPersistenceDelegate {
	1076	protected void initialize(Class<?> type, Object oldInstance,
	1077	Object newInstance, Encoder out) {
	1078	super.initialize(type, oldInstance, newInstance, out);
	1079	Hashtable comptable = (Hashtable)ReflectionUtils.getPrivateField(oldInstance,
	1080	java.awt.GridBagLayout.class,
	1081	"comptable",
	1082	out.getExceptionListener());
	1083	if (comptable != null) {
	1084	for(Enumeration e = comptable.keys(); e.hasMoreElements();) {
	1085	Object child = e.nextElement();
	1086	invokeStatement(oldInstance, "addLayoutComponent",
	1087	new Object[]{child, comptable.get(child)}, out);
	1088	}
	1089	}
	1090	}
	1091	}
	1092
	1093	// Swing
	1094
	1095	// JFrame (If we do this for Window instead of JFrame, the setVisible call
	1096	// will be issued before we have added all the children to the JFrame and
	1097	// will appear blank).
	1098	class javax_swing_JFrame_PersistenceDelegate extends DefaultPersistenceDelegate {
	1099	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	1100	super.initialize(type, oldInstance, newInstance, out);
	1101	java.awt.Window oldC = (java.awt.Window)oldInstance;
	1102	java.awt.Window newC = (java.awt.Window)newInstance;
	1103	boolean oldV = oldC.isVisible();
	1104	boolean newV = newC.isVisible();
	1105	if (newV != oldV) {
	1106	// false means: don't execute this statement at write time.
	1107	boolean executeStatements = out.executeStatements;
	1108	out.executeStatements = false;
	1109	invokeStatement(oldInstance, "setVisible", new Object[]{Boolean.valueOf(oldV)}, out);
	1110	out.executeStatements = executeStatements;
	1111	}
	1112	}
	1113	}
	1114
	1115	// Models
	1116
	1117	// DefaultListModel
	1118	class javax_swing_DefaultListModel_PersistenceDelegate extends DefaultPersistenceDelegate {
	1119	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	1120	// Note, the "size" property will be set here.
	1121	super.initialize(type, oldInstance, newInstance, out);
	1122	javax.swing.DefaultListModel m = (javax.swing.DefaultListModel)oldInstance;
	1123	javax.swing.DefaultListModel n = (javax.swing.DefaultListModel)newInstance;
	1124	for (int i = n.getSize(); i < m.getSize(); i++) {
	1125	invokeStatement(oldInstance, "add", // Can also use "addElement".
	1126	new Object[]{m.getElementAt(i)}, out);
	1127	}
	1128	}
	1129	}
	1130
	1131	// DefaultComboBoxModel
	1132	class javax_swing_DefaultComboBoxModel_PersistenceDelegate extends DefaultPersistenceDelegate {
	1133	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	1134	super.initialize(type, oldInstance, newInstance, out);
	1135	javax.swing.DefaultComboBoxModel m = (javax.swing.DefaultComboBoxModel)oldInstance;
	1136	for (int i = 0; i < m.getSize(); i++) {
	1137	invokeStatement(oldInstance, "addElement", new Object[]{m.getElementAt(i)}, out);
	1138	}
	1139	}
	1140	}
	1141
	1142
	1143	// DefaultMutableTreeNode
	1144	class javax_swing_tree_DefaultMutableTreeNode_PersistenceDelegate extends DefaultPersistenceDelegate {
	1145	protected void initialize(Class<?> type, Object oldInstance, Object
	1146	newInstance, Encoder out) {
	1147	super.initialize(type, oldInstance, newInstance, out);
	1148	javax.swing.tree.DefaultMutableTreeNode m =
	1149	(javax.swing.tree.DefaultMutableTreeNode)oldInstance;
	1150	javax.swing.tree.DefaultMutableTreeNode n =
	1151	(javax.swing.tree.DefaultMutableTreeNode)newInstance;
	1152	for (int i = n.getChildCount(); i < m.getChildCount(); i++) {
	1153	invokeStatement(oldInstance, "add", new
	1154	Object[]{m.getChildAt(i)}, out);
	1155	}
	1156	}
	1157	}
	1158
	1159	// ToolTipManager
	1160	class javax_swing_ToolTipManager_PersistenceDelegate extends PersistenceDelegate {
	1161	protected Expression instantiate(Object oldInstance, Encoder out) {
	1162	return new Expression(oldInstance, javax.swing.ToolTipManager.class,
	1163	"sharedInstance", new Object[]{});
	1164	}
	1165	}
	1166
	1167	// JTabbedPane
	1168	class javax_swing_JTabbedPane_PersistenceDelegate extends DefaultPersistenceDelegate {
	1169	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	1170	super.initialize(type, oldInstance, newInstance, out);
	1171	javax.swing.JTabbedPane p = (javax.swing.JTabbedPane)oldInstance;
	1172	for (int i = 0; i < p.getTabCount(); i++) {
	1173	invokeStatement(oldInstance, "addTab",
	1174	new Object[]{
	1175	p.getTitleAt(i),
	1176	p.getIconAt(i),
	1177	p.getComponentAt(i)}, out);
	1178	}
	1179	}
	1180	}
	1181
	1182	// Box
	1183	class javax_swing_Box_PersistenceDelegate extends DefaultPersistenceDelegate {
	1184	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	1185	return super.mutatesTo(oldInstance, newInstance) && getAxis(oldInstance).equals(getAxis(newInstance));
	1186	}
	1187
	1188	protected Expression instantiate(Object oldInstance, Encoder out) {
	1189	return new Expression(oldInstance, oldInstance.getClass(), "new", new Object[] {getAxis(oldInstance)});
	1190	}
	1191
	1192	private Integer getAxis(Object object) {
	1193	Box box = (Box) object;
	1194	return (Integer) MetaData.getPrivateFieldValue(box.getLayout(), "javax.swing.BoxLayout.axis");
	1195	}
	1196	}
	1197
	1198	// JMenu
	1199	// Note that we do not need to state the initialiser for
	1200	// JMenuItems since the getComponents() method defined in
	1201	// Container will return all of the sub menu items that
	1202	// need to be added to the menu item.
	1203	// Not so for JMenu apparently.
	1204	class javax_swing_JMenu_PersistenceDelegate extends DefaultPersistenceDelegate {
	1205	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	1206	super.initialize(type, oldInstance, newInstance, out);
	1207	javax.swing.JMenu m = (javax.swing.JMenu)oldInstance;
	1208	java.awt.Component[] c = m.getMenuComponents();
	1209	for (int i = 0; i < c.length; i++) {
	1210	invokeStatement(oldInstance, "add", new Object[]{c[i]}, out);
	1211	}
	1212	}
	1213	}
	1214
	1215	/**
	1216	* The persistence delegate for {@link MatteBorder}.
	1217	* It is impossible to use {@link DefaultPersistenceDelegate}
	1218	* because this class does not have writable properties.
	1219	*
	1220	* @author Sergey A. Malenkov
	1221	*/
	1222	final class javax_swing_border_MatteBorder_PersistenceDelegate extends PersistenceDelegate {
	1223	protected Expression instantiate(Object oldInstance, Encoder out) {
	1224	MatteBorder border = (MatteBorder) oldInstance;
	1225	Insets insets = border.getBorderInsets();
	1226	Object object = border.getTileIcon();
	1227	if (object == null) {
	1228	object = border.getMatteColor();
	1229	}
	1230	Object[] args = new Object[] {
	1231	insets.top,
	1232	insets.left,
	1233	insets.bottom,
	1234	insets.right,
	1235	object,
	1236	};
	1237	return new Expression(border, border.getClass(), "new", args);
	1238	}
	1239	}
	1240
	1241	/* XXX - doens't seem to work. Debug later.
	1242	class javax_swing_JMenu_PersistenceDelegate extends DefaultPersistenceDelegate {
	1243	protected void initialize(Class<?> type, Object oldInstance, Object newInstance, Encoder out) {
	1244	super.initialize(type, oldInstance, newInstance, out);
	1245	javax.swing.JMenu m = (javax.swing.JMenu)oldInstance;
	1246	javax.swing.JMenu n = (javax.swing.JMenu)newInstance;
	1247	for (int i = n.getItemCount(); i < m.getItemCount(); i++) {
	1248	invokeStatement(oldInstance, "add", new Object[]{m.getItem(i)}, out);
	1249	}
	1250	}
	1251	}
	1252	*/
	1253
	1254	/**
	1255	* The persistence delegate for {@link PrintColorUIResource}.
	1256	* It is impossible to use {@link DefaultPersistenceDelegate}
	1257	* because this class has special rule for serialization:
	1258	* it should be converted to {@link ColorUIResource}.
	1259	*
	1260	* @see PrintColorUIResource#writeReplace
	1261	*
	1262	* @author Sergey A. Malenkov
	1263	*/
	1264	final class sun_swing_PrintColorUIResource_PersistenceDelegate extends PersistenceDelegate {
	1265	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	1266	return oldInstance.equals(newInstance);
	1267	}
	1268
	1269	protected Expression instantiate(Object oldInstance, Encoder out) {
	1270	Color color = (Color) oldInstance;
	1271	Object[] args = new Object[] {color.getRGB()};
	1272	return new Expression(color, ColorUIResource.class, "new", args);
	1273	}
	1274	}
	1275
	1276	class MetaData {
	1277	private static final Map<String,Field> fields = Collections.synchronizedMap(new WeakHashMap<String, Field>());
	1278	private static Hashtable internalPersistenceDelegates = new Hashtable();
	1279
	1280	private static PersistenceDelegate nullPersistenceDelegate = new NullPersistenceDelegate();
	1281	private static PersistenceDelegate enumPersistenceDelegate = new EnumPersistenceDelegate();
	1282	private static PersistenceDelegate primitivePersistenceDelegate = new PrimitivePersistenceDelegate();
	1283	private static PersistenceDelegate defaultPersistenceDelegate = new DefaultPersistenceDelegate();
	1284	private static PersistenceDelegate arrayPersistenceDelegate;
	1285	private static PersistenceDelegate proxyPersistenceDelegate;
	1286
	1287	static {
	1288
	1289	internalPersistenceDelegates.put("java.net.URI",
	1290	new PrimitivePersistenceDelegate());
	1291
	1292	// it is possible because MatteBorder is assignable from MatteBorderUIResource
	1293	internalPersistenceDelegates.put("javax.swing.plaf.BorderUIResource$MatteBorderUIResource",
	1294	new javax_swing_border_MatteBorder_PersistenceDelegate());
	1295
	1296	// it is possible because FontUIResource is supported by java_awt_Font_PersistenceDelegate
	1297	internalPersistenceDelegates.put("javax.swing.plaf.FontUIResource",
	1298	new java_awt_Font_PersistenceDelegate());
	1299
	1300	// it is possible because KeyStroke is supported by java_awt_AWTKeyStroke_PersistenceDelegate
	1301	internalPersistenceDelegates.put("javax.swing.KeyStroke",
	1302	new java_awt_AWTKeyStroke_PersistenceDelegate());
	1303
	1304	internalPersistenceDelegates.put("java.sql.Date", new java_util_Date_PersistenceDelegate());
	1305	internalPersistenceDelegates.put("java.sql.Time", new java_util_Date_PersistenceDelegate());
	1306
	1307	internalPersistenceDelegates.put("java.util.JumboEnumSet", new java_util_EnumSet_PersistenceDelegate());
	1308	internalPersistenceDelegates.put("java.util.RegularEnumSet", new java_util_EnumSet_PersistenceDelegate());
	1309	}
	1310
	1311	public synchronized static PersistenceDelegate getPersistenceDelegate(Class type) {
	1312	if (type == null) {
	1313	return nullPersistenceDelegate;
	1314	}
	1315	if (Enum.class.isAssignableFrom(type)) {
	1316	return enumPersistenceDelegate;
	1317	}
	1318	if (ReflectionUtils.isPrimitive(type)) {
	1319	return primitivePersistenceDelegate;
	1320	}
	1321	// The persistence delegate for arrays is non-trivial; instantiate it lazily.
	1322	if (type.isArray()) {
	1323	if (arrayPersistenceDelegate == null) {
	1324	arrayPersistenceDelegate = new ArrayPersistenceDelegate();
	1325	}
	1326	return arrayPersistenceDelegate;
	1327	}
	1328	// Handle proxies lazily for backward compatibility with 1.2.
	1329	try {
	1330	if (java.lang.reflect.Proxy.isProxyClass(type)) {
	1331	if (proxyPersistenceDelegate == null) {
	1332	proxyPersistenceDelegate = new ProxyPersistenceDelegate();
	1333	}
	1334	return proxyPersistenceDelegate;
	1335	}
	1336	}
	1337	catch(Exception e) {}
	1338	// else if (type.getDeclaringClass() != null) {
	1339	// return new DefaultPersistenceDelegate(new String[]{"this$0"});
	1340	// }
	1341
	1342	String typeName = type.getName();
	1343	PersistenceDelegate pd = (PersistenceDelegate)getBeanAttribute(type, "persistenceDelegate");
	1344	if (pd == null) {
	1345	pd = (PersistenceDelegate)internalPersistenceDelegates.get(typeName);
	1346	if (pd != null) {
	1347	return pd;
	1348	}
	1349	internalPersistenceDelegates.put(typeName, defaultPersistenceDelegate);
	1350	try {
	1351	String name = type.getName();
	1352	Class c = Class.forName("java.beans." + name.replace('.', '_')
	1353	+ "_PersistenceDelegate");
	1354	pd = (PersistenceDelegate)c.newInstance();
	1355	internalPersistenceDelegates.put(typeName, pd);
	1356	}
	1357	catch (ClassNotFoundException e) {
	1358	String[] properties = getConstructorProperties(type);
	1359	if (properties != null) {
	1360	pd = new DefaultPersistenceDelegate(properties);
	1361	internalPersistenceDelegates.put(typeName, pd);
	1362	}
	1363	}
	1364	catch (Exception e) {
	1365	System.err.println("Internal error: " + e);
	1366	}
	1367	}
	1368
	1369	return (pd != null) ? pd : defaultPersistenceDelegate;
	1370	}
	1371
	1372	private static String[] getConstructorProperties(Class type) {
	1373	String[] names = null;
	1374	int length = 0;
	1375	for (Constructor<?> constructor : type.getConstructors()) {
	1376	String[] value = getAnnotationValue(constructor);
	1377	if ((value != null) && (length < value.length) && isValid(constructor, value)) {
	1378	names = value;
	1379	length = value.length;
	1380	}
	1381	}
	1382	return names;
	1383	}
	1384
	1385	private static String[] getAnnotationValue(Constructor<?> constructor) {
	1386	ConstructorProperties annotation = constructor.getAnnotation(ConstructorProperties.class);
	1387	return (annotation != null)
	1388	? annotation.value()
	1389	: null;
	1390	}
	1391
	1392	private static boolean isValid(Constructor<?> constructor, String[] names) {
	1393	Class[] parameters = constructor.getParameterTypes();
	1394	if (names.length != parameters.length) {
	1395	return false;
	1396	}
	1397	for (String name : names) {
	1398	if (name == null) {
	1399	return false;
	1400	}
	1401	}
	1402	return true;
	1403	}
	1404
	1405	private static Object getBeanAttribute(Class type, String attribute) {
	1406	try {
	1407	return Introspector.getBeanInfo(type).getBeanDescriptor().getValue(attribute);
	1408	} catch (IntrospectionException exception) {
	1409	return null;
	1410	}
	1411	}
	1412
	1413	static Object getPrivateFieldValue(Object instance, String name) {
	1414	Field field = fields.get(name);
	1415	if (field == null) {
	1416	int index = name.lastIndexOf('.');
	1417	final String className = name.substring(0, index);
	1418	final String fieldName = name.substring(1 + index);
	1419	field = AccessController.doPrivileged(new PrivilegedAction<Field>() {
	1420	public Field run() {
	1421	try {
	1422	Field field = Class.forName(className).getDeclaredField(fieldName);
	1423	field.setAccessible(true);
	1424	return field;
	1425	}
	1426	catch (ClassNotFoundException exception) {
	1427	throw new IllegalStateException("Could not find class", exception);
	1428	}
	1429	catch (NoSuchFieldException exception) {
	1430	throw new IllegalStateException("Could not find field", exception);
	1431	}
	1432	}
	1433	});
	1434	fields.put(name, field);
	1435	}
	1436	try {
	1437	return field.get(instance);
	1438	}
	1439	catch (IllegalAccessException exception) {
	1440	throw new IllegalStateException("Could not get value of the field", exception);
	1441	}
	1442	}
	1443	}

java/pkg/java/beans/MethodDescriptor.class+0−0

Binary file not shown.

java/pkg/java/beans/MethodDescriptor.java+228−0

@@ -0,0 +1,228 @@
	1	/*
	2	* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.lang.ref.Reference;
	29	import java.lang.ref.WeakReference;
	30	import java.lang.reflect.Method;
	31	import java.util.List;
	32	import java.util.ArrayList;
	33
	34	/**
	35	* A MethodDescriptor describes a particular method that a Java Bean
	36	* supports for external access from other components.
	37	*/
	38
	39	public class MethodDescriptor extends FeatureDescriptor {
	40
	41	private Reference<Method> methodRef;
	42
	43	private String[] paramNames;
	44
	45	private List params;
	46
	47	private ParameterDescriptor parameterDescriptors[];
	48
	49	/**
	50	* Constructs a <code>MethodDescriptor</code> from a
	51	* <code>Method</code>.
	52	*
	53	* @param method The low-level method information.
	54	*/
	55	public MethodDescriptor(Method method) {
	56	this(method, null);
	57	}
	58
	59
	60	/**
	61	* Constructs a <code>MethodDescriptor</code> from a
	62	* <code>Method</code> providing descriptive information for each
	63	* of the method's parameters.
	64	*
	65	* @param method The low-level method information.
	66	* @param parameterDescriptors Descriptive information for each of the
	67	* method's parameters.
	68	*/
	69	public MethodDescriptor(Method method,
	70	ParameterDescriptor parameterDescriptors[]) {
	71	setName(method.getName());
	72	setMethod(method);
	73	this.parameterDescriptors = parameterDescriptors;
	74	}
	75
	76	/**
	77	* Gets the method that this MethodDescriptor encapsualtes.
	78	*
	79	* @return The low-level description of the method
	80	*/
	81	public synchronized Method getMethod() {
	82	Method method = getMethod0();
	83	if (method == null) {
	84	Class cls = getClass0();
	85	String name = getName();
	86	if ((cls != null) && (name != null)) {
	87	Class[] params = getParams();
	88	if (params == null) {
	89	for (int i = 0; i < 3; i++) {
	90	// Find methods for up to 2 params. We are guessing here.
	91	// This block should never execute unless the classloader
	92	// that loaded the argument classes disappears.
	93	method = Introspector.findMethod(cls, name, i, null);
	94	if (method != null) {
	95	break;
	96	}
	97	}
	98	} else {
	99	method = Introspector.findMethod(cls, name, params.length, params);
	100	}
	101	setMethod(method);
	102	}
	103	}
	104	return method;
	105	}
	106
	107	private synchronized void setMethod(Method method) {
	108	if (method == null) {
	109	return;
	110	}
	111	if (getClass0() == null) {
	112	setClass0(method.getDeclaringClass());
	113	}
	114	setParams(getParameterTypes(getClass0(), method));
	115	this.methodRef = getSoftReference(method);
	116	}
	117
	118	private Method getMethod0() {
	119	return (this.methodRef != null)
	120	? this.methodRef.get()
	121	: null;
	122	}
	123
	124	private synchronized void setParams(Class[] param) {
	125	if (param == null) {
	126	return;
	127	}
	128	paramNames = new String[param.length];
	129	params = new ArrayList(param.length);
	130	for (int i = 0; i < param.length; i++) {
	131	paramNames[i] = param[i].getName();
	132	params.add(new WeakReference(param[i]));
	133	}
	134	}
	135
	136	// pp getParamNames used as an optimization to avoid method.getParameterTypes.
	137	String[] getParamNames() {
	138	return paramNames;
	139	}
	140
	141	private synchronized Class[] getParams() {
	142	Class[] clss = new Class[params.size()];
	143
	144	for (int i = 0; i < params.size(); i++) {
	145	Reference ref = (Reference)params.get(i);
	146	Class cls = (Class)ref.get();
	147	if (cls == null) {
	148	return null;
	149	} else {
	150	clss[i] = cls;
	151	}
	152	}
	153	return clss;
	154	}
	155
	156	/**
	157	* Gets the ParameterDescriptor for each of this MethodDescriptor's
	158	* method's parameters.
	159	*
	160	* @return The locale-independent names of the parameters. May return
	161	* a null array if the parameter names aren't known.
	162	*/
	163	public ParameterDescriptor[] getParameterDescriptors() {
	164	return parameterDescriptors;
	165	}
	166
	167	/*
	168	* Package-private constructor
	169	* Merge two method descriptors. Where they conflict, give the
	170	* second argument (y) priority over the first argument (x).
	171	* @param x The first (lower priority) MethodDescriptor
	172	* @param y The second (higher priority) MethodDescriptor
	173	*/
	174
	175	MethodDescriptor(MethodDescriptor x, MethodDescriptor y) {
	176	super(x,y);
	177
	178	methodRef = x.methodRef;
	179	if (y.methodRef != null) {
	180	methodRef = y.methodRef;
	181	}
	182	params = x.params;
	183	if (y.params != null) {
	184	params = y.params;
	185	}
	186	paramNames = x.paramNames;
	187	if (y.paramNames != null) {
	188	paramNames = y.paramNames;
	189	}
	190
	191	parameterDescriptors = x.parameterDescriptors;
	192	if (y.parameterDescriptors != null) {
	193	parameterDescriptors = y.parameterDescriptors;
	194	}
	195	}
	196
	197	/*
	198	* Package-private dup constructor
	199	* This must isolate the new object from any changes to the old object.
	200	*/
	201	MethodDescriptor(MethodDescriptor old) {
	202	super(old);
	203
	204	methodRef = old.methodRef;
	205	params = old.params;
	206	paramNames = old.paramNames;
	207
	208	if (old.parameterDescriptors != null) {
	209	int len = old.parameterDescriptors.length;
	210	parameterDescriptors = new ParameterDescriptor[len];
	211	for (int i = 0; i < len ; i++) {
	212	parameterDescriptors[i] = new ParameterDescriptor(old.parameterDescriptors[i]);
	213	}
	214	}
	215	}
	216
	217	void appendTo(StringBuilder sb) {
	218	appendTo(sb, "method", this.methodRef);
	219	if (this.parameterDescriptors != null) {
	220	sb.append("; parameterDescriptors={");
	221	for (ParameterDescriptor pd : this.parameterDescriptors) {
	222	sb.append(pd).append(", ");
	223	}
	224	sb.setLength(sb.length() - 2);
	225	sb.append("}");
	226	}
	227	}
	228	}

java/pkg/java/beans/NameGenerator.class+0−0

Binary file not shown.

java/pkg/java/beans/NameGenerator.java+116−0

@@ -0,0 +1,116 @@
	1	/*
	2	* Copyright (c) 2000, 2005, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import java.util.HashMap;
	28	import java.util.IdentityHashMap;
	29	import java.util.Map;
	30
	31	import static java.util.Locale.ENGLISH;
	32
	33	/**
	34	* A utility class which generates unique names for object instances.
	35	* The name will be a concatenation of the unqualified class name
	36	* and an instance number.
	37	* <p>
	38	* For example, if the first object instance javax.swing.JButton
	39	* is passed into <code>instanceName</code> then the returned
	40	* string identifier will be "JButton0".
	41	*
	42	* @author Philip Milne
	43	*/
	44	class NameGenerator {
	45
	46	private Map valueToName;
	47	private Map nameToCount;
	48
	49	public NameGenerator() {
	50	valueToName = new IdentityHashMap();
	51	nameToCount = new HashMap();
	52	}
	53
	54	/**
	55	* Clears the name cache. Should be called to near the end of
	56	* the encoding cycle.
	57	*/
	58	public void clear() {
	59	valueToName.clear();
	60	nameToCount.clear();
	61	}
	62
	63	/**
	64	* Returns the root name of the class.
	65	*/
	66	public static String unqualifiedClassName(Class type) {
	67	if (type.isArray()) {
	68	return unqualifiedClassName(type.getComponentType())+"Array";
	69	}
	70	String name = type.getName();
	71	return name.substring(name.lastIndexOf('.')+1);
	72	}
	73
	74	/**
	75	* Returns a String which capitalizes the first letter of the string.
	76	*/
	77	public static String capitalize(String name) {
	78	if (name == null \|\| name.length() == 0) {
	79	return name;
	80	}
	81	return name.substring(0, 1).toUpperCase(ENGLISH) + name.substring(1);
	82	}
	83
	84	/**
	85	* Returns a unique string which identifies the object instance.
	86	* Invocations are cached so that if an object has been previously
	87	* passed into this method then the same identifier is returned.
	88	*
	89	* @param instance object used to generate string
	90	* @return a unique string representing the object
	91	*/
	92	public String instanceName(Object instance) {
	93	if (instance == null) {
	94	return "null";
	95	}
	96	if (instance instanceof Class) {
	97	return unqualifiedClassName((Class)instance);
	98	}
	99	else {
	100	String result = (String)valueToName.get(instance);
	101	if (result != null) {
	102	return result;
	103	}
	104	Class type = instance.getClass();
	105	String className = unqualifiedClassName(type);
	106
	107	Object size = nameToCount.get(className);
	108	int instanceNumber = (size == null) ? 0 : ((Integer)size).intValue() + 1;
	109	nameToCount.put(className, new Integer(instanceNumber));
	110
	111	result = className + instanceNumber;
	112	valueToName.put(instance, result);
	113	return result;
	114	}
	115	}
	116	}

java/pkg/java/beans/NullPersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/ObjectInputStreamWithLoader.class+0−0

Binary file not shown.

java/pkg/java/beans/ParameterDescriptor.class+0−0

Binary file not shown.

java/pkg/java/beans/ParameterDescriptor.java+53−0

@@ -0,0 +1,53 @@
	1	/*
	2	* Copyright (c) 1996, 1997, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* The ParameterDescriptor class allows bean implementors to provide
	30	* additional information on each of their parameters, beyond the
	31	* low level type information provided by the java.lang.reflect.Method
	32	* class.
	33	* <p>
	34	* Currently all our state comes from the FeatureDescriptor base class.
	35	*/
	36
	37	public class ParameterDescriptor extends FeatureDescriptor {
	38
	39	/**
	40	* Public default constructor.
	41	*/
	42	public ParameterDescriptor() {
	43	}
	44
	45	/**
	46	* Package private dup constructor.
	47	* This must isolate the new object from any changes to the old object.
	48	*/
	49	ParameterDescriptor(ParameterDescriptor old) {
	50	super(old);
	51	}
	52
	53	}

java/pkg/java/beans/PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/PersistenceDelegate.java+214−0

@@ -0,0 +1,214 @@
	1	/*
	2	* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	/**
	28	* The PersistenceDelegate class takes the responsibility
	29	* for expressing the state of an instance of a given class
	30	* in terms of the methods in the class's public API. Instead
	31	* of associating the responsibility of persistence with
	32	* the class itself as is done, for example, by the
	33	* <code>readObject</code> and <code>writeObject</code>
	34	* methods used by the <code>ObjectOutputStream</code>, streams like
	35	* the <code>XMLEncoder</code> which
	36	* use this delegation model can have their behavior controlled
	37	* independently of the classes themselves. Normally, the class
	38	* is the best place to put such information and conventions
	39	* can easily be expressed in this delegation scheme to do just that.
	40	* Sometimes however, it is the case that a minor problem
	41	* in a single class prevents an entire object graph from
	42	* being written and this can leave the application
	43	* developer with no recourse but to attempt to shadow
	44	* the problematic classes locally or use alternative
	45	* persistence techniques. In situations like these, the
	46	* delegation model gives a relatively clean mechanism for
	47	* the application developer to intervene in all parts of the
	48	* serialization process without requiring that modifications
	49	* be made to the implementation of classes which are not part
	50	* of the application itself.
	51	* <p>
	52	* In addition to using a delegation model, this persistence
	53	* scheme differs from traditional serialization schemes
	54	* in requiring an analog of the <code>writeObject</code>
	55	* method without a corresponding <code>readObject</code>
	56	* method. The <code>writeObject</code> analog encodes each
	57	* instance in terms of its public API and there is no need to
	58	* define a <code>readObject</code> analog
	59	* since the procedure for reading the serialized form
	60	* is defined by the semantics of method invocation as laid
	61	* out in the Java Language Specification.
	62	* Breaking the dependency between <code>writeObject</code>
	63	* and <code>readObject</code> implementations, which may
	64	* change from version to version, is the key factor
	65	* in making the archives produced by this technique immune
	66	* to changes in the private implementations of the classes
	67	* to which they refer.
	68	* <p>
	69	* A persistence delegate, may take control of all
	70	* aspects of the persistence of an object including:
	71	* <ul>
	72	* <li>
	73	* Deciding whether or not an instance can be mutated
	74	* into another instance of the same class.
	75	* <li>
	76	* Instantiating the object, either by calling a
	77	* public constructor or a public factory method.
	78	* <li>
	79	* Performing the initialization of the object.
	80	* </ul>
	81	* @see XMLEncoder
	82	*
	83	* @since 1.4
	84	*
	85	* @author Philip Milne
	86	*/
	87
	88	public abstract class PersistenceDelegate {
	89
	90	/**
	91	* The <code>writeObject</code> is a single entry point to the persistence
	92	* and is used by a <code>Encoder</code> in the traditional
	93	* mode of delegation. Although this method is not final,
	94	* it should not need to be subclassed under normal circumstances.
	95	* <p>
	96	* This implementation first checks to see if the stream
	97	* has already encountered this object. Next the
	98	* <code>mutatesTo</code> method is called to see if
	99	* that candidate returned from the stream can
	100	* be mutated into an accurate copy of <code>oldInstance</code>.
	101	* If it can, the <code>initialize</code> method is called to
	102	* perform the initialization. If not, the candidate is removed
	103	* from the stream, and the <code>instantiate</code> method
	104	* is called to create a new candidate for this object.
	105	*
	106	* @param oldInstance The instance that will be created by this expression.
	107	* @param out The stream to which this expression will be written.
	108	*
	109	* @throws NullPointerException if {@code out} is {@code null}
	110	*/
	111	public void writeObject(Object oldInstance, Encoder out) {
	112	Object newInstance = out.get(oldInstance);
	113	if (!mutatesTo(oldInstance, newInstance)) {
	114	out.remove(oldInstance);
	115	out.writeExpression(instantiate(oldInstance, out));
	116	}
	117	else {
	118	initialize(oldInstance.getClass(), oldInstance, newInstance, out);
	119	}
	120	}
	121
	122	/**
	123	* Returns true if an <em>equivalent</em> copy of <code>oldInstance</code> may be
	124	* created by applying a series of statements to <code>newInstance</code>.
	125	* In the specification of this method, we mean by equivalent that the modified instance
	126	* is indistinguishable from <code>oldInstance</code> in the behavior
	127	* of the relevant methods in its public API. [Note: we use the
	128	* phrase <em>relevant</em> methods rather than <em>all</em> methods
	129	* here only because, to be strictly correct, methods like <code>hashCode</code>
	130	* and <code>toString</code> prevent most classes from producing truly
	131	* indistinguishable copies of their instances].
	132	* <p>
	133	* The default behavior returns <code>true</code>
	134	* if the classes of the two instances are the same.
	135	*
	136	* @param oldInstance The instance to be copied.
	137	* @param newInstance The instance that is to be modified.
	138	* @return True if an equivalent copy of <code>newInstance</code> may be
	139	* created by applying a series of mutations to <code>oldInstance</code>.
	140	*/
	141	protected boolean mutatesTo(Object oldInstance, Object newInstance) {
	142	return (newInstance != null && oldInstance != null &&
	143	oldInstance.getClass() == newInstance.getClass());
	144	}
	145
	146	/**
	147	* Returns an expression whose value is <code>oldInstance</code>.
	148	* This method is used to characterize the constructor
	149	* or factory method that should be used to create the given object.
	150	* For example, the <code>instantiate</code> method of the persistence
	151	* delegate for the <code>Field</code> class could be defined as follows:
	152	* <pre>
	153	* Field f = (Field)oldInstance;
	154	* return new Expression(f, f.getDeclaringClass(), "getField", new Object[]{f.getName()});
	155	* </pre>
	156	* Note that we declare the value of the returned expression so that
	157	* the value of the expression (as returned by <code>getValue</code>)
	158	* will be identical to <code>oldInstance</code>.
	159	*
	160	* @param oldInstance The instance that will be created by this expression.
	161	* @param out The stream to which this expression will be written.
	162	* @return An expression whose value is <code>oldInstance</code>.
	163	*
	164	* @throws NullPointerException if {@code out} is {@code null}
	165	*/
	166	protected abstract Expression instantiate(Object oldInstance, Encoder out);
	167
	168	/**
	169	* Produce a series of statements with side effects on <code>newInstance</code>
	170	* so that the new instance becomes <em>equivalent</em> to <code>oldInstance</code>.
	171	* In the specification of this method, we mean by equivalent that, after the method
	172	* returns, the modified instance is indistinguishable from
	173	* <code>newInstance</code> in the behavior of all methods in its
	174	* public API.
	175	* <p>
	176	* The implementation typically achieves this goal by producing a series of
	177	* "what happened" statements involving the <code>oldInstance</code>
	178	* and its publicly available state. These statements are sent
	179	* to the output stream using its <code>writeExpression</code>
	180	* method which returns an expression involving elements in
	181	* a cloned environment simulating the state of an input stream during
	182	* reading. Each statement returned will have had all instances
	183	* the old environment replaced with objects which exist in the new
	184	* one. In particular, references to the target of these statements,
	185	* which start out as references to <code>oldInstance</code> are returned
	186	* as references to the <code>newInstance</code> instead.
	187	* Executing these statements effects an incremental
	188	* alignment of the state of the two objects as a series of
	189	* modifications to the objects in the new environment.
	190	* By the time the initialize method returns it should be impossible
	191	* to tell the two instances apart by using their public APIs.
	192	* Most importantly, the sequence of steps that were used to make
	193	* these objects appear equivalent will have been recorded
	194	* by the output stream and will form the actual output when
	195	* the stream is flushed.
	196	* <p>
	197	* The default implementation, calls the <code>initialize</code>
	198	* method of the type's superclass.
	199	*
	200	* @param oldInstance The instance to be copied.
	201	* @param newInstance The instance that is to be modified.
	202	* @param out The stream to which any initialization statements should be written.
	203	*
	204	* @throws NullPointerException if {@code out} is {@code null}
	205	*/
	206	protected void initialize(Class<?> type,
	207	Object oldInstance, Object newInstance,
	208	Encoder out)
	209	{
	210	Class superType = type.getSuperclass();
	211	PersistenceDelegate info = out.getPersistenceDelegate(superType);
	212	info.initialize(superType, oldInstance, newInstance, out);
	213	}
	214	}

java/pkg/java/beans/PrimitivePersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyChangeEvent.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyChangeEvent.java+164−0

@@ -0,0 +1,164 @@
	1	/*
	2	* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* A "PropertyChange" event gets delivered whenever a bean changes a "bound"
	30	* or "constrained" property. A PropertyChangeEvent object is sent as an
	31	* argument to the PropertyChangeListener and VetoableChangeListener methods.
	32	* <P>
	33	* Normally PropertyChangeEvents are accompanied by the name and the old
	34	* and new value of the changed property. If the new value is a primitive
	35	* type (such as int or boolean) it must be wrapped as the
	36	* corresponding java.lang.* Object type (such as Integer or Boolean).
	37	* <P>
	38	* Null values may be provided for the old and the new values if their
	39	* true values are not known.
	40	* <P>
	41	* An event source may send a null object as the name to indicate that an
	42	* arbitrary set of if its properties have changed. In this case the
	43	* old and new values should also be null.
	44	*/
	45
	46	public class PropertyChangeEvent extends java.util.EventObject {
	47	private static final long serialVersionUID = 7042693688939648123L;
	48
	49	/**
	50	* Constructs a new <code>PropertyChangeEvent</code>.
	51	*
	52	* @param source The bean that fired the event.
	53	* @param propertyName The programmatic name of the property
	54	* that was changed.
	55	* @param oldValue The old value of the property.
	56	* @param newValue The new value of the property.
	57	*/
	58	public PropertyChangeEvent(Object source, String propertyName,
	59	Object oldValue, Object newValue) {
	60	super(source);
	61	this.propertyName = propertyName;
	62	this.newValue = newValue;
	63	this.oldValue = oldValue;
	64	}
	65
	66	/**
	67	* Gets the programmatic name of the property that was changed.
	68	*
	69	* @return The programmatic name of the property that was changed.
	70	* May be null if multiple properties have changed.
	71	*/
	72	public String getPropertyName() {
	73	return propertyName;
	74	}
	75
	76	/**
	77	* Gets the new value for the property, expressed as an Object.
	78	*
	79	* @return The new value for the property, expressed as an Object.
	80	* May be null if multiple properties have changed.
	81	*/
	82	public Object getNewValue() {
	83	return newValue;
	84	}
	85
	86	/**
	87	* Gets the old value for the property, expressed as an Object.
	88	*
	89	* @return The old value for the property, expressed as an Object.
	90	* May be null if multiple properties have changed.
	91	*/
	92	public Object getOldValue() {
	93	return oldValue;
	94	}
	95
	96	/**
	97	* Sets the propagationId object for the event.
	98	*
	99	* @param propagationId The propagationId object for the event.
	100	*/
	101	public void setPropagationId(Object propagationId) {
	102	this.propagationId = propagationId;
	103	}
	104
	105	/**
	106	* The "propagationId" field is reserved for future use. In Beans 1.0
	107	* the sole requirement is that if a listener catches a PropertyChangeEvent
	108	* and then fires a PropertyChangeEvent of its own, then it should
	109	* make sure that it propagates the propagationId field from its
	110	* incoming event to its outgoing event.
	111	*
	112	* @return the propagationId object associated with a bound/constrained
	113	* property update.
	114	*/
	115	public Object getPropagationId() {
	116	return propagationId;
	117	}
	118
	119	/**
	120	* name of the property that changed. May be null, if not known.
	121	* @serial
	122	*/
	123	private String propertyName;
	124
	125	/**
	126	* New value for property. May be null if not known.
	127	* @serial
	128	*/
	129	private Object newValue;
	130
	131	/**
	132	* Previous value for property. May be null if not known.
	133	* @serial
	134	*/
	135	private Object oldValue;
	136
	137	/**
	138	* Propagation ID. May be null.
	139	* @serial
	140	* @see #getPropagationId
	141	*/
	142	private Object propagationId;
	143
	144	/**
	145	* Returns a string representation of the object.
	146	*
	147	* @return a string representation of the object
	148	*
	149	* @since 1.7
	150	*/
	151	public String toString() {
	152	StringBuilder sb = new StringBuilder(getClass().getName());
	153	sb.append("[propertyName=").append(getPropertyName());
	154	appendTo(sb);
	155	sb.append("; oldValue=").append(getOldValue());
	156	sb.append("; newValue=").append(getNewValue());
	157	sb.append("; propagationId=").append(getPropagationId());
	158	sb.append("; source=").append(getSource());
	159	return sb.append("]").toString();
	160	}
	161
	162	void appendTo(StringBuilder sb) {
	163	}
	164	}

java/pkg/java/beans/PropertyChangeListener.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyChangeListener.java+44−0

@@ -0,0 +1,44 @@
	1	/*
	2	* Copyright (c) 1996, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* A "PropertyChange" event gets fired whenever a bean changes a "bound"
	30	* property. You can register a PropertyChangeListener with a source
	31	* bean so as to be notified of any bound property updates.
	32	*/
	33
	34	public interface PropertyChangeListener extends java.util.EventListener {
	35
	36	/**
	37	* This method gets called when a bound property is changed.
	38	* @param evt A PropertyChangeEvent object describing the event source
	39	* and the property that has changed.
	40	*/
	41
	42	void propertyChange(PropertyChangeEvent evt);
	43
	44	}

java/pkg/java/beans/PropertyChangeListenerProxy.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyChangeListenerProxy.java+81−0

@@ -0,0 +1,81 @@
	1	/*
	2	* Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.util.EventListenerProxy;
	29
	30	/**
	31	* A class which extends the {@code EventListenerProxy}
	32	* specifically for adding a {@code PropertyChangeListener}
	33	* with a "bound" property.
	34	* Instances of this class can be added
	35	* as {@code PropertyChangeListener}s to a bean
	36	* which supports firing property change events.
	37	* <p>
	38	* If the object has a {@code getPropertyChangeListeners} method
	39	* then the array returned could be a mixture of {@code PropertyChangeListener}
	40	* and {@code PropertyChangeListenerProxy} objects.
	41	*
	42	* @see java.util.EventListenerProxy
	43	* @see PropertyChangeSupport#getPropertyChangeListeners
	44	* @since 1.4
	45	*/
	46	public class PropertyChangeListenerProxy
	47	extends EventListenerProxy<PropertyChangeListener>
	48	implements PropertyChangeListener {
	49
	50	private final String propertyName;
	51
	52	/**
	53	* Constructor which binds the {@code PropertyChangeListener}
	54	* to a specific property.
	55	*
	56	* @param propertyName the name of the property to listen on
	57	* @param listener the listener object
	58	*/
	59	public PropertyChangeListenerProxy(String propertyName, PropertyChangeListener listener) {
	60	super(listener);
	61	this.propertyName = propertyName;
	62	}
	63
	64	/**
	65	* Forwards the property change event to the listener delegate.
	66	*
	67	* @param event the property change event
	68	*/
	69	public void propertyChange(PropertyChangeEvent event) {
	70	getListener().propertyChange(event);
	71	}
	72
	73	/**
	74	* Returns the name of the named property associated with the listener.
	75	*
	76	* @return the name of the named property associated with the listener
	77	*/
	78	public String getPropertyName() {
	79	return this.propertyName;
	80	}
	81	}

java/pkg/java/beans/PropertyChangeSupport$1.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyChangeSupport$PropertyChangeListenerMap.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyChangeSupport.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyChangeSupport.java+536−0

@@ -0,0 +1,536 @@
	1	/*
	2	* Copyright (c) 1996, 2008, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import java.io.Serializable;
	28	import java.io.ObjectStreamField;
	29	import java.io.ObjectOutputStream;
	30	import java.io.ObjectInputStream;
	31	import java.io.IOException;
	32	import java.util.Hashtable;
	33	import java.util.Map.Entry;
	34
	35	/**
	36	* This is a utility class that can be used by beans that support bound
	37	* properties. It manages a list of listeners and dispatches
	38	* {@link PropertyChangeEvent}s to them. You can use an instance of this class
	39	* as a member field of your bean and delegate these types of work to it.
	40	* The {@link PropertyChangeListener} can be registered for all properties
	41	* or for a property specified by name.
	42	* <p>
	43	* Here is an example of {@code PropertyChangeSupport} usage that follows
	44	* the rules and recommendations laid out in the JavaBeans™ specification:
	45	* <pre>
	46	* public class MyBean {
	47	* private final PropertyChangeSupport pcs = new PropertyChangeSupport(this);
	48	*
	49	* public void addPropertyChangeListener(PropertyChangeListener listener) {
	50	* this.pcs.addPropertyChangeListener(listener);
	51	* }
	52	*
	53	* public void removePropertyChangeListener(PropertyChangeListener listener) {
	54	* this.pcs.removePropertyChangeListener(listener);
	55	* }
	56	*
	57	* private String value;
	58	*
	59	* public String getValue() {
	60	* return this.value;
	61	* }
	62	*
	63	* public void setValue(String newValue) {
	64	* String oldValue = this.value;
	65	* this.value = newValue;
	66	* this.pcs.firePropertyChange("value", oldValue, newValue);
	67	* }
	68	*
	69	* [...]
	70	* }
	71	* </pre>
	72	* <p>
	73	* A {@code PropertyChangeSupport} instance is thread-safe.
	74	* <p>
	75	* This class is serializable. When it is serialized it will save
	76	* (and restore) any listeners that are themselves serializable. Any
	77	* non-serializable listeners will be skipped during serialization.
	78	*
	79	* @see VetoableChangeSupport
	80	*/
	81	public class PropertyChangeSupport implements Serializable {
	82	private PropertyChangeListenerMap map = new PropertyChangeListenerMap();
	83
	84	/**
	85	* Constructs a <code>PropertyChangeSupport</code> object.
	86	*
	87	* @param sourceBean The bean to be given as the source for any events.
	88	*/
	89	public PropertyChangeSupport(Object sourceBean) {
	90	if (sourceBean == null) {
	91	throw new NullPointerException();
	92	}
	93	source = sourceBean;
	94	}
	95
	96	/**
	97	* Add a PropertyChangeListener to the listener list.
	98	* The listener is registered for all properties.
	99	* The same listener object may be added more than once, and will be called
	100	* as many times as it is added.
	101	* If <code>listener</code> is null, no exception is thrown and no action
	102	* is taken.
	103	*
	104	* @param listener The PropertyChangeListener to be added
	105	*/
	106	public void addPropertyChangeListener(PropertyChangeListener listener) {
	107	if (listener == null) {
	108	return;
	109	}
	110	if (listener instanceof PropertyChangeListenerProxy) {
	111	PropertyChangeListenerProxy proxy =
	112	(PropertyChangeListenerProxy)listener;
	113	// Call two argument add method.
	114	addPropertyChangeListener(proxy.getPropertyName(),
	115	proxy.getListener());
	116	} else {
	117	this.map.add(null, listener);
	118	}
	119	}
	120
	121	/**
	122	* Remove a PropertyChangeListener from the listener list.
	123	* This removes a PropertyChangeListener that was registered
	124	* for all properties.
	125	* If <code>listener</code> was added more than once to the same event
	126	* source, it will be notified one less time after being removed.
	127	* If <code>listener</code> is null, or was never added, no exception is
	128	* thrown and no action is taken.
	129	*
	130	* @param listener The PropertyChangeListener to be removed
	131	*/
	132	public void removePropertyChangeListener(PropertyChangeListener listener) {
	133	if (listener == null) {
	134	return;
	135	}
	136	if (listener instanceof PropertyChangeListenerProxy) {
	137	PropertyChangeListenerProxy proxy =
	138	(PropertyChangeListenerProxy)listener;
	139	// Call two argument remove method.
	140	removePropertyChangeListener(proxy.getPropertyName(),
	141	proxy.getListener());
	142	} else {
	143	this.map.remove(null, listener);
	144	}
	145	}
	146
	147	/**
	148	* Returns an array of all the listeners that were added to the
	149	* PropertyChangeSupport object with addPropertyChangeListener().
	150	* <p>
	151	* If some listeners have been added with a named property, then
	152	* the returned array will be a mixture of PropertyChangeListeners
	153	* and <code>PropertyChangeListenerProxy</code>s. If the calling
	154	* method is interested in distinguishing the listeners then it must
	155	* test each element to see if it's a
	156	* <code>PropertyChangeListenerProxy</code>, perform the cast, and examine
	157	* the parameter.
	158	*
	159	* <pre>
	160	* PropertyChangeListener[] listeners = bean.getPropertyChangeListeners();
	161	* for (int i = 0; i < listeners.length; i++) {
	162	* if (listeners[i] instanceof PropertyChangeListenerProxy) {
	163	* PropertyChangeListenerProxy proxy =
	164	* (PropertyChangeListenerProxy)listeners[i];
	165	* if (proxy.getPropertyName().equals("foo")) {
	166	* // proxy is a PropertyChangeListener which was associated
	167	* // with the property named "foo"
	168	* }
	169	* }
	170	* }
	171	*</pre>
	172	*
	173	* @see PropertyChangeListenerProxy
	174	* @return all of the <code>PropertyChangeListeners</code> added or an
	175	* empty array if no listeners have been added
	176	* @since 1.4
	177	*/
	178	public PropertyChangeListener[] getPropertyChangeListeners() {
	179	return this.map.getListeners();
	180	}
	181
	182	/**
	183	* Add a PropertyChangeListener for a specific property. The listener
	184	* will be invoked only when a call on firePropertyChange names that
	185	* specific property.
	186	* The same listener object may be added more than once. For each
	187	* property, the listener will be invoked the number of times it was added
	188	* for that property.
	189	* If <code>propertyName</code> or <code>listener</code> is null, no
	190	* exception is thrown and no action is taken.
	191	*
	192	* @param propertyName The name of the property to listen on.
	193	* @param listener The PropertyChangeListener to be added
	194	*/
	195	public void addPropertyChangeListener(
	196	String propertyName,
	197	PropertyChangeListener listener) {
	198	if (listener == null \|\| propertyName == null) {
	199	return;
	200	}
	201	listener = this.map.extract(listener);
	202	if (listener != null) {
	203	this.map.add(propertyName, listener);
	204	}
	205	}
	206
	207	/**
	208	* Remove a PropertyChangeListener for a specific property.
	209	* If <code>listener</code> was added more than once to the same event
	210	* source for the specified property, it will be notified one less time
	211	* after being removed.
	212	* If <code>propertyName</code> is null, no exception is thrown and no
	213	* action is taken.
	214	* If <code>listener</code> is null, or was never added for the specified
	215	* property, no exception is thrown and no action is taken.
	216	*
	217	* @param propertyName The name of the property that was listened on.
	218	* @param listener The PropertyChangeListener to be removed
	219	*/
	220	public void removePropertyChangeListener(
	221	String propertyName,
	222	PropertyChangeListener listener) {
	223	if (listener == null \|\| propertyName == null) {
	224	return;
	225	}
	226	listener = this.map.extract(listener);
	227	if (listener != null) {
	228	this.map.remove(propertyName, listener);
	229	}
	230	}
	231
	232	/**
	233	* Returns an array of all the listeners which have been associated
	234	* with the named property.
	235	*
	236	* @param propertyName The name of the property being listened to
	237	* @return all of the <code>PropertyChangeListeners</code> associated with
	238	* the named property. If no such listeners have been added,
	239	* or if <code>propertyName</code> is null, an empty array is
	240	* returned.
	241	* @since 1.4
	242	*/
	243	public PropertyChangeListener[] getPropertyChangeListeners(String propertyName) {
	244	return this.map.getListeners(propertyName);
	245	}
	246
	247	/**
	248	* Reports a bound property update to listeners
	249	* that have been registered to track updates of
	250	* all properties or a property with the specified name.
	251	* <p>
	252	* No event is fired if old and new values are equal and non-null.
	253	* <p>
	254	* This is merely a convenience wrapper around the more general
	255	* {@link #firePropertyChange(PropertyChangeEvent)} method.
	256	*
	257	* @param propertyName the programmatic name of the property that was changed
	258	* @param oldValue the old value of the property
	259	* @param newValue the new value of the property
	260	*/
	261	public void firePropertyChange(String propertyName, Object oldValue, Object newValue) {
	262	if (oldValue == null \|\| newValue == null \|\| !oldValue.equals(newValue)) {
	263	firePropertyChange(new PropertyChangeEvent(this.source, propertyName, oldValue, newValue));
	264	}
	265	}
	266
	267	/**
	268	* Reports an integer bound property update to listeners
	269	* that have been registered to track updates of
	270	* all properties or a property with the specified name.
	271	* <p>
	272	* No event is fired if old and new values are equal.
	273	* <p>
	274	* This is merely a convenience wrapper around the more general
	275	* {@link #firePropertyChange(String, Object, Object)} method.
	276	*
	277	* @param propertyName the programmatic name of the property that was changed
	278	* @param oldValue the old value of the property
	279	* @param newValue the new value of the property
	280	*/
	281	public void firePropertyChange(String propertyName, int oldValue, int newValue) {
	282	if (oldValue != newValue) {
	283	firePropertyChange(propertyName, Integer.valueOf(oldValue), Integer.valueOf(newValue));
	284	}
	285	}
	286
	287	/**
	288	* Reports a boolean bound property update to listeners
	289	* that have been registered to track updates of
	290	* all properties or a property with the specified name.
	291	* <p>
	292	* No event is fired if old and new values are equal.
	293	* <p>
	294	* This is merely a convenience wrapper around the more general
	295	* {@link #firePropertyChange(String, Object, Object)} method.
	296	*
	297	* @param propertyName the programmatic name of the property that was changed
	298	* @param oldValue the old value of the property
	299	* @param newValue the new value of the property
	300	*/
	301	public void firePropertyChange(String propertyName, boolean oldValue, boolean newValue) {
	302	if (oldValue != newValue) {
	303	firePropertyChange(propertyName, Boolean.valueOf(oldValue), Boolean.valueOf(newValue));
	304	}
	305	}
	306
	307	/**
	308	* Fires a property change event to listeners
	309	* that have been registered to track updates of
	310	* all properties or a property with the specified name.
	311	* <p>
	312	* No event is fired if the given event's old and new values are equal and non-null.
	313	*
	314	* @param event the {@code PropertyChangeEvent} to be fired
	315	*/
	316	public void firePropertyChange(PropertyChangeEvent event) {
	317	Object oldValue = event.getOldValue();
	318	Object newValue = event.getNewValue();
	319	if (oldValue == null \|\| newValue == null \|\| !oldValue.equals(newValue)) {
	320	String name = event.getPropertyName();
	321
	322	PropertyChangeListener[] common = this.map.get(null);
	323	PropertyChangeListener[] named = (name != null)
	324	? this.map.get(name)
	325	: null;
	326
	327	fire(common, event);
	328	fire(named, event);
	329	}
	330	}
	331
	332	private static void fire(PropertyChangeListener[] listeners, PropertyChangeEvent event) {
	333	if (listeners != null) {
	334	for (PropertyChangeListener listener : listeners) {
	335	listener.propertyChange(event);
	336	}
	337	}
	338	}
	339
	340	/**
	341	* Reports a bound indexed property update to listeners
	342	* that have been registered to track updates of
	343	* all properties or a property with the specified name.
	344	* <p>
	345	* No event is fired if old and new values are equal and non-null.
	346	* <p>
	347	* This is merely a convenience wrapper around the more general
	348	* {@link #firePropertyChange(PropertyChangeEvent)} method.
	349	*
	350	* @param propertyName the programmatic name of the property that was changed
	351	* @param index the index of the property element that was changed
	352	* @param oldValue the old value of the property
	353	* @param newValue the new value of the property
	354	* @since 1.5
	355	*/
	356	public void fireIndexedPropertyChange(String propertyName, int index, Object oldValue, Object newValue) {
	357	if (oldValue == null \|\| newValue == null \|\| !oldValue.equals(newValue)) {
	358	firePropertyChange(new IndexedPropertyChangeEvent(source, propertyName, oldValue, newValue, index));
	359	}
	360	}
	361
	362	/**
	363	* Reports an integer bound indexed property update to listeners
	364	* that have been registered to track updates of
	365	* all properties or a property with the specified name.
	366	* <p>
	367	* No event is fired if old and new values are equal.
	368	* <p>
	369	* This is merely a convenience wrapper around the more general
	370	* {@link #fireIndexedPropertyChange(String, int, Object, Object)} method.
	371	*
	372	* @param propertyName the programmatic name of the property that was changed
	373	* @param index the index of the property element that was changed
	374	* @param oldValue the old value of the property
	375	* @param newValue the new value of the property
	376	* @since 1.5
	377	*/
	378	public void fireIndexedPropertyChange(String propertyName, int index, int oldValue, int newValue) {
	379	if (oldValue != newValue) {
	380	fireIndexedPropertyChange(propertyName, index, Integer.valueOf(oldValue), Integer.valueOf(newValue));
	381	}
	382	}
	383
	384	/**
	385	* Reports a boolean bound indexed property update to listeners
	386	* that have been registered to track updates of
	387	* all properties or a property with the specified name.
	388	* <p>
	389	* No event is fired if old and new values are equal.
	390	* <p>
	391	* This is merely a convenience wrapper around the more general
	392	* {@link #fireIndexedPropertyChange(String, int, Object, Object)} method.
	393	*
	394	* @param propertyName the programmatic name of the property that was changed
	395	* @param index the index of the property element that was changed
	396	* @param oldValue the old value of the property
	397	* @param newValue the new value of the property
	398	* @since 1.5
	399	*/
	400	public void fireIndexedPropertyChange(String propertyName, int index, boolean oldValue, boolean newValue) {
	401	if (oldValue != newValue) {
	402	fireIndexedPropertyChange(propertyName, index, Boolean.valueOf(oldValue), Boolean.valueOf(newValue));
	403	}
	404	}
	405
	406	/**
	407	* Check if there are any listeners for a specific property, including
	408	* those registered on all properties. If <code>propertyName</code>
	409	* is null, only check for listeners registered on all properties.
	410	*
	411	* @param propertyName the property name.
	412	* @return true if there are one or more listeners for the given property
	413	*/
	414	public boolean hasListeners(String propertyName) {
	415	return this.map.hasListeners(propertyName);
	416	}
	417
	418	/**
	419	* @serialData Null terminated list of <code>PropertyChangeListeners</code>.
	420	* <p>
	421	* At serialization time we skip non-serializable listeners and
	422	* only serialize the serializable listeners.
	423	*/
	424	private void writeObject(ObjectOutputStream s) throws IOException {
	425	Hashtable<String, PropertyChangeSupport> children = null;
	426	PropertyChangeListener[] listeners = null;
	427	synchronized (this.map) {
	428	for (Entry<String, PropertyChangeListener[]> entry : this.map.getEntries()) {
	429	String property = entry.getKey();
	430	if (property == null) {
	431	listeners = entry.getValue();
	432	} else {
	433	if (children == null) {
	434	children = new Hashtable<String, PropertyChangeSupport>();
	435	}
	436	PropertyChangeSupport pcs = new PropertyChangeSupport(this.source);
	437	pcs.map.set(null, entry.getValue());
	438	children.put(property, pcs);
	439	}
	440	}
	441	}
	442	ObjectOutputStream.PutField fields = s.putFields();
	443	fields.put("children", children);
	444	fields.put("source", this.source);
	445	fields.put("propertyChangeSupportSerializedDataVersion", 2);
	446	s.writeFields();
	447
	448	if (listeners != null) {
	449	for (PropertyChangeListener l : listeners) {
	450	if (l instanceof Serializable) {
	451	s.writeObject(l);
	452	}
	453	}
	454	}
	455	s.writeObject(null);
	456	}
	457
	458	private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException {
	459	this.map = new PropertyChangeListenerMap();
	460
	461	ObjectInputStream.GetField fields = s.readFields();
	462
	463	Hashtable<String, PropertyChangeSupport> children = (Hashtable<String, PropertyChangeSupport>) fields.get("children", null);
	464	this.source = fields.get("source", null);
	465	fields.get("propertyChangeSupportSerializedDataVersion", 2);
	466
	467	Object listenerOrNull;
	468	while (null != (listenerOrNull = s.readObject())) {
	469	this.map.add(null, (PropertyChangeListener)listenerOrNull);
	470	}
	471	if (children != null) {
	472	for (Entry<String, PropertyChangeSupport> entry : children.entrySet()) {
	473	for (PropertyChangeListener listener : entry.getValue().getPropertyChangeListeners()) {
	474	this.map.add(entry.getKey(), listener);
	475	}
	476	}
	477	}
	478	}
	479
	480	/**
	481	* The object to be provided as the "source" for any generated events.
	482	*/
	483	private Object source;
	484
	485	/**
	486	* @serialField children Hashtable
	487	* @serialField source Object
	488	* @serialField propertyChangeSupportSerializedDataVersion int
	489	*/
	490	private static final ObjectStreamField[] serialPersistentFields = {
	491	new ObjectStreamField("children", Hashtable.class),
	492	new ObjectStreamField("source", Object.class),
	493	new ObjectStreamField("propertyChangeSupportSerializedDataVersion", Integer.TYPE)
	494	};
	495
	496	/**
	497	* Serialization version ID, so we're compatible with JDK 1.1
	498	*/
	499	static final long serialVersionUID = 6401253773779951803L;
	500
	501	/**
	502	* This is a {@link ChangeListenerMap ChangeListenerMap} implementation
	503	* that works with {@link PropertyChangeListener PropertyChangeListener} objects.
	504	*/
	505	private static final class PropertyChangeListenerMap extends ChangeListenerMap<PropertyChangeListener> {
	506	private static final PropertyChangeListener[] EMPTY = {};
	507
	508	/**
	509	* Creates an array of {@link PropertyChangeListener PropertyChangeListener} objects.
	510	* This method uses the same instance of the empty array
	511	* when {@code length} equals {@code 0}.
	512	*
	513	* @param length the array length
	514	* @return an array with specified length
	515	*/
	516	@Override
	517	protected PropertyChangeListener[] newArray(int length) {
	518	return (0 < length)
	519	? new PropertyChangeListener[length]
	520	: EMPTY;
	521	}
	522
	523	/**
	524	* Creates a {@link PropertyChangeListenerProxy PropertyChangeListenerProxy}
	525	* object for the specified property.
	526	*
	527	* @param name the name of the property to listen on
	528	* @param listener the listener to process events
	529	* @return a {@code PropertyChangeListenerProxy} object
	530	*/
	531	@Override
	532	protected PropertyChangeListener newProxy(String name, PropertyChangeListener listener) {
	533	return new PropertyChangeListenerProxy(name, listener);
	534	}
	535	}
	536	}

java/pkg/java/beans/PropertyDescriptor.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyDescriptor.java+719−0

@@ -0,0 +1,719 @@
	1	/*
	2	* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.lang.ref.Reference;
	29	import java.lang.reflect.Method;
	30	import java.lang.reflect.Constructor;
	31
	32	/**
	33	* A PropertyDescriptor describes one property that a Java Bean
	34	* exports via a pair of accessor methods.
	35	*/
	36	public class PropertyDescriptor extends FeatureDescriptor {
	37
	38	private Reference<Class> propertyTypeRef;
	39	private Reference<Method> readMethodRef;
	40	private Reference<Method> writeMethodRef;
	41	private Reference<Class> propertyEditorClassRef;
	42
	43	private boolean bound;
	44	private boolean constrained;
	45
	46	// The base name of the method name which will be prefixed with the
	47	// read and write method. If name == "foo" then the baseName is "Foo"
	48	private String baseName;
	49
	50	private String writeMethodName;
	51	private String readMethodName;
	52
	53	/**
	54	* Constructs a PropertyDescriptor for a property that follows
	55	* the standard Java convention by having getFoo and setFoo
	56	* accessor methods. Thus if the argument name is "fred", it will
	57	* assume that the writer method is "setFred" and the reader method
	58	* is "getFred" (or "isFred" for a boolean property). Note that the
	59	* property name should start with a lower case character, which will
	60	* be capitalized in the method names.
	61	*
	62	* @param propertyName The programmatic name of the property.
	63	* @param beanClass The Class object for the target bean. For
	64	* example sun.beans.OurButton.class.
	65	* @exception IntrospectionException if an exception occurs during
	66	* introspection.
	67	*/
	68	public PropertyDescriptor(String propertyName, Class<?> beanClass)
	69	throws IntrospectionException {
	70	this(propertyName, beanClass,
	71	Introspector.IS_PREFIX + NameGenerator.capitalize(propertyName),
	72	Introspector.SET_PREFIX + NameGenerator.capitalize(propertyName));
	73	}
	74
	75	/**
	76	* This constructor takes the name of a simple property, and method
	77	* names for reading and writing the property.
	78	*
	79	* @param propertyName The programmatic name of the property.
	80	* @param beanClass The Class object for the target bean. For
	81	* example sun.beans.OurButton.class.
	82	* @param readMethodName The name of the method used for reading the property
	83	* value. May be null if the property is write-only.
	84	* @param writeMethodName The name of the method used for writing the property
	85	* value. May be null if the property is read-only.
	86	* @exception IntrospectionException if an exception occurs during
	87	* introspection.
	88	*/
	89	public PropertyDescriptor(String propertyName, Class<?> beanClass,
	90	String readMethodName, String writeMethodName)
	91	throws IntrospectionException {
	92	if (beanClass == null) {
	93	throw new IntrospectionException("Target Bean class is null");
	94	}
	95	if (propertyName == null \|\| propertyName.length() == 0) {
	96	throw new IntrospectionException("bad property name");
	97	}
	98	if ("".equals(readMethodName) \|\| "".equals(writeMethodName)) {
	99	throw new IntrospectionException("read or write method name should not be the empty string");
	100	}
	101	setName(propertyName);
	102	setClass0(beanClass);
	103
	104	this.readMethodName = readMethodName;
	105	if (readMethodName != null && getReadMethod() == null) {
	106	throw new IntrospectionException("Method not found: " + readMethodName);
	107	}
	108	this.writeMethodName = writeMethodName;
	109	if (writeMethodName != null && getWriteMethod() == null) {
	110	throw new IntrospectionException("Method not found: " + writeMethodName);
	111	}
	112	// If this class or one of its base classes allow PropertyChangeListener,
	113	// then we assume that any properties we discover are "bound".
	114	// See Introspector.getTargetPropertyInfo() method.
	115	Class[] args = { PropertyChangeListener.class };
	116	this.bound = null != Introspector.findMethod(beanClass, "addPropertyChangeListener", args.length, args);
	117	}
	118
	119	/**
	120	* This constructor takes the name of a simple property, and Method
	121	* objects for reading and writing the property.
	122	*
	123	* @param propertyName The programmatic name of the property.
	124	* @param readMethod The method used for reading the property value.
	125	* May be null if the property is write-only.
	126	* @param writeMethod The method used for writing the property value.
	127	* May be null if the property is read-only.
	128	* @exception IntrospectionException if an exception occurs during
	129	* introspection.
	130	*/
	131	public PropertyDescriptor(String propertyName, Method readMethod, Method writeMethod)
	132	throws IntrospectionException {
	133	if (propertyName == null \|\| propertyName.length() == 0) {
	134	throw new IntrospectionException("bad property name");
	135	}
	136	setName(propertyName);
	137	setReadMethod(readMethod);
	138	setWriteMethod(writeMethod);
	139	}
	140
	141	/**
	142	* Creates <code>PropertyDescriptor</code> for the specified bean
	143	* with the specified name and methods to read/write the property value.
	144	*
	145	* @param bean the type of the target bean
	146	* @param base the base name of the property (the rest of the method name)
	147	* @param read the method used for reading the property value
	148	* @param write the method used for writing the property value
	149	* @exception IntrospectionException if an exception occurs during introspection
	150	*
	151	* @since 1.7
	152	*/
	153	PropertyDescriptor(Class<?> bean, String base, Method read, Method write) throws IntrospectionException {
	154	if (bean == null) {
	155	throw new IntrospectionException("Target Bean class is null");
	156	}
	157	setClass0(bean);
	158	setName(Introspector.decapitalize(base));
	159	setReadMethod(read);
	160	setWriteMethod(write);
	161	this.baseName = base;
	162	}
	163
	164	/**
	165	* Returns the Java type info for the property.
	166	* Note that the {@code Class} object may describe
	167	* primitive Java types such as {@code int}.
	168	* This type is returned by the read method
	169	* or is used as the parameter type of the write method.
	170	* Returns {@code null} if the type is an indexed property
	171	* that does not support non-indexed access.
	172	*
	173	* @return the {@code Class} object that represents the Java type info,
	174	* or {@code null} if the type cannot be determined
	175	*/
	176	public synchronized Class<?> getPropertyType() {
	177	Class type = getPropertyType0();
	178	if (type == null) {
	179	try {
	180	type = findPropertyType(getReadMethod(), getWriteMethod());
	181	setPropertyType(type);
	182	} catch (IntrospectionException ex) {
	183	// Fall
	184	}
	185	}
	186	return type;
	187	}
	188
	189	private void setPropertyType(Class type) {
	190	this.propertyTypeRef = getWeakReference(type);
	191	}
	192
	193	private Class getPropertyType0() {
	194	return (this.propertyTypeRef != null)
	195	? this.propertyTypeRef.get()
	196	: null;
	197	}
	198
	199	/**
	200	* Gets the method that should be used to read the property value.
	201	*
	202	* @return The method that should be used to read the property value.
	203	* May return null if the property can't be read.
	204	*/
	205	public synchronized Method getReadMethod() {
	206	Method readMethod = getReadMethod0();
	207	if (readMethod == null) {
	208	Class cls = getClass0();
	209	if (cls == null \|\| (readMethodName == null && readMethodRef == null)) {
	210	// The read method was explicitly set to null.
	211	return null;
	212	}
	213	if (readMethodName == null) {
	214	Class type = getPropertyType0();
	215	if (type == boolean.class \|\| type == null) {
	216	readMethodName = Introspector.IS_PREFIX + getBaseName();
	217	} else {
	218	readMethodName = Introspector.GET_PREFIX + getBaseName();
	219	}
	220	}
	221
	222	// Since there can be multiple write methods but only one getter
	223	// method, find the getter method first so that you know what the
	224	// property type is. For booleans, there can be "is" and "get"
	225	// methods. If an "is" method exists, this is the official
	226	// reader method so look for this one first.
	227	readMethod = Introspector.findMethod(cls, readMethodName, 0);
	228	if (readMethod == null) {
	229	readMethodName = Introspector.GET_PREFIX + getBaseName();
	230	readMethod = Introspector.findMethod(cls, readMethodName, 0);
	231	}
	232	try {
	233	setReadMethod(readMethod);
	234	} catch (IntrospectionException ex) {
	235	// fall
	236	}
	237	}
	238	return readMethod;
	239	}
	240
	241	/**
	242	* Sets the method that should be used to read the property value.
	243	*
	244	* @param readMethod The new read method.
	245	*/
	246	public synchronized void setReadMethod(Method readMethod)
	247	throws IntrospectionException {
	248	if (readMethod == null) {
	249	readMethodName = null;
	250	readMethodRef = null;
	251	return;
	252	}
	253	// The property type is determined by the read method.
	254	setPropertyType(findPropertyType(readMethod, getWriteMethod0()));
	255	setClass0(readMethod.getDeclaringClass());
	256
	257	readMethodName = readMethod.getName();
	258	this.readMethodRef = getSoftReference(readMethod);
	259	setTransient(readMethod.getAnnotation(Transient.class));
	260	}
	261
	262	/**
	263	* Gets the method that should be used to write the property value.
	264	*
	265	* @return The method that should be used to write the property value.
	266	* May return null if the property can't be written.
	267	*/
	268	public synchronized Method getWriteMethod() {
	269	Method writeMethod = getWriteMethod0();
	270	if (writeMethod == null) {
	271	Class cls = getClass0();
	272	if (cls == null \|\| (writeMethodName == null && writeMethodRef == null)) {
	273	// The write method was explicitly set to null.
	274	return null;
	275	}
	276
	277	// We need the type to fetch the correct method.
	278	Class type = getPropertyType0();
	279	if (type == null) {
	280	try {
	281	// Can't use getPropertyType since it will lead to recursive loop.
	282	type = findPropertyType(getReadMethod(), null);
	283	setPropertyType(type);
	284	} catch (IntrospectionException ex) {
	285	// Without the correct property type we can't be guaranteed
	286	// to find the correct method.
	287	return null;
	288	}
	289	}
	290
	291	if (writeMethodName == null) {
	292	writeMethodName = Introspector.SET_PREFIX + getBaseName();
	293	}
	294
	295	Class[] args = (type == null) ? null : new Class[] { type };
	296	writeMethod = Introspector.findMethod(cls, writeMethodName, 1, args);
	297	if (writeMethod != null) {
	298	if (!writeMethod.getReturnType().equals(void.class)) {
	299	writeMethod = null;
	300	}
	301	}
	302	try {
	303	setWriteMethod(writeMethod);
	304	} catch (IntrospectionException ex) {
	305	// fall through
	306	}
	307	}
	308	return writeMethod;
	309	}
	310
	311	/**
	312	* Sets the method that should be used to write the property value.
	313	*
	314	* @param writeMethod The new write method.
	315	*/
	316	public synchronized void setWriteMethod(Method writeMethod)
	317	throws IntrospectionException {
	318	if (writeMethod == null) {
	319	writeMethodName = null;
	320	writeMethodRef = null;
	321	return;
	322	}
	323	// Set the property type - which validates the method
	324	setPropertyType(findPropertyType(getReadMethod(), writeMethod));
	325	setClass0(writeMethod.getDeclaringClass());
	326
	327	writeMethodName = writeMethod.getName();
	328	this.writeMethodRef = getSoftReference(writeMethod);
	329	setTransient(writeMethod.getAnnotation(Transient.class));
	330	}
	331
	332	private Method getReadMethod0() {
	333	return (this.readMethodRef != null)
	334	? this.readMethodRef.get()
	335	: null;
	336	}
	337
	338	private Method getWriteMethod0() {
	339	return (this.writeMethodRef != null)
	340	? this.writeMethodRef.get()
	341	: null;
	342	}
	343
	344	/**
	345	* Overridden to ensure that a super class doesn't take precedent
	346	*/
	347	void setClass0(Class clz) {
	348	if (getClass0() != null && clz.isAssignableFrom(getClass0())) {
	349	// dont replace a subclass with a superclass
	350	return;
	351	}
	352	super.setClass0(clz);
	353	}
	354
	355	/**
	356	* Updates to "bound" properties will cause a "PropertyChange" event to
	357	* get fired when the property is changed.
	358	*
	359	* @return True if this is a bound property.
	360	*/
	361	public boolean isBound() {
	362	return bound;
	363	}
	364
	365	/**
	366	* Updates to "bound" properties will cause a "PropertyChange" event to
	367	* get fired when the property is changed.
	368	*
	369	* @param bound True if this is a bound property.
	370	*/
	371	public void setBound(boolean bound) {
	372	this.bound = bound;
	373	}
	374
	375	/**
	376	* Attempted updates to "Constrained" properties will cause a "VetoableChange"
	377	* event to get fired when the property is changed.
	378	*
	379	* @return True if this is a constrained property.
	380	*/
	381	public boolean isConstrained() {
	382	return constrained;
	383	}
	384
	385	/**
	386	* Attempted updates to "Constrained" properties will cause a "VetoableChange"
	387	* event to get fired when the property is changed.
	388	*
	389	* @param constrained True if this is a constrained property.
	390	*/
	391	public void setConstrained(boolean constrained) {
	392	this.constrained = constrained;
	393	}
	394
	395
	396	/**
	397	* Normally PropertyEditors will be found using the PropertyEditorManager.
	398	* However if for some reason you want to associate a particular
	399	* PropertyEditor with a given property, then you can do it with
	400	* this method.
	401	*
	402	* @param propertyEditorClass The Class for the desired PropertyEditor.
	403	*/
	404	public void setPropertyEditorClass(Class<?> propertyEditorClass) {
	405	this.propertyEditorClassRef = getWeakReference((Class)propertyEditorClass);
	406	}
	407
	408	/**
	409	* Gets any explicit PropertyEditor Class that has been registered
	410	* for this property.
	411	*
	412	* @return Any explicit PropertyEditor Class that has been registered
	413	* for this property. Normally this will return "null",
	414	* indicating that no special editor has been registered,
	415	* so the PropertyEditorManager should be used to locate
	416	* a suitable PropertyEditor.
	417	*/
	418	public Class<?> getPropertyEditorClass() {
	419	return (this.propertyEditorClassRef != null)
	420	? this.propertyEditorClassRef.get()
	421	: null;
	422	}
	423
	424	/**
	425	* Constructs an instance of a property editor using the current
	426	* property editor class.
	427	* <p>
	428	* If the property editor class has a public constructor that takes an
	429	* Object argument then it will be invoked using the bean parameter
	430	* as the argument. Otherwise, the default constructor will be invoked.
	431	*
	432	* @param bean the source object
	433	* @return a property editor instance or null if a property editor has
	434	* not been defined or cannot be created
	435	* @since 1.5
	436	*/
	437	public PropertyEditor createPropertyEditor(Object bean) {
	438	Object editor = null;
	439
	440	Class cls = getPropertyEditorClass();
	441	if (cls != null) {
	442	Constructor ctor = null;
	443	if (bean != null) {
	444	try {
	445	ctor = cls.getConstructor(new Class[] { Object.class });
	446	} catch (Exception ex) {
	447	// Fall through
	448	}
	449	}
	450	try {
	451	if (ctor == null) {
	452	editor = cls.newInstance();
	453	} else {
	454	editor = ctor.newInstance(new Object[] { bean });
	455	}
	456	} catch (Exception ex) {
	457	// A serious error has occured.
	458	// Proably due to an invalid property editor.
	459	throw new RuntimeException("PropertyEditor not instantiated",
	460	ex);
	461	}
	462	}
	463	return (PropertyEditor)editor;
	464	}
	465
	466
	467	/**
	468	* Compares this <code>PropertyDescriptor</code> against the specified object.
	469	* Returns true if the objects are the same. Two <code>PropertyDescriptor</code>s
	470	* are the same if the read, write, property types, property editor and
	471	* flags are equivalent.
	472	*
	473	* @since 1.4
	474	*/
	475	public boolean equals(Object obj) {
	476	if (this == obj) {
	477	return true;
	478	}
	479	if (obj != null && obj instanceof PropertyDescriptor) {
	480	PropertyDescriptor other = (PropertyDescriptor)obj;
	481	Method otherReadMethod = other.getReadMethod();
	482	Method otherWriteMethod = other.getWriteMethod();
	483
	484	if (!compareMethods(getReadMethod(), otherReadMethod)) {
	485	return false;
	486	}
	487
	488	if (!compareMethods(getWriteMethod(), otherWriteMethod)) {
	489	return false;
	490	}
	491
	492	if (getPropertyType() == other.getPropertyType() &&
	493	getPropertyEditorClass() == other.getPropertyEditorClass() &&
	494	bound == other.isBound() && constrained == other.isConstrained() &&
	495	writeMethodName == other.writeMethodName &&
	496	readMethodName == other.readMethodName) {
	497	return true;
	498	}
	499	}
	500	return false;
	501	}
	502
	503	/**
	504	* Package private helper method for Descriptor .equals methods.
	505	*
	506	* @param a first method to compare
	507	* @param b second method to compare
	508	* @return boolean to indicate that the methods are equivalent
	509	*/
	510	boolean compareMethods(Method a, Method b) {
	511	// Note: perhaps this should be a protected method in FeatureDescriptor
	512	if ((a == null) != (b == null)) {
	513	return false;
	514	}
	515
	516	if (a != null && b != null) {
	517	if (!a.equals(b)) {
	518	return false;
	519	}
	520	}
	521	return true;
	522	}
	523
	524	/**
	525	* Package-private constructor.
	526	* Merge two property descriptors. Where they conflict, give the
	527	* second argument (y) priority over the first argument (x).
	528	*
	529	* @param x The first (lower priority) PropertyDescriptor
	530	* @param y The second (higher priority) PropertyDescriptor
	531	*/
	532	PropertyDescriptor(PropertyDescriptor x, PropertyDescriptor y) {
	533	super(x,y);
	534
	535	if (y.baseName != null) {
	536	baseName = y.baseName;
	537	} else {
	538	baseName = x.baseName;
	539	}
	540
	541	if (y.readMethodName != null) {
	542	readMethodName = y.readMethodName;
	543	} else {
	544	readMethodName = x.readMethodName;
	545	}
	546
	547	if (y.writeMethodName != null) {
	548	writeMethodName = y.writeMethodName;
	549	} else {
	550	writeMethodName = x.writeMethodName;
	551	}
	552
	553	if (y.propertyTypeRef != null) {
	554	propertyTypeRef = y.propertyTypeRef;
	555	} else {
	556	propertyTypeRef = x.propertyTypeRef;
	557	}
	558
	559	// Figure out the merged read method.
	560	Method xr = x.getReadMethod();
	561	Method yr = y.getReadMethod();
	562
	563	// Normally give priority to y's readMethod.
	564	try {
	565	if (yr != null && yr.getDeclaringClass() == getClass0()) {
	566	setReadMethod(yr);
	567	} else {
	568	setReadMethod(xr);
	569	}
	570	} catch (IntrospectionException ex) {
	571	// fall through
	572	}
	573
	574	// However, if both x and y reference read methods in the same class,
	575	// give priority to a boolean "is" method over a boolean "get" method.
	576	if (xr != null && yr != null &&
	577	xr.getDeclaringClass() == yr.getDeclaringClass() &&
	578	getReturnType(getClass0(), xr) == boolean.class &&
	579	getReturnType(getClass0(), yr) == boolean.class &&
	580	xr.getName().indexOf(Introspector.IS_PREFIX) == 0 &&
	581	yr.getName().indexOf(Introspector.GET_PREFIX) == 0) {
	582	try {
	583	setReadMethod(xr);
	584	} catch (IntrospectionException ex) {
	585	// fall through
	586	}
	587	}
	588
	589	Method xw = x.getWriteMethod();
	590	Method yw = y.getWriteMethod();
	591
	592	try {
	593	if (yw != null && yw.getDeclaringClass() == getClass0()) {
	594	setWriteMethod(yw);
	595	} else {
	596	setWriteMethod(xw);
	597	}
	598	} catch (IntrospectionException ex) {
	599	// Fall through
	600	}
	601
	602	if (y.getPropertyEditorClass() != null) {
	603	setPropertyEditorClass(y.getPropertyEditorClass());
	604	} else {
	605	setPropertyEditorClass(x.getPropertyEditorClass());
	606	}
	607
	608
	609	bound = x.bound \| y.bound;
	610	constrained = x.constrained \| y.constrained;
	611	}
	612
	613	/*
	614	* Package-private dup constructor.
	615	* This must isolate the new object from any changes to the old object.
	616	*/
	617	PropertyDescriptor(PropertyDescriptor old) {
	618	super(old);
	619	propertyTypeRef = old.propertyTypeRef;
	620	readMethodRef = old.readMethodRef;
	621	writeMethodRef = old.writeMethodRef;
	622	propertyEditorClassRef = old.propertyEditorClassRef;
	623
	624	writeMethodName = old.writeMethodName;
	625	readMethodName = old.readMethodName;
	626	baseName = old.baseName;
	627
	628	bound = old.bound;
	629	constrained = old.constrained;
	630	}
	631
	632	/**
	633	* Returns the property type that corresponds to the read and write method.
	634	* The type precedence is given to the readMethod.
	635	*
	636	* @return the type of the property descriptor or null if both
	637	* read and write methods are null.
	638	* @throws IntrospectionException if the read or write method is invalid
	639	*/
	640	private Class findPropertyType(Method readMethod, Method writeMethod)
	641	throws IntrospectionException {
	642	Class propertyType = null;
	643	try {
	644	if (readMethod != null) {
	645	Class[] params = getParameterTypes(getClass0(), readMethod);
	646	if (params.length != 0) {
	647	throw new IntrospectionException("bad read method arg count: "
	648	+ readMethod);
	649	}
	650	propertyType = getReturnType(getClass0(), readMethod);
	651	if (propertyType == Void.TYPE) {
	652	throw new IntrospectionException("read method " +
	653	readMethod.getName() + " returns void");
	654	}
	655	}
	656	if (writeMethod != null) {
	657	Class params[] = getParameterTypes(getClass0(), writeMethod);
	658	if (params.length != 1) {
	659	throw new IntrospectionException("bad write method arg count: "
	660	+ writeMethod);
	661	}
	662	if (propertyType != null && propertyType != params[0]) {
	663	throw new IntrospectionException("type mismatch between read and write methods");
	664	}
	665	propertyType = params[0];
	666	}
	667	} catch (IntrospectionException ex) {
	668	throw ex;
	669	}
	670	return propertyType;
	671	}
	672
	673
	674	/**
	675	* Returns a hash code value for the object.
	676	* See {@link java.lang.Object#hashCode} for a complete description.
	677	*
	678	* @return a hash code value for this object.
	679	* @since 1.5
	680	*/
	681	public int hashCode() {
	682	int result = 7;
	683
	684	result = 37 * result + ((getPropertyType() == null) ? 0 :
	685	getPropertyType().hashCode());
	686	result = 37 * result + ((getReadMethod() == null) ? 0 :
	687	getReadMethod().hashCode());
	688	result = 37 * result + ((getWriteMethod() == null) ? 0 :
	689	getWriteMethod().hashCode());
	690	result = 37 * result + ((getPropertyEditorClass() == null) ? 0 :
	691	getPropertyEditorClass().hashCode());
	692	result = 37 * result + ((writeMethodName == null) ? 0 :
	693	writeMethodName.hashCode());
	694	result = 37 * result + ((readMethodName == null) ? 0 :
	695	readMethodName.hashCode());
	696	result = 37 * result + getName().hashCode();
	697	result = 37 * result + ((bound == false) ? 0 : 1);
	698	result = 37 * result + ((constrained == false) ? 0 : 1);
	699
	700	return result;
	701	}
	702
	703	// Calculate once since capitalize() is expensive.
	704	String getBaseName() {
	705	if (baseName == null) {
	706	baseName = NameGenerator.capitalize(getName());
	707	}
	708	return baseName;
	709	}
	710
	711	void appendTo(StringBuilder sb) {
	712	appendTo(sb, "bound", this.bound);
	713	appendTo(sb, "constrained", this.constrained);
	714	appendTo(sb, "propertyEditorClass", this.propertyEditorClassRef);
	715	appendTo(sb, "propertyType", this.propertyTypeRef);
	716	appendTo(sb, "readMethod", this.readMethodRef);
	717	appendTo(sb, "writeMethod", this.writeMethodRef);
	718	}
	719	}

java/pkg/java/beans/PropertyEditor.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyEditor.java+225−0

@@ -0,0 +1,225 @@
	1	/*
	2	* Copyright (c) 1996, 2003, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* A PropertyEditor class provides support for GUIs that want to
	30	* allow users to edit a property value of a given type.
	31	* <p>
	32	* PropertyEditor supports a variety of different kinds of ways of
	33	* displaying and updating property values. Most PropertyEditors will
	34	* only need to support a subset of the different options available in
	35	* this API.
	36	* <P>
	37	* Simple PropertyEditors may only support the getAsText and setAsText
	38	* methods and need not support (say) paintValue or getCustomEditor. More
	39	* complex types may be unable to support getAsText and setAsText but will
	40	* instead support paintValue and getCustomEditor.
	41	* <p>
	42	* Every propertyEditor must support one or more of the three simple
	43	* display styles. Thus it can either (1) support isPaintable or (2)
	44	* both return a non-null String[] from getTags() and return a non-null
	45	* value from getAsText or (3) simply return a non-null String from
	46	* getAsText().
	47	* <p>
	48	* Every property editor must support a call on setValue when the argument
	49	* object is of the type for which this is the corresponding propertyEditor.
	50	* In addition, each property editor must either support a custom editor,
	51	* or support setAsText.
	52	* <p>
	53	* Each PropertyEditor should have a null constructor.
	54	*/
	55
	56	public interface PropertyEditor {
	57
	58	/**
	59	* Set (or change) the object that is to be edited. Primitive types such
	60	* as "int" must be wrapped as the corresponding object type such as
	61	* "java.lang.Integer".
	62	*
	63	* @param value The new target object to be edited. Note that this
	64	* object should not be modified by the PropertyEditor, rather
	65	* the PropertyEditor should create a new object to hold any
	66	* modified value.
	67	*/
	68	void setValue(Object value);
	69
	70	/**
	71	* Gets the property value.
	72	*
	73	* @return The value of the property. Primitive types such as "int" will
	74	* be wrapped as the corresponding object type such as "java.lang.Integer".
	75	*/
	76
	77	Object getValue();
	78
	79	//----------------------------------------------------------------------
	80
	81	/**
	82	* Determines whether this property editor is paintable.
	83	*
	84	* @return True if the class will honor the paintValue method.
	85	*/
	86
	87	boolean isPaintable();
	88
	89	/**
	90	* Paint a representation of the value into a given area of screen
	91	* real estate. Note that the propertyEditor is responsible for doing
	92	* its own clipping so that it fits into the given rectangle.
	93	* <p>
	94	* If the PropertyEditor doesn't honor paint requests (see isPaintable)
	95	* this method should be a silent noop.
	96	* <p>
	97	* The given Graphics object will have the default font, color, etc of
	98	* the parent container. The PropertyEditor may change graphics attributes
	99	* such as font and color and doesn't need to restore the old values.
	100	*
	101	* @param gfx Graphics object to paint into.
	102	* @param box Rectangle within graphics object into which we should paint.
	103	*/
	104	void paintValue(java.awt.Graphics gfx, java.awt.Rectangle box);
	105
	106	//----------------------------------------------------------------------
	107
	108	/**
	109	* Returns a fragment of Java code that can be used to set a property
	110	* to match the editors current state. This method is intended
	111	* for use when generating Java code to reflect changes made through the
	112	* property editor.
	113	* <p>
	114	* The code fragment should be context free and must be a legal Java
	115	* expression as specified by the JLS.
	116	* <p>
	117	* Specifically, if the expression represents a computation then all
	118	* classes and static members should be fully qualified. This rule
	119	* applies to constructors, static methods and non primitive arguments.
	120	* <p>
	121	* Caution should be used when evaluating the expression as it may throw
	122	* exceptions. In particular, code generators must ensure that generated
	123	* code will compile in the presence of an expression that can throw
	124	* checked exceptions.
	125	* <p>
	126	* Example results are:
	127	* <ul>
	128	* <li>Primitive expresssion: <code>2</code>
	129	* <li>Class constructor: <code>new java.awt.Color(127,127,34)</code>
	130	* <li>Static field: <code>java.awt.Color.orange</code>
	131	* <li>Static method: <code>javax.swing.Box.createRigidArea(new
	132	* java.awt.Dimension(0, 5))</code>
	133	* </ul>
	134	*
	135	* @return a fragment of Java code representing an initializer for the
	136	* current value. It should not contain a semi-colon
	137	* ('<code>;</code>') to end the expression.
	138	*/
	139	String getJavaInitializationString();
	140
	141	//----------------------------------------------------------------------
	142
	143	/**
	144	* Gets the property value as text.
	145	*
	146	* @return The property value as a human editable string.
	147	* <p> Returns null if the value can't be expressed as an editable string.
	148	* <p> If a non-null value is returned, then the PropertyEditor should
	149	* be prepared to parse that string back in setAsText().
	150	*/
	151	String getAsText();
	152
	153	/**
	154	* Set the property value by parsing a given String. May raise
	155	* java.lang.IllegalArgumentException if either the String is
	156	* badly formatted or if this kind of property can't be expressed
	157	* as text.
	158	* @param text The string to be parsed.
	159	*/
	160	void setAsText(String text) throws java.lang.IllegalArgumentException;
	161
	162	//----------------------------------------------------------------------
	163
	164	/**
	165	* If the property value must be one of a set of known tagged values,
	166	* then this method should return an array of the tags. This can
	167	* be used to represent (for example) enum values. If a PropertyEditor
	168	* supports tags, then it should support the use of setAsText with
	169	* a tag value as a way of setting the value and the use of getAsText
	170	* to identify the current value.
	171	*
	172	* @return The tag values for this property. May be null if this
	173	* property cannot be represented as a tagged value.
	174	*
	175	*/
	176	String[] getTags();
	177
	178	//----------------------------------------------------------------------
	179
	180	/**
	181	* A PropertyEditor may choose to make available a full custom Component
	182	* that edits its property value. It is the responsibility of the
	183	* PropertyEditor to hook itself up to its editor Component itself and
	184	* to report property value changes by firing a PropertyChange event.
	185	* <P>
	186	* The higher-level code that calls getCustomEditor may either embed
	187	* the Component in some larger property sheet, or it may put it in
	188	* its own individual dialog, or ...
	189	*
	190	* @return A java.awt.Component that will allow a human to directly
	191	* edit the current property value. May be null if this is
	192	* not supported.
	193	*/
	194
	195	java.awt.Component getCustomEditor();
	196
	197	/**
	198	* Determines whether this property editor supports a custom editor.
	199	*
	200	* @return True if the propertyEditor can provide a custom editor.
	201	*/
	202	boolean supportsCustomEditor();
	203
	204	//----------------------------------------------------------------------
	205
	206	/**
	207	* Adds a listener for the value change.
	208	* When the property editor changes its value
	209	* it should fire a {@link PropertyChangeEvent}
	210	* on all registered {@link PropertyChangeListener}s,
	211	* specifying the {@code null} value for the property name
	212	* and itself as the source.
	213	*
	214	* @param listener the {@link PropertyChangeListener} to add
	215	*/
	216	void addPropertyChangeListener(PropertyChangeListener listener);
	217
	218	/**
	219	* Removes a listener for the value change.
	220	*
	221	* @param listener the {@link PropertyChangeListener} to remove
	222	*/
	223	void removePropertyChangeListener(PropertyChangeListener listener);
	224
	225	}

java/pkg/java/beans/PropertyEditorManager.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyEditorManager.java+141−0

@@ -0,0 +1,141 @@
	1	/*
	2	* Copyright (c) 1996, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import com.sun.beans.finder.PropertyEditorFinder;
	29	import sun.awt.AppContext;
	30
	31	/**
	32	* The PropertyEditorManager can be used to locate a property editor for
	33	* any given type name. This property editor must support the
	34	* java.beans.PropertyEditor interface for editing a given object.
	35	* <P>
	36	* The PropertyEditorManager uses three techniques for locating an editor
	37	* for a given type. First, it provides a registerEditor method to allow
	38	* an editor to be specifically registered for a given type. Second it
	39	* tries to locate a suitable class by adding "Editor" to the full
	40	* qualified classname of the given type (e.g. "foo.bah.FozEditor").
	41	* Finally it takes the simple classname (without the package name) adds
	42	* "Editor" to it and looks in a search-path of packages for a matching
	43	* class.
	44	* <P>
	45	* So for an input class foo.bah.Fred, the PropertyEditorManager would
	46	* first look in its tables to see if an editor had been registered for
	47	* foo.bah.Fred and if so use that. Then it will look for a
	48	* foo.bah.FredEditor class. Then it will look for (say)
	49	* standardEditorsPackage.FredEditor class.
	50	* <p>
	51	* Default PropertyEditors will be provided for the Java primitive types
	52	* "boolean", "byte", "short", "int", "long", "float", and "double"; and
	53	* for the classes java.lang.String. java.awt.Color, and java.awt.Font.
	54	*/
	55
	56	public class PropertyEditorManager {
	57
	58	private static final Object FINDER_KEY = new Object();
	59
	60	/**
	61	* Registers an editor class to edit values of the given target class.
	62	* If the editor class is {@code null},
	63	* then any existing definition will be removed.
	64	* Thus this method can be used to cancel the registration.
	65	* The registration is canceled automatically
	66	* if either the target or editor class is unloaded.
	67	* <p>
	68	* If there is a security manager, its {@code checkPropertiesAccess}
	69	* method is called. This could result in a {@linkplain SecurityException}.
	70	*
	71	* @param targetType the class object of the type to be edited
	72	* @param editorClass the class object of the editor class
	73	* @throws SecurityException if a security manager exists and
	74	* its {@code checkPropertiesAccess} method
	75	* doesn't allow setting of system properties
	76	*
	77	* @see SecurityManager#checkPropertiesAccess
	78	*/
	79	public static void registerEditor(Class<?> targetType, Class<?> editorClass) {
	80	SecurityManager sm = System.getSecurityManager();
	81	if (sm != null) {
	82	sm.checkPropertiesAccess();
	83	}
	84	getFinder().register(targetType, editorClass);
	85	}
	86
	87	/**
	88	* Locate a value editor for a given target type.
	89	*
	90	* @param targetType The Class object for the type to be edited
	91	* @return An editor object for the given target class.
	92	* The result is null if no suitable editor can be found.
	93	*/
	94	public static PropertyEditor findEditor(Class<?> targetType) {
	95	return getFinder().find(targetType);
	96	}
	97
	98	/**
	99	* Gets the package names that will be searched for property editors.
	100	*
	101	* @return The array of package names that will be searched in
	102	* order to find property editors.
	103	* <p> The default value for this array is implementation-dependent,
	104	* e.g. Sun implementation initially sets to {"sun.beans.editors"}.
	105	*/
	106	public static String[] getEditorSearchPath() {
	107	return getFinder().getPackages();
	108	}
	109
	110	/**
	111	* Change the list of package names that will be used for
	112	* finding property editors.
	113	*
	114	* <p>First, if there is a security manager, its <code>checkPropertiesAccess</code>
	115	* method is called. This could result in a SecurityException.
	116	*
	117	* @param path Array of package names.
	118	* @exception SecurityException if a security manager exists and its
	119	* <code>checkPropertiesAccess</code> method doesn't allow setting
	120	* of system properties.
	121	* @see SecurityManager#checkPropertiesAccess
	122	*/
	123	public static void setEditorSearchPath(String[] path) {
	124	SecurityManager sm = System.getSecurityManager();
	125	if (sm != null) {
	126	sm.checkPropertiesAccess();
	127	}
	128	getFinder().setPackages(path);
	129	}
	130
	131	private static PropertyEditorFinder getFinder() {
	132	AppContext context = AppContext.getAppContext();
	133	Object object = context.get(FINDER_KEY);
	134	if (object instanceof PropertyEditorFinder) {
	135	return (PropertyEditorFinder) object;
	136	}
	137	PropertyEditorFinder finder = new PropertyEditorFinder();
	138	context.put(FINDER_KEY, finder);
	139	return finder;
	140	}
	141	}

java/pkg/java/beans/PropertyEditorSupport.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyEditorSupport.java+302−0

@@ -0,0 +1,302 @@
	1	/*
	2	* Copyright (c) 1996, 2007, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.beans.*;
	29
	30	/**
	31	* This is a support class to help build property editors.
	32	* <p>
	33	* It can be used either as a base class or as a delagatee.
	34	*/
	35
	36	public class PropertyEditorSupport implements PropertyEditor {
	37
	38	/**
	39	* Constructs a <code>PropertyEditorSupport</code> object.
	40	*
	41	* @since 1.5
	42	*/
	43	public PropertyEditorSupport() {
	44	setSource(this);
	45	}
	46
	47	/**
	48	* Constructs a <code>PropertyEditorSupport</code> object.
	49	*
	50	* @param source the source used for event firing
	51	* @since 1.5
	52	*/
	53	public PropertyEditorSupport(Object source) {
	54	if (source == null) {
	55	throw new NullPointerException();
	56	}
	57	setSource(source);
	58	}
	59
	60	/**
	61	* Returns the bean that is used as the
	62	* source of events. If the source has not
	63	* been explicitly set then this instance of
	64	* <code>PropertyEditorSupport</code> is returned.
	65	*
	66	* @return the source object or this instance
	67	* @since 1.5
	68	*/
	69	public Object getSource() {
	70	return source;
	71	}
	72
	73	/**
	74	* Sets the source bean.
	75	* <p>
	76	* The source bean is used as the source of events
	77	* for the property changes. This source should be used for information
	78	* purposes only and should not be modified by the PropertyEditor.
	79	*
	80	* @param source source object to be used for events
	81	* @since 1.5
	82	*/
	83	public void setSource(Object source) {
	84	this.source = source;
	85	}
	86
	87	/**
	88	* Set (or change) the object that is to be edited.
	89	*
	90	* @param value The new target object to be edited. Note that this
	91	* object should not be modified by the PropertyEditor, rather
	92	* the PropertyEditor should create a new object to hold any
	93	* modified value.
	94	*/
	95	public void setValue(Object value) {
	96	this.value = value;
	97	firePropertyChange();
	98	}
	99
	100	/**
	101	* Gets the value of the property.
	102	*
	103	* @return The value of the property.
	104	*/
	105	public Object getValue() {
	106	return value;
	107	}
	108
	109	//----------------------------------------------------------------------
	110
	111	/**
	112	* Determines whether the class will honor the paintValue method.
	113	*
	114	* @return True if the class will honor the paintValue method.
	115	*/
	116
	117	public boolean isPaintable() {
	118	return false;
	119	}
	120
	121	/**
	122	* Paint a representation of the value into a given area of screen
	123	* real estate. Note that the propertyEditor is responsible for doing
	124	* its own clipping so that it fits into the given rectangle.
	125	* <p>
	126	* If the PropertyEditor doesn't honor paint requests (see isPaintable)
	127	* this method should be a silent noop.
	128	*
	129	* @param gfx Graphics object to paint into.
	130	* @param box Rectangle within graphics object into which we should paint.
	131	*/
	132	public void paintValue(java.awt.Graphics gfx, java.awt.Rectangle box) {
	133	}
	134
	135	//----------------------------------------------------------------------
	136
	137	/**
	138	* This method is intended for use when generating Java code to set
	139	* the value of the property. It should return a fragment of Java code
	140	* that can be used to initialize a variable with the current property
	141	* value.
	142	* <p>
	143	* Example results are "2", "new Color(127,127,34)", "Color.orange", etc.
	144	*
	145	* @return A fragment of Java code representing an initializer for the
	146	* current value.
	147	*/
	148	public String getJavaInitializationString() {
	149	return "???";
	150	}
	151
	152	//----------------------------------------------------------------------
	153
	154	/**
	155	* Gets the property value as a string suitable for presentation
	156	* to a human to edit.
	157	*
	158	* @return The property value as a string suitable for presentation
	159	* to a human to edit.
	160	* <p> Returns null if the value can't be expressed as a string.
	161	* <p> If a non-null value is returned, then the PropertyEditor should
	162	* be prepared to parse that string back in setAsText().
	163	*/
	164	public String getAsText() {
	165	return (this.value != null)
	166	? this.value.toString()
	167	: null;
	168	}
	169
	170	/**
	171	* Sets the property value by parsing a given String. May raise
	172	* java.lang.IllegalArgumentException if either the String is
	173	* badly formatted or if this kind of property can't be expressed
	174	* as text.
	175	*
	176	* @param text The string to be parsed.
	177	*/
	178	public void setAsText(String text) throws java.lang.IllegalArgumentException {
	179	if (value instanceof String) {
	180	setValue(text);
	181	return;
	182	}
	183	throw new java.lang.IllegalArgumentException(text);
	184	}
	185
	186	//----------------------------------------------------------------------
	187
	188	/**
	189	* If the property value must be one of a set of known tagged values,
	190	* then this method should return an array of the tag values. This can
	191	* be used to represent (for example) enum values. If a PropertyEditor
	192	* supports tags, then it should support the use of setAsText with
	193	* a tag value as a way of setting the value.
	194	*
	195	* @return The tag values for this property. May be null if this
	196	* property cannot be represented as a tagged value.
	197	*
	198	*/
	199	public String[] getTags() {
	200	return null;
	201	}
	202
	203	//----------------------------------------------------------------------
	204
	205	/**
	206	* A PropertyEditor may chose to make available a full custom Component
	207	* that edits its property value. It is the responsibility of the
	208	* PropertyEditor to hook itself up to its editor Component itself and
	209	* to report property value changes by firing a PropertyChange event.
	210	* <P>
	211	* The higher-level code that calls getCustomEditor may either embed
	212	* the Component in some larger property sheet, or it may put it in
	213	* its own individual dialog, or ...
	214	*
	215	* @return A java.awt.Component that will allow a human to directly
	216	* edit the current property value. May be null if this is
	217	* not supported.
	218	*/
	219
	220	public java.awt.Component getCustomEditor() {
	221	return null;
	222	}
	223
	224	/**
	225	* Determines whether the propertyEditor can provide a custom editor.
	226	*
	227	* @return True if the propertyEditor can provide a custom editor.
	228	*/
	229	public boolean supportsCustomEditor() {
	230	return false;
	231	}
	232
	233	//----------------------------------------------------------------------
	234
	235	/**
	236	* Adds a listener for the value change.
	237	* When the property editor changes its value
	238	* it should fire a {@link PropertyChangeEvent}
	239	* on all registered {@link PropertyChangeListener}s,
	240	* specifying the {@code null} value for the property name.
	241	* If the source property is set,
	242	* it should be used as the source of the event.
	243	* <p>
	244	* The same listener object may be added more than once,
	245	* and will be called as many times as it is added.
	246	* If {@code listener} is {@code null},
	247	* no exception is thrown and no action is taken.
	248	*
	249	* @param listener the {@link PropertyChangeListener} to add
	250	*/
	251	public synchronized void addPropertyChangeListener(
	252	PropertyChangeListener listener) {
	253	if (listeners == null) {
	254	listeners = new java.util.Vector();
	255	}
	256	listeners.addElement(listener);
	257	}
	258
	259	/**
	260	* Removes a listener for the value change.
	261	* <p>
	262	* If the same listener was added more than once,
	263	* it will be notified one less time after being removed.
	264	* If {@code listener} is {@code null}, or was never added,
	265	* no exception is thrown and no action is taken.
	266	*
	267	* @param listener the {@link PropertyChangeListener} to remove
	268	*/
	269	public synchronized void removePropertyChangeListener(
	270	PropertyChangeListener listener) {
	271	if (listeners == null) {
	272	return;
	273	}
	274	listeners.removeElement(listener);
	275	}
	276
	277	/**
	278	* Report that we have been modified to any interested listeners.
	279	*/
	280	public void firePropertyChange() {
	281	java.util.Vector targets;
	282	synchronized (this) {
	283	if (listeners == null) {
	284	return;
	285	}
	286	targets = (java.util.Vector) listeners.clone();
	287	}
	288	// Tell our listeners that "everything" has changed.
	289	PropertyChangeEvent evt = new PropertyChangeEvent(source, null, null, null);
	290
	291	for (int i = 0; i < targets.size(); i++) {
	292	PropertyChangeListener target = (PropertyChangeListener)targets.elementAt(i);
	293	target.propertyChange(evt);
	294	}
	295	}
	296
	297	//----------------------------------------------------------------------
	298
	299	private Object value;
	300	private Object source;
	301	private java.util.Vector listeners;
	302	}

java/pkg/java/beans/PropertyVetoException.class+0−0

Binary file not shown.

java/pkg/java/beans/PropertyVetoException.java+64−0

@@ -0,0 +1,64 @@
	1	/*
	2	* Copyright (c) 1996, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28
	29	/**
	30	* A PropertyVetoException is thrown when a proposed change to a
	31	* property represents an unacceptable value.
	32	*/
	33
	34	public
	35	class PropertyVetoException extends Exception {
	36	private static final long serialVersionUID = 129596057694162164L;
	37
	38	/**
	39	* Constructs a <code>PropertyVetoException</code> with a
	40	* detailed message.
	41	*
	42	* @param mess Descriptive message
	43	* @param evt A PropertyChangeEvent describing the vetoed change.
	44	*/
	45	public PropertyVetoException(String mess, PropertyChangeEvent evt) {
	46	super(mess);
	47	this.evt = evt;
	48	}
	49
	50	/**
	51	* Gets the vetoed <code>PropertyChangeEvent</code>.
	52	*
	53	* @return A PropertyChangeEvent describing the vetoed change.
	54	*/
	55	public PropertyChangeEvent getPropertyChangeEvent() {
	56	return evt;
	57	}
	58
	59	/**
	60	* A PropertyChangeEvent describing the vetoed change.
	61	* @serial
	62	*/
	63	private PropertyChangeEvent evt;
	64	}

java/pkg/java/beans/ProxyPersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/ReflectionUtils.class+0−0

Binary file not shown.

java/pkg/java/beans/ReflectionUtils.java+75−0

@@ -0,0 +1,75 @@
	1	/*
	2	* Copyright (c) 2003, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import java.lang.reflect.Field;
	28
	29	/**
	30	* A utility class for reflectively finding methods, constuctors and fields
	31	* using reflection.
	32	*/
	33	class ReflectionUtils {
	34
	35	public static boolean isPrimitive(Class type) {
	36	return primitiveTypeFor(type) != null;
	37	}
	38
	39	public static Class primitiveTypeFor(Class wrapper) {
	40	if (wrapper == Boolean.class) return Boolean.TYPE;
	41	if (wrapper == Byte.class) return Byte.TYPE;
	42	if (wrapper == Character.class) return Character.TYPE;
	43	if (wrapper == Short.class) return Short.TYPE;
	44	if (wrapper == Integer.class) return Integer.TYPE;
	45	if (wrapper == Long.class) return Long.TYPE;
	46	if (wrapper == Float.class) return Float.TYPE;
	47	if (wrapper == Double.class) return Double.TYPE;
	48	if (wrapper == Void.class) return Void.TYPE;
	49	return null;
	50	}
	51
	52	/**
	53	* Returns the value of a private field.
	54	*
	55	* @param instance object instance
	56	* @param cls class
	57	* @param name name of the field
	58	* @param el an exception listener to handle exceptions; or null
	59	* @return value of the field; null if not found or an error is encountered
	60	*/
	61	public static Object getPrivateField(Object instance, Class cls,
	62	String name, ExceptionListener el) {
	63	try {
	64	Field f = cls.getDeclaredField(name);
	65	f.setAccessible(true);
	66	return f.get(instance);
	67	}
	68	catch (Exception e) {
	69	if (el != null) {
	70	el.exceptionThrown(e);
	71	}
	72	}
	73	return null;
	74	}
	75	}

java/pkg/java/beans/SimpleBeanInfo$1.class+0−0

Binary file not shown.

java/pkg/java/beans/SimpleBeanInfo.class+0−0

Binary file not shown.

java/pkg/java/beans/SimpleBeanInfo.java+146−0

@@ -0,0 +1,146 @@
	1	/*
	2	* Copyright (c) 1996, 1998, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* This is a support class to make it easier for people to provide
	30	* BeanInfo classes.
	31	* <p>
	32	* It defaults to providing "noop" information, and can be selectively
	33	* overriden to provide more explicit information on chosen topics.
	34	* When the introspector sees the "noop" values, it will apply low
	35	* level introspection and design patterns to automatically analyze
	36	* the target bean.
	37	*/
	38
	39	public class SimpleBeanInfo implements BeanInfo {
	40
	41	/**
	42	* Deny knowledge about the class and customizer of the bean.
	43	* You can override this if you wish to provide explicit info.
	44	*/
	45	public BeanDescriptor getBeanDescriptor() {
	46	return null;
	47	}
	48
	49	/**
	50	* Deny knowledge of properties. You can override this
	51	* if you wish to provide explicit property info.
	52	*/
	53	public PropertyDescriptor[] getPropertyDescriptors() {
	54	return null;
	55	}
	56
	57	/**
	58	* Deny knowledge of a default property. You can override this
	59	* if you wish to define a default property for the bean.
	60	*/
	61	public int getDefaultPropertyIndex() {
	62	return -1;
	63	}
	64
	65	/**
	66	* Deny knowledge of event sets. You can override this
	67	* if you wish to provide explicit event set info.
	68	*/
	69	public EventSetDescriptor[] getEventSetDescriptors() {
	70	return null;
	71	}
	72
	73	/**
	74	* Deny knowledge of a default event. You can override this
	75	* if you wish to define a default event for the bean.
	76	*/
	77	public int getDefaultEventIndex() {
	78	return -1;
	79	}
	80
	81	/**
	82	* Deny knowledge of methods. You can override this
	83	* if you wish to provide explicit method info.
	84	*/
	85	public MethodDescriptor[] getMethodDescriptors() {
	86	return null;
	87	}
	88
	89	/**
	90	* Claim there are no other relevant BeanInfo objects. You
	91	* may override this if you want to (for example) return a
	92	* BeanInfo for a base class.
	93	*/
	94	public BeanInfo[] getAdditionalBeanInfo() {
	95	return null;
	96	}
	97
	98	/**
	99	* Claim there are no icons available. You can override
	100	* this if you want to provide icons for your bean.
	101	*/
	102	public java.awt.Image getIcon(int iconKind) {
	103	return null;
	104	}
	105
	106	/**
	107	* This is a utility method to help in loading icon images.
	108	* It takes the name of a resource file associated with the
	109	* current object's class file and loads an image object
	110	* from that file. Typically images will be GIFs.
	111	* <p>
	112	* @param resourceName A pathname relative to the directory
	113	* holding the class file of the current class. For example,
	114	* "wombat.gif".
	115	* @return an image object. May be null if the load failed.
	116	*/
	117	public java.awt.Image loadImage(final String resourceName) {
	118	try {
	119	final Class c = getClass();
	120	java.awt.image.ImageProducer ip = (java.awt.image.ImageProducer)
	121	java.security.AccessController.doPrivileged(
	122	new java.security.PrivilegedAction() {
	123	public Object run() {
	124	java.net.URL url;
	125	if ((url = c.getResource(resourceName)) == null) {
	126	return null;
	127	} else {
	128	try {
	129	return url.getContent();
	130	} catch (java.io.IOException ioe) {
	131	return null;
	132	}
	133	}
	134	}
	135	});
	136
	137	if (ip == null)
	138	return null;
	139	java.awt.Toolkit tk = java.awt.Toolkit.getDefaultToolkit();
	140	return tk.createImage(ip);
	141	} catch (Exception ex) {
	142	return null;
	143	}
	144	}
	145
	146	}

java/pkg/java/beans/Statement$1.class+0−0

Binary file not shown.

java/pkg/java/beans/Statement$2.class+0−0

Binary file not shown.

java/pkg/java/beans/Statement.class+0−0

Binary file not shown.

java/pkg/java/beans/Statement.java+363−0

@@ -0,0 +1,363 @@
	1	/*
	2	* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import java.lang.reflect.AccessibleObject;
	28	import java.lang.reflect.Array;
	29	import java.lang.reflect.Constructor;
	30	import java.lang.reflect.InvocationTargetException;
	31	import java.lang.reflect.Method;
	32	import java.security.AccessControlContext;
	33	import java.security.AccessController;
	34	import java.security.PrivilegedActionException;
	35	import java.security.PrivilegedExceptionAction;
	36
	37	import com.sun.beans.finder.ClassFinder;
	38	import com.sun.beans.finder.ConstructorFinder;
	39	import com.sun.beans.finder.MethodFinder;
	40	import sun.reflect.misc.MethodUtil;
	41
	42	/**
	43	* A <code>Statement</code> object represents a primitive statement
	44	* in which a single method is applied to a target and
	45	* a set of arguments - as in <code>"a.setFoo(b)"</code>.
	46	* Note that where this example uses names
	47	* to denote the target and its argument, a statement
	48	* object does not require a name space and is constructed with
	49	* the values themselves.
	50	* The statement object associates the named method
	51	* with its environment as a simple set of values:
	52	* the target and an array of argument values.
	53	*
	54	* @since 1.4
	55	*
	56	* @author Philip Milne
	57	*/
	58	public class Statement {
	59
	60	private static Object[] emptyArray = new Object[]{};
	61
	62	static ExceptionListener defaultExceptionListener = new ExceptionListener() {
	63	public void exceptionThrown(Exception e) {
	64	System.err.println(e);
	65	// e.printStackTrace();
	66	System.err.println("Continuing ...");
	67	}
	68	};
	69
	70	private final AccessControlContext acc = AccessController.getContext();
	71	private final Object target;
	72	private final String methodName;
	73	private final Object[] arguments;
	74	ClassLoader loader;
	75
	76	/**
	77	* Creates a new {@link Statement} object
	78	* for the specified target object to invoke the method
	79	* specified by the name and by the array of arguments.
	80	* <p>
	81	* The {@code target} and the {@code methodName} values should not be {@code null}.
	82	* Otherwise an attempt to execute this {@code Expression}
	83	* will result in a {@code NullPointerException}.
	84	* If the {@code arguments} value is {@code null},
	85	* an empty array is used as the value of the {@code arguments} property.
	86	*
	87	* @param target the target object of this statement
	88	* @param methodName the name of the method to invoke on the specified target
	89	* @param arguments the array of arguments to invoke the specified method
	90	*/
	91	@ConstructorProperties({"target", "methodName", "arguments"})
	92	public Statement(Object target, String methodName, Object[] arguments) {
	93	this.target = target;
	94	this.methodName = methodName;
	95	this.arguments = (arguments == null) ? emptyArray : arguments;
	96	}
	97
	98	/**
	99	* Returns the target object of this statement.
	100	* If this method returns {@code null},
	101	* the {@link #execute} method
	102	* throws a {@code NullPointerException}.
	103	*
	104	* @return the target object of this statement
	105	*/
	106	public Object getTarget() {
	107	return target;
	108	}
	109
	110	/**
	111	* Returns the name of the method to invoke.
	112	* If this method returns {@code null},
	113	* the {@link #execute} method
	114	* throws a {@code NullPointerException}.
	115	*
	116	* @return the name of the method
	117	*/
	118	public String getMethodName() {
	119	return methodName;
	120	}
	121
	122	/**
	123	* Returns the arguments for the method to invoke.
	124	* The number of arguments and their types
	125	* must match the method being called.
	126	* {@code null} can be used as a synonym of an empty array.
	127	*
	128	* @return the array of arguments
	129	*/
	130	public Object[] getArguments() {
	131	return arguments;
	132	}
	133
	134	/**
	135	* The {@code execute} method finds a method whose name is the same
	136	* as the {@code methodName} property, and invokes the method on
	137	* the target.
	138	*
	139	* When the target's class defines many methods with the given name
	140	* the implementation should choose the most specific method using
	141	* the algorithm specified in the Java Language Specification
	142	* (15.11). The dynamic class of the target and arguments are used
	143	* in place of the compile-time type information and, like the
	144	* {@link java.lang.reflect.Method} class itself, conversion between
	145	* primitive values and their associated wrapper classes is handled
	146	* internally.
	147	* <p>
	148	* The following method types are handled as special cases:
	149	* <ul>
	150	* <li>
	151	* Static methods may be called by using a class object as the target.
	152	* <li>
	153	* The reserved method name "new" may be used to call a class's constructor
	154	* as if all classes defined static "new" methods. Constructor invocations
	155	* are typically considered {@code Expression}s rather than {@code Statement}s
	156	* as they return a value.
	157	* <li>
	158	* The method names "get" and "set" defined in the {@link java.util.List}
	159	* interface may also be applied to array instances, mapping to
	160	* the static methods of the same name in the {@code Array} class.
	161	* </ul>
	162	*
	163	* @throws NullPointerException if the value of the {@code target} or
	164	* {@code methodName} property is {@code null}
	165	* @throws NoSuchMethodException if a matching method is not found
	166	* @throws SecurityException if a security manager exists and
	167	* it denies the method invocation
	168	* @throws Exception that is thrown by the invoked method
	169	*
	170	* @see java.lang.reflect.Method
	171	*/
	172	public void execute() throws Exception {
	173	invoke();
	174	}
	175
	176	Object invoke() throws Exception {
	177	AccessControlContext acc = this.acc;
	178	if ((acc == null) && (System.getSecurityManager() != null)) {
	179	throw new SecurityException("AccessControlContext is not set");
	180	}
	181	try {
	182	return AccessController.doPrivileged(
	183	new PrivilegedExceptionAction<Object>() {
	184	public Object run() throws Exception {
	185	return invokeInternal();
	186	}
	187	},
	188	acc
	189	);
	190	}
	191	catch (PrivilegedActionException exception) {
	192	throw exception.getException();
	193	}
	194	}
	195
	196	private Object invokeInternal() throws Exception {
	197	Object target = getTarget();
	198	String methodName = getMethodName();
	199
	200	if (target == null \|\| methodName == null) {
	201	throw new NullPointerException((target == null ? "target" :
	202	"methodName") + " should not be null");
	203	}
	204
	205	Object[] arguments = getArguments();
	206	if (arguments == null) {
	207	arguments = emptyArray;
	208	}
	209	// Class.forName() won't load classes outside
	210	// of core from a class inside core. Special
	211	// case this method.
	212	if (target == Class.class && methodName.equals("forName")) {
	213	return ClassFinder.resolveClass((String)arguments[0], this.loader);
	214	}
	215	Class[] argClasses = new Class[arguments.length];
	216	for(int i = 0; i < arguments.length; i++) {
	217	argClasses[i] = (arguments[i] == null) ? null : arguments[i].getClass();
	218	}
	219
	220	AccessibleObject m = null;
	221	if (target instanceof Class) {
	222	/*
	223	For class methods, simluate the effect of a meta class
	224	by taking the union of the static methods of the
	225	actual class, with the instance methods of "Class.class"
	226	and the overloaded "newInstance" methods defined by the
	227	constructors.
	228	This way "System.class", for example, will perform both
	229	the static method getProperties() and the instance method
	230	getSuperclass() defined in "Class.class".
	231	*/
	232	if (methodName.equals("new")) {
	233	methodName = "newInstance";
	234	}
	235	// Provide a short form for array instantiation by faking an nary-constructor.
	236	if (methodName.equals("newInstance") && ((Class)target).isArray()) {
	237	Object result = Array.newInstance(((Class)target).getComponentType(), arguments.length);
	238	for(int i = 0; i < arguments.length; i++) {
	239	Array.set(result, i, arguments[i]);
	240	}
	241	return result;
	242	}
	243	if (methodName.equals("newInstance") && arguments.length != 0) {
	244	// The Character class, as of 1.4, does not have a constructor
	245	// which takes a String. All of the other "wrapper" classes
	246	// for Java's primitive types have a String constructor so we
	247	// fake such a constructor here so that this special case can be
	248	// ignored elsewhere.
	249	if (target == Character.class && arguments.length == 1 &&
	250	argClasses[0] == String.class) {
	251	return new Character(((String)arguments[0]).charAt(0));
	252	}
	253	try {
	254	m = ConstructorFinder.findConstructor((Class)target, argClasses);
	255	}
	256	catch (NoSuchMethodException exception) {
	257	m = null;
	258	}
	259	}
	260	if (m == null && target != Class.class) {
	261	m = getMethod((Class)target, methodName, argClasses);
	262	}
	263	if (m == null) {
	264	m = getMethod(Class.class, methodName, argClasses);
	265	}
	266	}
	267	else {
	268	/*
	269	This special casing of arrays is not necessary, but makes files
	270	involving arrays much shorter and simplifies the archiving infrastrcure.
	271	The Array.set() method introduces an unusual idea - that of a static method
	272	changing the state of an instance. Normally statements with side
	273	effects on objects are instance methods of the objects themselves
	274	and we reinstate this rule (perhaps temporarily) by special-casing arrays.
	275	*/
	276	if (target.getClass().isArray() &&
	277	(methodName.equals("set") \|\| methodName.equals("get"))) {
	278	int index = ((Integer)arguments[0]).intValue();
	279	if (methodName.equals("get")) {
	280	return Array.get(target, index);
	281	}
	282	else {
	283	Array.set(target, index, arguments[1]);
	284	return null;
	285	}
	286	}
	287	m = getMethod(target.getClass(), methodName, argClasses);
	288	}
	289	if (m != null) {
	290	try {
	291	if (m instanceof Method) {
	292	return MethodUtil.invoke((Method)m, target, arguments);
	293	}
	294	else {
	295	return ((Constructor)m).newInstance(arguments);
	296	}
	297	}
	298	catch (IllegalAccessException iae) {
	299	throw new Exception("Statement cannot invoke: " +
	300	methodName + " on " + target.getClass(),
	301	iae);
	302	}
	303	catch (InvocationTargetException ite) {
	304	Throwable te = ite.getTargetException();
	305	if (te instanceof Exception) {
	306	throw (Exception)te;
	307	}
	308	else {
	309	throw ite;
	310	}
	311	}
	312	}
	313	throw new NoSuchMethodException(toString());
	314	}
	315
	316	String instanceName(Object instance) {
	317	if (instance == null) {
	318	return "null";
	319	} else if (instance.getClass() == String.class) {
	320	return "\""+(String)instance + "\"";
	321	} else {
	322	// Note: there is a minor problem with using the non-caching
	323	// NameGenerator method. The return value will not have
	324	// specific information about the inner class name. For example,
	325	// In 1.4.2 an inner class would be represented as JList$1 now
	326	// would be named Class.
	327
	328	return NameGenerator.unqualifiedClassName(instance.getClass());
	329	}
	330	}
	331
	332	/**
	333	* Prints the value of this statement using a Java-style syntax.
	334	*/
	335	public String toString() {
	336	// Respect a subclass's implementation here.
	337	Object target = getTarget();
	338	String methodName = getMethodName();
	339	Object[] arguments = getArguments();
	340	if (arguments == null) {
	341	arguments = emptyArray;
	342	}
	343	StringBuffer result = new StringBuffer(instanceName(target) + "." + methodName + "(");
	344	int n = arguments.length;
	345	for(int i = 0; i < n; i++) {
	346	result.append(instanceName(arguments[i]));
	347	if (i != n -1) {
	348	result.append(", ");
	349	}
	350	}
	351	result.append(");");
	352	return result.toString();
	353	}
	354
	355	static Method getMethod(Class<?> type, String name, Class<?>... args) {
	356	try {
	357	return MethodFinder.findMethod(type, name, args);
	358	}
	359	catch (NoSuchMethodException exception) {
	360	return null;
	361	}
	362	}
	363	}

java/pkg/java/beans/StaticFieldsPersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/Transient.class+0−0

Binary file not shown.

java/pkg/java/beans/Transient.java+68−0

@@ -0,0 +1,68 @@
	1	/*
	2	* Copyright (c) 2008, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.lang.annotation.Retention;
	29	import java.lang.annotation.Target;
	30
	31	import static java.lang.annotation.ElementType.METHOD;
	32	import static java.lang.annotation.RetentionPolicy.RUNTIME;
	33
	34	/**
	35	* Indicates that an attribute called "transient"
	36	* should be declared with the given {@code value}
	37	* when the {@link Introspector} constructs
	38	* a {@link PropertyDescriptor} or {@link EventSetDescriptor}
	39	* classes associated with the annotated code element.
	40	* A {@code true} value for the "transient" attribute
	41	* indicates to encoders derived from {@link Encoder}
	42	* that this feature should be ignored.
	43	* <p/>
	44	* The {@code Transient} annotation may be be used
	45	* in any of the methods that are involved
	46	* in a {@link FeatureDescriptor} subclass
	47	* to identify the transient feature in the annotated class and its subclasses.
	48	* Normally, the method that starts with "get" is the best place
	49	* to put the annotation and it is this declaration
	50	* that takes precedence in the case of multiple annotations
	51	* being defined for the same feature.
	52	* <p/>
	53	* To declare a feature non-transient in a class
	54	* whose superclass declares it transient,
	55	* use {@code @Transient(false)}.
	56	* In all cases, the {@link Introspector} decides
	57	* if a feature is transient by referring to the annotation
	58	* on the most specific superclass.
	59	* If no {@code Transient} annotation is present
	60	* in any superclass the feature is not transient.
	61	*
	62	* @since 1.7
	63	*/
	64	@Target({METHOD})
	65	@Retention(RUNTIME)
	66	public @interface Transient {
	67	boolean value() default true;
	68	}

java/pkg/java/beans/VetoableChangeListener.class+0−0

Binary file not shown.

java/pkg/java/beans/VetoableChangeListener.java+44−0

@@ -0,0 +1,44 @@
	1	/*
	2	* Copyright (c) 1996, 1997, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* A VetoableChange event gets fired whenever a bean changes a "constrained"
	30	* property. You can register a VetoableChangeListener with a source bean
	31	* so as to be notified of any constrained property updates.
	32	*/
	33	public interface VetoableChangeListener extends java.util.EventListener {
	34	/**
	35	* This method gets called when a constrained property is changed.
	36	*
	37	* @param evt a <code>PropertyChangeEvent</code> object describing the
	38	* event source and the property that has changed.
	39	* @exception PropertyVetoException if the recipient wishes the property
	40	* change to be rolled back.
	41	*/
	42	void vetoableChange(PropertyChangeEvent evt)
	43	throws PropertyVetoException;
	44	}

java/pkg/java/beans/VetoableChangeListenerProxy.class+0−0

Binary file not shown.

java/pkg/java/beans/VetoableChangeListenerProxy.java+84−0

@@ -0,0 +1,84 @@
	1	/*
	2	* Copyright (c) 2000, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	import java.util.EventListenerProxy;
	29
	30	/**
	31	* A class which extends the {@code EventListenerProxy}
	32	* specifically for adding a {@code VetoableChangeListener}
	33	* with a "constrained" property.
	34	* Instances of this class can be added
	35	* as {@code VetoableChangeListener}s to a bean
	36	* which supports firing vetoable change events.
	37	* <p>
	38	* If the object has a {@code getVetoableChangeListeners} method
	39	* then the array returned could be a mixture of {@code VetoableChangeListener}
	40	* and {@code VetoableChangeListenerProxy} objects.
	41	*
	42	* @see java.util.EventListenerProxy
	43	* @see VetoableChangeSupport#getVetoableChangeListeners
	44	* @since 1.4
	45	*/
	46	public class VetoableChangeListenerProxy
	47	extends EventListenerProxy<VetoableChangeListener>
	48	implements VetoableChangeListener {
	49
	50	private final String propertyName;
	51
	52	/**
	53	* Constructor which binds the {@code VetoableChangeListener}
	54	* to a specific property.
	55	*
	56	* @param propertyName the name of the property to listen on
	57	* @param listener the listener object
	58	*/
	59	public VetoableChangeListenerProxy(String propertyName, VetoableChangeListener listener) {
	60	super(listener);
	61	this.propertyName = propertyName;
	62	}
	63
	64	/**
	65	* Forwards the property change event to the listener delegate.
	66	*
	67	* @param event the property change event
	68	*
	69	* @exception PropertyVetoException if the recipient wishes the property
	70	* change to be rolled back
	71	*/
	72	public void vetoableChange(PropertyChangeEvent event) throws PropertyVetoException{
	73	getListener().vetoableChange(event);
	74	}
	75
	76	/**
	77	* Returns the name of the named property associated with the listener.
	78	*
	79	* @return the name of the named property associated with the listener
	80	*/
	81	public String getPropertyName() {
	82	return this.propertyName;
	83	}
	84	}

java/pkg/java/beans/VetoableChangeSupport$1.class+0−0

Binary file not shown.

java/pkg/java/beans/VetoableChangeSupport$VetoableChangeListenerMap.class+0−0

Binary file not shown.

java/pkg/java/beans/VetoableChangeSupport.class+0−0

Binary file not shown.

java/pkg/java/beans/VetoableChangeSupport.java+525−0

@@ -0,0 +1,525 @@
	1	/*
	2	* Copyright (c) 1996, 2011, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import java.io.Serializable;
	28	import java.io.ObjectStreamField;
	29	import java.io.ObjectOutputStream;
	30	import java.io.ObjectInputStream;
	31	import java.io.IOException;
	32	import java.util.Hashtable;
	33	import java.util.Map.Entry;
	34
	35	/**
	36	* This is a utility class that can be used by beans that support constrained
	37	* properties. It manages a list of listeners and dispatches
	38	* {@link PropertyChangeEvent}s to them. You can use an instance of this class
	39	* as a member field of your bean and delegate these types of work to it.
	40	* The {@link VetoableChangeListener} can be registered for all properties
	41	* or for a property specified by name.
	42	* <p>
	43	* Here is an example of {@code VetoableChangeSupport} usage that follows
	44	* the rules and recommendations laid out in the JavaBeans™ specification:
	45	* <pre>
	46	* public class MyBean {
	47	* private final VetoableChangeSupport vcs = new VetoableChangeSupport(this);
	48	*
	49	* public void addVetoableChangeListener(VetoableChangeListener listener) {
	50	* this.vcs.addVetoableChangeListener(listener);
	51	* }
	52	*
	53	* public void removeVetoableChangeListener(VetoableChangeListener listener) {
	54	* this.vcs.removeVetoableChangeListener(listener);
	55	* }
	56	*
	57	* private String value;
	58	*
	59	* public String getValue() {
	60	* return this.value;
	61	* }
	62	*
	63	* public void setValue(String newValue) throws PropertyVetoException {
	64	* String oldValue = this.value;
	65	* this.vcs.fireVetoableChange("value", oldValue, newValue);
	66	* this.value = newValue;
	67	* }
	68	*
	69	* [...]
	70	* }
	71	* </pre>
	72	* <p>
	73	* A {@code VetoableChangeSupport} instance is thread-safe.
	74	* <p>
	75	* This class is serializable. When it is serialized it will save
	76	* (and restore) any listeners that are themselves serializable. Any
	77	* non-serializable listeners will be skipped during serialization.
	78	*
	79	* @see PropertyChangeSupport
	80	*/
	81	public class VetoableChangeSupport implements Serializable {
	82	private VetoableChangeListenerMap map = new VetoableChangeListenerMap();
	83
	84	/**
	85	* Constructs a <code>VetoableChangeSupport</code> object.
	86	*
	87	* @param sourceBean The bean to be given as the source for any events.
	88	*/
	89	public VetoableChangeSupport(Object sourceBean) {
	90	if (sourceBean == null) {
	91	throw new NullPointerException();
	92	}
	93	source = sourceBean;
	94	}
	95
	96	/**
	97	* Add a VetoableChangeListener to the listener list.
	98	* The listener is registered for all properties.
	99	* The same listener object may be added more than once, and will be called
	100	* as many times as it is added.
	101	* If <code>listener</code> is null, no exception is thrown and no action
	102	* is taken.
	103	*
	104	* @param listener The VetoableChangeListener to be added
	105	*/
	106	public void addVetoableChangeListener(VetoableChangeListener listener) {
	107	if (listener == null) {
	108	return;
	109	}
	110	if (listener instanceof VetoableChangeListenerProxy) {
	111	VetoableChangeListenerProxy proxy =
	112	(VetoableChangeListenerProxy)listener;
	113	// Call two argument add method.
	114	addVetoableChangeListener(proxy.getPropertyName(),
	115	proxy.getListener());
	116	} else {
	117	this.map.add(null, listener);
	118	}
	119	}
	120
	121	/**
	122	* Remove a VetoableChangeListener from the listener list.
	123	* This removes a VetoableChangeListener that was registered
	124	* for all properties.
	125	* If <code>listener</code> was added more than once to the same event
	126	* source, it will be notified one less time after being removed.
	127	* If <code>listener</code> is null, or was never added, no exception is
	128	* thrown and no action is taken.
	129	*
	130	* @param listener The VetoableChangeListener to be removed
	131	*/
	132	public void removeVetoableChangeListener(VetoableChangeListener listener) {
	133	if (listener == null) {
	134	return;
	135	}
	136	if (listener instanceof VetoableChangeListenerProxy) {
	137	VetoableChangeListenerProxy proxy =
	138	(VetoableChangeListenerProxy)listener;
	139	// Call two argument remove method.
	140	removeVetoableChangeListener(proxy.getPropertyName(),
	141	proxy.getListener());
	142	} else {
	143	this.map.remove(null, listener);
	144	}
	145	}
	146
	147	/**
	148	* Returns an array of all the listeners that were added to the
	149	* VetoableChangeSupport object with addVetoableChangeListener().
	150	* <p>
	151	* If some listeners have been added with a named property, then
	152	* the returned array will be a mixture of VetoableChangeListeners
	153	* and <code>VetoableChangeListenerProxy</code>s. If the calling
	154	* method is interested in distinguishing the listeners then it must
	155	* test each element to see if it's a
	156	* <code>VetoableChangeListenerProxy</code>, perform the cast, and examine
	157	* the parameter.
	158	*
	159	* <pre>
	160	* VetoableChangeListener[] listeners = bean.getVetoableChangeListeners();
	161	* for (int i = 0; i < listeners.length; i++) {
	162	* if (listeners[i] instanceof VetoableChangeListenerProxy) {
	163	* VetoableChangeListenerProxy proxy =
	164	* (VetoableChangeListenerProxy)listeners[i];
	165	* if (proxy.getPropertyName().equals("foo")) {
	166	* // proxy is a VetoableChangeListener which was associated
	167	* // with the property named "foo"
	168	* }
	169	* }
	170	* }
	171	*</pre>
	172	*
	173	* @see VetoableChangeListenerProxy
	174	* @return all of the <code>VetoableChangeListeners</code> added or an
	175	* empty array if no listeners have been added
	176	* @since 1.4
	177	*/
	178	public VetoableChangeListener[] getVetoableChangeListeners(){
	179	return this.map.getListeners();
	180	}
	181
	182	/**
	183	* Add a VetoableChangeListener for a specific property. The listener
	184	* will be invoked only when a call on fireVetoableChange names that
	185	* specific property.
	186	* The same listener object may be added more than once. For each
	187	* property, the listener will be invoked the number of times it was added
	188	* for that property.
	189	* If <code>propertyName</code> or <code>listener</code> is null, no
	190	* exception is thrown and no action is taken.
	191	*
	192	* @param propertyName The name of the property to listen on.
	193	* @param listener The VetoableChangeListener to be added
	194	*/
	195	public void addVetoableChangeListener(
	196	String propertyName,
	197	VetoableChangeListener listener) {
	198	if (listener == null \|\| propertyName == null) {
	199	return;
	200	}
	201	listener = this.map.extract(listener);
	202	if (listener != null) {
	203	this.map.add(propertyName, listener);
	204	}
	205	}
	206
	207	/**
	208	* Remove a VetoableChangeListener for a specific property.
	209	* If <code>listener</code> was added more than once to the same event
	210	* source for the specified property, it will be notified one less time
	211	* after being removed.
	212	* If <code>propertyName</code> is null, no exception is thrown and no
	213	* action is taken.
	214	* If <code>listener</code> is null, or was never added for the specified
	215	* property, no exception is thrown and no action is taken.
	216	*
	217	* @param propertyName The name of the property that was listened on.
	218	* @param listener The VetoableChangeListener to be removed
	219	*/
	220	public void removeVetoableChangeListener(
	221	String propertyName,
	222	VetoableChangeListener listener) {
	223	if (listener == null \|\| propertyName == null) {
	224	return;
	225	}
	226	listener = this.map.extract(listener);
	227	if (listener != null) {
	228	this.map.remove(propertyName, listener);
	229	}
	230	}
	231
	232	/**
	233	* Returns an array of all the listeners which have been associated
	234	* with the named property.
	235	*
	236	* @param propertyName The name of the property being listened to
	237	* @return all the <code>VetoableChangeListeners</code> associated with
	238	* the named property. If no such listeners have been added,
	239	* or if <code>propertyName</code> is null, an empty array is
	240	* returned.
	241	* @since 1.4
	242	*/
	243	public VetoableChangeListener[] getVetoableChangeListeners(String propertyName) {
	244	return this.map.getListeners(propertyName);
	245	}
	246
	247	/**
	248	* Reports a constrained property update to listeners
	249	* that have been registered to track updates of
	250	* all properties or a property with the specified name.
	251	* <p>
	252	* Any listener can throw a {@code PropertyVetoException} to veto the update.
	253	* If one of the listeners vetoes the update, this method passes
	254	* a new "undo" {@code PropertyChangeEvent} that reverts to the old value
	255	* to all listeners that already confirmed this update
	256	* and throws the {@code PropertyVetoException} again.
	257	* <p>
	258	* No event is fired if old and new values are equal and non-null.
	259	* <p>
	260	* This is merely a convenience wrapper around the more general
	261	* {@link #fireVetoableChange(PropertyChangeEvent)} method.
	262	*
	263	* @param propertyName the programmatic name of the property that is about to change
	264	* @param oldValue the old value of the property
	265	* @param newValue the new value of the property
	266	* @throws PropertyVetoException if one of listeners vetoes the property update
	267	*/
	268	public void fireVetoableChange(String propertyName, Object oldValue, Object newValue)
	269	throws PropertyVetoException {
	270	if (oldValue == null \|\| newValue == null \|\| !oldValue.equals(newValue)) {
	271	fireVetoableChange(new PropertyChangeEvent(this.source, propertyName, oldValue, newValue));
	272	}
	273	}
	274
	275	/**
	276	* Reports an integer constrained property update to listeners
	277	* that have been registered to track updates of
	278	* all properties or a property with the specified name.
	279	* <p>
	280	* Any listener can throw a {@code PropertyVetoException} to veto the update.
	281	* If one of the listeners vetoes the update, this method passes
	282	* a new "undo" {@code PropertyChangeEvent} that reverts to the old value
	283	* to all listeners that already confirmed this update
	284	* and throws the {@code PropertyVetoException} again.
	285	* <p>
	286	* No event is fired if old and new values are equal.
	287	* <p>
	288	* This is merely a convenience wrapper around the more general
	289	* {@link #fireVetoableChange(String, Object, Object)} method.
	290	*
	291	* @param propertyName the programmatic name of the property that is about to change
	292	* @param oldValue the old value of the property
	293	* @param newValue the new value of the property
	294	* @throws PropertyVetoException if one of listeners vetoes the property update
	295	*/
	296	public void fireVetoableChange(String propertyName, int oldValue, int newValue)
	297	throws PropertyVetoException {
	298	if (oldValue != newValue) {
	299	fireVetoableChange(propertyName, Integer.valueOf(oldValue), Integer.valueOf(newValue));
	300	}
	301	}
	302
	303	/**
	304	* Reports a boolean constrained property update to listeners
	305	* that have been registered to track updates of
	306	* all properties or a property with the specified name.
	307	* <p>
	308	* Any listener can throw a {@code PropertyVetoException} to veto the update.
	309	* If one of the listeners vetoes the update, this method passes
	310	* a new "undo" {@code PropertyChangeEvent} that reverts to the old value
	311	* to all listeners that already confirmed this update
	312	* and throws the {@code PropertyVetoException} again.
	313	* <p>
	314	* No event is fired if old and new values are equal.
	315	* <p>
	316	* This is merely a convenience wrapper around the more general
	317	* {@link #fireVetoableChange(String, Object, Object)} method.
	318	*
	319	* @param propertyName the programmatic name of the property that is about to change
	320	* @param oldValue the old value of the property
	321	* @param newValue the new value of the property
	322	* @throws PropertyVetoException if one of listeners vetoes the property update
	323	*/
	324	public void fireVetoableChange(String propertyName, boolean oldValue, boolean newValue)
	325	throws PropertyVetoException {
	326	if (oldValue != newValue) {
	327	fireVetoableChange(propertyName, Boolean.valueOf(oldValue), Boolean.valueOf(newValue));
	328	}
	329	}
	330
	331	/**
	332	* Fires a property change event to listeners
	333	* that have been registered to track updates of
	334	* all properties or a property with the specified name.
	335	* <p>
	336	* Any listener can throw a {@code PropertyVetoException} to veto the update.
	337	* If one of the listeners vetoes the update, this method passes
	338	* a new "undo" {@code PropertyChangeEvent} that reverts to the old value
	339	* to all listeners that already confirmed this update
	340	* and throws the {@code PropertyVetoException} again.
	341	* <p>
	342	* No event is fired if the given event's old and new values are equal and non-null.
	343	*
	344	* @param event the {@code PropertyChangeEvent} to be fired
	345	* @throws PropertyVetoException if one of listeners vetoes the property update
	346	*/
	347	public void fireVetoableChange(PropertyChangeEvent event)
	348	throws PropertyVetoException {
	349	Object oldValue = event.getOldValue();
	350	Object newValue = event.getNewValue();
	351	if (oldValue == null \|\| newValue == null \|\| !oldValue.equals(newValue)) {
	352	String name = event.getPropertyName();
	353
	354	VetoableChangeListener[] common = this.map.get(null);
	355	VetoableChangeListener[] named = (name != null)
	356	? this.map.get(name)
	357	: null;
	358
	359	VetoableChangeListener[] listeners;
	360	if (common == null) {
	361	listeners = named;
	362	}
	363	else if (named == null) {
	364	listeners = common;
	365	}
	366	else {
	367	listeners = new VetoableChangeListener[common.length + named.length];
	368	System.arraycopy(common, 0, listeners, 0, common.length);
	369	System.arraycopy(named, 0, listeners, common.length, named.length);
	370	}
	371	if (listeners != null) {
	372	int current = 0;
	373	try {
	374	while (current < listeners.length) {
	375	listeners[current].vetoableChange(event);
	376	current++;
	377	}
	378	}
	379	catch (PropertyVetoException veto) {
	380	event = new PropertyChangeEvent(this.source, name, newValue, oldValue);
	381	for (int i = 0; i < current; i++) {
	382	try {
	383	listeners[i].vetoableChange(event);
	384	}
	385	catch (PropertyVetoException exception) {
	386	// ignore exceptions that occur during rolling back
	387	}
	388	}
	389	throw veto; // rethrow the veto exception
	390	}
	391	}
	392	}
	393	}
	394
	395	/**
	396	* Check if there are any listeners for a specific property, including
	397	* those registered on all properties. If <code>propertyName</code>
	398	* is null, only check for listeners registered on all properties.
	399	*
	400	* @param propertyName the property name.
	401	* @return true if there are one or more listeners for the given property
	402	*/
	403	public boolean hasListeners(String propertyName) {
	404	return this.map.hasListeners(propertyName);
	405	}
	406
	407	/**
	408	* @serialData Null terminated list of <code>VetoableChangeListeners</code>.
	409	* <p>
	410	* At serialization time we skip non-serializable listeners and
	411	* only serialize the serializable listeners.
	412	*/
	413	private void writeObject(ObjectOutputStream s) throws IOException {
	414	Hashtable<String, VetoableChangeSupport> children = null;
	415	VetoableChangeListener[] listeners = null;
	416	synchronized (this.map) {
	417	for (Entry<String, VetoableChangeListener[]> entry : this.map.getEntries()) {
	418	String property = entry.getKey();
	419	if (property == null) {
	420	listeners = entry.getValue();
	421	} else {
	422	if (children == null) {
	423	children = new Hashtable<String, VetoableChangeSupport>();
	424	}
	425	VetoableChangeSupport vcs = new VetoableChangeSupport(this.source);
	426	vcs.map.set(null, entry.getValue());
	427	children.put(property, vcs);
	428	}
	429	}
	430	}
	431	ObjectOutputStream.PutField fields = s.putFields();
	432	fields.put("children", children);
	433	fields.put("source", this.source);
	434	fields.put("vetoableChangeSupportSerializedDataVersion", 2);
	435	s.writeFields();
	436
	437	if (listeners != null) {
	438	for (VetoableChangeListener l : listeners) {
	439	if (l instanceof Serializable) {
	440	s.writeObject(l);
	441	}
	442	}
	443	}
	444	s.writeObject(null);
	445	}
	446
	447	private void readObject(ObjectInputStream s) throws ClassNotFoundException, IOException {
	448	this.map = new VetoableChangeListenerMap();
	449
	450	ObjectInputStream.GetField fields = s.readFields();
	451
	452	Hashtable<String, VetoableChangeSupport> children = (Hashtable<String, VetoableChangeSupport>) fields.get("children", null);
	453	this.source = fields.get("source", null);
	454	fields.get("vetoableChangeSupportSerializedDataVersion", 2);
	455
	456	Object listenerOrNull;
	457	while (null != (listenerOrNull = s.readObject())) {
	458	this.map.add(null, (VetoableChangeListener)listenerOrNull);
	459	}
	460	if (children != null) {
	461	for (Entry<String, VetoableChangeSupport> entry : children.entrySet()) {
	462	for (VetoableChangeListener listener : entry.getValue().getVetoableChangeListeners()) {
	463	this.map.add(entry.getKey(), listener);
	464	}
	465	}
	466	}
	467	}
	468
	469	/**
	470	* The object to be provided as the "source" for any generated events.
	471	*/
	472	private Object source;
	473
	474	/**
	475	* @serialField children Hashtable
	476	* @serialField source Object
	477	* @serialField vetoableChangeSupportSerializedDataVersion int
	478	*/
	479	private static final ObjectStreamField[] serialPersistentFields = {
	480	new ObjectStreamField("children", Hashtable.class),
	481	new ObjectStreamField("source", Object.class),
	482	new ObjectStreamField("vetoableChangeSupportSerializedDataVersion", Integer.TYPE)
	483	};
	484
	485	/**
	486	* Serialization version ID, so we're compatible with JDK 1.1
	487	*/
	488	static final long serialVersionUID = -5090210921595982017L;
	489
	490	/**
	491	* This is a {@link ChangeListenerMap ChangeListenerMap} implementation
	492	* that works with {@link VetoableChangeListener VetoableChangeListener} objects.
	493	*/
	494	private static final class VetoableChangeListenerMap extends ChangeListenerMap<VetoableChangeListener> {
	495	private static final VetoableChangeListener[] EMPTY = {};
	496
	497	/**
	498	* Creates an array of {@link VetoableChangeListener VetoableChangeListener} objects.
	499	* This method uses the same instance of the empty array
	500	* when {@code length} equals {@code 0}.
	501	*
	502	* @param length the array length
	503	* @return an array with specified length
	504	*/
	505	@Override
	506	protected VetoableChangeListener[] newArray(int length) {
	507	return (0 < length)
	508	? new VetoableChangeListener[length]
	509	: EMPTY;
	510	}
	511
	512	/**
	513	* Creates a {@link VetoableChangeListenerProxy VetoableChangeListenerProxy}
	514	* object for the specified property.
	515	*
	516	* @param name the name of the property to listen on
	517	* @param listener the listener to process events
	518	* @return a {@code VetoableChangeListenerProxy} object
	519	*/
	520	@Override
	521	protected VetoableChangeListener newProxy(String name, VetoableChangeListener listener) {
	522	return new VetoableChangeListenerProxy(name, listener);
	523	}
	524	}
	525	}

java/pkg/java/beans/Visibility.class+0−0

Binary file not shown.

java/pkg/java/beans/Visibility.java+67−0

@@ -0,0 +1,67 @@
	1	/*
	2	* Copyright (c) 1996, 1998, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans;
	27
	28	/**
	29	* Under some circumstances a bean may be run on servers where a GUI
	30	* is not available. This interface can be used to query a bean to
	31	* determine whether it absolutely needs a gui, and to advise the
	32	* bean whether a GUI is available.
	33	* <p>
	34	* This interface is for expert developers, and is not needed
	35	* for normal simple beans. To avoid confusing end-users we
	36	* avoid using getXXX setXXX design patterns for these methods.
	37	*/
	38
	39	public interface Visibility {
	40
	41	/**
	42	* Determines whether this bean needs a GUI.
	43	*
	44	* @return True if the bean absolutely needs a GUI available in
	45	* order to get its work done.
	46	*/
	47	boolean needsGui();
	48
	49	/**
	50	* This method instructs the bean that it should not use the Gui.
	51	*/
	52	void dontUseGui();
	53
	54	/**
	55	* This method instructs the bean that it is OK to use the Gui.
	56	*/
	57	void okToUseGui();
	58
	59	/**
	60	* Determines whether this bean is avoiding using a GUI.
	61	*
	62	* @return true if the bean is currently avoiding use of the Gui.
	63	* e.g. due to a call on dontUseGui().
	64	*/
	65	boolean avoidingGui();
	66
	67	}

java/pkg/java/beans/XMLDecoder.class+0−0

Binary file not shown.

java/pkg/java/beans/XMLDecoder.java+294−0

@@ -0,0 +1,294 @@
	1	/*
	2	* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import com.sun.beans.decoder.DocumentHandler;
	28
	29	import java.io.Closeable;
	30	import java.io.InputStream;
	31	import java.io.IOException;
	32
	33	import org.xml.sax.InputSource;
	34	import org.xml.sax.helpers.DefaultHandler;
	35
	36	/**
	37	* The <code>XMLDecoder</code> class is used to read XML documents
	38	* created using the <code>XMLEncoder</code> and is used just like
	39	* the <code>ObjectInputStream</code>. For example, one can use
	40	* the following fragment to read the first object defined
	41	* in an XML document written by the <code>XMLEncoder</code>
	42	* class:
	43	* <pre>
	44	* XMLDecoder d = new XMLDecoder(
	45	* new BufferedInputStream(
	46	* new FileInputStream("Test.xml")));
	47	* Object result = d.readObject();
	48	* d.close();
	49	* </pre>
	50	*
	51	*<p>
	52	* For more information you might also want to check out
	53	* <a
	54	href="http://java.sun.com/products/jfc/tsc/articles/persistence3">Long Term Persistence of JavaBeans Components: XML Schema</a>,
	55	* an article in <em>The Swing Connection.</em>
	56	* @see XMLEncoder
	57	* @see java.io.ObjectInputStream
	58	*
	59	* @since 1.4
	60	*
	61	* @author Philip Milne
	62	*/
	63	public class XMLDecoder implements AutoCloseable {
	64	private final DocumentHandler handler = new DocumentHandler();
	65	private final InputSource input;
	66	private Object owner;
	67	private Object[] array;
	68	private int index;
	69
	70	/**
	71	* Creates a new input stream for reading archives
	72	* created by the <code>XMLEncoder</code> class.
	73	*
	74	* @param in The underlying stream.
	75	*
	76	* @see XMLEncoder#XMLEncoder(java.io.OutputStream)
	77	*/
	78	public XMLDecoder(InputStream in) {
	79	this(in, null);
	80	}
	81
	82	/**
	83	* Creates a new input stream for reading archives
	84	* created by the <code>XMLEncoder</code> class.
	85	*
	86	* @param in The underlying stream.
	87	* @param owner The owner of this stream.
	88	*
	89	*/
	90	public XMLDecoder(InputStream in, Object owner) {
	91	this(in, owner, null);
	92	}
	93
	94	/**
	95	* Creates a new input stream for reading archives
	96	* created by the <code>XMLEncoder</code> class.
	97	*
	98	* @param in the underlying stream.
	99	* @param owner the owner of this stream.
	100	* @param exceptionListener the exception handler for the stream;
	101	* if <code>null</code> the default exception listener will be used.
	102	*/
	103	public XMLDecoder(InputStream in, Object owner, ExceptionListener exceptionListener) {
	104	this(in, owner, exceptionListener, null);
	105	}
	106
	107	/**
	108	* Creates a new input stream for reading archives
	109	* created by the <code>XMLEncoder</code> class.
	110	*
	111	* @param in the underlying stream. <code>null</code> may be passed without
	112	* error, though the resulting XMLDecoder will be useless
	113	* @param owner the owner of this stream. <code>null</code> is a legal
	114	* value
	115	* @param exceptionListener the exception handler for the stream, or
	116	* <code>null</code> to use the default
	117	* @param cl the class loader used for instantiating objects.
	118	* <code>null</code> indicates that the default class loader should
	119	* be used
	120	* @since 1.5
	121	*/
	122	public XMLDecoder(InputStream in, Object owner,
	123	ExceptionListener exceptionListener, ClassLoader cl) {
	124	this(new InputSource(in), owner, exceptionListener, cl);
	125	}
	126
	127
	128	/**
	129	* Creates a new decoder to parse XML archives
	130	* created by the {@code XMLEncoder} class.
	131	* If the input source {@code is} is {@code null},
	132	* no exception is thrown and no parsing is performed.
	133	* This behavior is similar to behavior of other constructors
	134	* that use {@code InputStream} as a parameter.
	135	*
	136	* @param is the input source to parse
	137	*
	138	* @since 1.7
	139	*/
	140	public XMLDecoder(InputSource is) {
	141	this(is, null, null, null);
	142	}
	143
	144	/**
	145	* Creates a new decoder to parse XML archives
	146	* created by the {@code XMLEncoder} class.
	147	*
	148	* @param is the input source to parse
	149	* @param owner the owner of this decoder
	150	* @param el the exception handler for the parser,
	151	* or {@code null} to use the default exception handler
	152	* @param cl the class loader used for instantiating objects,
	153	* or {@code null} to use the default class loader
	154	*
	155	* @since 1.7
	156	*/
	157	private XMLDecoder(InputSource is, Object owner, ExceptionListener el, ClassLoader cl) {
	158	this.input = is;
	159	this.owner = owner;
	160	setExceptionListener(el);
	161	this.handler.setClassLoader(cl);
	162	this.handler.setOwner(this);
	163	}
	164
	165	/**
	166	* This method closes the input stream associated
	167	* with this stream.
	168	*/
	169	public void close() {
	170	if (parsingComplete()) {
	171	close(this.input.getCharacterStream());
	172	close(this.input.getByteStream());
	173	}
	174	}
	175
	176	private void close(Closeable in) {
	177	if (in != null) {
	178	try {
	179	in.close();
	180	}
	181	catch (IOException e) {
	182	getExceptionListener().exceptionThrown(e);
	183	}
	184	}
	185	}
	186
	187	private boolean parsingComplete() {
	188	if (this.input == null) {
	189	return false;
	190	}
	191	if (this.array == null) {
	192	this.handler.parse(this.input);
	193	this.array = this.handler.getObjects();
	194	}
	195	return true;
	196	}
	197
	198	/**
	199	* Sets the exception handler for this stream to <code>exceptionListener</code>.
	200	* The exception handler is notified when this stream catches recoverable
	201	* exceptions.
	202	*
	203	* @param exceptionListener The exception handler for this stream;
	204	* if <code>null</code> the default exception listener will be used.
	205	*
	206	* @see #getExceptionListener
	207	*/
	208	public void setExceptionListener(ExceptionListener exceptionListener) {
	209	if (exceptionListener == null) {
	210	exceptionListener = Statement.defaultExceptionListener;
	211	}
	212	this.handler.setExceptionListener(exceptionListener);
	213	}
	214
	215	/**
	216	* Gets the exception handler for this stream.
	217	*
	218	* @return The exception handler for this stream.
	219	* Will return the default exception listener if this has not explicitly been set.
	220	*
	221	* @see #setExceptionListener
	222	*/
	223	public ExceptionListener getExceptionListener() {
	224	return this.handler.getExceptionListener();
	225	}
	226
	227	/**
	228	* Reads the next object from the underlying input stream.
	229	*
	230	* @return the next object read
	231	*
	232	* @throws ArrayIndexOutOfBoundsException if the stream contains no objects
	233	* (or no more objects)
	234	*
	235	* @see XMLEncoder#writeObject
	236	*/
	237	public Object readObject() {
	238	return (parsingComplete())
	239	? this.array[this.index++]
	240	: null;
	241	}
	242
	243	/**
	244	* Sets the owner of this decoder to <code>owner</code>.
	245	*
	246	* @param owner The owner of this decoder.
	247	*
	248	* @see #getOwner
	249	*/
	250	public void setOwner(Object owner) {
	251	this.owner = owner;
	252	}
	253
	254	/**
	255	* Gets the owner of this decoder.
	256	*
	257	* @return The owner of this decoder.
	258	*
	259	* @see #setOwner
	260	*/
	261	public Object getOwner() {
	262	return owner;
	263	}
	264
	265	/**
	266	* Creates a new handler for SAX parser
	267	* that can be used to parse embedded XML archives
	268	* created by the {@code XMLEncoder} class.
	269	*
	270	* The {@code owner} should be used if parsed XML document contains
	271	* the method call within context of the <java> element.
	272	* The {@code null} value may cause illegal parsing in such case.
	273	* The same problem may occur, if the {@code owner} class
	274	* does not contain expected method to call. See details <a
	275	* href="http://java.sun.com/products/jfc/tsc/articles/persistence3/">here</a>.
	276	*
	277	* @param owner the owner of the default handler
	278	* that can be used as a value of <java> element
	279	* @param el the exception handler for the parser,
	280	* or {@code null} to use the default exception handler
	281	* @param cl the class loader used for instantiating objects,
	282	* or {@code null} to use the default class loader
	283	* @return an instance of {@code DefaultHandler} for SAX parser
	284	*
	285	* @since 1.7
	286	*/
	287	public static DefaultHandler createHandler(Object owner, ExceptionListener el, ClassLoader cl) {
	288	DocumentHandler handler = new DocumentHandler();
	289	handler.setOwner(owner);
	290	handler.setExceptionListener(el);
	291	handler.setClassLoader(cl);
	292	return handler;
	293	}
	294	}

java/pkg/java/beans/XMLEncoder$1.class+0−0

Binary file not shown.

java/pkg/java/beans/XMLEncoder$ValueData.class+0−0

Binary file not shown.

java/pkg/java/beans/XMLEncoder.class+0−0

Binary file not shown.

java/pkg/java/beans/XMLEncoder.java+774−0

@@ -0,0 +1,774 @@
	1	/*
	2	* Copyright (c) 2000, 2010, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans;
	26
	27	import java.io.*;
	28	import java.util.*;
	29	import java.lang.reflect.*;
	30	import java.nio.charset.Charset;
	31	import java.nio.charset.CharsetEncoder;
	32	import java.nio.charset.IllegalCharsetNameException;
	33	import java.nio.charset.UnsupportedCharsetException;
	34
	35	/**
	36	* The <code>XMLEncoder</code> class is a complementary alternative to
	37	* the <code>ObjectOutputStream</code> and can used to generate
	38	* a textual representation of a <em>JavaBean</em> in the same
	39	* way that the <code>ObjectOutputStream</code> can
	40	* be used to create binary representation of <code>Serializable</code>
	41	* objects. For example, the following fragment can be used to create
	42	* a textual representation the supplied <em>JavaBean</em>
	43	* and all its properties:
	44	* <pre>
	45	* XMLEncoder e = new XMLEncoder(
	46	* new BufferedOutputStream(
	47	* new FileOutputStream("Test.xml")));
	48	* e.writeObject(new JButton("Hello, world"));
	49	* e.close();
	50	* </pre>
	51	* Despite the similarity of their APIs, the <code>XMLEncoder</code>
	52	* class is exclusively designed for the purpose of archiving graphs
	53	* of <em>JavaBean</em>s as textual representations of their public
	54	* properties. Like Java source files, documents written this way
	55	* have a natural immunity to changes in the implementations of the classes
	56	* involved. The <code>ObjectOutputStream</code> continues to be recommended
	57	* for interprocess communication and general purpose serialization.
	58	* <p>
	59	* The <code>XMLEncoder</code> class provides a default denotation for
	60	* <em>JavaBean</em>s in which they are represented as XML documents
	61	* complying with version 1.0 of the XML specification and the
	62	* UTF-8 character encoding of the Unicode/ISO 10646 character set.
	63	* The XML documents produced by the <code>XMLEncoder</code> class are:
	64	* <ul>
	65	* <li>
	66	* <em>Portable and version resilient</em>: they have no dependencies
	67	* on the private implementation of any class and so, like Java source
	68	* files, they may be exchanged between environments which may have
	69	* different versions of some of the classes and between VMs from
	70	* different vendors.
	71	* <li>
	72	* <em>Structurally compact</em>: The <code>XMLEncoder</code> class
	73	* uses a <em>redundancy elimination</em> algorithm internally so that the
	74	* default values of a Bean's properties are not written to the stream.
	75	* <li>
	76	* <em>Fault tolerant</em>: Non-structural errors in the file,
	77	* caused either by damage to the file or by API changes
	78	* made to classes in an archive remain localized
	79	* so that a reader can report the error and continue to load the parts
	80	* of the document which were not affected by the error.
	81	* </ul>
	82	* <p>
	83	* Below is an example of an XML archive containing
	84	* some user interface components from the <em>swing</em> toolkit:
	85	* <pre>
	86	* <?xml version="1.0" encoding="UTF-8"?>
	87	* <java version="1.0" class="java.beans.XMLDecoder">
	88	* <object class="javax.swing.JFrame">
	89	* <void property="name">
	90	* <string>frame1</string>
	91	* </void>
	92	* <void property="bounds">
	93	* <object class="java.awt.Rectangle">
	94	* <int>0</int>
	95	* <int>0</int>
	96	* <int>200</int>
	97	* <int>200</int>
	98	* </object>
	99	* </void>
	100	* <void property="contentPane">
	101	* <void method="add">
	102	* <object class="javax.swing.JButton">
	103	* <void property="label">
	104	* <string>Hello</string>
	105	* </void>
	106	* </object>
	107	* </void>
	108	* </void>
	109	* <void property="visible">
	110	* <boolean>true</boolean>
	111	* </void>
	112	* </object>
	113	* </java>
	114	* </pre>
	115	* The XML syntax uses the following conventions:
	116	* <ul>
	117	* <li>
	118	* Each element represents a method call.
	119	* <li>
	120	* The "object" tag denotes an <em>expression</em> whose value is
	121	* to be used as the argument to the enclosing element.
	122	* <li>
	123	* The "void" tag denotes a <em>statement</em> which will
	124	* be executed, but whose result will not be used as an
	125	* argument to the enclosing method.
	126	* <li>
	127	* Elements which contain elements use those elements as arguments,
	128	* unless they have the tag: "void".
	129	* <li>
	130	* The name of the method is denoted by the "method" attribute.
	131	* <li>
	132	* XML's standard "id" and "idref" attributes are used to make
	133	* references to previous expressions - so as to deal with
	134	* circularities in the object graph.
	135	* <li>
	136	* The "class" attribute is used to specify the target of a static
	137	* method or constructor explicitly; its value being the fully
	138	* qualified name of the class.
	139	* <li>
	140	* Elements with the "void" tag are executed using
	141	* the outer context as the target if no target is defined
	142	* by a "class" attribute.
	143	* <li>
	144	* Java's String class is treated specially and is
	145	* written <string>Hello, world</string> where
	146	* the characters of the string are converted to bytes
	147	* using the UTF-8 character encoding.
	148	* </ul>
	149	* <p>
	150	* Although all object graphs may be written using just these three
	151	* tags, the following definitions are included so that common
	152	* data structures can be expressed more concisely:
	153	* <p>
	154	* <ul>
	155	* <li>
	156	* The default method name is "new".
	157	* <li>
	158	* A reference to a java class is written in the form
	159	* <class>javax.swing.JButton</class>.
	160	* <li>
	161	* Instances of the wrapper classes for Java's primitive types are written
	162	* using the name of the primitive type as the tag. For example, an
	163	* instance of the <code>Integer</code> class could be written:
	164	* <int>123</int>. Note that the <code>XMLEncoder</code> class
	165	* uses Java's reflection package in which the conversion between
	166	* Java's primitive types and their associated "wrapper classes"
	167	* is handled internally. The API for the <code>XMLEncoder</code> class
	168	* itself deals only with <code>Object</code>s.
	169	* <li>
	170	* In an element representing a nullary method whose name
	171	* starts with "get", the "method" attribute is replaced
	172	* with a "property" attribute whose value is given by removing
	173	* the "get" prefix and decapitalizing the result.
	174	* <li>
	175	* In an element representing a monadic method whose name
	176	* starts with "set", the "method" attribute is replaced
	177	* with a "property" attribute whose value is given by removing
	178	* the "set" prefix and decapitalizing the result.
	179	* <li>
	180	* In an element representing a method named "get" taking one
	181	* integer argument, the "method" attribute is replaced
	182	* with an "index" attribute whose value the value of the
	183	* first argument.
	184	* <li>
	185	* In an element representing a method named "set" taking two arguments,
	186	* the first of which is an integer, the "method" attribute is replaced
	187	* with an "index" attribute whose value the value of the
	188	* first argument.
	189	* <li>
	190	* A reference to an array is written using the "array"
	191	* tag. The "class" and "length" attributes specify the
	192	* sub-type of the array and its length respectively.
	193	* </ul>
	194	*
	195	*<p>
	196	* For more information you might also want to check out
	197	* <a
	198	href="http://java.sun.com/products/jfc/tsc/articles/persistence4">Using XMLEncoder</a>,
	199	* an article in <em>The Swing Connection.</em>
	200	* @see XMLDecoder
	201	* @see java.io.ObjectOutputStream
	202	*
	203	* @since 1.4
	204	*
	205	* @author Philip Milne
	206	*/
	207	public class XMLEncoder extends Encoder implements AutoCloseable {
	208
	209	private final CharsetEncoder encoder;
	210	private final String charset;
	211	private final boolean declaration;
	212
	213	private OutputStreamWriter out;
	214	private Object owner;
	215	private int indentation = 0;
	216	private boolean internal = false;
	217	private Map<Object, ValueData> valueToExpression;
	218	private Map<Object, List<Statement>> targetToStatementList;
	219	private boolean preambleWritten = false;
	220	private NameGenerator nameGenerator;
	221
	222	private class ValueData {
	223	public int refs = 0;
	224	public boolean marked = false; // Marked -> refs > 0 unless ref was a target.
	225	public String name = null;
	226	public Expression exp = null;
	227	}
	228
	229	/**
	230	* Creates a new XML encoder to write out <em>JavaBeans</em>
	231	* to the stream <code>out</code> using an XML encoding.
	232	*
	233	* @param out the stream to which the XML representation of
	234	* the objects will be written
	235	*
	236	* @throws IllegalArgumentException
	237	* if <code>out</code> is <code>null</code>
	238	*
	239	* @see XMLDecoder#XMLDecoder(InputStream)
	240	*/
	241	public XMLEncoder(OutputStream out) {
	242	this(out, "UTF-8", true, 0);
	243	}
	244
	245	/**
	246	* Creates a new XML encoder to write out <em>JavaBeans</em>
	247	* to the stream <code>out</code> using the given <code>charset</code>
	248	* starting from the given <code>indentation</code>.
	249	*
	250	* @param out the stream to which the XML representation of
	251	* the objects will be written
	252	* @param charset the name of the requested charset;
	253	* may be either a canonical name or an alias
	254	* @param declaration whether the XML declaration should be generated;
	255	* set this to <code>false</code>
	256	* when embedding the contents in another XML document
	257	* @param indentation the number of space characters to indent the entire XML document by
	258	*
	259	* @throws IllegalArgumentException
	260	* if <code>out</code> or <code>charset</code> is <code>null</code>,
	261	* or if <code>indentation</code> is less than 0
	262	*
	263	* @throws IllegalCharsetNameException
	264	* if <code>charset</code> name is illegal
	265	*
	266	* @throws UnsupportedCharsetException
	267	* if no support for the named charset is available
	268	* in this instance of the Java virtual machine
	269	*
	270	* @throws UnsupportedOperationException
	271	* if loaded charset does not support encoding
	272	*
	273	* @see Charset#forName(String)
	274	*
	275	* @since 1.7
	276	*/
	277	public XMLEncoder(OutputStream out, String charset, boolean declaration, int indentation) {
	278	if (out == null) {
	279	throw new IllegalArgumentException("the output stream cannot be null");
	280	}
	281	if (indentation < 0) {
	282	throw new IllegalArgumentException("the indentation must be >= 0");
	283	}
	284	Charset cs = Charset.forName(charset);
	285	this.encoder = cs.newEncoder();
	286	this.charset = charset;
	287	this.declaration = declaration;
	288	this.indentation = indentation;
	289	this.out = new OutputStreamWriter(out, cs.newEncoder());
	290	valueToExpression = new IdentityHashMap<Object, ValueData>();
	291	targetToStatementList = new IdentityHashMap<Object, List<Statement>>();
	292	nameGenerator = new NameGenerator();
	293	}
	294
	295	/**
	296	* Sets the owner of this encoder to <code>owner</code>.
	297	*
	298	* @param owner The owner of this encoder.
	299	*
	300	* @see #getOwner
	301	*/
	302	public void setOwner(Object owner) {
	303	this.owner = owner;
	304	writeExpression(new Expression(this, "getOwner", new Object[0]));
	305	}
	306
	307	/**
	308	* Gets the owner of this encoder.
	309	*
	310	* @return The owner of this encoder.
	311	*
	312	* @see #setOwner
	313	*/
	314	public Object getOwner() {
	315	return owner;
	316	}
	317
	318	/**
	319	* Write an XML representation of the specified object to the output.
	320	*
	321	* @param o The object to be written to the stream.
	322	*
	323	* @see XMLDecoder#readObject
	324	*/
	325	public void writeObject(Object o) {
	326	if (internal) {
	327	super.writeObject(o);
	328	}
	329	else {
	330	writeStatement(new Statement(this, "writeObject", new Object[]{o}));
	331	}
	332	}
	333
	334	private List<Statement> statementList(Object target) {
	335	List<Statement> list = targetToStatementList.get(target);
	336	if (list == null) {
	337	list = new ArrayList<Statement>();
	338	targetToStatementList.put(target, list);
	339	}
	340	return list;
	341	}
	342
	343
	344	private void mark(Object o, boolean isArgument) {
	345	if (o == null \|\| o == this) {
	346	return;
	347	}
	348	ValueData d = getValueData(o);
	349	Expression exp = d.exp;
	350	// Do not mark liternal strings. Other strings, which might,
	351	// for example, come from resource bundles should still be marked.
	352	if (o.getClass() == String.class && exp == null) {
	353	return;
	354	}
	355
	356	// Bump the reference counts of all arguments
	357	if (isArgument) {
	358	d.refs++;
	359	}
	360	if (d.marked) {
	361	return;
	362	}
	363	d.marked = true;
	364	Object target = exp.getTarget();
	365	mark(exp);
	366	if (!(target instanceof Class)) {
	367	statementList(target).add(exp);
	368	// Pending: Why does the reference count need to
	369	// be incremented here?
	370	d.refs++;
	371	}
	372	}
	373
	374	private void mark(Statement stm) {
	375	Object[] args = stm.getArguments();
	376	for (int i = 0; i < args.length; i++) {
	377	Object arg = args[i];
	378	mark(arg, true);
	379	}
	380	mark(stm.getTarget(), false);
	381	}
	382
	383
	384	/**
	385	* Records the Statement so that the Encoder will
	386	* produce the actual output when the stream is flushed.
	387	* <P>
	388	* This method should only be invoked within the context
	389	* of initializing a persistence delegate.
	390	*
	391	* @param oldStm The statement that will be written
	392	* to the stream.
	393	* @see java.beans.PersistenceDelegate#initialize
	394	*/
	395	public void writeStatement(Statement oldStm) {
	396	// System.out.println("XMLEncoder::writeStatement: " + oldStm);
	397	boolean internal = this.internal;
	398	this.internal = true;
	399	try {
	400	super.writeStatement(oldStm);
	401	/*
	402	Note we must do the mark first as we may
	403	require the results of previous values in
	404	this context for this statement.
	405	Test case is:
	406	os.setOwner(this);
	407	os.writeObject(this);
	408	*/
	409	mark(oldStm);
	410	Object target = oldStm.getTarget();
	411	if (target instanceof Field) {
	412	String method = oldStm.getMethodName();
	413	Object[] args = oldStm.getArguments();
	414	if ((method == null) \|\| (args == null)) {
	415	}
	416	else if (method.equals("get") && (args.length == 1)) {
	417	target = args[0];
	418	}
	419	else if (method.equals("set") && (args.length == 2)) {
	420	target = args[0];
	421	}
	422	}
	423	statementList(target).add(oldStm);
	424	}
	425	catch (Exception e) {
	426	getExceptionListener().exceptionThrown(new Exception("XMLEncoder: discarding statement " + oldStm, e));
	427	}
	428	this.internal = internal;
	429	}
	430
	431
	432	/**
	433	* Records the Expression so that the Encoder will
	434	* produce the actual output when the stream is flushed.
	435	* <P>
	436	* This method should only be invoked within the context of
	437	* initializing a persistence delegate or setting up an encoder to
	438	* read from a resource bundle.
	439	* <P>
	440	* For more information about using resource bundles with the
	441	* XMLEncoder, see
	442	* http://java.sun.com/products/jfc/tsc/articles/persistence4/#i18n
	443	*
	444	* @param oldExp The expression that will be written
	445	* to the stream.
	446	* @see java.beans.PersistenceDelegate#initialize
	447	*/
	448	public void writeExpression(Expression oldExp) {
	449	boolean internal = this.internal;
	450	this.internal = true;
	451	Object oldValue = getValue(oldExp);
	452	if (get(oldValue) == null \|\| (oldValue instanceof String && !internal)) {
	453	getValueData(oldValue).exp = oldExp;
	454	super.writeExpression(oldExp);
	455	}
	456	this.internal = internal;
	457	}
	458
	459	/**
	460	* This method writes out the preamble associated with the
	461	* XML encoding if it has not been written already and
	462	* then writes out all of the values that been
	463	* written to the stream since the last time <code>flush</code>
	464	* was called. After flushing, all internal references to the
	465	* values that were written to this stream are cleared.
	466	*/
	467	public void flush() {
	468	if (!preambleWritten) { // Don't do this in constructor - it throws ... pending.
	469	if (this.declaration) {
	470	writeln("<?xml version=" + quote("1.0") +
	471	" encoding=" + quote(this.charset) + "?>");
	472	}
	473	writeln("<java version=" + quote(System.getProperty("java.version")) +
	474	" class=" + quote(XMLDecoder.class.getName()) + ">");
	475	preambleWritten = true;
	476	}
	477	indentation++;
	478	List<Statement> statements = statementList(this);
	479	while (!statements.isEmpty()) {
	480	Statement s = statements.remove(0);
	481	if ("writeObject".equals(s.getMethodName())) {
	482	outputValue(s.getArguments()[0], this, true);
	483	}
	484	else {
	485	outputStatement(s, this, false);
	486	}
	487	}
	488	indentation--;
	489
	490	try {
	491	out.flush();
	492	}
	493	catch (IOException e) {
	494	getExceptionListener().exceptionThrown(e);
	495	}
	496	clear();
	497	}
	498
	499	void clear() {
	500	super.clear();
	501	nameGenerator.clear();
	502	valueToExpression.clear();
	503	targetToStatementList.clear();
	504	}
	505
	506
	507	/**
	508	* This method calls <code>flush</code>, writes the closing
	509	* postamble and then closes the output stream associated
	510	* with this stream.
	511	*/
	512	public void close() {
	513	flush();
	514	writeln("</java>");
	515	try {
	516	out.close();
	517	}
	518	catch (IOException e) {
	519	getExceptionListener().exceptionThrown(e);
	520	}
	521	}
	522
	523	private String quote(String s) {
	524	return "\"" + s + "\"";
	525	}
	526
	527	private ValueData getValueData(Object o) {
	528	ValueData d = valueToExpression.get(o);
	529	if (d == null) {
	530	d = new ValueData();
	531	valueToExpression.put(o, d);
	532	}
	533	return d;
	534	}
	535
	536	/**
	537	* Returns <code>true</code> if the argument,
	538	* a Unicode code point, is valid in XML documents.
	539	* Unicode characters fit into the low sixteen bits of a Unicode code point,
	540	* and pairs of Unicode <em>surrogate characters</em> can be combined
	541	* to encode Unicode code point in documents containing only Unicode.
	542	* (The <code>char</code> datatype in the Java Programming Language
	543	* represents Unicode characters, including unpaired surrogates.)
	544	* <par>
	545	* [2] Char ::= #x0009 \| #x000A \| #x000D
	546	* \| [#x0020-#xD7FF]
	547	* \| [#xE000-#xFFFD]
	548	* \| [#x10000-#x10ffff]
	549	* </par>
	550	*
	551	* @param code the 32-bit Unicode code point being tested
	552	* @return <code>true</code> if the Unicode code point is valid,
	553	* <code>false</code> otherwise
	554	*/
	555	private static boolean isValidCharCode(int code) {
	556	return (0x0020 <= code && code <= 0xD7FF)
	557	\|\| (0x000A == code)
	558	\|\| (0x0009 == code)
	559	\|\| (0x000D == code)
	560	\|\| (0xE000 <= code && code <= 0xFFFD)
	561	\|\| (0x10000 <= code && code <= 0x10ffff);
	562	}
	563
	564	private void writeln(String exp) {
	565	try {
	566	StringBuilder sb = new StringBuilder();
	567	for(int i = 0; i < indentation; i++) {
	568	sb.append(' ');
	569	}
	570	sb.append(exp);
	571	sb.append('\n');
	572	this.out.write(sb.toString());
	573	}
	574	catch (IOException e) {
	575	getExceptionListener().exceptionThrown(e);
	576	}
	577	}
	578
	579	private void outputValue(Object value, Object outer, boolean isArgument) {
	580	if (value == null) {
	581	writeln("<null/>");
	582	return;
	583	}
	584
	585	if (value instanceof Class) {
	586	writeln("<class>" + ((Class)value).getName() + "</class>");
	587	return;
	588	}
	589
	590	ValueData d = getValueData(value);
	591	if (d.exp != null) {
	592	Object target = d.exp.getTarget();
	593	String methodName = d.exp.getMethodName();
	594
	595	if (target == null \|\| methodName == null) {
	596	throw new NullPointerException((target == null ? "target" :
	597	"methodName") + " should not be null");
	598	}
	599
	600	if (target instanceof Field && methodName.equals("get")) {
	601	Field f = (Field)target;
	602	writeln("<object class=" + quote(f.getDeclaringClass().getName()) +
	603	" field=" + quote(f.getName()) + "/>");
	604	return;
	605	}
	606
	607	Class primitiveType = ReflectionUtils.primitiveTypeFor(value.getClass());
	608	if (primitiveType != null && target == value.getClass() &&
	609	methodName.equals("new")) {
	610	String primitiveTypeName = primitiveType.getName();
	611	// Make sure that character types are quoted correctly.
	612	if (primitiveType == Character.TYPE) {
	613	char code = ((Character) value).charValue();
	614	if (!isValidCharCode(code)) {
	615	writeln(createString(code));
	616	return;
	617	}
	618	value = quoteCharCode(code);
	619	if (value == null) {
	620	value = Character.valueOf(code);
	621	}
	622	}
	623	writeln("<" + primitiveTypeName + ">" + value + "</" +
	624	primitiveTypeName + ">");
	625	return;
	626	}
	627
	628	} else if (value instanceof String) {
	629	writeln(createString((String) value));
	630	return;
	631	}
	632
	633	if (d.name != null) {
	634	outputXML(isArgument ? "object" : "void", " idref=" + quote(d.name), value);
	635	}
	636	else if (d.exp != null) {
	637	outputStatement(d.exp, outer, isArgument);
	638	}
	639	}
	640
	641	private static String quoteCharCode(int code) {
	642	switch(code) {
	643	case '&': return "&";
	644	case '<': return "<";
	645	case '>': return ">";
	646	case '"': return """;
	647	case '\'': return "'";
	648	case '\r': return " ";
	649	default: return null;
	650	}
	651	}
	652
	653	private static String createString(int code) {
	654	return "<char code=\"#" + Integer.toString(code, 16) + "\"/>";
	655	}
	656
	657	private String createString(String string) {
	658	StringBuilder sb = new StringBuilder();
	659	sb.append("<string>");
	660	int index = 0;
	661	while (index < string.length()) {
	662	int point = string.codePointAt(index);
	663	int count = Character.charCount(point);
	664
	665	if (isValidCharCode(point) && this.encoder.canEncode(string.substring(index, index + count))) {
	666	String value = quoteCharCode(point);
	667	if (value != null) {
	668	sb.append(value);
	669	} else {
	670	sb.appendCodePoint(point);
	671	}
	672	index += count;
	673	} else {
	674	sb.append(createString(string.charAt(index)));
	675	index++;
	676	}
	677	}
	678	sb.append("</string>");
	679	return sb.toString();
	680	}
	681
	682	private void outputStatement(Statement exp, Object outer, boolean isArgument) {
	683	Object target = exp.getTarget();
	684	String methodName = exp.getMethodName();
	685
	686	if (target == null \|\| methodName == null) {
	687	throw new NullPointerException((target == null ? "target" :
	688	"methodName") + " should not be null");
	689	}
	690
	691	Object[] args = exp.getArguments();
	692	boolean expression = exp.getClass() == Expression.class;
	693	Object value = (expression) ? getValue((Expression)exp) : null;
	694
	695	String tag = (expression && isArgument) ? "object" : "void";
	696	String attributes = "";
	697	ValueData d = getValueData(value);
	698
	699	// Special cases for targets.
	700	if (target == outer) {
	701	}
	702	else if (target == Array.class && methodName.equals("newInstance")) {
	703	tag = "array";
	704	attributes = attributes + " class=" + quote(((Class)args[0]).getName());
	705	attributes = attributes + " length=" + quote(args[1].toString());
	706	args = new Object[]{};
	707	}
	708	else if (target.getClass() == Class.class) {
	709	attributes = attributes + " class=" + quote(((Class)target).getName());
	710	}
	711	else {
	712	d.refs = 2;
	713	getValueData(target).refs++;
	714	List<Statement> statements = statementList(target);
	715	if (!statements.contains(exp)) {
	716	statements.add(exp);
	717	}
	718	outputValue(target, outer, false);
	719	if (expression) {
	720	outputValue(value, outer, isArgument);
	721	}
	722	return;
	723	}
	724	if (expression && (d.refs > 1)) {
	725	String instanceName = nameGenerator.instanceName(value);
	726	d.name = instanceName;
	727	attributes = attributes + " id=" + quote(instanceName);
	728	}
	729
	730	// Special cases for methods.
	731	if ((!expression && methodName.equals("set") && args.length == 2 &&
	732	args[0] instanceof Integer) \|\|
	733	(expression && methodName.equals("get") && args.length == 1 &&
	734	args[0] instanceof Integer)) {
	735	attributes = attributes + " index=" + quote(args[0].toString());
	736	args = (args.length == 1) ? new Object[]{} : new Object[]{args[1]};
	737	}
	738	else if ((!expression && methodName.startsWith("set") && args.length == 1) \|\|
	739	(expression && methodName.startsWith("get") && args.length == 0)) {
	740	if (3 < methodName.length()) {
	741	attributes = attributes + " property=" +
	742	quote(Introspector.decapitalize(methodName.substring(3)));
	743	}
	744	}
	745	else if (!methodName.equals("new") && !methodName.equals("newInstance")) {
	746	attributes = attributes + " method=" + quote(methodName);
	747	}
	748	outputXML(tag, attributes, value, args);
	749	}
	750
	751	private void outputXML(String tag, String attributes, Object value, Object... args) {
	752	List<Statement> statements = statementList(value);
	753	// Use XML's short form when there is no body.
	754	if (args.length == 0 && statements.size() == 0) {
	755	writeln("<" + tag + attributes + "/>");
	756	return;
	757	}
	758
	759	writeln("<" + tag + attributes + ">");
	760	indentation++;
	761
	762	for(int i = 0; i < args.length; i++) {
	763	outputValue(args[i], null, true);
	764	}
	765
	766	while (!statements.isEmpty()) {
	767	Statement s = statements.remove(0);
	768	outputStatement(s, value, false);
	769	}
	770
	771	indentation--;
	772	writeln("</" + tag + ">");
	773	}
	774	}

java/pkg/java/beans/beancontext/BeanContext.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContext.java+132−0

@@ -0,0 +1,132 @@
	1	/*
	2	* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.beans.DesignMode;
	29	import java.beans.Visibility;
	30
	31	import java.io.InputStream;
	32	import java.io.IOException;
	33
	34	import java.net.URL;
	35
	36	import java.util.Collection;
	37	import java.util.Locale;
	38
	39	/**
	40	* <p>
	41	* The BeanContext acts a logical hierarchical container for JavaBeans.
	42	* </p>
	43	*
	44	* @author Laurence P. G. Cable
	45	* @since 1.2
	46	*
	47	* @see java.beans.Beans
	48	* @see java.beans.beancontext.BeanContextChild
	49	* @see java.beans.beancontext.BeanContextMembershipListener
	50	* @see java.beans.PropertyChangeEvent
	51	* @see java.beans.DesignMode
	52	* @see java.beans.Visibility
	53	* @see java.util.Collection
	54	*/
	55
	56	public interface BeanContext extends BeanContextChild, Collection, DesignMode, Visibility {
	57
	58	/**
	59	* Instantiate the javaBean named as a
	60	* child of this <code>BeanContext</code>.
	61	* The implementation of the JavaBean is
	62	* derived from the value of the beanName parameter,
	63	* and is defined by the
	64	* <code>java.beans.Beans.instantiate()</code> method.
	65	*
	66	* @param beanName The name of the JavaBean to instantiate
	67	* as a child of this <code>BeanContext</code>
	68	* @throws <code>IOException</code>
	69	* @throws <code>ClassNotFoundException</code> if the class identified
	70	* by the beanName parameter is not found
	71	*/
	72	Object instantiateChild(String beanName) throws IOException, ClassNotFoundException;
	73
	74	/**
	75	* Analagous to <code>java.lang.ClassLoader.getResourceAsStream()</code>,
	76	* this method allows a <code>BeanContext</code> implementation
	77	* to interpose behavior between the child <code>Component</code>
	78	* and underlying <code>ClassLoader</code>.
	79	*
	80	* @param name the resource name
	81	* @param bcc the specified child
	82	* @return an <code>InputStream</code> for reading the resource,
	83	* or <code>null</code> if the resource could not
	84	* be found.
	85	* @throws <code>IllegalArgumentException</code> if
	86	* the resource is not valid
	87	*/
	88	InputStream getResourceAsStream(String name, BeanContextChild bcc) throws IllegalArgumentException;
	89
	90	/**
	91	* Analagous to <code>java.lang.ClassLoader.getResource()</code>, this
	92	* method allows a <code>BeanContext</code> implementation to interpose
	93	* behavior between the child <code>Component</code>
	94	* and underlying <code>ClassLoader</code>.
	95	*
	96	* @param name the resource name
	97	* @param bcc the specified child
	98	* @return a <code>URL</code> for the named
	99	* resource for the specified child
	100	* @throws <code>IllegalArgumentException</code>
	101	* if the resource is not valid
	102	*/
	103	URL getResource(String name, BeanContextChild bcc) throws IllegalArgumentException;
	104
	105	/**
	106	* Adds the specified <code>BeanContextMembershipListener</code>
	107	* to receive <code>BeanContextMembershipEvents</code> from
	108	* this <code>BeanContext</code> whenever it adds
	109	* or removes a child <code>Component</code>(s).
	110	*
	111	* @param bcml the <code>BeanContextMembershipListener</code> to be added
	112	*/
	113	void addBeanContextMembershipListener(BeanContextMembershipListener bcml);
	114
	115	/**
	116	* Removes the specified <code>BeanContextMembershipListener</code>
	117	* so that it no longer receives <code>BeanContextMembershipEvent</code>s
	118	* when the child <code>Component</code>(s) are added or removed.
	119	*
	120	* @param bcml the <code>BeanContextMembershipListener</code>
	121	* to be removed
	122	*/
	123	void removeBeanContextMembershipListener(BeanContextMembershipListener bcml);
	124
	125	/**
	126	* This global lock is used by both <code>BeanContext</code>
	127	* and <code>BeanContextServices</code> implementors
	128	* to serialize changes in a <code>BeanContext</code>
	129	* hierarchy and any service requests etc.
	130	*/
	131	public static final Object globalHierarchyLock = new Object();
	132	}

java/pkg/java/beans/beancontext/BeanContextChild.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextChild.java+137−0

@@ -0,0 +1,137 @@
	1	/*
	2	* Copyright (c) 1997, 2006, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.beans.PropertyChangeListener;
	29	import java.beans.VetoableChangeListener;
	30	import java.beans.PropertyVetoException;
	31
	32	import java.beans.beancontext.BeanContext;
	33
	34	/**
	35	* <p>
	36	* JavaBeans wishing to be nested within, and obtain a reference to their
	37	* execution environment, or context, as defined by the BeanContext
	38	* sub-interface shall implement this interface.
	39	* </p>
	40	* <p>
	41	* Conformant BeanContexts shall as a side effect of adding a BeanContextChild
	42	* object shall pass a reference to itself via the setBeanContext() method of
	43	* this interface.
	44	* </p>
	45	* <p>
	46	* Note that a BeanContextChild may refuse a change in state by throwing
	47	* PropertyVetoedException in response.
	48	* </p>
	49	* <p>
	50	* In order for persistence mechanisms to function properly on BeanContextChild
	51	* instances across a broad variety of scenarios, implementing classes of this
	52	* interface are required to define as transient, any or all fields, or
	53	* instance variables, that may contain, or represent, references to the
	54	* nesting BeanContext instance or other resources obtained
	55	* from the BeanContext via any unspecified mechanisms.
	56	* </p>
	57	*
	58	* @author Laurence P. G. Cable
	59	* @since 1.2
	60	*
	61	* @see java.beans.beancontext.BeanContext
	62	* @see java.beans.PropertyChangeEvent
	63	* @see java.beans.PropertyChangeListener
	64	* @see java.beans.PropertyVetoException
	65	* @see java.beans.VetoableChangeListener
	66	*/
	67
	68	public interface BeanContextChild {
	69
	70	/**
	71	* <p>
	72	* Objects that implement this interface,
	73	* shall fire a java.beans.PropertyChangeEvent, with parameters:
	74	*
	75	* propertyName "beanContext", oldValue (the previous nesting
	76	* <code>BeanContext</code> instance, or <code>null</code>),
	77	* newValue (the current nesting
	78	* <code>BeanContext</code> instance, or <code>null</code>).
	79	* <p>
	80	* A change in the value of the nesting BeanContext property of this
	81	* BeanContextChild may be vetoed by throwing the appropriate exception.
	82	* </p>
	83	* @param bc The <code>BeanContext</code> with which
	84	* to associate this <code>BeanContextChild</code>.
	85	* @throws <code>PropertyVetoException</code> if the
	86	* addition of the specified <code>BeanContext</code> is refused.
	87	*/
	88	void setBeanContext(BeanContext bc) throws PropertyVetoException;
	89
	90	/**
	91	* Gets the <code>BeanContext</code> associated
	92	* with this <code>BeanContextChild</code>.
	93	* @return the <code>BeanContext</code> associated
	94	* with this <code>BeanContextChild</code>.
	95	*/
	96	BeanContext getBeanContext();
	97
	98	/**
	99	* Adds a <code>PropertyChangeListener</code>
	100	* to this <code>BeanContextChild</code>
	101	* in order to receive a <code>PropertyChangeEvent</code>
	102	* whenever the specified property has changed.
	103	* @param name the name of the property to listen on
	104	* @param pcl the <code>PropertyChangeListener</code> to add
	105	*/
	106	void addPropertyChangeListener(String name, PropertyChangeListener pcl);
	107
	108	/**
	109	* Removes a <code>PropertyChangeListener</code> from this
	110	* <code>BeanContextChild</code> so that it no longer
	111	* receives <code>PropertyChangeEvents</code> when the
	112	* specified property is changed.
	113	*
	114	* @param name the name of the property that was listened on
	115	* @param pcl the <code>PropertyChangeListener</code> to remove
	116	*/
	117	void removePropertyChangeListener(String name, PropertyChangeListener pcl);
	118
	119	/**
	120	* Adds a <code>VetoableChangeListener</code> to
	121	* this <code>BeanContextChild</code>
	122	* to receive events whenever the specified property changes.
	123	* @param name the name of the property to listen on
	124	* @param vcl the <code>VetoableChangeListener</code> to add
	125	*/
	126	void addVetoableChangeListener(String name, VetoableChangeListener vcl);
	127
	128	/**
	129	* Removes a <code>VetoableChangeListener</code> from this
	130	* <code>BeanContextChild</code> so that it no longer receives
	131	* events when the specified property changes.
	132	* @param name the name of the property that was listened on.
	133	* @param vcl the <code>VetoableChangeListener</code> to remove.
	134	*/
	135	void removeVetoableChangeListener(String name, VetoableChangeListener vcl);
	136
	137	}

java/pkg/java/beans/beancontext/BeanContextChildComponentProxy.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextChildComponentProxy.java+54−0

@@ -0,0 +1,54 @@
	1	/*
	2	* Copyright (c) 1998, 2002, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.awt.Component;
	29
	30	/**
	31	* <p>
	32	* This interface is implemented by
	33	* <code>BeanContextChildren</code> that have an AWT <code>Component</code>
	34	* associated with them.
	35	* </p>
	36	*
	37	* @author Laurence P. G. Cable
	38	* @since 1.2
	39	*
	40	* @see java.beans.beancontext.BeanContext
	41	* @see java.beans.beancontext.BeanContextSupport
	42	*/
	43
	44	public interface BeanContextChildComponentProxy {
	45
	46	/**
	47	* Gets the <code>java.awt.Component</code> associated with
	48	* this <code>BeanContextChild</code>.
	49	* @return the AWT <code>Component</code> associated with
	50	* this <code>BeanContextChild</code>
	51	*/
	52
	53	Component getComponent();
	54	}

java/pkg/java/beans/beancontext/BeanContextChildSupport.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextChildSupport.java+373−0

@@ -0,0 +1,373 @@
	1	/*
	2	* Copyright (c) 1998, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.beans.PropertyChangeEvent;
	29	import java.beans.PropertyChangeListener;
	30	import java.beans.PropertyChangeSupport;
	31
	32	import java.beans.VetoableChangeListener;
	33	import java.beans.VetoableChangeSupport;
	34
	35	import java.beans.PropertyVetoException;
	36
	37	import java.io.IOException;
	38	import java.io.ObjectInputStream;
	39	import java.io.ObjectOutputStream;
	40	import java.io.Serializable;
	41
	42	/**
	43	* <p>
	44	* This is a general support class to provide support for implementing the
	45	* BeanContextChild protocol.
	46	*
	47	* This class may either be directly subclassed, or encapsulated and delegated
	48	* to in order to implement this interface for a given component.
	49	* </p>
	50	*
	51	* @author Laurence P. G. Cable
	52	* @since 1.2
	53	*
	54	* @see java.beans.beancontext.BeanContext
	55	* @see java.beans.beancontext.BeanContextServices
	56	* @see java.beans.beancontext.BeanContextChild
	57	*/
	58
	59	public class BeanContextChildSupport implements BeanContextChild, BeanContextServicesListener, Serializable {
	60
	61	static final long serialVersionUID = 6328947014421475877L;
	62
	63	/**
	64	* construct a BeanContextChildSupport where this class has been
	65	* subclassed in order to implement the JavaBean component itself.
	66	*/
	67
	68	public BeanContextChildSupport() {
	69	super();
	70
	71	beanContextChildPeer = this;
	72
	73	pcSupport = new PropertyChangeSupport(beanContextChildPeer);
	74	vcSupport = new VetoableChangeSupport(beanContextChildPeer);
	75	}
	76
	77	/**
	78	* construct a BeanContextChildSupport where the JavaBean component
	79	* itself implements BeanContextChild, and encapsulates this, delegating
	80	* that interface to this implementation
	81	*/
	82
	83	public BeanContextChildSupport(BeanContextChild bcc) {
	84	super();
	85
	86	beanContextChildPeer = (bcc != null) ? bcc : this;
	87
	88	pcSupport = new PropertyChangeSupport(beanContextChildPeer);
	89	vcSupport = new VetoableChangeSupport(beanContextChildPeer);
	90	}
	91
	92	/**
	93	* Sets the <code>BeanContext</code> for
	94	* this <code>BeanContextChildSupport</code>.
	95	* @param bc the new value to be assigned to the <code>BeanContext</code>
	96	* property
	97	* @throws <code>PropertyVetoException</code> if the change is rejected
	98	*/
	99	public synchronized void setBeanContext(BeanContext bc) throws PropertyVetoException {
	100	if (bc == beanContext) return;
	101
	102	BeanContext oldValue = beanContext;
	103	BeanContext newValue = bc;
	104
	105	if (!rejectedSetBCOnce) {
	106	if (rejectedSetBCOnce = !validatePendingSetBeanContext(bc)) {
	107	throw new PropertyVetoException(
	108	"setBeanContext() change rejected:",
	109	new PropertyChangeEvent(beanContextChildPeer, "beanContext", oldValue, newValue)
	110	);
	111	}
	112
	113	try {
	114	fireVetoableChange("beanContext",
	115	oldValue,
	116	newValue
	117	);
	118	} catch (PropertyVetoException pve) {
	119	rejectedSetBCOnce = true;
	120
	121	throw pve; // re-throw
	122	}
	123	}
	124
	125	if (beanContext != null) releaseBeanContextResources();
	126
	127	beanContext = newValue;
	128	rejectedSetBCOnce = false;
	129
	130	firePropertyChange("beanContext",
	131	oldValue,
	132	newValue
	133	);
	134
	135	if (beanContext != null) initializeBeanContextResources();
	136	}
	137
	138	/**
	139	* Gets the nesting <code>BeanContext</code>
	140	* for this <code>BeanContextChildSupport</code>.
	141	* @return the nesting <code>BeanContext</code> for
	142	* this <code>BeanContextChildSupport</code>.
	143	*/
	144	public synchronized BeanContext getBeanContext() { return beanContext; }
	145
	146	/**
	147	* Add a PropertyChangeListener for a specific property.
	148	* The same listener object may be added more than once. For each
	149	* property, the listener will be invoked the number of times it was added
	150	* for that property.
	151	* If <code>name</code> or <code>pcl</code> is null, no exception is thrown
	152	* and no action is taken.
	153	*
	154	* @param name The name of the property to listen on
	155	* @param pcl The <code>PropertyChangeListener</code> to be added
	156	*/
	157	public void addPropertyChangeListener(String name, PropertyChangeListener pcl) {
	158	pcSupport.addPropertyChangeListener(name, pcl);
	159	}
	160
	161	/**
	162	* Remove a PropertyChangeListener for a specific property.
	163	* If <code>pcl</code> was added more than once to the same event
	164	* source for the specified property, it will be notified one less time
	165	* after being removed.
	166	* If <code>name</code> is null, no exception is thrown
	167	* and no action is taken.
	168	* If <code>pcl</code> is null, or was never added for the specified
	169	* property, no exception is thrown and no action is taken.
	170	*
	171	* @param name The name of the property that was listened on
	172	* @param pcl The PropertyChangeListener to be removed
	173	*/
	174	public void removePropertyChangeListener(String name, PropertyChangeListener pcl) {
	175	pcSupport.removePropertyChangeListener(name, pcl);
	176	}
	177
	178	/**
	179	* Add a VetoableChangeListener for a specific property.
	180	* The same listener object may be added more than once. For each
	181	* property, the listener will be invoked the number of times it was added
	182	* for that property.
	183	* If <code>name</code> or <code>vcl</code> is null, no exception is thrown
	184	* and no action is taken.
	185	*
	186	* @param name The name of the property to listen on
	187	* @param vcl The <code>VetoableChangeListener</code> to be added
	188	*/
	189	public void addVetoableChangeListener(String name, VetoableChangeListener vcl) {
	190	vcSupport.addVetoableChangeListener(name, vcl);
	191	}
	192
	193	/**
	194	* Removes a <code>VetoableChangeListener</code>.
	195	* If <code>pcl</code> was added more than once to the same event
	196	* source for the specified property, it will be notified one less time
	197	* after being removed.
	198	* If <code>name</code> is null, no exception is thrown
	199	* and no action is taken.
	200	* If <code>vcl</code> is null, or was never added for the specified
	201	* property, no exception is thrown and no action is taken.
	202	*
	203	* @param name The name of the property that was listened on
	204	* @param vcl The <code>VetoableChangeListener</code> to be removed
	205	*/
	206	public void removeVetoableChangeListener(String name, VetoableChangeListener vcl) {
	207	vcSupport.removeVetoableChangeListener(name, vcl);
	208	}
	209
	210	/**
	211	* A service provided by the nesting BeanContext has been revoked.
	212	*
	213	* Subclasses may override this method in order to implement their own
	214	* behaviors.
	215	* @param bcsre The <code>BeanContextServiceRevokedEvent</code> fired as a
	216	* result of a service being revoked
	217	*/
	218	public void serviceRevoked(BeanContextServiceRevokedEvent bcsre) { }
	219
	220	/**
	221	* A new service is available from the nesting BeanContext.
	222	*
	223	* Subclasses may override this method in order to implement their own
	224	* behaviors
	225	* @param bcsae The BeanContextServiceAvailableEvent fired as a
	226	* result of a service becoming available
	227	*
	228	*/
	229	public void serviceAvailable(BeanContextServiceAvailableEvent bcsae) { }
	230
	231	/**
	232	* Gets the <tt>BeanContextChild</tt> associated with this
	233	* <tt>BeanContextChildSupport</tt>.
	234	*
	235	* @return the <tt>BeanContextChild</tt> peer of this class
	236	*/
	237	public BeanContextChild getBeanContextChildPeer() { return beanContextChildPeer; }
	238
	239	/**
	240	* Reports whether or not this class is a delegate of another.
	241	*
	242	* @return true if this class is a delegate of another
	243	*/
	244	public boolean isDelegated() { return !this.equals(beanContextChildPeer); }
	245
	246	/**
	247	* Report a bound property update to any registered listeners. No event is
	248	* fired if old and new are equal and non-null.
	249	* @param name The programmatic name of the property that was changed
	250	* @param oldValue The old value of the property
	251	* @param newValue The new value of the property
	252	*/
	253	public void firePropertyChange(String name, Object oldValue, Object newValue) {
	254	pcSupport.firePropertyChange(name, oldValue, newValue);
	255	}
	256
	257	/**
	258	* Report a vetoable property update to any registered listeners.
	259	* If anyone vetos the change, then fire a new event
	260	* reverting everyone to the old value and then rethrow
	261	* the PropertyVetoException. <P>
	262	*
	263	* No event is fired if old and new are equal and non-null.
	264	* <P>
	265	* @param name The programmatic name of the property that is about to
	266	* change
	267	*
	268	* @param oldValue The old value of the property
	269	* @param newValue - The new value of the property
	270	*
	271	* @throws PropertyVetoException if the recipient wishes the property
	272	* change to be rolled back.
	273	*/
	274	public void fireVetoableChange(String name, Object oldValue, Object newValue) throws PropertyVetoException {
	275	vcSupport.fireVetoableChange(name, oldValue, newValue);
	276	}
	277
	278	/**
	279	* Called from setBeanContext to validate (or otherwise) the
	280	* pending change in the nesting BeanContext property value.
	281	* Returning false will cause setBeanContext to throw
	282	* PropertyVetoException.
	283	* @param newValue the new value that has been requested for
	284	* the BeanContext property
	285	* @return <code>true</code> if the change operation is to be vetoed
	286	*/
	287	public boolean validatePendingSetBeanContext(BeanContext newValue) {
	288	return true;
	289	}
	290
	291	/**
	292	* This method may be overridden by subclasses to provide their own
	293	* release behaviors. When invoked any resources held by this instance
	294	* obtained from its current BeanContext property should be released
	295	* since the object is no longer nested within that BeanContext.
	296	*/
	297
	298	protected void releaseBeanContextResources() {
	299	// do nothing
	300	}
	301
	302	/**
	303	* This method may be overridden by subclasses to provide their own
	304	* initialization behaviors. When invoked any resources requried by the
	305	* BeanContextChild should be obtained from the current BeanContext.
	306	*/
	307
	308	protected void initializeBeanContextResources() {
	309	// do nothing
	310	}
	311
	312	/**
	313	* Write the persistence state of the object.
	314	*/
	315
	316	private void writeObject(ObjectOutputStream oos) throws IOException {
	317
	318	/*
	319	* dont serialize if we are delegated and the delegator isnt also
	320	* serializable.
	321	*/
	322
	323	if (!equals(beanContextChildPeer) && !(beanContextChildPeer instanceof Serializable))
	324	throw new IOException("BeanContextChildSupport beanContextChildPeer not Serializable");
	325
	326	else
	327	oos.defaultWriteObject();
	328
	329	}
	330
	331
	332	/**
	333	* Restore a persistent object, must wait for subsequent setBeanContext()
	334	* to fully restore any resources obtained from the new nesting
	335	* BeanContext
	336	*/
	337
	338	private void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
	339	ois.defaultReadObject();
	340	}
	341
	342	/*
	343	* fields
	344	*/
	345
	346	/**
	347	* The <code>BeanContext</code> in which
	348	* this <code>BeanContextChild</code> is nested.
	349	*/
	350	public BeanContextChild beanContextChildPeer;
	351
	352	/**
	353	* The <tt>PropertyChangeSupport</tt> associated with this
	354	* <tt>BeanContextChildSupport</tt>.
	355	*/
	356	protected PropertyChangeSupport pcSupport;
	357
	358	/**
	359	* The <tt>VetoableChangeSupport</tt> associated with this
	360	* <tt>BeanContextChildSupport</tt>.
	361	*/
	362	protected VetoableChangeSupport vcSupport;
	363
	364	protected transient BeanContext beanContext;
	365
	366	/**
	367	* A flag indicating that there has been
	368	* at least one <code>PropertyChangeVetoException</code>
	369	* thrown for the attempted setBeanContext operation.
	370	*/
	371	protected transient boolean rejectedSetBCOnce;
	372
	373	}

java/pkg/java/beans/beancontext/BeanContextContainerProxy.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextContainerProxy.java+52−0

@@ -0,0 +1,52 @@
	1	/*
	2	* Copyright (c) 1998, 2002, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.awt.Container;
	29
	30	/**
	31	* <p>
	32	* This interface is implemented by BeanContexts' that have an AWT Container
	33	* associated with them.
	34	* </p>
	35	*
	36	* @author Laurence P. G. Cable
	37	* @since 1.2
	38	*
	39	* @see java.beans.beancontext.BeanContext
	40	* @see java.beans.beancontext.BeanContextSupport
	41	*/
	42
	43	public interface BeanContextContainerProxy {
	44
	45	/**
	46	* Gets the <code>java.awt.Container</code> associated
	47	* with this <code>BeanContext</code>.
	48	* @return the <code>java.awt.Container</code> associated
	49	* with this <code>BeanContext</code>.
	50	*/
	51	Container getContainer();
	52	}

java/pkg/java/beans/beancontext/BeanContextEvent.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextEvent.java+104−0

@@ -0,0 +1,104 @@
	1	/*
	2	* Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.util.EventObject;
	29
	30	import java.beans.beancontext.BeanContext;
	31
	32	/**
	33	* <p>
	34	* <code>BeanContextEvent</code> is the abstract root event class
	35	* for all events emitted
	36	* from, and pertaining to the semantics of, a <code>BeanContext</code>.
	37	* This class introduces a mechanism to allow the propagation of
	38	* <code>BeanContextEvent</code> subclasses through a hierarchy of
	39	* <code>BeanContext</code>s. The <code>setPropagatedFrom()</code>
	40	* and <code>getPropagatedFrom()</code> methods allow a
	41	* <code>BeanContext</code> to identify itself as the source
	42	* of a propagated event.
	43	* </p>
	44	*
	45	* @author Laurence P. G. Cable
	46	* @since 1.2
	47	* @see java.beans.beancontext.BeanContext
	48	*/
	49
	50	public abstract class BeanContextEvent extends EventObject {
	51	private static final long serialVersionUID = 7267998073569045052L;
	52
	53	/**
	54	* Contruct a BeanContextEvent
	55	*
	56	* @param bc The BeanContext source
	57	*/
	58	protected BeanContextEvent(BeanContext bc) {
	59	super(bc);
	60	}
	61
	62	/**
	63	* Gets the <code>BeanContext</code> associated with this event.
	64	* @return the <code>BeanContext</code> associated with this event.
	65	*/
	66	public BeanContext getBeanContext() { return (BeanContext)getSource(); }
	67
	68	/**
	69	* Sets the <code>BeanContext</code> from which this event was propagated.
	70	* @param bc the <code>BeanContext</code> from which this event
	71	* was propagated
	72	*/
	73	public synchronized void setPropagatedFrom(BeanContext bc) {
	74	propagatedFrom = bc;
	75	}
	76
	77	/**
	78	* Gets the <code>BeanContext</code> from which this event was propagated.
	79	* @return the <code>BeanContext</code> from which this
	80	* event was propagated
	81	*/
	82	public synchronized BeanContext getPropagatedFrom() {
	83	return propagatedFrom;
	84	}
	85
	86	/**
	87	* Reports whether or not this event is
	88	* propagated from some other <code>BeanContext</code>.
	89	* @return <code>true</code> if propagated, <code>false</code>
	90	* if not
	91	*/
	92	public synchronized boolean isPropagated() {
	93	return propagatedFrom != null;
	94	}
	95
	96	/*
	97	* fields
	98	*/
	99
	100	/**
	101	* The <code>BeanContext</code> from which this event was propagated
	102	*/
	103	protected BeanContext propagatedFrom;
	104	}

java/pkg/java/beans/beancontext/BeanContextMembershipEvent.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextMembershipEvent.java+131−0

@@ -0,0 +1,131 @@
	1	/*
	2	* Copyright (c) 1997, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.util.EventObject;
	29
	30	import java.beans.beancontext.BeanContext;
	31	import java.beans.beancontext.BeanContextEvent;
	32
	33	import java.util.Arrays;
	34	import java.util.Collection;
	35	import java.util.Iterator;
	36
	37	/**
	38	* A <code>BeanContextMembershipEvent</code> encapsulates
	39	* the list of children added to, or removed from,
	40	* the membership of a particular <code>BeanContext</code>.
	41	* An instance of this event is fired whenever a successful
	42	* add(), remove(), retainAll(), removeAll(), or clear() is
	43	* invoked on a given <code>BeanContext</code> instance.
	44	* Objects interested in receiving events of this type must
	45	* implement the <code>BeanContextMembershipListener</code>
	46	* interface, and must register their intent via the
	47	* <code>BeanContext</code>'s
	48	* <code>addBeanContextMembershipListener(BeanContextMembershipListener bcml)
	49	* </code> method.
	50	*
	51	* @author Laurence P. G. Cable
	52	* @since 1.2
	53	* @see java.beans.beancontext.BeanContext
	54	* @see java.beans.beancontext.BeanContextEvent
	55	* @see java.beans.beancontext.BeanContextMembershipListener
	56	*/
	57	public class BeanContextMembershipEvent extends BeanContextEvent {
	58	private static final long serialVersionUID = 3499346510334590959L;
	59
	60	/**
	61	* Contruct a BeanContextMembershipEvent
	62	*
	63	* @param bc The BeanContext source
	64	* @param changes The Children affected
	65	* @throws NullPointerException if <CODE>changes</CODE> is <CODE>null</CODE>
	66	*/
	67
	68	public BeanContextMembershipEvent(BeanContext bc, Collection changes) {
	69	super(bc);
	70
	71	if (changes == null) throw new NullPointerException(
	72	"BeanContextMembershipEvent constructor: changes is null.");
	73
	74	children = changes;
	75	}
	76
	77	/**
	78	* Contruct a BeanContextMembershipEvent
	79	*
	80	* @param bc The BeanContext source
	81	* @param changes The Children effected
	82	* @exception NullPointerException if changes associated with this
	83	* event are null.
	84	*/
	85
	86	public BeanContextMembershipEvent(BeanContext bc, Object[] changes) {
	87	super(bc);
	88
	89	if (changes == null) throw new NullPointerException(
	90	"BeanContextMembershipEvent: changes is null.");
	91
	92	children = Arrays.asList(changes);
	93	}
	94
	95	/**
	96	* Gets the number of children affected by the notification.
	97	* @return the number of children affected by the notification
	98	*/
	99	public int size() { return children.size(); }
	100
	101	/**
	102	* Is the child specified affected by the event?
	103	* @return <code>true</code> if affected, <code>false</code>
	104	* if not
	105	*/
	106	public boolean contains(Object child) {
	107	return children.contains(child);
	108	}
	109
	110	/**
	111	* Gets the array of children affected by this event.
	112	* @return the array of children affected
	113	*/
	114	public Object[] toArray() { return children.toArray(); }
	115
	116	/**
	117	* Gets the array of children affected by this event.
	118	* @return the array of children effected
	119	*/
	120	public Iterator iterator() { return children.iterator(); }
	121
	122	/*
	123	* fields
	124	*/
	125
	126	/**
	127	* The list of children affected by this
	128	* event notification.
	129	*/
	130	protected Collection children;
	131	}

java/pkg/java/beans/beancontext/BeanContextMembershipListener.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextMembershipListener.java+61−0

@@ -0,0 +1,61 @@
	1	/*
	2	* Copyright (c) 1997, 1999, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.beans.beancontext.BeanContextMembershipEvent;
	29
	30	import java.util.EventListener;
	31
	32	/**
	33	* <p>
	34	* Compliant BeanContexts fire events on this interface when the state of
	35	* the membership of the BeanContext changes.
	36	* </p>
	37	*
	38	* @author Laurence P. G. Cable
	39	* @since 1.2
	40	* @see java.beans.beancontext.BeanContext
	41	*/
	42
	43	public interface BeanContextMembershipListener extends EventListener {
	44
	45	/**
	46	* Called when a child or list of children is added to a
	47	* <code>BeanContext</code> that this listener is registered with.
	48	* @param bcme The <code>BeanContextMembershipEvent</code>
	49	* describing the change that occurred.
	50	*/
	51	void childrenAdded(BeanContextMembershipEvent bcme);
	52
	53	/**
	54	* Called when a child or list of children is removed
	55	* from a <code>BeanContext</code> that this listener
	56	* is registered with.
	57	* @param bcme The <code>BeanContextMembershipEvent</code>
	58	* describing the change that occurred.
	59	*/
	60	void childrenRemoved(BeanContextMembershipEvent bcme);
	61	}

java/pkg/java/beans/beancontext/BeanContextProxy.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextProxy.java+85−0

@@ -0,0 +1,85 @@
	1	/*
	2	* Copyright (c) 1998, 2002, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	/**
	29	* <p>
	30	* This interface is implemented by a JavaBean that does
	31	* not directly have a BeanContext(Child) associated with
	32	* it (via implementing that interface or a subinterface thereof),
	33	* but has a public BeanContext(Child) delegated from it.
	34	* For example, a subclass of java.awt.Container may have a BeanContext
	35	* associated with it that all Component children of that Container shall
	36	* be contained within.
	37	* </p>
	38	* <p>
	39	* An Object may not implement this interface and the
	40	* BeanContextChild interface
	41	* (or any subinterfaces thereof) they are mutually exclusive.
	42	* </p>
	43	* <p>
	44	* Callers of this interface shall examine the return type in order to
	45	* obtain a particular subinterface of BeanContextChild as follows:
	46	* <code>
	47	* BeanContextChild bcc = o.getBeanContextProxy();
	48	*
	49	* if (bcc instanceof BeanContext) {
	50	* // ...
	51	* }
	52	* </code>
	53	* or
	54	* <code>
	55	* BeanContextChild bcc = o.getBeanContextProxy();
	56	* BeanContext bc = null;
	57	*
	58	* try {
	59	* bc = (BeanContext)bcc;
	60	* } catch (ClassCastException cce) {
	61	* // cast failed, bcc is not an instanceof BeanContext
	62	* }
	63	* </code>
	64	* </p>
	65	* <p>
	66	* The return value is a constant for the lifetime of the implementing
	67	* instance
	68	* </p>
	69	* @author Laurence P. G. Cable
	70	* @since 1.2
	71	*
	72	* @see java.beans.beancontext.BeanContextChild
	73	* @see java.beans.beancontext.BeanContextChildSupport
	74	*/
	75
	76	public interface BeanContextProxy {
	77
	78	/**
	79	* Gets the <code>BeanContextChild</code> (or subinterface)
	80	* associated with this object.
	81	* @return the <code>BeanContextChild</code> (or subinterface)
	82	* associated with this object
	83	*/
	84	BeanContextChild getBeanContextProxy();
	85	}

java/pkg/java/beans/beancontext/BeanContextServiceAvailableEvent.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServiceAvailableEvent.java+86−0

@@ -0,0 +1,86 @@
	1	/*
	2	* Copyright (c) 1998, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.beans.beancontext.BeanContextChild;
	29	import java.beans.beancontext.BeanContextEvent;
	30
	31	import java.beans.beancontext.BeanContextServices;
	32
	33	import java.util.Iterator;
	34
	35	/**
	36	* <p>
	37	* This event type is used by the BeanContextServicesListener in order to
	38	* identify the service being registered.
	39	* </p>
	40	*/
	41
	42	public class BeanContextServiceAvailableEvent extends BeanContextEvent {
	43	private static final long serialVersionUID = -5333985775656400778L;
	44
	45	/**
	46	* Construct a <code>BeanContextAvailableServiceEvent</code>.
	47	* @param bcs The context in which the service has become available
	48	* @param sc A <code>Class</code> reference to the newly available service
	49	*/
	50	public BeanContextServiceAvailableEvent(BeanContextServices bcs, Class sc) {
	51	super((BeanContext)bcs);
	52
	53	serviceClass = sc;
	54	}
	55
	56	/**
	57	* Gets the source as a reference of type <code>BeanContextServices</code>.
	58	* @return The context in which the service has become available
	59	*/
	60	public BeanContextServices getSourceAsBeanContextServices() {
	61	return (BeanContextServices)getBeanContext();
	62	}
	63
	64	/**
	65	* Gets the service class that is the subject of this notification.
	66	* @return A <code>Class</code> reference to the newly available service
	67	*/
	68	public Class getServiceClass() { return serviceClass; }
	69
	70	/**
	71	* Gets the list of service dependent selectors.
	72	* @return the current selectors available from the service
	73	*/
	74	public Iterator getCurrentServiceSelectors() {
	75	return ((BeanContextServices)getSource()).getCurrentServiceSelectors(serviceClass);
	76	}
	77
	78	/*
	79	* fields
	80	*/
	81
	82	/**
	83	* A <code>Class</code> reference to the newly available service
	84	*/
	85	protected Class serviceClass;
	86	}

java/pkg/java/beans/beancontext/BeanContextServiceProvider.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServiceProvider.java+104−0

@@ -0,0 +1,104 @@
	1	/*
	2	* Copyright (c) 1998, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.util.Iterator;
	29
	30	/**
	31	* <p>
	32	* One of the primary functions of a BeanContext is to act a as rendezvous
	33	* between JavaBeans, and BeanContextServiceProviders.
	34	* </p>
	35	* <p>
	36	* A JavaBean nested within a BeanContext, may ask that BeanContext to
	37	* provide an instance of a "service", based upon a reference to a Java
	38	* Class object that represents that service.
	39	* </p>
	40	* <p>
	41	* If such a service has been registered with the context, or one of its
	42	* nesting context's, in the case where a context delegate to its context
	43	* to satisfy a service request, then the BeanContextServiceProvider associated with
	44	* the service is asked to provide an instance of that service.
	45	* </p>
	46	* <p>
	47	* The ServcieProvider may always return the same instance, or it may
	48	* construct a new instance for each request.
	49	* </p>
	50	*/
	51
	52	public interface BeanContextServiceProvider {
	53
	54	/**
	55	* Invoked by <code>BeanContextServices</code>, this method
	56	* requests an instance of a
	57	* service from this <code>BeanContextServiceProvider</code>.
	58	*
	59	* @param bcs The <code>BeanContextServices</code> associated with this
	60	* particular request. This parameter enables the
	61	* <code>BeanContextServiceProvider</code> to distinguish service
	62	* requests from multiple sources.
	63	*
	64	* @param requestor The object requesting the service
	65	*
	66	* @param serviceClass The service requested
	67	*
	68	* @param serviceSelector the service dependent parameter
	69	* for a particular service, or <code>null</code> if not applicable.
	70	*
	71	* @return a reference to the requested service
	72	*/
	73	Object getService(BeanContextServices bcs, Object requestor, Class serviceClass, Object serviceSelector);
	74
	75	/**
	76	* Invoked by <code>BeanContextServices</code>,
	77	* this method releases a nested <code>BeanContextChild</code>'s
	78	* (or any arbitrary object associated with a
	79	* <code>BeanContextChild</code>) reference to the specified service.
	80	*
	81	* @param bcs the <code>BeanContextServices</code> associated with this
	82	* particular release request
	83	*
	84	* @param requestor the object requesting the service to be released
	85	*
	86	* @param service the service that is to be released
	87	*/
	88	public void releaseService(BeanContextServices bcs, Object requestor, Object service);
	89
	90	/**
	91	* Invoked by <code>BeanContextServices</code>, this method
	92	* gets the current service selectors for the specified service.
	93	* A service selector is a service specific parameter,
	94	* typical examples of which could include: a
	95	* parameter to a constructor for the service implementation class,
	96	* a value for a particular service's property, or a key into a
	97	* map of existing implementations.
	98	*
	99	* @param bcs the <code>BeanContextServices</code> for this request
	100	* @param serviceClass the specified service
	101	* @return the current service selectors for the specified serviceClass
	102	*/
	103	Iterator getCurrentServiceSelectors(BeanContextServices bcs, Class serviceClass);
	104	}

java/pkg/java/beans/beancontext/BeanContextServiceProviderBeanInfo.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServiceProviderBeanInfo.java+47−0

@@ -0,0 +1,47 @@
	1	/*
	2	* Copyright (c) 1998, 1999, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.beans.BeanInfo;
	29
	30	/**
	31	* A BeanContextServiceProvider implementor who wishes to provide explicit
	32	* information about the services their bean may provide shall implement a
	33	* BeanInfo class that implements this BeanInfo subinterface and provides
	34	* explicit information about the methods, properties, events, etc, of their
	35	* services.
	36	*/
	37
	38	public interface BeanContextServiceProviderBeanInfo extends BeanInfo {
	39
	40	/**
	41	* Gets a <code>BeanInfo</code> array, one for each
	42	* service class or interface statically available
	43	* from this ServiceProvider.
	44	* @return the <code>BeanInfo</code> array
	45	*/
	46	BeanInfo[] getServicesBeanInfo();
	47	}

java/pkg/java/beans/beancontext/BeanContextServiceRevokedEvent.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServiceRevokedEvent.java+99−0

@@ -0,0 +1,99 @@
	1	/*
	2	* Copyright (c) 1998, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.beans.beancontext.BeanContextEvent;
	29
	30	import java.beans.beancontext.BeanContextServices;
	31
	32	/**
	33	* <p>
	34	* This event type is used by the
	35	* <code>BeanContextServiceRevokedListener</code> in order to
	36	* identify the service being revoked.
	37	* </p>
	38	*/
	39	public class BeanContextServiceRevokedEvent extends BeanContextEvent {
	40	private static final long serialVersionUID = -1295543154724961754L;
	41
	42	/**
	43	* Construct a <code>BeanContextServiceEvent</code>.
	44	* @param bcs the <code>BeanContextServices</code>
	45	* from which this service is being revoked
	46	* @param sc the service that is being revoked
	47	* @param invalidate <code>true</code> for immediate revocation
	48	*/
	49	public BeanContextServiceRevokedEvent(BeanContextServices bcs, Class sc, boolean invalidate) {
	50	super((BeanContext)bcs);
	51
	52	serviceClass = sc;
	53	invalidateRefs = invalidate;
	54	}
	55
	56	/**
	57	* Gets the source as a reference of type <code>BeanContextServices</code>
	58	* @return the <code>BeanContextServices</code> from which
	59	* this service is being revoked
	60	*/
	61	public BeanContextServices getSourceAsBeanContextServices() {
	62	return (BeanContextServices)getBeanContext();
	63	}
	64
	65	/**
	66	* Gets the service class that is the subject of this notification
	67	* @return A <code>Class</code> reference to the
	68	* service that is being revoked
	69	*/
	70	public Class getServiceClass() { return serviceClass; }
	71
	72	/**
	73	* Checks this event to determine whether or not
	74	* the service being revoked is of a particular class.
	75	* @param service the service of interest (should be non-null)
	76	* @return <code>true</code> if the service being revoked is of the
	77	* same class as the specified service
	78	*/
	79	public boolean isServiceClass(Class service) {
	80	return serviceClass.equals(service);
	81	}
	82
	83	/**
	84	* Reports if the current service is being forcibly revoked,
	85	* in which case the references are now invalidated and unusable.
	86	* @return <code>true</code> if current service is being forcibly revoked
	87	*/
	88	public boolean isCurrentServiceInvalidNow() { return invalidateRefs; }
	89
	90	/**
	91	* fields
	92	*/
	93
	94	/**
	95	* A <code>Class</code> reference to the service that is being revoked.
	96	*/
	97	protected Class serviceClass;
	98	private boolean invalidateRefs;
	99	}

java/pkg/java/beans/beancontext/BeanContextServiceRevokedListener.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServiceRevokedListener.java+46−0

@@ -0,0 +1,46 @@
	1	/*
	2	* Copyright (c) 1998, 1999, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25	package java.beans.beancontext;
	26
	27	import java.beans.beancontext.BeanContextServiceRevokedEvent;
	28
	29	import java.util.EventListener;
	30
	31	/**
	32	* The listener interface for receiving
	33	* <code>BeanContextServiceRevokedEvent</code> objects. A class that is
	34	* interested in processing a <code>BeanContextServiceRevokedEvent</code>
	35	* implements this interface.
	36	*/
	37	public interface BeanContextServiceRevokedListener extends EventListener {
	38
	39	/**
	40	* The service named has been revoked. getService requests for
	41	* this service will no longer be satisifed.
	42	* @param bcsre the <code>BeanContextServiceRevokedEvent</code> received
	43	* by this listener.
	44	*/
	45	void serviceRevoked(BeanContextServiceRevokedEvent bcsre);
	46	}

java/pkg/java/beans/beancontext/BeanContextServices.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServices.java+159−0

@@ -0,0 +1,159 @@
	1	/*
	2	* Copyright (c) 1998, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.util.Iterator;
	29
	30	import java.util.TooManyListenersException;
	31
	32	import java.beans.beancontext.BeanContext;
	33
	34	import java.beans.beancontext.BeanContextServiceProvider;
	35
	36	import java.beans.beancontext.BeanContextServicesListener;
	37
	38
	39	/**
	40	* <p>
	41	* The BeanContextServices interface provides a mechanism for a BeanContext
	42	* to expose generic "services" to the BeanContextChild objects within.
	43	* </p>
	44	*/
	45	public interface BeanContextServices extends BeanContext, BeanContextServicesListener {
	46
	47	/**
	48	* Adds a service to this BeanContext.
	49	* <code>BeanContextServiceProvider</code>s call this method
	50	* to register a particular service with this context.
	51	* If the service has not previously been added, the
	52	* <code>BeanContextServices</code> associates
	53	* the service with the <code>BeanContextServiceProvider</code> and
	54	* fires a <code>BeanContextServiceAvailableEvent</code> to all
	55	* currently registered <code>BeanContextServicesListeners</code>.
	56	* The method then returns <code>true</code>, indicating that
	57	* the addition of the service was successful.
	58	* If the given service has already been added, this method
	59	* simply returns <code>false</code>.
	60	* @param serviceClass the service to add
	61	* @param serviceProvider the <code>BeanContextServiceProvider</code>
	62	* associated with the service
	63	*/
	64	boolean addService(Class serviceClass, BeanContextServiceProvider serviceProvider);
	65
	66	/**
	67	* BeanContextServiceProviders wishing to remove
	68	* a currently registered service from this context
	69	* may do so via invocation of this method. Upon revocation of
	70	* the service, the <code>BeanContextServices</code> fires a
	71	* <code>BeanContextServiceRevokedEvent</code> to its
	72	* list of currently registered
	73	* <code>BeanContextServiceRevokedListeners</code> and
	74	* <code>BeanContextServicesListeners</code>.
	75	* @param serviceClass the service to revoke from this BeanContextServices
	76	* @param serviceProvider the BeanContextServiceProvider associated with
	77	* this particular service that is being revoked
	78	* @param revokeCurrentServicesNow a value of <code>true</code>
	79	* indicates an exceptional circumstance where the
	80	* <code>BeanContextServiceProvider</code> or
	81	* <code>BeanContextServices</code> wishes to immediately
	82	* terminate service to all currently outstanding references
	83	* to the specified service.
	84	*/
	85	void revokeService(Class serviceClass, BeanContextServiceProvider serviceProvider, boolean revokeCurrentServicesNow);
	86
	87	/**
	88	* Reports whether or not a given service is
	89	* currently available from this context.
	90	* @param serviceClass the service in question
	91	* @return true if the service is available
	92	*/
	93	boolean hasService(Class serviceClass);
	94
	95	/**
	96	* A <code>BeanContextChild</code>, or any arbitrary object
	97	* associated with a <code>BeanContextChild</code>, may obtain
	98	* a reference to a currently registered service from its
	99	* nesting <code>BeanContextServices</code>
	100	* via invocation of this method. When invoked, this method
	101	* gets the service by calling the getService() method on the
	102	* underlying <code>BeanContextServiceProvider</code>.
	103	* @param child the <code>BeanContextChild</code>
	104	* associated with this request
	105	* @param requestor the object requesting the service
	106	* @param serviceClass class of the requested service
	107	* @param serviceSelector the service dependent parameter
	108	* @param bcsrl the
	109	* <code>BeanContextServiceRevokedListener</code> to notify
	110	* if the service should later become revoked
	111	* @throws TooManyListenersException
	112	* @return a reference to this context's named
	113	* Service as requested or <code>null</code>
	114	*/
	115	Object getService(BeanContextChild child, Object requestor, Class serviceClass, Object serviceSelector, BeanContextServiceRevokedListener bcsrl) throws TooManyListenersException;
	116
	117	/**
	118	* Releases a <code>BeanContextChild</code>'s
	119	* (or any arbitrary object associated with a BeanContextChild)
	120	* reference to the specified service by calling releaseService()
	121	* on the underlying <code>BeanContextServiceProvider</code>.
	122	* @param child the <code>BeanContextChild</code>
	123	* @param requestor the requestor
	124	* @param service the service
	125	*/
	126	void releaseService(BeanContextChild child, Object requestor, Object service);
	127
	128	/**
	129	* Gets the currently available services for this context.
	130	* @return an <code>Iterator</code> consisting of the
	131	* currently available services
	132	*/
	133	Iterator getCurrentServiceClasses();
	134
	135	/**
	136	* Gets the list of service dependent service parameters
	137	* (Service Selectors) for the specified service, by
	138	* calling getCurrentServiceSelectors() on the
	139	* underlying BeanContextServiceProvider.
	140	* @param serviceClass the specified service
	141	* @return the currently available service selectors
	142	* for the named serviceClass
	143	*/
	144	Iterator getCurrentServiceSelectors(Class serviceClass);
	145
	146	/**
	147	* Adds a <code>BeanContextServicesListener</code> to this BeanContext
	148	* @param bcsl the <code>BeanContextServicesListener</code> to add
	149	*/
	150	void addBeanContextServicesListener(BeanContextServicesListener bcsl);
	151
	152	/**
	153	* Removes a <code>BeanContextServicesListener</code>
	154	* from this <code>BeanContext</code>
	155	* @param bcsl the <code>BeanContextServicesListener</code>
	156	* to remove from this context
	157	*/
	158	void removeBeanContextServicesListener(BeanContextServicesListener bcsl);
	159	}

java/pkg/java/beans/beancontext/BeanContextServicesListener.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServicesListener.java+46−0

@@ -0,0 +1,46 @@
	1	/*
	2	* Copyright (c) 1998, 1999, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.beans.beancontext.BeanContextServiceAvailableEvent;
	29	import java.beans.beancontext.BeanContextServiceRevokedEvent;
	30	import java.beans.beancontext.BeanContextServiceRevokedListener;
	31
	32	/**
	33	* The listener interface for receiving
	34	* <code>BeanContextServiceAvailableEvent</code> objects.
	35	* A class that is interested in processing a
	36	* <code>BeanContextServiceAvailableEvent</code> implements this interface.
	37	*/
	38	public interface BeanContextServicesListener extends BeanContextServiceRevokedListener {
	39
	40	/**
	41	* The service named has been registered. getService requests for
	42	* this service may now be made.
	43	* @param bcsae the <code>BeanContextServiceAvailableEvent</code>
	44	*/
	45	void serviceAvailable(BeanContextServiceAvailableEvent bcsae);
	46	}

java/pkg/java/beans/beancontext/BeanContextServicesSupport$BCSSChild$BCSSCServiceClassRef.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServicesSupport$BCSSChild$BCSSCServiceRef.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServicesSupport$BCSSChild.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServicesSupport$BCSSProxyServiceProvider.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServicesSupport$BCSSServiceProvider.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServicesSupport.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextServicesSupport.java+1238−0

@@ -0,0 +1,1238 @@
	1	/*
	2	* Copyright (c) 1998, 2009, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.util.ArrayList;
	29	import java.util.Collection;
	30	import java.util.HashMap;
	31	import java.util.HashSet;
	32	import java.util.Iterator;
	33	import java.util.Map;
	34	import java.util.Map.Entry;
	35
	36	import java.io.IOException;
	37	import java.io.ObjectInputStream;
	38	import java.io.ObjectOutputStream;
	39	import java.io.Serializable;
	40
	41	import java.util.TooManyListenersException;
	42
	43	import java.util.Locale;
	44
	45	/**
	46	* <p>
	47	* This helper class provides a utility implementation of the
	48	* java.beans.beancontext.BeanContextServices interface.
	49	* </p>
	50	* <p>
	51	* Since this class directly implements the BeanContextServices interface,
	52	* the class can, and is intended to be used either by subclassing this
	53	* implementation, or via delegation of an instance of this class
	54	* from another through the BeanContextProxy interface.
	55	* </p>
	56	*
	57	* @author Laurence P. G. Cable
	58	* @since 1.2
	59	*/
	60
	61	public class BeanContextServicesSupport extends BeanContextSupport
	62	implements BeanContextServices {
	63	private static final long serialVersionUID = -8494482757288719206L;
	64
	65	/**
	66	* <p>
	67	* Construct a BeanContextServicesSupport instance
	68	* </p>
	69	*
	70	* @param peer The peer BeanContext we are supplying an implementation for, if null the this object is its own peer
	71	* @param lcle The current Locale for this BeanContext.
	72	* @param dTime The initial state, true if in design mode, false if runtime.
	73	* @param visible The initial visibility.
	74	*
	75	*/
	76
	77	public BeanContextServicesSupport(BeanContextServices peer, Locale lcle, boolean dTime, boolean visible) {
	78	super(peer, lcle, dTime, visible);
	79	}
	80
	81	/**
	82	* Create an instance using the specified Locale and design mode.
	83	*
	84	* @param peer The peer BeanContext we are supplying an implementation for, if null the this object is its own peer
	85	* @param lcle The current Locale for this BeanContext.
	86	* @param dtime The initial state, true if in design mode, false if runtime.
	87	*/
	88
	89	public BeanContextServicesSupport(BeanContextServices peer, Locale lcle, boolean dtime) {
	90	this (peer, lcle, dtime, true);
	91	}
	92
	93	/**
	94	* Create an instance using the specified locale
	95	*
	96	* @param peer The peer BeanContext we are supplying an implementation for, if null the this object is its own peer
	97	* @param lcle The current Locale for this BeanContext.
	98	*/
	99
	100	public BeanContextServicesSupport(BeanContextServices peer, Locale lcle) {
	101	this (peer, lcle, false, true);
	102	}
	103
	104	/**
	105	* Create an instance with a peer
	106	*
	107	* @param peer The peer BeanContext we are supplying an implementation for, if null the this object is its own peer
	108	*/
	109
	110	public BeanContextServicesSupport(BeanContextServices peer) {
	111	this (peer, null, false, true);
	112	}
	113
	114	/**
	115	* Create an instance that is not a delegate of another object
	116	*/
	117
	118	public BeanContextServicesSupport() {
	119	this (null, null, false, true);
	120	}
	121
	122	/**
	123	* called by BeanContextSupport superclass during construction and
	124	* deserialization to initialize subclass transient state.
	125	*
	126	* subclasses may envelope this method, but should not override it or
	127	* call it directly.
	128	*/
	129
	130	public void initialize() {
	131	super.initialize();
	132
	133	services = new HashMap(serializable + 1);
	134	bcsListeners = new ArrayList(1);
	135	}
	136
	137	/**
	138	* Gets the <tt>BeanContextServices</tt> associated with this
	139	* <tt>BeanContextServicesSupport</tt>.
	140	*
	141	* @return the instance of <tt>BeanContext</tt>
	142	* this object is providing the implementation for.
	143	*/
	144	public BeanContextServices getBeanContextServicesPeer() {
	145	return (BeanContextServices)getBeanContextChildPeer();
	146	}
	147
	148	/************************************************************************/
	149
	150	/*
	151	* protected nested class containing per child information, an instance
	152	* of which is associated with each child in the "children" hashtable.
	153	* subclasses can extend this class to include their own per-child state.
	154	*
	155	* Note that this 'value' is serialized with the corresponding child 'key'
	156	* when the BeanContextSupport is serialized.
	157	*/
	158
	159	protected class BCSSChild extends BeanContextSupport.BCSChild {
	160
	161	private static final long serialVersionUID = -3263851306889194873L;
	162
	163	/*
	164	* private nested class to map serviceClass to Provider and requestors
	165	* listeners.
	166	*/
	167
	168	class BCSSCServiceClassRef {
	169
	170	// create an instance of a service ref
	171
	172	BCSSCServiceClassRef(Class sc, BeanContextServiceProvider bcsp, boolean delegated) {
	173	super();
	174
	175	serviceClass = sc;
	176
	177	if (delegated)
	178	delegateProvider = bcsp;
	179	else
	180	serviceProvider = bcsp;
	181	}
	182
	183	// add a requestor and assoc listener
	184
	185	void addRequestor(Object requestor, BeanContextServiceRevokedListener bcsrl) throws TooManyListenersException {
	186	BeanContextServiceRevokedListener cbcsrl = (BeanContextServiceRevokedListener)requestors.get(requestor);
	187
	188	if (cbcsrl != null && !cbcsrl.equals(bcsrl))
	189	throw new TooManyListenersException();
	190
	191	requestors.put(requestor, bcsrl);
	192	}
	193
	194	// remove a requestor
	195
	196	void removeRequestor(Object requestor) {
	197	requestors.remove(requestor);
	198	}
	199
	200	// check a requestors listener
	201
	202	void verifyRequestor(Object requestor, BeanContextServiceRevokedListener bcsrl) throws TooManyListenersException {
	203	BeanContextServiceRevokedListener cbcsrl = (BeanContextServiceRevokedListener)requestors.get(requestor);
	204
	205	if (cbcsrl != null && !cbcsrl.equals(bcsrl))
	206	throw new TooManyListenersException();
	207	}
	208
	209	void verifyAndMaybeSetProvider(BeanContextServiceProvider bcsp, boolean isDelegated) {
	210	BeanContextServiceProvider current;
	211
	212	if (isDelegated) { // the provider is delegated
	213	current = delegateProvider;
	214
	215	if (current == null \|\| bcsp == null) {
	216	delegateProvider = bcsp;
	217	return;
	218	}
	219	} else { // the provider is registered with this BCS
	220	current = serviceProvider;
	221
	222	if (current == null \|\| bcsp == null) {
	223	serviceProvider = bcsp;
	224	return;
	225	}
	226	}
	227
	228	if (!current.equals(bcsp))
	229	throw new UnsupportedOperationException("existing service reference obtained from different BeanContextServiceProvider not supported");
	230
	231	}
	232
	233	Iterator cloneOfEntries() {
	234	return ((HashMap)requestors.clone()).entrySet().iterator();
	235	}
	236
	237	Iterator entries() { return requestors.entrySet().iterator(); }
	238
	239	boolean isEmpty() { return requestors.isEmpty(); }
	240
	241	Class getServiceClass() { return serviceClass; }
	242
	243	BeanContextServiceProvider getServiceProvider() {
	244	return serviceProvider;
	245	}
	246
	247	BeanContextServiceProvider getDelegateProvider() {
	248	return delegateProvider;
	249	}
	250
	251	boolean isDelegated() { return delegateProvider != null; }
	252
	253	void addRef(boolean delegated) {
	254	if (delegated) {
	255	delegateRefs++;
	256	} else {
	257	serviceRefs++;
	258	}
	259	}
	260
	261
	262	void releaseRef(boolean delegated) {
	263	if (delegated) {
	264	if (--delegateRefs == 0) {
	265	delegateProvider = null;
	266	}
	267	} else {
	268	if (--serviceRefs <= 0) {
	269	serviceProvider = null;
	270	}
	271	}
	272	}
	273
	274	int getRefs() { return serviceRefs + delegateRefs; }
	275
	276	int getDelegateRefs() { return delegateRefs; }
	277
	278	int getServiceRefs() { return serviceRefs; }
	279
	280	/*
	281	* fields
	282	*/
	283
	284	Class serviceClass;
	285
	286	BeanContextServiceProvider serviceProvider;
	287	int serviceRefs;
	288
	289	BeanContextServiceProvider delegateProvider; // proxy
	290	int delegateRefs;
	291
	292	HashMap requestors = new HashMap(1);
	293	}
	294
	295	/*
	296	* per service reference info ...
	297	*/
	298
	299	class BCSSCServiceRef {
	300	BCSSCServiceRef(BCSSCServiceClassRef scref, boolean isDelegated) {
	301	serviceClassRef = scref;
	302	delegated = isDelegated;
	303	}
	304
	305	void addRef() { refCnt++; }
	306	int release() { return --refCnt; }
	307
	308	BCSSCServiceClassRef getServiceClassRef() { return serviceClassRef; }
	309
	310	boolean isDelegated() { return delegated; }
	311
	312	/*
	313	* fields
	314	*/
	315
	316	BCSSCServiceClassRef serviceClassRef;
	317	int refCnt = 1;
	318	boolean delegated = false;
	319	}
	320
	321	BCSSChild(Object bcc, Object peer) { super(bcc, peer); }
	322
	323	// note usage of service per requestor, per service
	324
	325	synchronized void usingService(Object requestor, Object service, Class serviceClass, BeanContextServiceProvider bcsp, boolean isDelegated, BeanContextServiceRevokedListener bcsrl) throws TooManyListenersException, UnsupportedOperationException {
	326
	327	// first, process mapping from serviceClass to requestor(s)
	328
	329	BCSSCServiceClassRef serviceClassRef = null;
	330
	331	if (serviceClasses == null)
	332	serviceClasses = new HashMap(1);
	333	else
	334	serviceClassRef = (BCSSCServiceClassRef)serviceClasses.get(serviceClass);
	335
	336	if (serviceClassRef == null) { // new service being used ...
	337	serviceClassRef = new BCSSCServiceClassRef(serviceClass, bcsp, isDelegated);
	338	serviceClasses.put(serviceClass, serviceClassRef);
	339
	340	} else { // existing service ...
	341	serviceClassRef.verifyAndMaybeSetProvider(bcsp, isDelegated); // throws
	342	serviceClassRef.verifyRequestor(requestor, bcsrl); // throws
	343	}
	344
	345	serviceClassRef.addRequestor(requestor, bcsrl);
	346	serviceClassRef.addRef(isDelegated);
	347
	348	// now handle mapping from requestor to service(s)
	349
	350	BCSSCServiceRef serviceRef = null;
	351	Map services = null;
	352
	353	if (serviceRequestors == null) {
	354	serviceRequestors = new HashMap(1);
	355	} else {
	356	services = (Map)serviceRequestors.get(requestor);
	357	}
	358
	359	if (services == null) {
	360	services = new HashMap(1);
	361
	362	serviceRequestors.put(requestor, services);
	363	} else
	364	serviceRef = (BCSSCServiceRef)services.get(service);
	365
	366	if (serviceRef == null) {
	367	serviceRef = new BCSSCServiceRef(serviceClassRef, isDelegated);
	368
	369	services.put(service, serviceRef);
	370	} else {
	371	serviceRef.addRef();
	372	}
	373	}
	374
	375	// release a service reference
	376
	377	synchronized void releaseService(Object requestor, Object service) {
	378	if (serviceRequestors == null) return;
	379
	380	Map services = (Map)serviceRequestors.get(requestor);
	381
	382	if (services == null) return; // oops its not there anymore!
	383
	384	BCSSCServiceRef serviceRef = (BCSSCServiceRef)services.get(service);
	385
	386	if (serviceRef == null) return; // oops its not there anymore!
	387
	388	BCSSCServiceClassRef serviceClassRef = serviceRef.getServiceClassRef();
	389	boolean isDelegated = serviceRef.isDelegated();
	390	BeanContextServiceProvider bcsp = isDelegated ? serviceClassRef.getDelegateProvider() : serviceClassRef.getServiceProvider();
	391
	392	bcsp.releaseService(BeanContextServicesSupport.this.getBeanContextServicesPeer(), requestor, service);
	393
	394	serviceClassRef.releaseRef(isDelegated);
	395	serviceClassRef.removeRequestor(requestor);
	396
	397	if (serviceRef.release() == 0) {
	398
	399	services.remove(service);
	400
	401	if (services.isEmpty()) {
	402	serviceRequestors.remove(requestor);
	403	serviceClassRef.removeRequestor(requestor);
	404	}
	405
	406	if (serviceRequestors.isEmpty()) {
	407	serviceRequestors = null;
	408	}
	409
	410	if (serviceClassRef.isEmpty()) {
	411	serviceClasses.remove(serviceClassRef.getServiceClass());
	412	}
	413
	414	if (serviceClasses.isEmpty())
	415	serviceClasses = null;
	416	}
	417	}
	418
	419	// revoke a service
	420
	421	synchronized void revokeService(Class serviceClass, boolean isDelegated, boolean revokeNow) {
	422	if (serviceClasses == null) return;
	423
	424	BCSSCServiceClassRef serviceClassRef = (BCSSCServiceClassRef)serviceClasses.get(serviceClass);
	425
	426	if (serviceClassRef == null) return;
	427
	428	Iterator i = serviceClassRef.cloneOfEntries();
	429
	430	BeanContextServiceRevokedEvent bcsre = new BeanContextServiceRevokedEvent(BeanContextServicesSupport.this.getBeanContextServicesPeer(), serviceClass, revokeNow);
	431	boolean noMoreRefs = false;
	432
	433	while (i.hasNext() && serviceRequestors != null) {
	434	Map.Entry entry = (Map.Entry)i.next();
	435	BeanContextServiceRevokedListener listener = (BeanContextServiceRevokedListener)entry.getValue();
	436
	437	if (revokeNow) {
	438	Object requestor = entry.getKey();
	439	Map services = (Map)serviceRequestors.get(requestor);
	440
	441	if (services != null) {
	442	Iterator i1 = services.entrySet().iterator();
	443
	444	while (i1.hasNext()) {
	445	Map.Entry tmp = (Map.Entry)i1.next();
	446
	447	BCSSCServiceRef serviceRef = (BCSSCServiceRef)tmp.getValue();
	448	if (serviceRef.getServiceClassRef().equals(serviceClassRef) && isDelegated == serviceRef.isDelegated()) {
	449	i1.remove();
	450	}
	451	}
	452
	453	if (noMoreRefs = services.isEmpty()) {
	454	serviceRequestors.remove(requestor);
	455	}
	456	}
	457
	458	if (noMoreRefs) serviceClassRef.removeRequestor(requestor);
	459	}
	460
	461	listener.serviceRevoked(bcsre);
	462	}
	463
	464	if (revokeNow && serviceClasses != null) {
	465	if (serviceClassRef.isEmpty())
	466	serviceClasses.remove(serviceClass);
	467
	468	if (serviceClasses.isEmpty())
	469	serviceClasses = null;
	470	}
	471
	472	if (serviceRequestors != null && serviceRequestors.isEmpty())
	473	serviceRequestors = null;
	474	}
	475
	476	// release all references for this child since it has been unnested.
	477
	478	void cleanupReferences() {
	479
	480	if (serviceRequestors == null) return;
	481
	482	Iterator requestors = serviceRequestors.entrySet().iterator();
	483
	484	while(requestors.hasNext()) {
	485	Map.Entry tmp = (Map.Entry)requestors.next();
	486	Object requestor = tmp.getKey();
	487	Iterator services = ((Map)tmp.getValue()).entrySet().iterator();
	488
	489	requestors.remove();
	490
	491	while (services.hasNext()) {
	492	Map.Entry entry = (Map.Entry)services.next();
	493	Object service = entry.getKey();
	494	BCSSCServiceRef sref = (BCSSCServiceRef)entry.getValue();
	495
	496	BCSSCServiceClassRef scref = sref.getServiceClassRef();
	497
	498	BeanContextServiceProvider bcsp = sref.isDelegated() ? scref.getDelegateProvider() : scref.getServiceProvider();
	499
	500	scref.removeRequestor(requestor);
	501	services.remove();
	502
	503	while (sref.release() >= 0) {
	504	bcsp.releaseService(BeanContextServicesSupport.this.getBeanContextServicesPeer(), requestor, service);
	505	}
	506	}
	507	}
	508
	509	serviceRequestors = null;
	510	serviceClasses = null;
	511	}
	512
	513	void revokeAllDelegatedServicesNow() {
	514	if (serviceClasses == null) return;
	515
	516	Iterator serviceClassRefs =
	517	new HashSet(serviceClasses.values()).iterator();
	518
	519	while (serviceClassRefs.hasNext()) {
	520	BCSSCServiceClassRef serviceClassRef = (BCSSCServiceClassRef)serviceClassRefs.next();
	521
	522	if (!serviceClassRef.isDelegated()) continue;
	523
	524	Iterator i = serviceClassRef.cloneOfEntries();
	525	BeanContextServiceRevokedEvent bcsre = new BeanContextServiceRevokedEvent(BeanContextServicesSupport.this.getBeanContextServicesPeer(), serviceClassRef.getServiceClass(), true);
	526	boolean noMoreRefs = false;
	527
	528	while (i.hasNext()) {
	529	Map.Entry entry = (Map.Entry)i.next();
	530	BeanContextServiceRevokedListener listener = (BeanContextServiceRevokedListener)entry.getValue();
	531
	532	Object requestor = entry.getKey();
	533	Map services = (Map)serviceRequestors.get(requestor);
	534
	535	if (services != null) {
	536	Iterator i1 = services.entrySet().iterator();
	537
	538	while (i1.hasNext()) {
	539	Map.Entry tmp = (Map.Entry)i1.next();
	540
	541	BCSSCServiceRef serviceRef = (BCSSCServiceRef)tmp.getValue();
	542	if (serviceRef.getServiceClassRef().equals(serviceClassRef) && serviceRef.isDelegated()) {
	543	i1.remove();
	544	}
	545	}
	546
	547	if (noMoreRefs = services.isEmpty()) {
	548	serviceRequestors.remove(requestor);
	549	}
	550	}
	551
	552	if (noMoreRefs) serviceClassRef.removeRequestor(requestor);
	553
	554	listener.serviceRevoked(bcsre);
	555
	556	if (serviceClassRef.isEmpty())
	557	serviceClasses.remove(serviceClassRef.getServiceClass());
	558	}
	559	}
	560
	561	if (serviceClasses.isEmpty()) serviceClasses = null;
	562
	563	if (serviceRequestors != null && serviceRequestors.isEmpty())
	564	serviceRequestors = null;
	565	}
	566
	567	/*
	568	* fields
	569	*/
	570
	571	private transient HashMap serviceClasses;
	572	private transient HashMap serviceRequestors;
	573	}
	574
	575	/**
	576	* <p>
	577	* Subclasses can override this method to insert their own subclass
	578	* of Child without having to override add() or the other Collection
	579	* methods that add children to the set.
	580	* </p>
	581	*
	582	* @param targetChild the child to create the Child on behalf of
	583	* @param peer the peer if the targetChild and peer are related by BeanContextProxy
	584	*/
	585
	586	protected BCSChild createBCSChild(Object targetChild, Object peer) {
	587	return new BCSSChild(targetChild, peer);
	588	}
	589
	590	/************************************************************************/
	591
	592	/**
	593	* subclasses may subclass this nested class to add behaviors for
	594	* each BeanContextServicesProvider.
	595	*/
	596
	597	protected static class BCSSServiceProvider implements Serializable {
	598	private static final long serialVersionUID = 861278251667444782L;
	599
	600	BCSSServiceProvider(Class sc, BeanContextServiceProvider bcsp) {
	601	super();
	602
	603	serviceProvider = bcsp;
	604	}
	605
	606	protected BeanContextServiceProvider getServiceProvider() {
	607	return serviceProvider;
	608	}
	609
	610	/*
	611	* fields
	612	*/
	613
	614	protected BeanContextServiceProvider serviceProvider;
	615	}
	616
	617	/**
	618	* subclasses can override this method to create new subclasses of
	619	* BCSSServiceProvider without having to overrride addService() in
	620	* order to instantiate.
	621	*/
	622
	623	protected BCSSServiceProvider createBCSSServiceProvider(Class sc, BeanContextServiceProvider bcsp) {
	624	return new BCSSServiceProvider(sc, bcsp);
	625	}
	626
	627	/************************************************************************/
	628
	629	/**
	630	* add a BeanContextServicesListener
	631	*
	632	* @throws NullPointerException
	633	*/
	634
	635	public void addBeanContextServicesListener(BeanContextServicesListener bcsl) {
	636	if (bcsl == null) throw new NullPointerException("bcsl");
	637
	638	synchronized(bcsListeners) {
	639	if (bcsListeners.contains(bcsl))
	640	return;
	641	else
	642	bcsListeners.add(bcsl);
	643	}
	644	}
	645
	646	/**
	647	* remove a BeanContextServicesListener
	648	*/
	649
	650	public void removeBeanContextServicesListener(BeanContextServicesListener bcsl) {
	651	if (bcsl == null) throw new NullPointerException("bcsl");
	652
	653	synchronized(bcsListeners) {
	654	if (!bcsListeners.contains(bcsl))
	655	return;
	656	else
	657	bcsListeners.remove(bcsl);
	658	}
	659	}
	660
	661	/**
	662	* add a service
	663	*/
	664
	665	public boolean addService(Class serviceClass, BeanContextServiceProvider bcsp) {
	666	return addService(serviceClass, bcsp, true);
	667	}
	668
	669	/**
	670	* add a service
	671	*/
	672
	673	protected boolean addService(Class serviceClass, BeanContextServiceProvider bcsp, boolean fireEvent) {
	674
	675	if (serviceClass == null) throw new NullPointerException("serviceClass");
	676	if (bcsp == null) throw new NullPointerException("bcsp");
	677
	678	synchronized(BeanContext.globalHierarchyLock) {
	679	if (services.containsKey(serviceClass))
	680	return false;
	681	else {
	682	services.put(serviceClass, createBCSSServiceProvider(serviceClass, bcsp));
	683
	684	if (bcsp instanceof Serializable) serializable++;
	685
	686	if (!fireEvent) return true;
	687
	688
	689	BeanContextServiceAvailableEvent bcssae = new BeanContextServiceAvailableEvent(getBeanContextServicesPeer(), serviceClass);
	690
	691	fireServiceAdded(bcssae);
	692
	693	synchronized(children) {
	694	Iterator i = children.keySet().iterator();
	695
	696	while (i.hasNext()) {
	697	Object c = i.next();
	698
	699	if (c instanceof BeanContextServices) {
	700	((BeanContextServicesListener)c).serviceAvailable(bcssae);
	701	}
	702	}
	703	}
	704
	705	return true;
	706	}
	707	}
	708	}
	709
	710	/**
	711	* remove a service
	712	*/
	713
	714	public void revokeService(Class serviceClass, BeanContextServiceProvider bcsp, boolean revokeCurrentServicesNow) {
	715
	716	if (serviceClass == null) throw new NullPointerException("serviceClass");
	717	if (bcsp == null) throw new NullPointerException("bcsp");
	718
	719	synchronized(BeanContext.globalHierarchyLock) {
	720	if (!services.containsKey(serviceClass)) return;
	721
	722	BCSSServiceProvider bcsssp = (BCSSServiceProvider)services.get(serviceClass);
	723
	724	if (!bcsssp.getServiceProvider().equals(bcsp))
	725	throw new IllegalArgumentException("service provider mismatch");
	726
	727	services.remove(serviceClass);
	728
	729	if (bcsp instanceof Serializable) serializable--;
	730
	731	Iterator i = bcsChildren(); // get the BCSChild values.
	732
	733	while (i.hasNext()) {
	734	((BCSSChild)i.next()).revokeService(serviceClass, false, revokeCurrentServicesNow);
	735	}
	736
	737	fireServiceRevoked(serviceClass, revokeCurrentServicesNow);
	738	}
	739	}
	740
	741	/**
	742	* has a service, which may be delegated
	743	*/
	744
	745	public synchronized boolean hasService(Class serviceClass) {
	746	if (serviceClass == null) throw new NullPointerException("serviceClass");
	747
	748	synchronized(BeanContext.globalHierarchyLock) {
	749	if (services.containsKey(serviceClass)) return true;
	750
	751	BeanContextServices bcs = null;
	752
	753	try {
	754	bcs = (BeanContextServices)getBeanContext();
	755	} catch (ClassCastException cce) {
	756	return false;
	757	}
	758
	759	return bcs == null ? false : bcs.hasService(serviceClass);
	760	}
	761	}
	762
	763	/************************************************************************/
	764
	765	/*
	766	* a nested subclass used to represent a proxy for serviceClasses delegated
	767	* to an enclosing BeanContext.
	768	*/
	769
	770	protected class BCSSProxyServiceProvider implements BeanContextServiceProvider, BeanContextServiceRevokedListener {
	771
	772	BCSSProxyServiceProvider(BeanContextServices bcs) {
	773	super();
	774
	775	nestingCtxt = bcs;
	776	}
	777
	778	public Object getService(BeanContextServices bcs, Object requestor, Class serviceClass, Object serviceSelector) {
	779	Object service = null;
	780
	781	try {
	782	service = nestingCtxt.getService(bcs, requestor, serviceClass, serviceSelector, this);
	783	} catch (TooManyListenersException tmle) {
	784	return null;
	785	}
	786
	787	return service;
	788	}
	789
	790	public void releaseService(BeanContextServices bcs, Object requestor, Object service) {
	791	nestingCtxt.releaseService(bcs, requestor, service);
	792	}
	793
	794	public Iterator getCurrentServiceSelectors(BeanContextServices bcs, Class serviceClass) {
	795	return nestingCtxt.getCurrentServiceSelectors(serviceClass);
	796	}
	797
	798	public void serviceRevoked(BeanContextServiceRevokedEvent bcsre) {
	799	Iterator i = bcsChildren(); // get the BCSChild values.
	800
	801	while (i.hasNext()) {
	802	((BCSSChild)i.next()).revokeService(bcsre.getServiceClass(), true, bcsre.isCurrentServiceInvalidNow());
	803	}
	804	}
	805
	806	/*
	807	* fields
	808	*/
	809
	810	private BeanContextServices nestingCtxt;
	811	}
	812
	813	/************************************************************************/
	814
	815	/**
	816	* obtain a service which may be delegated
	817	*/
	818
	819	public Object getService(BeanContextChild child, Object requestor, Class serviceClass, Object serviceSelector, BeanContextServiceRevokedListener bcsrl) throws TooManyListenersException {
	820	if (child == null) throw new NullPointerException("child");
	821	if (serviceClass == null) throw new NullPointerException("serviceClass");
	822	if (requestor == null) throw new NullPointerException("requestor");
	823	if (bcsrl == null) throw new NullPointerException("bcsrl");
	824
	825	Object service = null;
	826	BCSSChild bcsc;
	827	BeanContextServices bcssp = getBeanContextServicesPeer();
	828
	829	synchronized(BeanContext.globalHierarchyLock) {
	830	synchronized(children) { bcsc = (BCSSChild)children.get(child); }
	831
	832	if (bcsc == null) throw new IllegalArgumentException("not a child of this context"); // not a child ...
	833
	834	BCSSServiceProvider bcsssp = (BCSSServiceProvider)services.get(serviceClass);
	835
	836	if (bcsssp != null) {
	837	BeanContextServiceProvider bcsp = bcsssp.getServiceProvider();
	838	service = bcsp.getService(bcssp, requestor, serviceClass, serviceSelector);
	839	if (service != null) { // do bookkeeping ...
	840	try {
	841	bcsc.usingService(requestor, service, serviceClass, bcsp, false, bcsrl);
	842	} catch (TooManyListenersException tmle) {
	843	bcsp.releaseService(bcssp, requestor, service);
	844	throw tmle;
	845	} catch (UnsupportedOperationException uope) {
	846	bcsp.releaseService(bcssp, requestor, service);
	847	throw uope; // unchecked rt exception
	848	}
	849
	850	return service;
	851	}
	852	}
	853
	854
	855	if (proxy != null) {
	856
	857	// try to delegate ...
	858
	859	service = proxy.getService(bcssp, requestor, serviceClass, serviceSelector);
	860
	861	if (service != null) { // do bookkeeping ...
	862	try {
	863	bcsc.usingService(requestor, service, serviceClass, proxy, true, bcsrl);
	864	} catch (TooManyListenersException tmle) {
	865	proxy.releaseService(bcssp, requestor, service);
	866	throw tmle;
	867	} catch (UnsupportedOperationException uope) {
	868	proxy.releaseService(bcssp, requestor, service);
	869	throw uope; // unchecked rt exception
	870	}
	871
	872	return service;
	873	}
	874	}
	875	}
	876
	877	return null;
	878	}
	879
	880	/**
	881	* release a service
	882	*/
	883
	884	public void releaseService(BeanContextChild child, Object requestor, Object service) {
	885	if (child == null) throw new NullPointerException("child");
	886	if (requestor == null) throw new NullPointerException("requestor");
	887	if (service == null) throw new NullPointerException("service");
	888
	889	BCSSChild bcsc;
	890
	891	synchronized(BeanContext.globalHierarchyLock) {
	892	synchronized(children) { bcsc = (BCSSChild)children.get(child); }
	893
	894	if (bcsc != null)
	895	bcsc.releaseService(requestor, service);
	896	else
	897	throw new IllegalArgumentException("child actual is not a child of this BeanContext");
	898	}
	899	}
	900
	901	/**
	902	* @return an iterator for all the currently registered service classes.
	903	*/
	904
	905	public Iterator getCurrentServiceClasses() {
	906	return new BCSIterator(services.keySet().iterator());
	907	}
	908
	909	/**
	910	* @return an iterator for all the currently available service selectors
	911	* (if any) available for the specified service.
	912	*/
	913
	914	public Iterator getCurrentServiceSelectors(Class serviceClass) {
	915
	916	BCSSServiceProvider bcsssp = (BCSSServiceProvider)services.get(serviceClass);
	917
	918	return bcsssp != null ? new BCSIterator(bcsssp.getServiceProvider().getCurrentServiceSelectors(getBeanContextServicesPeer(), serviceClass)) : null;
	919	}
	920
	921	/**
	922	* BeanContextServicesListener callback, propagates event to all
	923	* currently registered listeners and BeanContextServices children,
	924	* if this BeanContextService does not already implement this service
	925	* itself.
	926	*
	927	* subclasses may override or envelope this method to implement their
	928	* own propagation semantics.
	929	*/
	930
	931	public void serviceAvailable(BeanContextServiceAvailableEvent bcssae) {
	932	synchronized(BeanContext.globalHierarchyLock) {
	933	if (services.containsKey(bcssae.getServiceClass())) return;
	934
	935	fireServiceAdded(bcssae);
	936
	937	Iterator i;
	938
	939	synchronized(children) {
	940	i = children.keySet().iterator();
	941	}
	942
	943	while (i.hasNext()) {
	944	Object c = i.next();
	945
	946	if (c instanceof BeanContextServices) {
	947	((BeanContextServicesListener)c).serviceAvailable(bcssae);
	948	}
	949	}
	950	}
	951	}
	952
	953	/**
	954	* BeanContextServicesListener callback, propagates event to all
	955	* currently registered listeners and BeanContextServices children,
	956	* if this BeanContextService does not already implement this service
	957	* itself.
	958	*
	959	* subclasses may override or envelope this method to implement their
	960	* own propagation semantics.
	961	*/
	962
	963	public void serviceRevoked(BeanContextServiceRevokedEvent bcssre) {
	964	synchronized(BeanContext.globalHierarchyLock) {
	965	if (services.containsKey(bcssre.getServiceClass())) return;
	966
	967	fireServiceRevoked(bcssre);
	968
	969	Iterator i;
	970
	971	synchronized(children) {
	972	i = children.keySet().iterator();
	973	}
	974
	975	while (i.hasNext()) {
	976	Object c = i.next();
	977
	978	if (c instanceof BeanContextServices) {
	979	((BeanContextServicesListener)c).serviceRevoked(bcssre);
	980	}
	981	}
	982	}
	983	}
	984
	985	/**
	986	* Gets the <tt>BeanContextServicesListener</tt> (if any) of the specified
	987	* child.
	988	*
	989	* @param child the specified child
	990	* @return the BeanContextServicesListener (if any) of the specified child
	991	*/
	992	protected static final BeanContextServicesListener getChildBeanContextServicesListener(Object child) {
	993	try {
	994	return (BeanContextServicesListener)child;
	995	} catch (ClassCastException cce) {
	996	return null;
	997	}
	998	}
	999
	1000	/**
	1001	* called from superclass child removal operations after a child
	1002	* has been successfully removed. called with child synchronized.
	1003	*
	1004	* This subclass uses this hook to immediately revoke any services
	1005	* being used by this child if it is a BeanContextChild.
	1006	*
	1007	* subclasses may envelope this method in order to implement their
	1008	* own child removal side-effects.
	1009	*/
	1010
	1011	protected void childJustRemovedHook(Object child, BCSChild bcsc) {
	1012	BCSSChild bcssc = (BCSSChild)bcsc;
	1013
	1014	bcssc.cleanupReferences();
	1015	}
	1016
	1017	/**
	1018	* called from setBeanContext to notify a BeanContextChild
	1019	* to release resources obtained from the nesting BeanContext.
	1020	*
	1021	* This method revokes any services obtained from its parent.
	1022	*
	1023	* subclasses may envelope this method to implement their own semantics.
	1024	*/
	1025
	1026	protected synchronized void releaseBeanContextResources() {
	1027	Object[] bcssc;
	1028
	1029	super.releaseBeanContextResources();
	1030
	1031	synchronized(children) {
	1032	if (children.isEmpty()) return;
	1033
	1034	bcssc = children.values().toArray();
	1035	}
	1036
	1037
	1038	for (int i = 0; i < bcssc.length; i++) {
	1039	((BCSSChild)bcssc[i]).revokeAllDelegatedServicesNow();
	1040	}
	1041
	1042	proxy = null;
	1043	}
	1044
	1045	/**
	1046	* called from setBeanContext to notify a BeanContextChild
	1047	* to allocate resources obtained from the nesting BeanContext.
	1048	*
	1049	* subclasses may envelope this method to implement their own semantics.
	1050	*/
	1051
	1052	protected synchronized void initializeBeanContextResources() {
	1053	super.initializeBeanContextResources();
	1054
	1055	BeanContext nbc = getBeanContext();
	1056
	1057	if (nbc == null) return;
	1058
	1059	try {
	1060	BeanContextServices bcs = (BeanContextServices)nbc;
	1061
	1062	proxy = new BCSSProxyServiceProvider(bcs);
	1063	} catch (ClassCastException cce) {
	1064	// do nothing ...
	1065	}
	1066	}
	1067
	1068	/**
	1069	* Fires a <tt>BeanContextServiceEvent</tt> notifying of a new service.
	1070	*/
	1071	protected final void fireServiceAdded(Class serviceClass) {
	1072	BeanContextServiceAvailableEvent bcssae = new BeanContextServiceAvailableEvent(getBeanContextServicesPeer(), serviceClass);
	1073
	1074	fireServiceAdded(bcssae);
	1075	}
	1076
	1077	/**
	1078	* Fires a <tt>BeanContextServiceAvailableEvent</tt> indicating that a new
	1079	* service has become available.
	1080	*
	1081	* @param bcssae the <tt>BeanContextServiceAvailableEvent</tt>
	1082	*/
	1083	protected final void fireServiceAdded(BeanContextServiceAvailableEvent bcssae) {
	1084	Object[] copy;
	1085
	1086	synchronized (bcsListeners) { copy = bcsListeners.toArray(); }
	1087
	1088	for (int i = 0; i < copy.length; i++) {
	1089	((BeanContextServicesListener)copy[i]).serviceAvailable(bcssae);
	1090	}
	1091	}
	1092
	1093	/**
	1094	* Fires a <tt>BeanContextServiceEvent</tt> notifying of a service being revoked.
	1095	*
	1096	* @param bcsre the <tt>BeanContextServiceRevokedEvent</tt>
	1097	*/
	1098	protected final void fireServiceRevoked(BeanContextServiceRevokedEvent bcsre) {
	1099	Object[] copy;
	1100
	1101	synchronized (bcsListeners) { copy = bcsListeners.toArray(); }
	1102
	1103	for (int i = 0; i < copy.length; i++) {
	1104	((BeanContextServiceRevokedListener)copy[i]).serviceRevoked(bcsre);
	1105	}
	1106	}
	1107
	1108	/**
	1109	* Fires a <tt>BeanContextServiceRevokedEvent</tt>
	1110	* indicating that a particular service is
	1111	* no longer available.
	1112	*/
	1113	protected final void fireServiceRevoked(Class serviceClass, boolean revokeNow) {
	1114	Object[] copy;
	1115	BeanContextServiceRevokedEvent bcsre = new BeanContextServiceRevokedEvent(getBeanContextServicesPeer(), serviceClass, revokeNow);
	1116
	1117	synchronized (bcsListeners) { copy = bcsListeners.toArray(); }
	1118
	1119	for (int i = 0; i < copy.length; i++) {
	1120	((BeanContextServicesListener)copy[i]).serviceRevoked(bcsre);
	1121	}
	1122	}
	1123
	1124	/**
	1125	* called from BeanContextSupport writeObject before it serializes the
	1126	* children ...
	1127	*
	1128	* This class will serialize any Serializable BeanContextServiceProviders
	1129	* herein.
	1130	*
	1131	* subclasses may envelope this method to insert their own serialization
	1132	* processing that has to occur prior to serialization of the children
	1133	*/
	1134
	1135	protected synchronized void bcsPreSerializationHook(ObjectOutputStream oos) throws IOException {
	1136
	1137	oos.writeInt(serializable);
	1138
	1139	if (serializable <= 0) return;
	1140
	1141	int count = 0;
	1142
	1143	Iterator i = services.entrySet().iterator();
	1144
	1145	while (i.hasNext() && count < serializable) {
	1146	Map.Entry entry = (Map.Entry)i.next();
	1147	BCSSServiceProvider bcsp = null;
	1148
	1149	try {
	1150	bcsp = (BCSSServiceProvider)entry.getValue();
	1151	} catch (ClassCastException cce) {
	1152	continue;
	1153	}
	1154
	1155	if (bcsp.getServiceProvider() instanceof Serializable) {
	1156	oos.writeObject(entry.getKey());
	1157	oos.writeObject(bcsp);
	1158	count++;
	1159	}
	1160	}
	1161
	1162	if (count != serializable)
	1163	throw new IOException("wrote different number of service providers than expected");
	1164	}
	1165
	1166	/**
	1167	* called from BeanContextSupport readObject before it deserializes the
	1168	* children ...
	1169	*
	1170	* This class will deserialize any Serializable BeanContextServiceProviders
	1171	* serialized earlier thus making them available to the children when they
	1172	* deserialized.
	1173	*
	1174	* subclasses may envelope this method to insert their own serialization
	1175	* processing that has to occur prior to serialization of the children
	1176	*/
	1177
	1178	protected synchronized void bcsPreDeserializationHook(ObjectInputStream ois) throws IOException, ClassNotFoundException {
	1179
	1180	serializable = ois.readInt();
	1181
	1182	int count = serializable;
	1183
	1184	while (count > 0) {
	1185	services.put(ois.readObject(), ois.readObject());
	1186	count--;
	1187	}
	1188	}
	1189
	1190	/**
	1191	* serialize the instance
	1192	*/
	1193
	1194	private synchronized void writeObject(ObjectOutputStream oos) throws IOException {
	1195	oos.defaultWriteObject();
	1196
	1197	serialize(oos, (Collection)bcsListeners);
	1198	}
	1199
	1200	/**
	1201	* deserialize the instance
	1202	*/
	1203
	1204	private synchronized void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
	1205
	1206	ois.defaultReadObject();
	1207
	1208	deserialize(ois, (Collection)bcsListeners);
	1209	}
	1210
	1211
	1212	/*
	1213	* fields
	1214	*/
	1215
	1216	/**
	1217	* all accesses to the <code> protected transient HashMap services </code>
	1218	* field should be synchronized on that object
	1219	*/
	1220	protected transient HashMap services;
	1221
	1222	/**
	1223	* The number of instances of a serializable <tt>BeanContextServceProvider</tt>.
	1224	*/
	1225	protected transient int serializable = 0;
	1226
	1227
	1228	/**
	1229	* Delegate for the <tt>BeanContextServiceProvider</tt>.
	1230	*/
	1231	protected transient BCSSProxyServiceProvider proxy;
	1232
	1233
	1234	/**
	1235	* List of <tt>BeanContextServicesListener</tt> objects.
	1236	*/
	1237	protected transient ArrayList bcsListeners;
	1238	}

java/pkg/java/beans/beancontext/BeanContextSupport$1.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextSupport$2.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextSupport$BCSChild.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextSupport$BCSIterator.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextSupport.class+0−0

Binary file not shown.

java/pkg/java/beans/beancontext/BeanContextSupport.java+1393−0

@@ -0,0 +1,1393 @@
	1	/*
	2	* Copyright (c) 1997, 2004, Oracle and/or its affiliates. All rights reserved.
	3	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4	*
	5	* This code is free software; you can redistribute it and/or modify it
	6	* under the terms of the GNU General Public License version 2 only, as
	7	* published by the Free Software Foundation. Oracle designates this
	8	* particular file as subject to the "Classpath" exception as provided
	9	* by Oracle in the LICENSE file that accompanied this code.
	10	*
	11	* This code is distributed in the hope that it will be useful, but WITHOUT
	12	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	* version 2 for more details (a copy is included in the LICENSE file that
	15	* accompanied this code).
	16	*
	17	* You should have received a copy of the GNU General Public License version
	18	* 2 along with this work; if not, write to the Free Software Foundation,
	19	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20	*
	21	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	* or visit www.oracle.com if you need additional information or have any
	23	* questions.
	24	*/
	25
	26	package java.beans.beancontext;
	27
	28	import java.awt.Component;
	29	import java.awt.Container;
	30
	31	import java.beans.Beans;
	32	import java.beans.AppletInitializer;
	33
	34	import java.beans.DesignMode;
	35
	36	import java.beans.PropertyChangeEvent;
	37	import java.beans.PropertyChangeListener;
	38	import java.beans.PropertyChangeSupport;
	39
	40	import java.beans.VetoableChangeListener;
	41	import java.beans.VetoableChangeSupport;
	42	import java.beans.PropertyVetoException;
	43
	44	import java.beans.Visibility;
	45
	46	import java.io.IOException;
	47	import java.io.InputStream;
	48	import java.io.ObjectInputStream;
	49	import java.io.ObjectOutputStream;
	50	import java.io.Serializable;
	51
	52	import java.net.URL;
	53
	54	import java.util.ArrayList;
	55	import java.util.Collection;
	56	import java.util.HashMap;
	57	import java.util.Iterator;
	58	import java.util.Locale;
	59	import java.util.Map;
	60
	61
	62	/**
	63	* This helper class provides a utility implementation of the
	64	* java.beans.beancontext.BeanContext interface.
	65	* </p>
	66	* <p>
	67	* Since this class directly implements the BeanContext interface, the class
	68	* can, and is intended to be used either by subclassing this implementation,
	69	* or via ad-hoc delegation of an instance of this class from another.
	70	* </p>
	71	*
	72	* @author Laurence P. G. Cable
	73	* @since 1.2
	74	*/
	75	public class BeanContextSupport extends BeanContextChildSupport
	76	implements BeanContext,
	77	Serializable,
	78	PropertyChangeListener,
	79	VetoableChangeListener {
	80
	81	// Fix for bug 4282900 to pass JCK regression test
	82	static final long serialVersionUID = -4879613978649577204L;
	83
	84	/**
	85	*
	86	* Construct a BeanContextSupport instance
	87	*
	88	*
	89	* @param peer The peer <tt>BeanContext</tt> we are
	90	* supplying an implementation for,
	91	* or <tt>null</tt>
	92	* if this object is its own peer
	93	* @param lcle The current Locale for this BeanContext. If
	94	* <tt>lcle</tt> is <tt>null</tt>, the default locale
	95	* is assigned to the <tt>BeanContext</tt> instance.
	96	* @param dTime The initial state,
	97	* <tt>true</tt> if in design mode,
	98	* <tt>false</tt> if runtime.
	99	* @param visible The initial visibility.
	100	* @see java.util.Locale#getDefault()
	101	* @see java.util.Locale#setDefault(java.util.Locale)
	102	*/
	103	public BeanContextSupport(BeanContext peer, Locale lcle, boolean dTime, boolean visible) {
	104	super(peer);
	105
	106	locale = lcle != null ? lcle : Locale.getDefault();
	107	designTime = dTime;
	108	okToUseGui = visible;
	109
	110	initialize();
	111	}
	112
	113	/**
	114	* Create an instance using the specified Locale and design mode.
	115	*
	116	* @param peer The peer <tt>BeanContext</tt> we
	117	* are supplying an implementation for,
	118	* or <tt>null</tt> if this object is its own peer
	119	* @param lcle The current Locale for this <tt>BeanContext</tt>. If
	120	* <tt>lcle</tt> is <tt>null</tt>, the default locale
	121	* is assigned to the <tt>BeanContext</tt> instance.
	122	* @param dtime The initial state, <tt>true</tt>
	123	* if in design mode,
	124	* <tt>false</tt> if runtime.
	125	* @see java.util.Locale#getDefault()
	126	* @see java.util.Locale#setDefault(java.util.Locale)
	127	*/
	128	public BeanContextSupport(BeanContext peer, Locale lcle, boolean dtime) {
	129	this (peer, lcle, dtime, true);
	130	}
	131
	132	/**
	133	* Create an instance using the specified locale
	134	*
	135	* @param peer The peer BeanContext we are
	136	* supplying an implementation for,
	137	* or <tt>null</tt> if this object
	138	* is its own peer
	139	* @param lcle The current Locale for this
	140	* <tt>BeanContext</tt>. If
	141	* <tt>lcle</tt> is <tt>null</tt>,
	142	* the default locale
	143	* is assigned to the <tt>BeanContext</tt>
	144	* instance.
	145	* @see java.util.Locale#getDefault()
	146	* @see java.util.Locale#setDefault(java.util.Locale)
	147	*/
	148	public BeanContextSupport(BeanContext peer, Locale lcle) {
	149	this (peer, lcle, false, true);
	150	}
	151
	152	/**
	153	* Create an instance using with a default locale
	154	*
	155	* @param peer The peer <tt>BeanContext</tt> we are
	156	* supplying an implementation for,
	157	* or <tt>null</tt> if this object
	158	* is its own peer
	159	*/
	160	public BeanContextSupport(BeanContext peer) {
	161	this (peer, null, false, true);
	162	}
	163
	164	/**
	165	* Create an instance that is not a delegate of another object
	166	*/
	167
	168	public BeanContextSupport() {
	169	this (null, null, false, true);
	170	}
	171
	172	/**
	173	* Gets the instance of <tt>BeanContext</tt> that
	174	* this object is providing the implementation for.
	175	* @return the BeanContext instance
	176	*/
	177	public BeanContext getBeanContextPeer() { return (BeanContext)getBeanContextChildPeer(); }
	178
	179	/**
	180	* <p>
	181	* The instantiateChild method is a convenience hook
	182	* in BeanContext to simplify
	183	* the task of instantiating a Bean, nested,
	184	* into a <tt>BeanContext</tt>.
	185	* </p>
	186	* <p>
	187	* The semantics of the beanName parameter are defined by java.beans.Beans.instantate.
	188	* </p>
	189	*
	190	* @param beanName the name of the Bean to instantiate within this BeanContext
	191	* @throws IOException if there is an I/O error when the bean is being deserialized
	192	* @throws ClassNotFoundException if the class
	193	* identified by the beanName parameter is not found
	194	* @return the new object
	195	*/
	196	public Object instantiateChild(String beanName)
	197	throws IOException, ClassNotFoundException {
	198	BeanContext bc = getBeanContextPeer();
	199
	200	return Beans.instantiate(bc.getClass().getClassLoader(), beanName, bc);
	201	}
	202
	203	/**
	204	* Gets the number of children currently nested in
	205	* this BeanContext.
	206	*
	207	* @return number of children
	208	*/
	209	public int size() {
	210	synchronized(children) {
	211	return children.size();
	212	}
	213	}
	214
	215	/**
	216	* Reports whether or not this
	217	* <tt>BeanContext</tt> is empty.
	218	* A <tt>BeanContext</tt> is considered
	219	* empty when it contains zero
	220	* nested children.
	221	* @return if there are not children
	222	*/
	223	public boolean isEmpty() {
	224	synchronized(children) {
	225	return children.isEmpty();
	226	}
	227	}
	228
	229	/**
	230	* Determines whether or not the specified object
	231	* is currently a child of this <tt>BeanContext</tt>.
	232	* @param o the Object in question
	233	* @return if this object is a child
	234	*/
	235	public boolean contains(Object o) {
	236	synchronized(children) {
	237	return children.containsKey(o);
	238	}
	239	}
	240
	241	/**
	242	* Determines whether or not the specified object
	243	* is currently a child of this <tt>BeanContext</tt>.
	244	* @param o the Object in question
	245	* @return if this object is a child
	246	*/
	247	public boolean containsKey(Object o) {
	248	synchronized(children) {
	249	return children.containsKey(o);
	250	}
	251	}
	252
	253	/**
	254	* Gets all JavaBean or <tt>BeanContext</tt> instances
	255	* currently nested in this <tt>BeanContext</tt>.
	256	* @return an <tt>Iterator</tt> of the nested children
	257	*/
	258	public Iterator iterator() {
	259	synchronized(children) {
	260	return new BCSIterator(children.keySet().iterator());
	261	}
	262	}
	263
	264	/**
	265	* Gets all JavaBean or <tt>BeanContext</tt>
	266	* instances currently nested in this BeanContext.
	267	*/
	268	public Object[] toArray() {
	269	synchronized(children) {
	270	return children.keySet().toArray();
	271	}
	272	}
	273
	274	/**
	275	* Gets an array containing all children of
	276	* this <tt>BeanContext</tt> that match
	277	* the types contained in arry.
	278	* @param arry The array of object
	279	* types that are of interest.
	280	* @return an array of children
	281	*/
	282	public Object[] toArray(Object[] arry) {
	283	synchronized(children) {
	284	return children.keySet().toArray(arry);
	285	}
	286	}
	287
	288
	289	/************************************************************************/
	290
	291	/**
	292	* protected final subclass that encapsulates an iterator but implements
	293	* a noop remove() method.
	294	*/
	295
	296	protected static final class BCSIterator implements Iterator {
	297	BCSIterator(Iterator i) { super(); src = i; }
	298
	299	public boolean hasNext() { return src.hasNext(); }
	300	public Object next() { return src.next(); }
	301	public void remove() { /* do nothing */ }
	302
	303	private Iterator src;
	304	}
	305
	306	/************************************************************************/
	307
	308	/*
	309	* protected nested class containing per child information, an instance
	310	* of which is associated with each child in the "children" hashtable.
	311	* subclasses can extend this class to include their own per-child state.
	312	*
	313	* Note that this 'value' is serialized with the corresponding child 'key'
	314	* when the BeanContextSupport is serialized.
	315	*/
	316
	317	protected class BCSChild implements Serializable {
	318
	319	private static final long serialVersionUID = -5815286101609939109L;
	320
	321	BCSChild(Object bcc, Object peer) {
	322	super();
	323
	324	child = bcc;
	325	proxyPeer = peer;
	326	}
	327
	328	Object getChild() { return child; }
	329
	330	void setRemovePending(boolean v) { removePending = v; }
	331
	332	boolean isRemovePending() { return removePending; }
	333
	334	boolean isProxyPeer() { return proxyPeer != null; }
	335
	336	Object getProxyPeer() { return proxyPeer; }
	337	/*
	338	* fields
	339	*/
	340
	341
	342	private Object child;
	343	private Object proxyPeer;
	344
	345	private transient boolean removePending;
	346	}
	347
	348	/**
	349	* <p>
	350	* Subclasses can override this method to insert their own subclass
	351	* of Child without having to override add() or the other Collection
	352	* methods that add children to the set.
	353	* </p>
	354	*
	355	* @param targetChild the child to create the Child on behalf of
	356	* @param peer the peer if the tragetChild and the peer are related by an implementation of BeanContextProxy
	357	*/
	358
	359	protected BCSChild createBCSChild(Object targetChild, Object peer) {
	360	return new BCSChild(targetChild, peer);
	361	}
	362
	363	/************************************************************************/
	364
	365	/**
	366	* Adds/nests a child within this <tt>BeanContext</tt>.
	367	* <p>
	368	* Invoked as a side effect of java.beans.Beans.instantiate().
	369	* If the child object is not valid for adding then this method
	370	* throws an IllegalStateException.
	371	* </p>
	372	*
	373	*
	374	* @param targetChild The child objects to nest
	375	* within this <tt>BeanContext</tt>
	376	* @return true if the child was added successfully.
	377	* @see #validatePendingAdd
	378	*/
	379	public boolean add(Object targetChild) {
	380
	381	if (targetChild == null) throw new IllegalArgumentException();
	382
	383	// The specification requires that we do nothing if the child
	384	// is already nested herein.
	385
	386	if (children.containsKey(targetChild)) return false; // test before locking
	387
	388	synchronized(BeanContext.globalHierarchyLock) {
	389	if (children.containsKey(targetChild)) return false; // check again
	390
	391	if (!validatePendingAdd(targetChild)) {
	392	throw new IllegalStateException();
	393	}
	394
	395
	396	// The specification requires that we invoke setBeanContext() on the
	397	// newly added child if it implements the java.beans.beancontext.BeanContextChild interface
	398
	399	BeanContextChild cbcc = getChildBeanContextChild(targetChild);
	400	BeanContextChild bccp = null;
	401
	402	synchronized(targetChild) {
	403
	404	if (targetChild instanceof BeanContextProxy) {
	405	bccp = ((BeanContextProxy)targetChild).getBeanContextProxy();
	406
	407	if (bccp == null) throw new NullPointerException("BeanContextPeer.getBeanContextProxy()");
	408	}
	409
	410	BCSChild bcsc = createBCSChild(targetChild, bccp);
	411	BCSChild pbcsc = null;
	412
	413	synchronized (children) {
	414	children.put(targetChild, bcsc);
	415
	416	if (bccp != null) children.put(bccp, pbcsc = createBCSChild(bccp, targetChild));
	417	}
	418
	419	if (cbcc != null) synchronized(cbcc) {
	420	try {
	421	cbcc.setBeanContext(getBeanContextPeer());
	422	} catch (PropertyVetoException pve) {
	423
	424	synchronized (children) {
	425	children.remove(targetChild);
	426
	427	if (bccp != null) children.remove(bccp);
	428	}
	429
	430	throw new IllegalStateException();
	431	}
	432
	433	cbcc.addPropertyChangeListener("beanContext", childPCL);
	434	cbcc.addVetoableChangeListener("beanContext", childVCL);
	435	}
	436
	437	Visibility v = getChildVisibility(targetChild);
	438
	439	if (v != null) {
	440	if (okToUseGui)
	441	v.okToUseGui();
	442	else
	443	v.dontUseGui();
	444	}
	445
	446	if (getChildSerializable(targetChild) != null) serializable++;
	447
	448	childJustAddedHook(targetChild, bcsc);
	449
	450	if (bccp != null) {
	451	v = getChildVisibility(bccp);
	452
	453	if (v != null) {
	454	if (okToUseGui)
	455	v.okToUseGui();
	456	else
	457	v.dontUseGui();
	458	}
	459
	460	if (getChildSerializable(bccp) != null) serializable++;
	461
	462	childJustAddedHook(bccp, pbcsc);
	463	}
	464
	465
	466	}
	467
	468	// The specification requires that we fire a notification of the change
	469
	470	fireChildrenAdded(new BeanContextMembershipEvent(getBeanContextPeer(), bccp == null ? new Object[] { targetChild } : new Object[] { targetChild, bccp } ));
	471
	472	}
	473
	474	return true;
	475	}
	476
	477	/**
	478	* Removes a child from this BeanContext. If the child object is not
	479	* for adding then this method throws an IllegalStateException.
	480	* @param targetChild The child objects to remove
	481	* @see #validatePendingRemove
	482	*/
	483	public boolean remove(Object targetChild) {
	484	return remove(targetChild, true);
	485	}
	486
	487	/**
	488	* internal remove used when removal caused by
	489	* unexpected <tt>setBeanContext</tt> or
	490	* by <tt>remove()</tt> invocation.
	491	* @param targetChild the JavaBean, BeanContext, or Object to be removed
	492	* @param callChildSetBC used to indicate that
	493	* the child should be notified that it is no
	494	* longer nested in this <tt>BeanContext</tt>.
	495	*/
	496	protected boolean remove(Object targetChild, boolean callChildSetBC) {
	497
	498	if (targetChild == null) throw new IllegalArgumentException();
	499
	500	synchronized(BeanContext.globalHierarchyLock) {
	501	if (!containsKey(targetChild)) return false;
	502
	503	if (!validatePendingRemove(targetChild)) {
	504	throw new IllegalStateException();
	505	}
	506
	507	BCSChild bcsc = (BCSChild)children.get(targetChild);
	508	BCSChild pbcsc = null;
	509	Object peer = null;
	510
	511	// we are required to notify the child that it is no longer nested here if
	512	// it implements java.beans.beancontext.BeanContextChild
	513
	514	synchronized(targetChild) {
	515	if (callChildSetBC) {
	516	BeanContextChild cbcc = getChildBeanContextChild(targetChild);
	517	if (cbcc != null) synchronized(cbcc) {
	518	cbcc.removePropertyChangeListener("beanContext", childPCL);
	519	cbcc.removeVetoableChangeListener("beanContext", childVCL);
	520
	521	try {
	522	cbcc.setBeanContext(null);
	523	} catch (PropertyVetoException pve1) {
	524	cbcc.addPropertyChangeListener("beanContext", childPCL);
	525	cbcc.addVetoableChangeListener("beanContext", childVCL);
	526	throw new IllegalStateException();
	527	}
	528
	529	}
	530	}
	531
	532	synchronized (children) {
	533	children.remove(targetChild);
	534
	535	if (bcsc.isProxyPeer()) {
	536	pbcsc = (BCSChild)children.get(peer = bcsc.getProxyPeer());
	537	children.remove(peer);
	538	}
	539	}
	540
	541	if (getChildSerializable(targetChild) != null) serializable--;
	542
	543	childJustRemovedHook(targetChild, bcsc);
	544
	545	if (peer != null) {
	546	if (getChildSerializable(peer) != null) serializable--;
	547
	548	childJustRemovedHook(peer, pbcsc);
	549	}
	550	}
	551
	552	fireChildrenRemoved(new BeanContextMembershipEvent(getBeanContextPeer(), peer == null ? new Object[] { targetChild } : new Object[] { targetChild, peer } ));
	553
	554	}
	555
	556	return true;
	557	}
	558
	559	/**
	560	* Tests to see if all objects in the
	561	* specified <tt>Collection</tt> are children of
	562	* this <tt>BeanContext</tt>.
	563	* @param c the specified <tt>Collection</tt>
	564	*
	565	* @return <tt>true</tt> if all objects
	566	* in the collection are children of
	567	* this <tt>BeanContext</tt>, false if not.
	568	*/
	569	public boolean containsAll(Collection c) {
	570	synchronized(children) {
	571	Iterator i = c.iterator();
	572	while (i.hasNext())
	573	if(!contains(i.next()))
	574	return false;
	575
	576	return true;
	577	}
	578	}
	579
	580	/**
	581	* add Collection to set of Children (Unsupported)
	582	* implementations must synchronized on the hierarchy lock and "children" protected field
	583	* @throws UnsupportedOperationException
	584	*/
	585	public boolean addAll(Collection c) {
	586	throw new UnsupportedOperationException();
	587	}
	588
	589	/**
	590	* remove all specified children (Unsupported)
	591	* implementations must synchronized on the hierarchy lock and "children" protected field
	592	* @throws UnsupportedOperationException
	593	*/
	594	public boolean removeAll(Collection c) {
	595	throw new UnsupportedOperationException();
	596	}
	597
	598
	599	/**
	600	* retain only specified children (Unsupported)
	601	* implementations must synchronized on the hierarchy lock and "children" protected field
	602	* @throws UnsupportedOperationException
	603	*/
	604	public boolean retainAll(Collection c) {
	605	throw new UnsupportedOperationException();
	606	}
	607
	608	/**
	609	* clear the children (Unsupported)
	610	* implementations must synchronized on the hierarchy lock and "children" protected field
	611	* @throws UnsupportedOperationException
	612	*/
	613	public void clear() {
	614	throw new UnsupportedOperationException();
	615	}
	616
	617	/**
	618	* Adds a BeanContextMembershipListener
	619	*
	620	* @param bcml the BeanContextMembershipListener to add
	621	* @throws NullPointerException
	622	*/
	623
	624	public void addBeanContextMembershipListener(BeanContextMembershipListener bcml) {
	625	if (bcml == null) throw new NullPointerException("listener");
	626
	627	synchronized(bcmListeners) {
	628	if (bcmListeners.contains(bcml))
	629	return;
	630	else
	631	bcmListeners.add(bcml);
	632	}
	633	}
	634
	635	/**
	636	* Removes a BeanContextMembershipListener
	637	*
	638	* @param bcml the BeanContextMembershipListener to remove
	639	* @throws NullPointerException
	640	*/
	641
	642	public void removeBeanContextMembershipListener(BeanContextMembershipListener bcml) {
	643	if (bcml == null) throw new NullPointerException("listener");
	644
	645	synchronized(bcmListeners) {
	646	if (!bcmListeners.contains(bcml))
	647	return;
	648	else
	649	bcmListeners.remove(bcml);
	650	}
	651	}
	652
	653	/**
	654	* @param name the name of the resource requested.
	655	* @param bcc the child object making the request.
	656	*
	657	* @return the requested resource as an InputStream
	658	* @throws NullPointerException
	659	*/
	660
	661	public InputStream getResourceAsStream(String name, BeanContextChild bcc) {
	662	if (name == null) throw new NullPointerException("name");
	663	if (bcc == null) throw new NullPointerException("bcc");
	664
	665	if (containsKey(bcc)) {
	666	ClassLoader cl = bcc.getClass().getClassLoader();
	667
	668	return cl != null ? cl.getResourceAsStream(name)
	669	: ClassLoader.getSystemResourceAsStream(name);
	670	} else throw new IllegalArgumentException("Not a valid child");
	671	}
	672
	673	/**
	674	* @param name the name of the resource requested.
	675	* @param bcc the child object making the request.
	676	*
	677	* @return the requested resource as an InputStream
	678	*/
	679
	680	public URL getResource(String name, BeanContextChild bcc) {
	681	if (name == null) throw new NullPointerException("name");
	682	if (bcc == null) throw new NullPointerException("bcc");
	683
	684	if (containsKey(bcc)) {
	685	ClassLoader cl = bcc.getClass().getClassLoader();
	686
	687	return cl != null ? cl.getResource(name)
	688	: ClassLoader.getSystemResource(name);
	689	} else throw new IllegalArgumentException("Not a valid child");
	690	}
	691
	692	/**
	693	* Sets the new design time value for this <tt>BeanContext</tt>.
	694	* @param dTime the new designTime value
	695	*/
	696	public synchronized void setDesignTime(boolean dTime) {
	697	if (designTime != dTime) {
	698	designTime = dTime;
	699
	700	firePropertyChange("designMode", Boolean.valueOf(!dTime), Boolean.valueOf(dTime));
	701	}
	702	}
	703
	704
	705	/**
	706	* Reports whether or not this object is in
	707	* currently in design time mode.
	708	* @return <tt>true</tt> if in design time mode,
	709	* <tt>false</tt> if not
	710	*/
	711	public synchronized boolean isDesignTime() { return designTime; }
	712
	713	/**
	714	* Sets the locale of this BeanContext.
	715	* @param newLocale the new locale. This method call will have
	716	* no effect if newLocale is <CODE>null</CODE>.
	717	* @throws PropertyVetoException if the new value is rejected
	718	*/
	719	public synchronized void setLocale(Locale newLocale) throws PropertyVetoException {
	720
	721	if ((locale != null && !locale.equals(newLocale)) && newLocale != null) {
	722	Locale old = locale;
	723
	724	fireVetoableChange("locale", old, newLocale); // throws
	725
	726	locale = newLocale;
	727
	728	firePropertyChange("locale", old, newLocale);
	729	}
	730	}
	731
	732	/**
	733	* Gets the locale for this <tt>BeanContext</tt>.
	734	*
	735	* @return the current Locale of the <tt>BeanContext</tt>
	736	*/
	737	public synchronized Locale getLocale() { return locale; }
	738
	739	/**
	740	* <p>
	741	* This method is typically called from the environment in order to determine
	742	* if the implementor "needs" a GUI.
	743	* </p>
	744	* <p>
	745	* The algorithm used herein tests the BeanContextPeer, and its current children
	746	* to determine if they are either Containers, Components, or if they implement
	747	* Visibility and return needsGui() == true.
	748	* </p>
	749	* @return <tt>true</tt> if the implementor needs a GUI
	750	*/
	751	public synchronized boolean needsGui() {
	752	BeanContext bc = getBeanContextPeer();
	753
	754	if (bc != this) {
	755	if (bc instanceof Visibility) return ((Visibility)bc).needsGui();
	756
	757	if (bc instanceof Container \|\| bc instanceof Component)
	758	return true;
	759	}
	760
	761	synchronized(children) {
	762	for (Iterator i = children.keySet().iterator(); i.hasNext();) {
	763	Object c = i.next();
	764
	765	try {
	766	return ((Visibility)c).needsGui();
	767	} catch (ClassCastException cce) {
	768	// do nothing ...
	769	}
	770
	771	if (c instanceof Container \|\| c instanceof Component)
	772	return true;
	773	}
	774	}
	775
	776	return false;
	777	}
	778
	779	/**
	780	* notify this instance that it may no longer render a GUI.
	781	*/
	782
	783	public synchronized void dontUseGui() {
	784	if (okToUseGui) {
	785	okToUseGui = false;
	786
	787	// lets also tell the Children that can that they may not use their GUI's
	788	synchronized(children) {
	789	for (Iterator i = children.keySet().iterator(); i.hasNext();) {
	790	Visibility v = getChildVisibility(i.next());
	791
	792	if (v != null) v.dontUseGui();
	793	}
	794	}
	795	}
	796	}
	797
	798	/**
	799	* Notify this instance that it may now render a GUI
	800	*/
	801
	802	public synchronized void okToUseGui() {
	803	if (!okToUseGui) {
	804	okToUseGui = true;
	805
	806	// lets also tell the Children that can that they may use their GUI's
	807	synchronized(children) {
	808	for (Iterator i = children.keySet().iterator(); i.hasNext();) {
	809	Visibility v = getChildVisibility(i.next());
	810
	811	if (v != null) v.okToUseGui();
	812	}
	813	}
	814	}
	815	}
	816
	817	/**
	818	* Used to determine if the <tt>BeanContext</tt>
	819	* child is avoiding using its GUI.
	820	* @return is this instance avoiding using its GUI?
	821	* @see Visibility
	822	*/
	823	public boolean avoidingGui() {
	824	return !okToUseGui && needsGui();
	825	}
	826
	827	/**
	828	* Is this <tt>BeanContext</tt> in the
	829	* process of being serialized?
	830	* @return if this <tt>BeanContext</tt> is
	831	* currently being serialized
	832	*/
	833	public boolean isSerializing() { return serializing; }
	834
	835	/**
	836	* Returns an iterator of all children
	837	* of this <tt>BeanContext</tt>.
	838	* @return an iterator for all the current BCSChild values
	839	*/
	840	protected Iterator bcsChildren() { synchronized(children) { return children.values().iterator(); } }
	841
	842	/**
	843	* called by writeObject after defaultWriteObject() but prior to
	844	* serialization of currently serializable children.
	845	*
	846	* This method may be overridden by subclasses to perform custom
	847	* serialization of their state prior to this superclass serializing
	848	* the children.
	849	*
	850	* This method should not however be used by subclasses to replace their
	851	* own implementation (if any) of writeObject().
	852	*/
	853
	854	protected void bcsPreSerializationHook(ObjectOutputStream oos) throws IOException {
	855	}
	856
	857	/**
	858	* called by readObject after defaultReadObject() but prior to
	859	* deserialization of any children.
	860	*
	861	* This method may be overridden by subclasses to perform custom
	862	* deserialization of their state prior to this superclass deserializing
	863	* the children.
	864	*
	865	* This method should not however be used by subclasses to replace their
	866	* own implementation (if any) of readObject().
	867	*/
	868
	869	protected void bcsPreDeserializationHook(ObjectInputStream ois) throws IOException, ClassNotFoundException {
	870	}
	871
	872	/**
	873	* Called by readObject with the newly deserialized child and BCSChild.
	874	* @param child the newly deserialized child
	875	* @param bcsc the newly deserialized BCSChild
	876	*/
	877	protected void childDeserializedHook(Object child, BCSChild bcsc) {
	878	synchronized(children) {
	879	children.put(child, bcsc);
	880	}
	881	}
	882
	883	/**
	884	* Used by writeObject to serialize a Collection.
	885	* @param oos the <tt>ObjectOutputStream</tt>
	886	* to use during serialization
	887	* @param coll the <tt>Collection</tt> to serialize
	888	* @throws IOException if serialization failed
	889	*/
	890	protected final void serialize(ObjectOutputStream oos, Collection coll) throws IOException {
	891	int count = 0;
	892	Object[] objects = coll.toArray();
	893
	894	for (int i = 0; i < objects.length; i++) {
	895	if (objects[i] instanceof Serializable)
	896	count++;
	897	else
	898	objects[i] = null;
	899	}
	900
	901	oos.writeInt(count); // number of subsequent objects
	902
	903	for (int i = 0; count > 0; i++) {
	904	Object o = objects[i];
	905
	906	if (o != null) {
	907	oos.writeObject(o);
	908	count--;
	909	}
	910	}
	911	}
	912
	913	/**
	914	* used by readObject to deserialize a collection.
	915	* @param ois the ObjectInputStream to use
	916	* @param coll the Collection
	917	*/
	918	protected final void deserialize(ObjectInputStream ois, Collection coll) throws IOException, ClassNotFoundException {
	919	int count = 0;
	920
	921	count = ois.readInt();
	922
	923	while (count-- > 0) {
	924	coll.add(ois.readObject());
	925	}
	926	}
	927
	928	/**
	929	* Used to serialize all children of
	930	* this <tt>BeanContext</tt>.
	931	* @param oos the <tt>ObjectOutputStream</tt>
	932	* to use during serialization
	933	* @throws IOException if serialization failed
	934	*/
	935	public final void writeChildren(ObjectOutputStream oos) throws IOException {
	936	if (serializable <= 0) return;
	937
	938	boolean prev = serializing;
	939
	940	serializing = true;
	941
	942	int count = 0;
	943
	944	synchronized(children) {
	945	Iterator i = children.entrySet().iterator();
	946
	947	while (i.hasNext() && count < serializable) {
	948	Map.Entry entry = (Map.Entry)i.next();
	949
	950	if (entry.getKey() instanceof Serializable) {
	951	try {
	952	oos.writeObject(entry.getKey()); // child
	953	oos.writeObject(entry.getValue()); // BCSChild
	954	} catch (IOException ioe) {
	955	serializing = prev;
	956	throw ioe;
	957	}
	958	count++;
	959	}
	960	}
	961	}
	962
	963	serializing = prev;
	964
	965	if (count != serializable) {
	966	throw new IOException("wrote different number of children than expected");
	967	}
	968
	969	}
	970
	971	/**
	972	* Serialize the BeanContextSupport, if this instance has a distinct
	973	* peer (that is this object is acting as a delegate for another) then
	974	* the children of this instance are not serialized here due to a
	975	* 'chicken and egg' problem that occurs on deserialization of the
	976	* children at the same time as this instance.
	977	*
	978	* Therefore in situations where there is a distinct peer to this instance
	979	* it should always call writeObject() followed by writeChildren() and
	980	* readObject() followed by readChildren().
	981	*
	982	* @param oos the ObjectOutputStream
	983	*/
	984
	985	private synchronized void writeObject(ObjectOutputStream oos) throws IOException, ClassNotFoundException {
	986	serializing = true;
	987
	988	synchronized (BeanContext.globalHierarchyLock) {
	989	try {
	990	oos.defaultWriteObject(); // serialize the BeanContextSupport object
	991
	992	bcsPreSerializationHook(oos);
	993
	994	if (serializable > 0 && this.equals(getBeanContextPeer()))
	995	writeChildren(oos);
	996
	997	serialize(oos, (Collection)bcmListeners);
	998	} finally {
	999	serializing = false;
	1000	}
	1001	}
	1002	}
	1003
	1004	/**
	1005	* When an instance of this class is used as a delegate for the
	1006	* implementation of the BeanContext protocols (and its subprotocols)
	1007	* there exists a 'chicken and egg' problem during deserialization
	1008	*/
	1009
	1010	public final void readChildren(ObjectInputStream ois) throws IOException, ClassNotFoundException {
	1011	int count = serializable;
	1012
	1013	while (count-- > 0) {
	1014	Object child = null;
	1015	BeanContextSupport.BCSChild bscc = null;
	1016
	1017	try {
	1018	child = ois.readObject();
	1019	bscc = (BeanContextSupport.BCSChild)ois.readObject();
	1020	} catch (IOException ioe) {
	1021	continue;
	1022	} catch (ClassNotFoundException cnfe) {
	1023	continue;
	1024	}
	1025
	1026
	1027	synchronized(child) {
	1028	BeanContextChild bcc = null;
	1029
	1030	try {
	1031	bcc = (BeanContextChild)child;
	1032	} catch (ClassCastException cce) {
	1033	// do nothing;
	1034	}
	1035
	1036	if (bcc != null) {
	1037	try {
	1038	bcc.setBeanContext(getBeanContextPeer());
	1039
	1040	bcc.addPropertyChangeListener("beanContext", childPCL);
	1041	bcc.addVetoableChangeListener("beanContext", childVCL);
	1042
	1043	} catch (PropertyVetoException pve) {
	1044	continue;
	1045	}
	1046	}
	1047
	1048	childDeserializedHook(child, bscc);
	1049	}
	1050	}
	1051	}
	1052
	1053	/**
	1054	* deserialize contents ... if this instance has a distinct peer the
	1055	* children are not serialized here, the peer's readObject() must call
	1056	* readChildren() after deserializing this instance.
	1057	*/
	1058
	1059	private synchronized void readObject(ObjectInputStream ois) throws IOException, ClassNotFoundException {
	1060
	1061	synchronized(BeanContext.globalHierarchyLock) {
	1062	ois.defaultReadObject();
	1063
	1064	initialize();
	1065
	1066	bcsPreDeserializationHook(ois);
	1067
	1068	if (serializable > 0 && this.equals(getBeanContextPeer()))
	1069	readChildren(ois);
	1070
	1071	deserialize(ois, bcmListeners = new ArrayList(1));
	1072	}
	1073	}
	1074
	1075	/**
	1076	* subclasses may envelope to monitor veto child property changes.
	1077	*/
	1078
	1079	public void vetoableChange(PropertyChangeEvent pce) throws PropertyVetoException {
	1080	String propertyName = pce.getPropertyName();
	1081	Object source = pce.getSource();
	1082
	1083	synchronized(children) {
	1084	if ("beanContext".equals(propertyName) &&
	1085	containsKey(source) &&
	1086	!getBeanContextPeer().equals(pce.getNewValue())
	1087	) {
	1088	if (!validatePendingRemove(source)) {
	1089	throw new PropertyVetoException("current BeanContext vetoes setBeanContext()", pce);
	1090	} else ((BCSChild)children.get(source)).setRemovePending(true);
	1091	}
	1092	}
	1093	}
	1094
	1095	/**
	1096	* subclasses may envelope to monitor child property changes.
	1097	*/
	1098
	1099	public void propertyChange(PropertyChangeEvent pce) {
	1100	String propertyName = pce.getPropertyName();
	1101	Object source = pce.getSource();
	1102
	1103	synchronized(children) {
	1104	if ("beanContext".equals(propertyName) &&
	1105	containsKey(source) &&
	1106	((BCSChild)children.get(source)).isRemovePending()) {
	1107	BeanContext bc = getBeanContextPeer();
	1108
	1109	if (bc.equals(pce.getOldValue()) && !bc.equals(pce.getNewValue())) {
	1110	remove(source, false);
	1111	} else {
	1112	((BCSChild)children.get(source)).setRemovePending(false);
	1113	}
	1114	}
	1115	}
	1116	}
	1117
	1118	/**
	1119	* <p>
	1120	* Subclasses of this class may override, or envelope, this method to
	1121	* add validation behavior for the BeanContext to examine child objects
	1122	* immediately prior to their being added to the BeanContext.
	1123	* </p>
	1124	*
	1125	* @return true iff the child may be added to this BeanContext, otherwise false.
	1126	*/
	1127
	1128	protected boolean validatePendingAdd(Object targetChild) {
	1129	return true;
	1130	}
	1131
	1132	/**
	1133	* <p>
	1134	* Subclasses of this class may override, or envelope, this method to
	1135	* add validation behavior for the BeanContext to examine child objects
	1136	* immediately prior to their being removed from the BeanContext.
	1137	* </p>
	1138	*
	1139	* @return true iff the child may be removed from this BeanContext, otherwise false.
	1140	*/
	1141
	1142	protected boolean validatePendingRemove(Object targetChild) {
	1143	return true;
	1144	}
	1145
	1146	/**
	1147	* subclasses may override this method to simply extend add() semantics
	1148	* after the child has been added and before the event notification has
	1149	* occurred. The method is called with the child synchronized.
	1150	*/
	1151
	1152	protected void childJustAddedHook(Object child, BCSChild bcsc) {
	1153	}
	1154
	1155	/**
	1156	* subclasses may override this method to simply extend remove() semantics
	1157	* after the child has been removed and before the event notification has
	1158	* occurred. The method is called with the child synchronized.
	1159	*/
	1160
	1161	protected void childJustRemovedHook(Object child, BCSChild bcsc) {
	1162	}
	1163
	1164	/**
	1165	* Gets the Component (if any) associated with the specified child.
	1166	* @param child the specified child
	1167	* @return the Component (if any) associated with the specified child.
	1168	*/
	1169	protected static final Visibility getChildVisibility(Object child) {
	1170	try {
	1171	return (Visibility)child;
	1172	} catch (ClassCastException cce) {
	1173	return null;
	1174	}
	1175	}
	1176
	1177	/**
	1178	* Gets the Serializable (if any) associated with the specified Child
	1179	* @param child the specified child
	1180	* @return the Serializable (if any) associated with the specified Child
	1181	*/
	1182	protected static final Serializable getChildSerializable(Object child) {
	1183	try {
	1184	return (Serializable)child;
	1185	} catch (ClassCastException cce) {
	1186	return null;
	1187	}
	1188	}
	1189
	1190	/**
	1191	* Gets the PropertyChangeListener
	1192	* (if any) of the specified child
	1193	* @param child the specified child
	1194	* @return the PropertyChangeListener (if any) of the specified child
	1195	*/
	1196	protected static final PropertyChangeListener getChildPropertyChangeListener(Object child) {
	1197	try {
	1198	return (PropertyChangeListener)child;
	1199	} catch (ClassCastException cce) {
	1200	return null;
	1201	}
	1202	}
	1203
	1204	/**
	1205	* Gets the VetoableChangeListener
	1206	* (if any) of the specified child
	1207	* @param child the specified child
	1208	* @return the VetoableChangeListener (if any) of the specified child
	1209	*/
	1210	protected static final VetoableChangeListener getChildVetoableChangeListener(Object child) {
	1211	try {
	1212	return (VetoableChangeListener)child;
	1213	} catch (ClassCastException cce) {
	1214	return null;
	1215	}
	1216	}
	1217
	1218	/**
	1219	* Gets the BeanContextMembershipListener
	1220	* (if any) of the specified child
	1221	* @param child the specified child
	1222	* @return the BeanContextMembershipListener (if any) of the specified child
	1223	*/
	1224	protected static final BeanContextMembershipListener getChildBeanContextMembershipListener(Object child) {
	1225	try {
	1226	return (BeanContextMembershipListener)child;
	1227	} catch (ClassCastException cce) {
	1228	return null;
	1229	}
	1230	}
	1231
	1232	/**
	1233	* Gets the BeanContextChild (if any) of the specified child
	1234	* @param child the specified child
	1235	* @return the BeanContextChild (if any) of the specified child
	1236	* @throws IllegalArgumentException if child implements both BeanContextChild and BeanContextProxy
	1237	*/
	1238	protected static final BeanContextChild getChildBeanContextChild(Object child) {
	1239	try {
	1240	BeanContextChild bcc = (BeanContextChild)child;
	1241
	1242	if (child instanceof BeanContextChild && child instanceof BeanContextProxy)
	1243	throw new IllegalArgumentException("child cannot implement both BeanContextChild and BeanContextProxy");
	1244	else
	1245	return bcc;
	1246	} catch (ClassCastException cce) {
	1247	try {
	1248	return ((BeanContextProxy)child).getBeanContextProxy();
	1249	} catch (ClassCastException cce1) {
	1250	return null;
	1251	}
	1252	}
	1253	}
	1254
	1255	/**
	1256	* Fire a BeanContextshipEvent on the BeanContextMembershipListener interface
	1257	*/
	1258
	1259	protected final void fireChildrenAdded(BeanContextMembershipEvent bcme) {
	1260	Object[] copy;
	1261
	1262	synchronized(bcmListeners) { copy = bcmListeners.toArray(); }
	1263
	1264	for (int i = 0; i < copy.length; i++)
	1265	((BeanContextMembershipListener)copy[i]).childrenAdded(bcme);
	1266	}
	1267
	1268	/**
	1269	* Fire a BeanContextshipEvent on the BeanContextMembershipListener interface
	1270	*/
	1271
	1272	protected final void fireChildrenRemoved(BeanContextMembershipEvent bcme) {
	1273	Object[] copy;
	1274
	1275	synchronized(bcmListeners) { copy = bcmListeners.toArray(); }
	1276
	1277	for (int i = 0; i < copy.length; i++)
	1278	((BeanContextMembershipListener)copy[i]).childrenRemoved(bcme);
	1279	}
	1280
	1281	/**
	1282	* protected method called from constructor and readObject to initialize
	1283	* transient state of BeanContextSupport instance.
	1284	*
	1285	* This class uses this method to instantiate inner class listeners used
	1286	* to monitor PropertyChange and VetoableChange events on children.
	1287	*
	1288	* subclasses may envelope this method to add their own initialization
	1289	* behavior
	1290	*/
	1291
	1292	protected synchronized void initialize() {
	1293	children = new HashMap(serializable + 1);
	1294	bcmListeners = new ArrayList(1);
	1295
	1296	childPCL = new PropertyChangeListener() {
	1297
	1298	/*
	1299	* this adaptor is used by the BeanContextSupport class to forward
	1300	* property changes from a child to the BeanContext, avoiding
	1301	* accidential serialization of the BeanContext by a badly
	1302	* behaved Serializable child.
	1303	*/
	1304
	1305	public void propertyChange(PropertyChangeEvent pce) {
	1306	BeanContextSupport.this.propertyChange(pce);
	1307	}
	1308	};
	1309
	1310	childVCL = new VetoableChangeListener() {
	1311
	1312	/*
	1313	* this adaptor is used by the BeanContextSupport class to forward
	1314	* vetoable changes from a child to the BeanContext, avoiding
	1315	* accidential serialization of the BeanContext by a badly
	1316	* behaved Serializable child.
	1317	*/
	1318
	1319	public void vetoableChange(PropertyChangeEvent pce) throws PropertyVetoException {
	1320	BeanContextSupport.this.vetoableChange(pce);
	1321	}
	1322	};
	1323	}
	1324
	1325	/**
	1326	* Gets a copy of the this BeanContext's children.
	1327	* @return a copy of the current nested children
	1328	*/
	1329	protected final Object[] copyChildren() {
	1330	synchronized(children) { return children.keySet().toArray(); }
	1331	}
	1332
	1333	/**
	1334	* Tests to see if two class objects,
	1335	* or their names are equal.
	1336	* @param first the first object
	1337	* @param second the second object
	1338	* @return true if equal, false if not
	1339	*/
	1340	protected static final boolean classEquals(Class first, Class second) {
	1341	return first.equals(second) \|\| first.getName().equals(second.getName());
	1342	}
	1343
	1344
	1345	/*
	1346	* fields
	1347	*/
	1348
	1349
	1350	/**
	1351	* all accesses to the <code> protected HashMap children </code> field
	1352	* shall be synchronized on that object.
	1353	*/
	1354	protected transient HashMap children;
	1355
	1356	private int serializable = 0; // children serializable
	1357
	1358	/**
	1359	* all accesses to the <code> protected ArrayList bcmListeners </code> field
	1360	* shall be synchronized on that object.
	1361	*/
	1362	protected transient ArrayList bcmListeners;
	1363
	1364	//
	1365
	1366	/**
	1367	* The current locale of this BeanContext.
	1368	*/
	1369	protected Locale locale;
	1370
	1371	/**
	1372	* A <tt>boolean</tt> indicating if this
	1373	* instance may now render a GUI.
	1374	*/
	1375	protected boolean okToUseGui;
	1376
	1377
	1378	/**
	1379	* A <tt>boolean</tt> indicating whether or not
	1380	* this object is currently in design time mode.
	1381	*/
	1382	protected boolean designTime;
	1383
	1384	/*
	1385	* transient
	1386	*/
	1387
	1388	private transient PropertyChangeListener childPCL;
	1389
	1390	private transient VetoableChangeListener childVCL;
	1391
	1392	private transient boolean serializing;
	1393	}

java/pkg/java/beans/beancontext/mkfile+25−0

@@ -0,0 +1,25 @@
	1	<../../../../../mkconfig
	2
	3	TARG=\
	4	BeanContext.dis\
	5	BeanContextChild.dis\
	6	BeanContextChildComponentProxy.dis\
	7	BeanContextChildSupport.dis\
	8	BeanContextContainerProxy.dis\
	9	BeanContextEvent.dis\
	10	BeanContextMembershipEvent.dis\
	11	BeanContextMembershipListener.dis\
	12	BeanContextProxy.dis\
	13	BeanContextServiceAvailableEvent.dis\
	14	BeanContextServiceProvider.dis\
	15	BeanContextServiceProviderBeanInfo.dis\
	16	BeanContextServiceRevokedEvent.dis\
	17	BeanContextServiceRevokedListener.dis\
	18	BeanContextServices.dis\
	19	BeanContextServicesListener.dis\
	20	BeanContextServicesSupport.dis\
	21	BeanContextSupport.dis\
	22
	23	DISBIN=$ROOT/java/dis/java/java/java/beans/beancontext
	24
	25	<$ROOT/mkfiles/mkjava

java/pkg/java/beans/beancontext/package.html+55−0

@@ -0,0 +1,55 @@
	1	<!--
	2	Copyright (c) 1998, 1999, Oracle and/or its affiliates. All rights reserved.
	3	DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4
	5	This code is free software; you can redistribute it and/or modify it
	6	under the terms of the GNU General Public License version 2 only, as
	7	published by the Free Software Foundation. Oracle designates this
	8	particular file as subject to the "Classpath" exception as provided
	9	by Oracle in the LICENSE file that accompanied this code.
	10
	11	This code is distributed in the hope that it will be useful, but WITHOUT
	12	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	version 2 for more details (a copy is included in the LICENSE file that
	15	accompanied this code).
	16
	17	You should have received a copy of the GNU General Public License version
	18	2 along with this work; if not, write to the Free Software Foundation,
	19	Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20
	21	Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	or visit www.oracle.com if you need additional information or have any
	23	questions.
	24	-->
	25
	26	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
	27	<html>
	28	<body bgcolor="white">
	29
	30	Provides classes and interfaces relating to bean context.
	31	A bean context is a container for beans and defines the execution
	32	environment for the beans it contains. There can be several beans in
	33	a single bean context, and a bean context can be nested within another
	34	bean context. This package also contains events and listener
	35	interface for beans being added and removed from a bean context.
	36
	37	<!--
	38	<h2>Package Specification</h2>
	39
	40	##### FILL IN ANY SPECS NEEDED BY JAVA COMPATIBILITY KIT #####
	41	<ul>
	42	<li><a href="">##### REFER TO ANY FRAMEMAKER SPECIFICATION HERE #####</a>
	43	</ul>
	44
	45	<h2>Related Documentation</h2>
	46
	47	For overviews, tutorials, examples, guides, and tool documentation, please see:
	48	<ul>
	49	<li><a href="">##### REFER TO NON-SPEC DOCUMENTATION HERE #####</a>
	50	</ul>
	51	-->
	52
	53	@since 1.2
	54	</body>
	55	</html>

java/pkg/java/beans/java_awt_AWTKeyStroke_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_BorderLayout_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_CardLayout_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_Choice_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_Component_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_Container_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_Font_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_GridBagLayout_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_Insets_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_List_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_MenuBar_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_MenuShortcut_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_Menu_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_SystemColor_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_awt_font_TextAttribute_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_beans_beancontext_BeanContextSupport_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_lang_Class_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_lang_String_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_lang_reflect_Field_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_lang_reflect_Method_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_sql_Timestamp_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_AbstractCollection_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_AbstractList_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_AbstractMap_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collection_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$CheckedCollection_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$CheckedList_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$CheckedMap_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$CheckedRandomAccessList_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$CheckedSet_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$CheckedSortedMap_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$CheckedSortedSet_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$EmptyList_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$EmptyMap_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$EmptySet_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$SingletonList_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$SingletonMap_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$SingletonSet_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$SynchronizedCollection_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$SynchronizedList_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$SynchronizedMap_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$SynchronizedRandomAccessList_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$SynchronizedSet_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$SynchronizedSortedMap_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$SynchronizedSortedSet_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$UnmodifiableCollection_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$UnmodifiableList_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$UnmodifiableMap_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$UnmodifiableRandomAccessList_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$UnmodifiableSet_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$UnmodifiableSortedMap_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections$UnmodifiableSortedSet_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Collections.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Date_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_EnumMap_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_EnumSet_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Hashtable_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_List_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/java_util_Map_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/javax_swing_Box_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/javax_swing_DefaultComboBoxModel_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/javax_swing_DefaultListModel_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/javax_swing_JFrame_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/javax_swing_JMenu_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/javax_swing_JTabbedPane_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/javax_swing_ToolTipManager_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/javax_swing_border_MatteBorder_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/javax_swing_tree_DefaultMutableTreeNode_PersistenceDelegate.class+0−0

Binary file not shown.

java/pkg/java/beans/mkfile+54−0

@@ -0,0 +1,54 @@
	1	<../../../../mkconfig
	2
	3	DIRS=\
	4	beancontext\
	5
	6	TARG=\
	7	AppletInitializer.dis\
	8	BeanDescriptor.dis\
	9	BeanInfo.dis\
	10	Beans.dis\
	11	ChangeListenerMap.dis\
	12	ConstructorProperties.dis\
	13	Customizer.dis\
	14	DefaultPersistenceDelegate.dis\
	15	DesignMode.dis\
	16	Encoder.dis\
	17	EventHandler.dis\
	18	EventSetDescriptor.dis\
	19	ExceptionListener.dis\
	20	Expression.dis\
	21	FeatureDescriptor.dis\
	22	IndexedPropertyChangeEvent.dis\
	23	IndexedPropertyDescriptor.dis\
	24	IntrospectionException.dis\
	25	Introspector.dis\
	26	MetaData.dis\
	27	MethodDescriptor.dis\
	28	NameGenerator.dis\
	29	ParameterDescriptor.dis\
	30	PersistenceDelegate.dis\
	31	PropertyChangeEvent.dis\
	32	PropertyChangeListener.dis\
	33	PropertyChangeListenerProxy.dis\
	34	PropertyChangeSupport.dis\
	35	PropertyDescriptor.dis\
	36	PropertyEditor.dis\
	37	PropertyEditorManager.dis\
	38	PropertyEditorSupport.dis\
	39	PropertyVetoException.dis\
	40	ReflectionUtils.dis\
	41	SimpleBeanInfo.dis\
	42	Statement.dis\
	43	Transient.dis\
	44	VetoableChangeListener.dis\
	45	VetoableChangeListenerProxy.dis\
	46	VetoableChangeSupport.dis\
	47	Visibility.dis\
	48	XMLDecoder.dis\
	49	XMLEncoder.dis\
	50
	51	DISBIN=$ROOT/java/dis/java/java/java/beans
	52
	53	<$ROOT/mkfiles/mkjava
	54	<$ROOT/mkfiles/mksubdirs

java/pkg/java/beans/package.html+156−0

@@ -0,0 +1,156 @@
	1	<!--
	2	Copyright (c) 1998, 2011, Oracle and/or its affiliates. All rights reserved.
	3	DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	4
	5	This code is free software; you can redistribute it and/or modify it
	6	under the terms of the GNU General Public License version 2 only, as
	7	published by the Free Software Foundation. Oracle designates this
	8	particular file as subject to the "Classpath" exception as provided
	9	by Oracle in the LICENSE file that accompanied this code.
	10
	11	This code is distributed in the hope that it will be useful, but WITHOUT
	12	ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	13	FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	14	version 2 for more details (a copy is included in the LICENSE file that
	15	accompanied this code).
	16
	17	You should have received a copy of the GNU General Public License version
	18	2 along with this work; if not, write to the Free Software Foundation,
	19	Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	20
	21	Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	22	or visit www.oracle.com if you need additional information or have any
	23	questions.
	24	-->
	25
	26	<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 3.2 Final//EN">
	27	<html>
	28	<body bgcolor="white">
	29
	30	Contains classes related to developing
	31	<em>beans</em> -- components
	32	based on the JavaBeans™ architecture.
	33	A few of the
	34	classes are used by beans while they run in an application.
	35	For example, the event classes are
	36	used by beans that fire property and vetoable change
	37	events (see
	38	{@link java.beans.PropertyChangeEvent}). However, most of the classes in this
	39	package are meant to be used by a bean editor (that is, a development environment
	40	for customizing and putting together beans to create an application). In
	41	particular, these classes help the bean editor create a user
	42	interface that the user can use to customize the bean. For example, a bean may
	43	contain a property of a special type that a bean editor may not know how to handle.
	44	By using the <code>PropertyEditor</code> interface, a bean developer can
	45	provide an editor for this special type.
	46
	47	<p>
	48	To minimize the resources used by a bean, the classes used by bean editors are loaded only
	49	when the bean is being edited. They are not needed while the bean is running in an application
	50	and therefore not loaded. This information is kept in what's called a bean-info (see {@link java.beans.BeanInfo}).
	51
	52	<p>
	53	Unless explicitly stated, null values or empty Strings are not valid
	54	parameters for the methods in this package. You may expect to see
	55	exceptions if these parameters are used.
	56
	57
	58	<h2>Long-Term Persistence</h2>
	59
	60	As of v1.4,
	61	the <code>java.beans</code> package provides support for
	62	<em>long-term persistence</em> -- reading and
	63	writing a bean as a textual representation of its property values.
	64	The property values are treated as beans,
	65	and are recursively read or written to capture
	66	their publicly available state.
	67	This approach is suitable for long-term storage
	68	because it relies only on public API,
	69	rather than the likely-to-change private implementation.
	70
	71	<blockquote>
	72	<hr>
	73	<b>Note:</b>
	74	The persistence scheme cannot automatically instantiate
	75	custom inner classes, such as you might use for event handlers.
	76	By using the {@link java.beans.EventHandler} class
	77	instead of inner classes for custom event handlers,
	78	you can avoid this problem.
	79	<hr>
	80	</blockquote>
	81
	82	<p>
	83
	84	You read and write beans in XML format using the
	85	{@link java.beans.XMLDecoder}
	86	and
	87	{@link java.beans.XMLEncoder}
	88	classes, respectively.
	89	One notable feature of the persistence scheme is that
	90	reading in a bean requires no special knowledge of the bean.
	91
	92	<p>
	93	Writing out a bean, on the other hand,
	94	sometimes requires special knowledge of the bean's type.
	95	If the bean's state can be
	96	expressed using only the no-argument constructor and
	97	public getter and setter methods for properties,
	98	no special knowledge is required.
	99	Otherwise, the bean requires a custom <em>persistence delegate</em> --
	100	an object that is in charge of writing out beans of a particular type.
	101	All classes provided in the JDK that descend
	102	from <code>java.awt.Component</code>,
	103	as well as all their properties,
	104	automatically have persistence delegates.
	105
	106	<p>
	107
	108	If you need (or choose) to provide a persistence delegate for a bean,
	109	you can do so either by using a
	110	{@link java.beans.DefaultPersistenceDelegate}
	111	instance
	112	or by creating your own subclass of <code>PersistenceDelegate</code>.
	113	If the only reason a bean needs a persistence delegate
	114	is because you want to invoke the bean's constructor with
	115	property values as arguments,
	116	you can create the bean's persistence delegate
	117	with the one-argument
	118	<code>DefaultPersistenceDelegate</code>
	119	constructor.
	120	Otherwise,
	121	you need to implement your own persistence delegate,
	122	for which you're likely to need the following classes:
	123
	124	<dl>
	125	<dt> {@link java.beans.PersistenceDelegate}
	126	<dd> The abstract class from which all persistence delegates descend.
	127	Your subclass should use its knowledge of the bean's type to provide
	128	whatever <code>Statement</code>s and <code>Expression</code>s
	129	are necessary to create the bean
	130	and restore its state.
	131	<dt> {@link java.beans.Statement}
	132	<dd> Represents the invocation of a single method on an object.
	133	Includes a set of arguments to the method.
	134	<dt> {@link java.beans.Expression}
	135	<dd> A subclass of <code>Statement</code>
	136	used for methods that return a value.
	137	</dl>
	138
	139	<p>
	140	Once you create a persistence delegate,
	141	you register it using the
	142	<code>setPersistenceDelegate</code> method of
	143	<code>XMLEncoder</code>.
	144
	145
	146	<h2>Related Documentation</h2>
	147
	148	For overview, architecture, and tutorial documentation, please see:
	149	<ul>
	150	<li><a href="http://java.sun.com/docs/books/tutorial/javabeans/">JavaBeans</a>, a trail in <em>The Java Tutorial</em>.
	151	<li><a href="http://java.sun.com/products/jfc/tsc/articles/persistence2/">Long-Term Persistence</a>, an article in <em>The Swing Connection</em>.
	152	</ul>
	153	<p>
	154
	155	</body>
	156	</html>

java/pkg/java/beans/sun_swing_PrintColorUIResource_PersistenceDelegate.class+0−0

Binary file not shown.