author | malenkov |
Tue, 11 Sep 2012 10:58:39 +0400 | |
changeset 13773 | 69665c88db93 |
parent 11120 | f8576c769572 |
child 14887 | 226dd1cda199 |
permissions | -rw-r--r-- |
2 | 1 |
/* |
9035
1255eb81cc2f
7033660: Update copyright year to 2011 on any files changed in 2011
ohair
parents:
8760
diff
changeset
|
2 |
* Copyright (c) 2000, 2011, Oracle and/or its affiliates. All rights reserved. |
2 | 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 |
|
5506 | 7 |
* published by the Free Software Foundation. Oracle designates this |
2 | 8 |
* particular file as subject to the "Classpath" exception as provided |
5506 | 9 |
* by Oracle in the LICENSE file that accompanied this code. |
2 | 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 |
* |
|
5506 | 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. |
|
2 | 24 |
*/ |
25 |
package java.beans; |
|
26 |
||
27 |
import java.util.*; |
|
28 |
import java.lang.reflect.*; |
|
9548 | 29 |
import java.util.Objects; |
2 | 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 |
|
8760
83843c0b84f7
7021517: java.beans code comments have issues with HTML4 compliance
malenkov
parents:
5597
diff
changeset
|
39 |
* classes that follow the JavaBeans™ conventions without any class specific |
2 | 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 |
||
11120
f8576c769572
7116954: Misc warnings in java.beans/java.beans.context
mcimadamore
parents:
9548
diff
changeset
|
98 |
private static boolean definesEquals(Class<?> type) { |
2 | 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 |
* |
|
4849
c83eca4dbb8f
6412286: DOC: LTP: Unspecified NPE in java.beans.DefaultPersistenceDelegate.instantiate method
malenkov
parents:
1280
diff
changeset
|
150 |
* @throws NullPointerException if {@code out} is {@code null} |
c83eca4dbb8f
6412286: DOC: LTP: Unspecified NPE in java.beans.DefaultPersistenceDelegate.instantiate method
malenkov
parents:
1280
diff
changeset
|
151 |
* |
2 | 152 |
* @see #DefaultPersistenceDelegate(String[]) |
153 |
*/ |
|
154 |
protected Expression instantiate(Object oldInstance, Encoder out) { |
|
155 |
int nArgs = constructor.length; |
|
11120
f8576c769572
7116954: Misc warnings in java.beans/java.beans.context
mcimadamore
parents:
9548
diff
changeset
|
156 |
Class<?> type = oldInstance.getClass(); |
2 | 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 |
||
11120
f8576c769572
7116954: Misc warnings in java.beans/java.beans.context
mcimadamore
parents:
9548
diff
changeset
|
170 |
private Method findMethod(Class<?> type, String property) { |
2 | 171 |
if (property == null) { |
172 |
throw new IllegalArgumentException("Property name is null"); |
|
173 |
} |
|
466
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
174 |
PropertyDescriptor pd = getPropertyDescriptor(type, property); |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
175 |
if (pd == null) { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
176 |
throw new IllegalStateException("Could not find property by the name " + property); |
2 | 177 |
} |
466
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
178 |
Method method = pd.getReadMethod(); |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
179 |
if (method == null) { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
180 |
throw new IllegalStateException("Could not find getter for the property " + property); |
2 | 181 |
} |
466
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
182 |
return method; |
2 | 183 |
} |
184 |
||
11120
f8576c769572
7116954: Misc warnings in java.beans/java.beans.context
mcimadamore
parents:
9548
diff
changeset
|
185 |
private void doProperty(Class<?> type, PropertyDescriptor pd, Object oldInstance, Object newInstance, Encoder out) throws Exception { |
2 | 186 |
Method getter = pd.getReadMethod(); |
187 |
Method setter = pd.getWriteMethod(); |
|
188 |
||
466
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
189 |
if (getter != null && setter != null) { |
2 | 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); |
|
9548 | 195 |
if (!Objects.equals(newValue, out.get(oldValue))) { |
2 | 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. |
|
11120
f8576c769572
7116954: Misc warnings in java.beans/java.beans.context
mcimadamore
parents:
9548
diff
changeset
|
221 |
private void initBean(Class<?> type, Object oldInstance, Object newInstance, Encoder out) { |
5583
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
222 |
for (Field field : type.getFields()) { |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
223 |
int mod = field.getModifiers(); |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
224 |
if (Modifier.isFinal(mod) || Modifier.isStatic(mod) || Modifier.isTransient(mod)) { |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
225 |
continue; |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
226 |
} |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
227 |
try { |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
228 |
Expression oldGetExp = new Expression(field, "get", new Object[] { oldInstance }); |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
229 |
Expression newGetExp = new Expression(field, "get", new Object[] { newInstance }); |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
230 |
Object oldValue = oldGetExp.getValue(); |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
231 |
Object newValue = newGetExp.getValue(); |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
232 |
out.writeExpression(oldGetExp); |
9548 | 233 |
if (!Objects.equals(newValue, out.get(oldValue))) { |
5583
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
234 |
out.writeStatement(new Statement(field, "set", new Object[] { oldInstance, oldValue })); |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
235 |
} |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
236 |
} |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
237 |
catch (Exception exception) { |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
238 |
out.getExceptionListener().exceptionThrown(exception); |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
239 |
} |
6cb5bb2e8335
6479191: LTP: XMLEncoder does not update initialized property of GridBagConstraints type
malenkov
parents:
4849
diff
changeset
|
240 |
} |
466
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
241 |
BeanInfo info; |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
242 |
try { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
243 |
info = Introspector.getBeanInfo(type); |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
244 |
} catch (IntrospectionException exception) { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
245 |
return; |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
246 |
} |
2 | 247 |
// Properties |
466
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
248 |
for (PropertyDescriptor d : info.getPropertyDescriptors()) { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
249 |
if (d.isTransient()) { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
250 |
continue; |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
251 |
} |
2 | 252 |
try { |
466
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
253 |
doProperty(type, d, oldInstance, newInstance, out); |
2 | 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 |
} |
|
466
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
287 |
for (EventSetDescriptor d : info.getEventSetDescriptors()) { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
288 |
if (d.isTransient()) { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
289 |
continue; |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
290 |
} |
11120
f8576c769572
7116954: Misc warnings in java.beans/java.beans.context
mcimadamore
parents:
9548
diff
changeset
|
291 |
Class<?> listenerType = d.getListenerType(); |
2 | 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 |
} |
|
1280
f58fc9f575e3
6351692: catch(Throwable) in java.beans.MetaData preventing thread shutdown
malenkov
parents:
466
diff
changeset
|
319 |
catch (Exception e2) { |
2 | 320 |
try { |
11120
f8576c769572
7116954: Misc warnings in java.beans/java.beans.context
mcimadamore
parents:
9548
diff
changeset
|
321 |
Method m = type.getMethod("getListeners", new Class<?>[]{Class.class}); |
2 | 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 |
* |
|
4849
c83eca4dbb8f
6412286: DOC: LTP: Unspecified NPE in java.beans.DefaultPersistenceDelegate.instantiate method
malenkov
parents:
1280
diff
changeset
|
388 |
* @throws NullPointerException if {@code out} is {@code null} |
c83eca4dbb8f
6412286: DOC: LTP: Unspecified NPE in java.beans.DefaultPersistenceDelegate.instantiate method
malenkov
parents:
1280
diff
changeset
|
389 |
* |
2 | 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 |
} |
|
466
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
403 |
|
11120
f8576c769572
7116954: Misc warnings in java.beans/java.beans.context
mcimadamore
parents:
9548
diff
changeset
|
404 |
private static PropertyDescriptor getPropertyDescriptor(Class<?> type, String property) { |
466
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
405 |
try { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
406 |
for (PropertyDescriptor pd : Introspector.getBeanInfo(type).getPropertyDescriptors()) { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
407 |
if (property.equals(pd.getName())) |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
408 |
return pd; |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
409 |
} |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
410 |
} catch (IntrospectionException exception) { |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
411 |
} |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
412 |
return null; |
6acd5ec503a8
4935607: RFE: LTP: Should be possible to set the TRANSIENT attribute of propertiies to FALSE
malenkov
parents:
2
diff
changeset
|
413 |
} |
2 | 414 |
} |