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