API Overview API Index Package Overview Direct link to this page
JDK 1.6
  javax.xml.stream. XMLStreamWriter View Javadoc
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
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
406
407
408
409
410
411
412
413
414
415
416
417
418
419
420
421
422
423
424
425
426
427
428
429
430
431
432
433
434
435
436
437
438
439
440
441
442
443
444
445
446
447
448
449
450
451
452
453
454
455
456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501

font color='#880088'>
package javax.xml.stream;

import javax.xml.namespace.NamespaceContext;

/**
 * The XMLStreamWriter interface specifies how to write XML.  The XMLStreamWriter  does
 * not perform well formedness checking on its input.  However
 * the writeCharacters method is required to escape & , < and >
 * For attribute values the writeAttribute method will escape the 
 * above characters plus " to ensure that all character content
 * and attribute values are well formed. 
 *
 * Each NAMESPACE 
 * and ATTRIBUTE must be individually written.
 *
 * <table border="1" cellpadding="2" cellspacing="0">
 *     <thead>
 *         <tr>
 *             <th colspan="5">XML Namespaces, <code>javax.xml.stream.isRepairingNamespaces</code> and write method behaviour</th>            
 *         </tr>
 *         <tr>
 *             <th>Method</th> <!-- method -->
 *             <th colspan="2"><code>isRepairingNamespaces</code> == true</th>
 *             <th colspan="2"><code>isRepairingNamespaces</code> == false</th>
 *         </tr>
 *         <tr>
 *             <th></th> <!-- method -->
 *             <th>namespaceURI bound</th>
 *             <th>namespaceURI unbound</th>
 *             <th>namespaceURI bound</th>
 *             <th>namespaceURI unbound</th>
 *         </tr>
 *     </thead>
 *     
 *     <tbody>
 *         <tr>
 *             <th><code>writeAttribute(namespaceURI, localName, value)</code></th>
 *             <!-- isRepairingNamespaces == true -->
 *             <td>
 *                 <!-- namespaceURI bound -->
 *                 prefix:localName="value"&nbsp;<sup>[1]</sup>
 *             </td>
 *             <td>
 *                 <!-- namespaceURI unbound -->
 *                 xmlns:{generated}="namespaceURI" {generated}:localName="value"
 *             </td>
 *             <!-- isRepairingNamespaces == false -->
 *             <td>
 *                 <!-- namespaceURI bound -->
 *                 prefix:localName="value"&nbsp;<sup>[1]</sup>
 *             </td>
 *             <td>
 *                 <!-- namespaceURI unbound -->
 *                 <code>XMLStreamException</code>
 *             </td>
 *         </tr>
 *         
 *         <tr>
 *             <th><code>writeAttribute(prefix, namespaceURI, localName, value)</code></th>
 *             <!-- isRepairingNamespaces == true -->
 *             <td>
 *                 <!-- namespaceURI bound -->
 *                 bound to same prefix:<br />
 *                 prefix:localName="value"&nbsp;<sup>[1]</sup><br />
 *                 <br />
 *                 bound to different prefix:<br />
 *                 xmlns:{generated}="namespaceURI" {generated}:localName="value"
 *             </td>
 *             <td>
 *                 <!-- namespaceURI unbound -->
 *                 xmlns:prefix="namespaceURI" prefix:localName="value"&nbsp;<sup>[3]</sup>
 *             </td>
 *             <!-- isRepairingNamespaces == false -->
 *             <td>
 *                 <!-- namespaceURI bound -->
 *                 bound to same prefix:<br />
 *                 prefix:localName="value"&nbsp;<sup>[1][2]</sup><br />
 *                 <br />
 *                 bound to different prefix:<br />
 *                 <code>XMLStreamException</code><sup>[2]</sup>
 *             </td>
 *             <td>
 *                 <!-- namespaceURI unbound -->
 *                 xmlns:prefix="namespaceURI" prefix:localName="value"&nbsp;<sup>[2][5]</sup>
 *             </td>
 *         </tr>
 *         
 *         <tr>
 *             <th><code>writeStartElement(namespaceURI, localName)</code><br />
 *                 <br />
 *                 <code>writeEmptyElement(namespaceURI, localName)</code></th>
 *             <!-- isRepairingNamespaces == true -->
 *             <td >
 *                 <!-- namespaceURI bound -->
 *                 &lt;prefix:localName&gt;&nbsp;<sup>[1]</sup>
 *             </td>
 *             <td>
 *                 <!-- namespaceURI unbound -->
 *                 &lt;{generated}:localName xmlns:{generated}="namespaceURI"&gt;
 *             </td>
 *             <!-- isRepairingNamespaces == false -->
 *             <td>
 *                 <!-- namespaceURI bound -->
 *                 &lt;prefix:localName&gt;&nbsp;<sup>[1]</sup>
 *             </td>
 *             <td>
 *                 <!-- namespaceURI unbound -->
 *                 <code>XMLStreamException</code>
 *             </td>
 *         </tr>
 *         
 *         <tr>
 *             <th><code>writeStartElement(prefix, localName, namespaceURI)</code><br />
 *                 <br />
 *                 <code>writeEmptyElement(prefix, localName, namespaceURI)</code></th>
 *             <!-- isRepairingNamespaces == true -->
 *             <td>
 *                 <!-- namespaceURI bound -->
 *                 bound to same prefix:<br />
 *                 &lt;prefix:localName&gt;&nbsp;<sup>[1]</sup><br />
 *                 <br />
 *                 bound to different prefix:<br />
 *                 &lt;{generated}:localName xmlns:{generated}="namespaceURI"&gt;
 *             </td>
 *             <td>
 *                 <!-- namespaceURI unbound -->
 *                 &lt;prefix:localName xmlns:prefix="namespaceURI"&gt;&nbsp;<sup>[4]</sup>
 *             </td>
 *             <!-- isRepairingNamespaces == false -->
 *             <td>
 *                 <!-- namespaceURI bound -->
 *                 bound to same prefix:<br />
 *                 &lt;prefix:localName&gt;&nbsp;<sup>[1]</sup><br />
 *                 <br />
 *                 bound to different prefix:<br />
 *                 <code>XMLStreamException</code>
 *             </td>
 *             <td>
 *                 <!-- namespaceURI unbound -->
 *                 &lt;prefix:localName&gt;&nbsp;
 *             </td>
 *         </tr>
 *     </tbody>
 *     <tfoot>
 *         <tr>
 *             <td colspan="5">
 *                 Notes:
 *                 <ul>
 *                     <li>[1] if namespaceURI == default Namespace URI, then no prefix is written</li>
 *                     <li>[2] if prefix == "" || null && namespaceURI == "", then no prefix or Namespace declaration is generated or written</li>
 *                     <li>[3] if prefix == "" || null, then a prefix is randomly generated</li>
 *                     <li>[4] if prefix == "" || null, then it is treated as the default Namespace and no prefix is generated or written, an xmlns declaration is generated and written if the namespaceURI is unbound</li>
 *                     <li>[5] if prefix == "" || null, then it is treated as an invalid attempt to define the default Namespace and an XMLStreamException is thrown</li>
 *                 </ul>
 *             </td>
 *         </tr>
 *     </tfoot>
 * </table>
 *
 * @version 1.0
 * @author Copyright (c) 2003 by BEA Systems. All Rights Reserved.
 * @see XMLOutputFactory
 * @see XMLStreamReader
 * @since 1.6
 */
public interface XMLStreamWriter {
  
  /**
   * Writes a start tag to the output.  All writeStartElement methods
   * open a new scope in the internal namespace context.  Writing the
   * corresponding EndElement causes the scope to be closed.
   * @param localName local name of the tag, may not be null
   * @throws XMLStreamException
   */
  public void writeStartElement(String localName) 
    throws XMLStreamException;

  /**
   * Writes a start tag to the output
   * @param namespaceURI the namespaceURI of the prefix to use, may not be null
   * @param localName local name of the tag, may not be null
   * @throws XMLStreamException if the namespace URI has not been bound to a prefix and
   * javax.xml.stream.isRepairingNamespaces has not been set to true
   */
  public void writeStartElement(String namespaceURI, String localName) 
    throws XMLStreamException;

  /**
   * Writes a start tag to the output
   * @param localName local name of the tag, may not be null
   * @param prefix the prefix of the tag, may not be null
   * @param namespaceURI the uri to bind the prefix to, may not be null
   * @throws XMLStreamException
   */
  public void writeStartElement(String prefix,
                                String localName,
                                String namespaceURI) 
    throws XMLStreamException;

  /**
   * Writes an empty element tag to the output
   * @param namespaceURI the uri to bind the tag to, may not be null
   * @param localName local name of the tag, may not be null
   * @throws XMLStreamException if the namespace URI has not been bound to a prefix and
   * javax.xml.stream.isRepairingNamespaces has not been set to true
   */
  public void writeEmptyElement(String namespaceURI, String localName) 
    throws XMLStreamException;

  /**
   * Writes an empty element tag to the output
   * @param prefix the prefix of the tag, may not be null
   * @param localName local name of the tag, may not be null
   * @param namespaceURI the uri to bind the tag to, may not be null
   * @throws XMLStreamException
   */
  public void writeEmptyElement(String prefix, String localName, String namespaceURI) 
    throws XMLStreamException;

  /**
   * Writes an empty element tag to the output
   * @param localName local name of the tag, may not be null
   * @throws XMLStreamException
   */
  public void writeEmptyElement(String localName) 
    throws XMLStreamException;

  /**
   * Writes string data to the output without checking for well formedness.
   * The data is opaque to the XMLStreamWriter, i.e. the characters are written
   * blindly to the underlying output.  If the method cannot be supported
   * in the currrent writing context the implementation may throw a
   * UnsupportedOperationException.  For example note that any 
   * namespace declarations, end tags, etc. will be ignored and could
   * interfere with proper maintanence of the writers internal state.
   * 
   * @param data the data to write
   */
  //  public void writeRaw(String data) throws XMLStreamException;

  /**
   * Writes an end tag to the output relying on the internal 
   * state of the writer to determine the prefix and local name
   * of the event.
   * @throws XMLStreamException 
   */
  public void writeEndElement() 
    throws XMLStreamException;

  /**
   * Closes any start tags and writes corresponding end tags.
   * @throws XMLStreamException 
   */
  public void writeEndDocument() 
    throws XMLStreamException;
 
  /**
   * Close this writer and free any resources associated with the 
   * writer.  This must not close the underlying output stream.
   * @throws XMLStreamException 
   */
  public void close() 
    throws XMLStreamException;

  /**
   * Write any cached data to the underlying output mechanism.
   * @throws XMLStreamException 
   */
  public void flush() 
    throws XMLStreamException;
  
  /**
   * Writes an attribute to the output stream without
   * a prefix.
   * @param localName the local name of the attribute
   * @param value the value of the attribute
   * @throws IllegalStateException if the current state does not allow Attribute writing
   * @throws XMLStreamException 
   */
  public void writeAttribute(String localName, String value) 
    throws XMLStreamException;

  /**
   * Writes an attribute to the output stream
   * @param prefix the prefix for this attribute
   * @param namespaceURI the uri of the prefix for this attribute
   * @param localName the local name of the attribute
   * @param value the value of the attribute
   * @throws IllegalStateException if the current state does not allow Attribute writing
   * @throws XMLStreamException if the namespace URI has not been bound to a prefix and
   * javax.xml.stream.isRepairingNamespaces has not been set to true
   */

  public void writeAttribute(String prefix,
                             String namespaceURI,
                             String localName,
                             String value) 
    throws XMLStreamException;

  /**
   * Writes an attribute to the output stream
   * @param namespaceURI the uri of the prefix for this attribute
   * @param localName the local name of the attribute
   * @param value the value of the attribute
   * @throws IllegalStateException if the current state does not allow Attribute writing
   * @throws XMLStreamException if the namespace URI has not been bound to a prefix and
   * javax.xml.stream.isRepairingNamespaces has not been set to true
   */
  public void writeAttribute(String namespaceURI,
                             String localName,
                             String value) 
    throws XMLStreamException;

  /**
   * Writes a namespace to the output stream
   * If the prefix argument to this method is the empty string,
   * "xmlns", or null this method will delegate to writeDefaultNamespace
   *
   * @param prefix the prefix to bind this namespace to
   * @param namespaceURI the uri to bind the prefix to
   * @throws IllegalStateException if the current state does not allow Namespace writing
   * @throws XMLStreamException 
   */
  public void writeNamespace(String prefix, String namespaceURI) 
    throws XMLStreamException;

  /**
   * Writes the default namespace to the stream
   * @param namespaceURI the uri to bind the default namespace to
   * @throws IllegalStateException if the current state does not allow Namespace writing
   * @throws XMLStreamException 
   */
  public void writeDefaultNamespace(String namespaceURI)
    throws XMLStreamException;

  /**
   * Writes an xml comment with the data enclosed
   * @param data the data contained in the comment, may be null
   * @throws XMLStreamException 
   */
  public void writeComment(String data) 
    throws XMLStreamException;

  /**
   * Writes a processing instruction
   * @param target the target of the processing instruction, may not be null
   * @throws XMLStreamException 
   */
  public void writeProcessingInstruction(String target) 
    throws XMLStreamException;

  /**
   * Writes a processing instruction
   * @param target the target of the processing instruction, may not be null
   * @param data the data contained in the processing instruction, may not be null
   * @throws XMLStreamException 
   */
  public void writeProcessingInstruction(String target,
                                         String data) 
    throws XMLStreamException;

  /**
   * Writes a CData section
   * @param data the data contained in the CData Section, may not be null
   * @throws XMLStreamException 
   */
  public void writeCData(String data) 
    throws XMLStreamException;

  /**
   * Write a DTD section.  This string represents the entire doctypedecl production
   * from the XML 1.0 specification.
   *
   * @param dtd the DTD to be written
   * @throws XMLStreamException 
   */
  public void writeDTD(String dtd) 
    throws XMLStreamException;

  /**
   * Writes an entity reference
   * @param name the name of the entity
   * @throws XMLStreamException 
   */
  public void writeEntityRef(String name) 
    throws XMLStreamException;

  /**
   * Write the XML Declaration. Defaults the XML version to 1.0, and the encoding to utf-8
   * @throws XMLStreamException 
   */
  public void writeStartDocument() 
    throws XMLStreamException;

  /**
   * Write the XML Declaration. Defaults the XML version to 1.0
   * @param version version of the xml document
   * @throws XMLStreamException 
   */
  public void writeStartDocument(String version) 
    throws XMLStreamException;

  /**
   * Write the XML Declaration.  Note that the encoding parameter does
   * not set the actual encoding of the underlying output.  That must 
   * be set when the instance of the XMLStreamWriter is created using the
   * XMLOutputFactory
   * @param encoding encoding of the xml declaration
   * @param version version of the xml document
   * @throws XMLStreamException If given encoding does not match encoding 
   * of the underlying stream
   */
  public void writeStartDocument(String encoding,
                                 String version) 
    throws XMLStreamException;

  /**
   * Write text to the output
   * @param text the value to write
   * @throws XMLStreamException 
   */
  public void writeCharacters(String text) 
    throws XMLStreamException;

  /**
   * Write text to the output
   * @param text the value to write
   * @param start the starting position in the array
   * @param len the number of characters to write
   * @throws XMLStreamException 
   */
  public void writeCharacters(char[] text, int start, int len) 
    throws XMLStreamException;

  /**
   * Gets the prefix the uri is bound to
   * @return the prefix or null
   * @throws XMLStreamException 
   */
  public String getPrefix(String uri) 
    throws XMLStreamException;

  /**
   * Sets the prefix the uri is bound to.  This prefix is bound
   * in the scope of the current START_ELEMENT / END_ELEMENT pair.
   * If this method is called before a START_ELEMENT has been written
   * the prefix is bound in the root scope.
   * @param prefix the prefix to bind to the uri, may not be null
   * @param uri the uri to bind to the prefix, may be null
   * @throws XMLStreamException 
   */
  public void setPrefix(String prefix, String uri) 
    throws XMLStreamException;


  /**
   * Binds a URI to the default namespace
   * This URI is bound
   * in the scope of the current START_ELEMENT / END_ELEMENT pair.
   * If this method is called before a START_ELEMENT has been written
   * the uri is bound in the root scope.
   * @param uri the uri to bind to the default namespace, may be null
   * @throws XMLStreamException 
   */
  public void setDefaultNamespace(String uri) 
    throws XMLStreamException;

  /**
   * Sets the current namespace context for prefix and uri bindings.
   * This context becomes the root namespace context for writing and
   * will replace the current root namespace context.  Subsequent calls
   * to setPrefix and setDefaultNamespace will bind namespaces using
   * the context passed to the method as the root context for resolving
   * namespaces.  This method may only be called once at the start of
   * the document.  It does not cause the namespaces to be declared.
   * If a namespace URI to prefix mapping is found in the namespace
   * context it is treated as declared and the prefix may be used
   * by the StreamWriter.
   * @param context the namespace context to use for this writer, may not be null
   * @throws XMLStreamException 
   */
  public void setNamespaceContext(NamespaceContext context)
    throws XMLStreamException;

  /**
   * Returns the current namespace context.  
   * @return the current NamespaceContext
   */
  public NamespaceContext getNamespaceContext();

  /**
   * Get the value of a feature/property from the underlying implementation
   * @param name The name of the property, may not be null
   * @return The value of the property
   * @throws IllegalArgumentException if the property is not supported
   * @throws NullPointerException if the name is null
   */
  public Object getProperty(java.lang.String name) throws IllegalArgumentException;

}

Generated By: JavaOnTracks Doclet 0.1.4     ©Thibaut Colar