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<>();
291 targetToStatementList = new IdentityHashMap<>();
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<>();
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(), stm instanceof Expression);
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 Statement statement = getMissedStatement();
491 while (statement != null) {
492 outputStatement(statement, this, false);
493 statement = getMissedStatement();
494 }
495
496 try {
497 out.flush();
498 }
499 catch (IOException e) {
500 getExceptionListener().exceptionThrown(e);
501 }
502 clear();
503 }
504
505 void clear() {
506 super.clear();
507 nameGenerator.clear();
508 valueToExpression.clear();
509 targetToStatementList.clear();
510 }
511
512 Statement getMissedStatement() {
513 for (List<Statement> statements : this.targetToStatementList.values()) {
514 for (int i = 0; i < statements.size(); i++) {
515 if (Statement.class == statements.get(i).getClass()) {
516 return statements.remove(i);
517 }
518 }
519 }
520 return null;
521 }
522
523
524 /**
525 * This method calls <code>flush</code>, writes the closing
526 * postamble and then closes the output stream associated
527 * with this stream.
528 */
529 public void close() {
530 flush();
531 writeln("</java>");
532 try {
533 out.close();
534 }
535 catch (IOException e) {
536 getExceptionListener().exceptionThrown(e);
537 }
538 }
539
540 private String quote(String s) {
541 return "\"" + s + "\"";
542 }
543
544 private ValueData getValueData(Object o) {
545 ValueData d = valueToExpression.get(o);
546 if (d == null) {
547 d = new ValueData();
548 valueToExpression.put(o, d);
549 }
550 return d;
551 }
552
553 /**
554 * Returns <code>true</code> if the argument,
555 * a Unicode code point, is valid in XML documents.
556 * Unicode characters fit into the low sixteen bits of a Unicode code point,
557 * and pairs of Unicode <em>surrogate characters</em> can be combined
558 * to encode Unicode code point in documents containing only Unicode.
559 * (The <code>char</code> datatype in the Java Programming Language
560 * represents Unicode characters, including unpaired surrogates.)
561 * <par>
562 * [2] Char ::= #x0009 | #x000A | #x000D
563 * | [#x0020-#xD7FF]
564 * | [#xE000-#xFFFD]
565 * | [#x10000-#x10ffff]
566 * </par>
567 *
568 * @param code the 32-bit Unicode code point being tested
569 * @return <code>true</code> if the Unicode code point is valid,
570 * <code>false</code> otherwise
571 */
572 private static boolean isValidCharCode(int code) {
573 return (0x0020 <= code && code <= 0xD7FF)
574 || (0x000A == code)
575 || (0x0009 == code)
576 || (0x000D == code)
577 || (0xE000 <= code && code <= 0xFFFD)
578 || (0x10000 <= code && code <= 0x10ffff);
579 }
580
581 private void writeln(String exp) {
582 try {
583 StringBuilder sb = new StringBuilder();
584 for(int i = 0; i < indentation; i++) {
585 sb.append(' ');
586 }
587 sb.append(exp);
588 sb.append('\n');
589 this.out.write(sb.toString());
590 }
591 catch (IOException e) {
592 getExceptionListener().exceptionThrown(e);
593 }
594 }
595
596 private void outputValue(Object value, Object outer, boolean isArgument) {
597 if (value == null) {
598 writeln("<null/>");
599 return;
600 }
601
602 if (value instanceof Class) {
603 writeln("<class>" + ((Class)value).getName() + "</class>");
604 return;
605 }
606
607 ValueData d = getValueData(value);
608 if (d.exp != null) {
609 Object target = d.exp.getTarget();
610 String methodName = d.exp.getMethodName();
611
612 if (target == null || methodName == null) {
613 throw new NullPointerException((target == null ? "target" :
614 "methodName") + " should not be null");
615 }
616
617 if (isArgument && target instanceof Field && methodName.equals("get")) {
618 Field f = (Field)target;
619 writeln("<object class=" + quote(f.getDeclaringClass().getName()) +
620 " field=" + quote(f.getName()) + "/>");
621 return;
622 }
623
624 Class<?> primitiveType = primitiveTypeFor(value.getClass());
625 if (primitiveType != null && target == value.getClass() &&
626 methodName.equals("new")) {
627 String primitiveTypeName = primitiveType.getName();
628 // Make sure that character types are quoted correctly.
629 if (primitiveType == Character.TYPE) {
630 char code = ((Character) value).charValue();
631 if (!isValidCharCode(code)) {
632 writeln(createString(code));
633 return;
634 }
635 value = quoteCharCode(code);
636 if (value == null) {
637 value = Character.valueOf(code);
638 }
639 }
640 writeln("<" + primitiveTypeName + ">" + value + "</" +
641 primitiveTypeName + ">");
642 return;
643 }
644
645 } else if (value instanceof String) {
646 writeln(createString((String) value));
647 return;
648 }
649
650 if (d.name != null) {
651 if (isArgument) {
652 writeln("<object idref=" + quote(d.name) + "/>");
653 }
654 else {
655 outputXML("void", " idref=" + quote(d.name), value);
656 }
657 }
658 else if (d.exp != null) {
659 outputStatement(d.exp, outer, isArgument);
660 }
661 }
662
663 private static String quoteCharCode(int code) {
664 switch(code) {
665 case '&': return "&";
666 case '<': return "<";
667 case '>': return ">";
668 case '"': return """;
669 case '\'': return "'";
670 case '\r': return "
";
671 default: return null;
672 }
673 }
674
675 private static String createString(int code) {
676 return "<char code=\"#" + Integer.toString(code, 16) + "\"/>";
677 }
678
679 private String createString(String string) {
680 StringBuilder sb = new StringBuilder();
681 sb.append("<string>");
682 int index = 0;
683 while (index < string.length()) {
684 int point = string.codePointAt(index);
685 int count = Character.charCount(point);
686
687 if (isValidCharCode(point) && this.encoder.canEncode(string.substring(index, index + count))) {
688 String value = quoteCharCode(point);
689 if (value != null) {
690 sb.append(value);
691 } else {
692 sb.appendCodePoint(point);
693 }
694 index += count;
695 } else {
696 sb.append(createString(string.charAt(index)));
697 index++;
698 }
699 }
700 sb.append("</string>");
701 return sb.toString();
702 }
703
704 private void outputStatement(Statement exp, Object outer, boolean isArgument) {
705 Object target = exp.getTarget();
706 String methodName = exp.getMethodName();
707
708 if (target == null || methodName == null) {
709 throw new NullPointerException((target == null ? "target" :
710 "methodName") + " should not be null");
711 }
712
713 Object[] args = exp.getArguments();
714 boolean expression = exp.getClass() == Expression.class;
715 Object value = (expression) ? getValue((Expression)exp) : null;
716
717 String tag = (expression && isArgument) ? "object" : "void";
718 String attributes = "";
719 ValueData d = getValueData(value);
720
721 // Special cases for targets.
722 if (target == outer) {
723 }
724 else if (target == Array.class && methodName.equals("newInstance")) {
725 tag = "array";
726 attributes = attributes + " class=" + quote(((Class)args[0]).getName());
727 attributes = attributes + " length=" + quote(args[1].toString());
728 args = new Object[]{};
729 }
730 else if (target.getClass() == Class.class) {
731 attributes = attributes + " class=" + quote(((Class)target).getName());
732 }
733 else {
734 d.refs = 2;
735 if (d.name == null) {
736 getValueData(target).refs++;
737 List<Statement> statements = statementList(target);
738 if (!statements.contains(exp)) {
739 statements.add(exp);
740 }
741 outputValue(target, outer, false);
742 }
743 if (expression) {
744 outputValue(value, outer, isArgument);
745 }
746 return;
747 }
748 if (expression && (d.refs > 1)) {
749 String instanceName = nameGenerator.instanceName(value);
750 d.name = instanceName;
751 attributes = attributes + " id=" + quote(instanceName);
752 }
753
754 // Special cases for methods.
755 if ((!expression && methodName.equals("set") && args.length == 2 &&
756 args[0] instanceof Integer) ||
757 (expression && methodName.equals("get") && args.length == 1 &&
758 args[0] instanceof Integer)) {
759 attributes = attributes + " index=" + quote(args[0].toString());
760 args = (args.length == 1) ? new Object[]{} : new Object[]{args[1]};
761 }
762 else if ((!expression && methodName.startsWith("set") && args.length == 1) ||
763 (expression && methodName.startsWith("get") && args.length == 0)) {
764 if (3 < methodName.length()) {
765 attributes = attributes + " property=" +
766 quote(Introspector.decapitalize(methodName.substring(3)));
767 }
768 }
769 else if (!methodName.equals("new") && !methodName.equals("newInstance")) {
770 attributes = attributes + " method=" + quote(methodName);
771 }
772 outputXML(tag, attributes, value, args);
773 }
774
775 private void outputXML(String tag, String attributes, Object value, Object... args) {
776 List<Statement> statements = statementList(value);
777 // Use XML's short form when there is no body.
778 if (args.length == 0 && statements.size() == 0) {
779 writeln("<" + tag + attributes + "/>");
780 return;
781 }
782
783 writeln("<" + tag + attributes + ">");
784 indentation++;
785
786 for(int i = 0; i < args.length; i++) {
787 outputValue(args[i], null, true);
788 }
789
790 while (!statements.isEmpty()) {
791 Statement s = statements.remove(0);
792 outputStatement(s, value, false);
793 }
794
795 indentation--;
796 writeln("</" + tag + ">");
797 }
798
799 @SuppressWarnings("rawtypes")
800 static Class primitiveTypeFor(Class wrapper) {
801 if (wrapper == Boolean.class) return Boolean.TYPE;
802 if (wrapper == Byte.class) return Byte.TYPE;
803 if (wrapper == Character.class) return Character.TYPE;
804 if (wrapper == Short.class) return Short.TYPE;
805 if (wrapper == Integer.class) return Integer.TYPE;
806 if (wrapper == Long.class) return Long.TYPE;
807 if (wrapper == Float.class) return Float.TYPE;
808 if (wrapper == Double.class) return Double.TYPE;
809 if (wrapper == Void.class) return Void.TYPE;
810 return null;
811 }
812 }