History

My first initial commit with all of mine experimental changes.

Dmitry Kabak (userdima committed 13 years ago

Commit d37b88d1 parent 3f5b46618352 files · +2598093 −-8690Browse files

Showing the changes to java/pkg/java/beans/XMLEncoder.java (1 of 18352 files). Show all

Unified · Split

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