-
Notifications
You must be signed in to change notification settings - Fork 111
/
StAXStreamReader.java
359 lines (319 loc) · 12.1 KB
/
StAXStreamReader.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
/*--
Copyright (C) 2000-2012 Jason Hunter & Brett McLaughlin.
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
1. Redistributions of source code must retain the above copyright
notice, this list of conditions, and the following disclaimer.
2. Redistributions in binary form must reproduce the above copyright
notice, this list of conditions, and the disclaimer that follows
these conditions in the documentation and/or other materials
provided with the distribution.
3. The name "JDOM" must not be used to endorse or promote products
derived from this software without prior written permission. For
written permission, please contact <request_AT_jdom_DOT_org>.
4. Products derived from this software may not be called "JDOM", nor
may "JDOM" appear in their name, without prior written permission
from the JDOM Project Management <request_AT_jdom_DOT_org>.
In addition, we request (but do not require) that you include in the
end-user documentation provided with the redistribution and/or in the
software itself an acknowledgement equivalent to the following:
"This product includes software developed by the
JDOM Project (http://www.jdom.org/)."
Alternatively, the acknowledgment may be graphical using the logos
available at http://www.jdom.org/images/logos.
THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
DISCLAIMED. IN NO EVENT SHALL THE JDOM AUTHORS OR THE PROJECT
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
SUCH DAMAGE.
This software consists of voluntary contributions made by many
individuals on behalf of the JDOM Project and was originally
created by Jason Hunter <jhunter_AT_jdom_DOT_org> and
Brett McLaughlin <brett_AT_jdom_DOT_org>. For more information
on the JDOM Project, please see <http://www.jdom.org/>.
*/
package org.jdom2.output;
import javax.xml.stream.XMLStreamReader;
import org.jdom2.Document;
import org.jdom2.output.support.AbstractStAXStreamReaderProcessor;
import org.jdom2.output.support.StAXStreamReaderProcessor;
/**
* Represents a JDOM document as a StAX XMLStreamReader that can be read from.
* <p>
* The StAXStreamReader can manage many styles of document formatting, from
* untouched to 'pretty' printed. The default is to output the document content
* exactly as created, but this can be changed by setting a new Format object:
* <ul>
* <li>For pretty-print output, use
* <code>{@link Format#getPrettyFormat()}</code>.
* <li>For whitespace-normalised output, use
* <code>{@link Format#getCompactFormat()}</code>.
* <li>For unmodified-format output, use
* <code>{@link Format#getRawFormat()}</code>.
* </ul>
* <p>
* There is only one <code>{@link #output output(Document)}</code> method that exposes
* a JDOM Document as a StAX Stream.
* <p>
* If changing the {@link Format} settings are insufficient for your output
* needs you can customise this StAXStreamReader further by setting a different
* {@link StAXStreamReaderProcessor} with the
* {@link #setStAXAsStreamProcessor(StAXStreamReaderProcessor)} method or an appropriate
* constructor. A fully-enabled Abstract class
* {@link AbstractStAXStreamReaderProcessor} is available to be further extended to
* your needs if all you want to do is tweak some details.
*
* @author Rolf Lear
* @since JDOM 2.1.0
*/
public final class StAXStreamReader implements Cloneable {
/*
* =====================================================================
* Static content.
* =====================================================================
*/
/**
* Create a final and static instance of the StAXStreamReaderProcessor The
* final part is important because it improves performance.
* <p>
* The JDOM user can change the actual XMLOutputProcessor with the
* {@link StAXStreamReader#setStAXAsStreamProcessor(StAXStreamReaderProcessor)} method.
*
* @author rolf
*/
private static final class DefaultStAXAsStreamProcessor extends AbstractStAXStreamReaderProcessor {
// do nothing different
}
/**
* This constant XMLOutputProcessor is used for all non-customised
* XMLOutputters
*/
private static final DefaultStAXAsStreamProcessor DEFAULTPROCESSOR =
new DefaultStAXAsStreamProcessor();
/*
* =====================================================================
* Instance content.
* =====================================================================
*/
// For normal output
private Format myFormat = null;
// The actual XMLOutputProcessor to delegate to.
private StAXStreamReaderProcessor myProcessor = null;
/*
* =====================================================================
* Constructors
* =====================================================================
*/
/**
* This will create an <code>XMLOutputter</code> with the specified format
* characteristics.
* <p>
* <b>Note:</b> the format object is cloned internally before use. If you
* want to modify the Format after constructing the XMLOutputter you can
* modify the Format instance {@link #getFormat()} returns.
*
* @param format
* The Format instance to use. This instance will be cloned() and as
* a consequence, changes made to the specified format instance
* <b>will not</b> be reflected in this XMLOutputter. A null input
* format indicates that XMLOutputter should use the default
* {@link Format#getRawFormat()}
* @param processor
* The XMLOutputProcessor to delegate output to. If null the
* XMLOutputter will use the default XMLOutputProcessor.
*/
public StAXStreamReader(Format format, StAXStreamReaderProcessor processor) {
myFormat = format == null ? Format.getRawFormat() : format.clone();
myProcessor = processor == null ? DEFAULTPROCESSOR : processor;
}
/**
* This will create an <code>XMLOutputter</code> with a default
* {@link Format} and {@link StAXStreamReaderProcessor}.
*/
public StAXStreamReader() {
this(null, null);
}
/**
* This will create an <code>XMLOutputter</code> with the same
* customisations set in the given <code>XMLOutputter</code> instance. Note
* that <code>XMLOutputter two = one.clone();</code> would work equally
* well.
*
* @param that
* the XMLOutputter to clone
*/
public StAXStreamReader(StAXStreamReader that) {
this(that.myFormat, null);
}
/**
* This will create an <code>XMLOutputter</code> with the specified format
* characteristics.
* <p>
* <b>Note:</b> the format object is cloned internally before use.
*
* @param format
* The Format instance to use. This instance will be cloned() and as
* a consequence, changes made to the specified format instance
* <b>will not</b> be reflected in this XMLOutputter. A null input
* format indicates that XMLOutputter should use the default
* {@link Format#getRawFormat()}
*/
public StAXStreamReader(Format format) {
this(format, null);
}
/**
* This will create an <code>XMLOutputter</code> with the specified
* XMLOutputProcessor.
*
* @param processor
* The XMLOutputProcessor to delegate output to. If null the
* XMLOutputter will use the default XMLOutputProcessor.
*/
public StAXStreamReader(StAXStreamReaderProcessor processor) {
this(null, processor);
}
/*
* =======================================================================
* API - Settings...
* =======================================================================
*/
/**
* Sets the new format logic for the XMLOutputter. Note the Format object is
* cloned internally before use.
*
* @see #getFormat()
* @param newFormat
* the format to use for subsequent output
*/
public void setFormat(Format newFormat) {
this.myFormat = newFormat.clone();
}
/**
* Returns the current format in use by the XMLOutputter. Note the Format
* object returned is <b>not</b> a clone of the one used internally, thus,
* an XMLOutputter instance is able to have its Format changed by changing
* the settings on the Format instance returned by this method.
*
* @return the current Format instance used by this XMLOutputter.
*/
public Format getFormat() {
return myFormat;
}
/**
* Returns the current XMLOutputProcessor instance in use by the
* StAXStreamReader.
*
* @return the current XMLOutputProcessor instance.
*/
public StAXStreamReaderProcessor getStAXAsStreamProcessor() {
return myProcessor;
}
/**
* Sets a new StAXStreamReaderProcessor instance for this StAXStreamReader. Note the
* processor object is expected to be thread-safe.
*
* @param processor
* the new XMLOutputProcesor to use for output
*/
public void setStAXAsStreamProcessor(StAXStreamReaderProcessor processor) {
this.myProcessor = processor;
}
/*
* =======================================================================
* API - Output to STREAM Methods ... All methods defer to the WRITER
* equivalents
* =======================================================================
*/
/**
* This will expose the <code>{@link Document}</code> as a StAX XMLStreamReader.
*
* @param doc
* <code>Document</code> to format.
* @return The XMLStreamReader representing the input Document.
* @throws NullPointerException
* if the specified content is null.
*/
public final XMLStreamReader output(Document doc) {
return myProcessor.buildReader(doc, myFormat.clone());
}
/*
* ========================================================================
* Basic Support methods.
* ========================================================================
*/
/**
* Returns a cloned copy of this XMLOutputter.
*/
@Override
public StAXStreamReader clone() {
// Implementation notes: Since all state of an XMLOutputter is
// embodied in simple private instance variables, Object.clone
// can be used. Note that since Object.clone is totally
// broken, we must catch an exception that will never be
// thrown.
try {
return (StAXStreamReader) super.clone();
} catch (java.lang.CloneNotSupportedException e) {
// even though this should never ever happen, it's still
// possible to fool Java into throwing a
// CloneNotSupportedException. If that happens, we
// shouldn't swallow it.
throw new RuntimeException("Unexpected CloneNotSupportedException", e);
}
}
/**
* Return a string listing of the settings for this XMLOutputter instance.
*
* @return a string listing the settings for this XMLOutputter instance
*/
@Override
public String toString() {
StringBuilder buffer = new StringBuilder();
buffer.append("StAXStreamReader[omitDeclaration = ");
buffer.append(myFormat.omitDeclaration);
buffer.append(", ");
buffer.append("encoding = ");
buffer.append(myFormat.encoding);
buffer.append(", ");
buffer.append("omitEncoding = ");
buffer.append(myFormat.omitEncoding);
buffer.append(", ");
buffer.append("indent = '");
buffer.append(myFormat.indent);
buffer.append("'");
buffer.append(", ");
buffer.append("expandEmptyElements = ");
buffer.append(myFormat.expandEmptyElements);
buffer.append(", ");
buffer.append("lineSeparator = '");
for (char ch : myFormat.lineSeparator.toCharArray()) {
switch (ch) {
case '\r':
buffer.append("\\r");
break;
case '\n':
buffer.append("\\n");
break;
case '\t':
buffer.append("\\t");
break;
default:
buffer.append("[" + ((int) ch) + "]");
break;
}
}
buffer.append("', ");
buffer.append("textMode = ");
buffer.append(myFormat.mode + "]");
return buffer.toString();
}
}