All Downloads are FREE. Search and download functionalities are using the official Maven repository.

javolution.xml.internal.stream.XMLStreamWriterImpl Maven / Gradle / Ivy

Go to download

Only the Java Core part of Javolution library, with slight modifications for use in MSFTBX.

There is a newer version: 6.11.8
Show newest version
/*
 * Javolution - Java(TM) Solution for Real-Time and Embedded Systems
 * Copyright (C) 2012 - Javolution (http://javolution.org/)
 * All rights reserved.
 * 
 * Permission to use, copy, modify, and distribute this software is
 * freely granted, provided that this notice is preserved.
 */
package javolution.xml.internal.stream;

import java.io.IOException;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;

import javolution.io.UTF8StreamWriter;
import javolution.lang.Realtime;
import javolution.text.CharArray;
import javolution.text.TextBuilder;
import javolution.xml.stream.XMLOutputFactory;
import javolution.xml.stream.XMLStreamException;
import javolution.xml.stream.XMLStreamWriter;

/**
 * 

This class represents an implementation of {@link XMLStreamWriter}.

* *

The writeCharacters methods will escape & , < and * >. For attribute values, the writeAttribute methods will * escape the above characters plus " and control characters.

* * @author Jean-Marie Dautelle * @version 4.0, September 4, 2006 */ @Realtime public final class XMLStreamWriterImpl implements XMLStreamWriter { /** * Holds the length of intermediate buffer. */ private static final int BUFFER_LENGTH = 2048; /** * Holds the current nesting level. */ private int _nesting = 0; /** * Holds the element qualified name (indexed per nesting level) */ private TextBuilder[] _qNames = new TextBuilder[16]; /** * Indicates if the current element is open. */ private boolean _isElementOpen; /** * Indicates if the current element is an empty element. */ private boolean _isEmptyElement; /** * Holds intermediate buffer. */ private final char[] _buffer = new char[BUFFER_LENGTH]; /** * Holds the namespace stack. */ private final NamespacesImpl _namespaces = new NamespacesImpl(); /** * Holds the buffer current index. */ private int _index; /** * Holds repairing namespace property. */ private boolean _isRepairingNamespaces; /** * Holds repairing prefix property. */ private String _repairingPrefix = "ns"; /** * Holds indentation property. */ private String _indentation; /** * Holds line separator property. */ private String _lineSeparator = "\n"; /** * Holds current indentation level. */ private int _indentationLevel; /** * Holds automatic empty elements property. */ private boolean _automaticEmptyElements; /** * Holds no empty element tag property. */ private boolean _noEmptyElementTag; /** * Holds counter for automatic namespace generation. */ private int _autoNSCount; /** * Indicates if the current object written is an attribute value. */ private boolean _isAttributeValue; //////////////////////// // Temporary Settings // //////////////////////// /** * Holds the writer destination (null when unused). */ private Writer _writer; /** * Holds the encoding (null if N/A). */ private String _encoding; /** * Holds the default writer for output streams. */ private final UTF8StreamWriter _utf8StreamWriter = new UTF8StreamWriter(); /** * Holds the factory (if any) */ private final XMLOutputFactoryImpl _factory; /** * Default constructor. */ public XMLStreamWriterImpl() { this(null); } /** * Factory-based constructor. */ XMLStreamWriterImpl(XMLOutputFactoryImpl factory) { _factory = factory; for (int i = 0; i < _qNames.length;) { _qNames[i++] = new TextBuilder(); } } /** * Sets the output stream destination for this XML stream writer * (UTF-8 encoding). * * @param out the output source with utf-8 encoding. */ public void setOutput(OutputStream out) throws XMLStreamException { _utf8StreamWriter.setOutput(out); _encoding = "UTF-8"; setOutput(_utf8StreamWriter); } /** * Sets the output stream destination and encoding for this XML stream * writer. * * @param out the output source. * @param encoding the associated encoding. * @throws XMLStreamException if the specified encoding is not supported. */ public void setOutput(OutputStream out, String encoding) throws XMLStreamException { if (encoding.equals("UTF-8") || encoding.equals("utf-8") || encoding.equals("ASCII")) { setOutput(out); // Default encoding. } else { try { _encoding = encoding; setOutput(new OutputStreamWriter(out, encoding)); } catch (UnsupportedEncodingException e) { throw new XMLStreamException(e); } } } /** * Sets the writer output destination for this XML stream writer. * * @param writer the output destination writer. * @see javolution.io.UTF8StreamWriter * @see javolution.io.UTF8ByteBufferWriter * @see javolution.io.AppendableWriter */ public void setOutput(Writer writer) throws XMLStreamException { if (_writer != null) throw new IllegalStateException("Writer not closed or reset"); _writer = writer; } /** * Requires this writer to create a new prefix when a namespace has none * (default false). * * @param isRepairingNamespaces true if namespaces * are repaired; false otherwise. */ public void setRepairingNamespaces(boolean isRepairingNamespaces) { _isRepairingNamespaces = isRepairingNamespaces; } /** * Specifies the prefix to be append by a trailing part * (a sequence number) in order to make it unique to be usable as * a temporary non-colliding prefix when repairing namespaces * (default "ns"). * * @param repairingPrefix the prefix root. */ public void setRepairingPrefix(String repairingPrefix) { _repairingPrefix = repairingPrefix; } /** * Specifies the indentation string; non-null indentation * forces the writer to write elements into separate lines * (default null). * * @param indentation the indentation string. */ public void setIndentation(String indentation) { _indentation = indentation; } /** * Specifies the line separator (default "\n"). * * @param lineSeparator the line separator string. */ public void setLineSeparator(String lineSeparator) { _lineSeparator = lineSeparator; } /** * Requires this writer to automatically output empty elements when a * start element is immediately followed by matching end element * (default false). * * @param automaticEmptyElements true if start element * immediately followed by end element results in an empty element * beign written; false otherwise. */ public void setAutomaticEmptyElements(boolean automaticEmptyElements) { _automaticEmptyElements = automaticEmptyElements; } /** * Prevent this writer from using empty element tags * (default false). * * @param noEmptyElementTag true if empty element tags * are replaced by start/end elements with no content; * false otherwise. */ public void setNoEmptyElementTag(boolean noEmptyElementTag) { _noEmptyElementTag = noEmptyElementTag; } // Implements reusable. public void reset() { _automaticEmptyElements = false; _autoNSCount = 0; _encoding = null; _indentation = null; _indentationLevel = 0; _index = 0; _isAttributeValue = false; _isElementOpen = false; _isEmptyElement = false; _isRepairingNamespaces = false; _namespaces.reset(); _nesting = 0; _noEmptyElementTag = false; _repairingPrefix = "ns"; _utf8StreamWriter.reset(); _writer = null; if (_factory != null) _factory.recycle(this); } // Implements XMLStreamWriter interface. public void writeStartElement(CharSequence localName) throws XMLStreamException { if (localName == null) throw new XMLStreamException("Local name cannot be null"); writeNewElement(null, localName, null); } // Implements XMLStreamWriter interface. public void writeStartElement(CharSequence namespaceURI, CharSequence localName) throws XMLStreamException { if (localName == null) throw new XMLStreamException("Local name cannot be null"); if (namespaceURI == null) throw new XMLStreamException("Namespace URI cannot be null"); writeNewElement(null, localName, namespaceURI); } // Implements XMLStreamWriter interface. public void writeStartElement(CharSequence prefix, CharSequence localName, CharSequence namespaceURI) throws XMLStreamException { if (localName == null) throw new XMLStreamException("Local name cannot be null"); if (namespaceURI == null) throw new XMLStreamException("Namespace URI cannot be null"); if (prefix == null) throw new XMLStreamException("Prefix cannot be null"); writeNewElement(prefix, localName, namespaceURI); } // Implements XMLStreamWriter interface. public void writeEmptyElement(CharSequence localName) throws XMLStreamException { writeStartElement(localName); _isEmptyElement = true; } // Implements XMLStreamWriter interface. public void writeEmptyElement(CharSequence namespaceURI, CharSequence localName) throws XMLStreamException { writeStartElement(namespaceURI, localName); _isEmptyElement = true; } // Implements XMLStreamWriter interface. public void writeEmptyElement(CharSequence prefix, CharSequence localName, CharSequence namespaceURI) throws XMLStreamException { writeStartElement(prefix, localName, namespaceURI); _isEmptyElement = true; } // Implements XMLStreamWriter interface. public void writeEndElement() throws XMLStreamException { if (_isElementOpen) { // Empty element. if (_isEmptyElement) { // Closes the empty element tag. closeOpenTag(); } else { // Start element open. if (_automaticEmptyElements) { // Do as if empty element written. _isEmptyElement = true; closeOpenTag(); return; } else { // Closes the start element tag. closeOpenTag(); } } } if ((_indentation != null) && (_indentationLevel != _nesting - 1)) { // Do not indent if no change in indentation level // to avoid interfering with text only elements. writeNoEscape(_lineSeparator); for (int i = 1; i < _nesting; i++) { writeNoEscape(_indentation); } } write('<'); write('/'); writeNoEscape(_qNames[_nesting--]); write('>'); _namespaces.pop(); } // Implements XMLStreamWriter interface. public void writeEndDocument() throws XMLStreamException { if (_isElementOpen) closeOpenTag(); while (_nesting > 0) { // Implicits closing of all elements. writeEndElement(); } flush(); // Not mandatory but safer. } // Implements XMLStreamWriter interface. public void close() throws XMLStreamException { if (_writer != null) { if (_nesting != 0) { // Closes all elements. writeEndDocument(); } flush(); } reset(); // Explicit reset. } // Implements XMLStreamWriter interface. public void flush() throws XMLStreamException { flushBuffer(); try { _writer.flush(); } catch (IOException e) { throw new XMLStreamException(e); } } // Implements XMLStreamWriter interface. public void writeAttribute(CharSequence localName, CharSequence value) throws XMLStreamException { if (localName == null) throw new XMLStreamException("Local name cannot be null"); if (value == null) throw new XMLStreamException("Value cannot be null"); writeAttributeOrNamespace(null, null, localName, value); } // Implements XMLStreamWriter interface. public void writeAttribute(CharSequence namespaceURI, CharSequence localName, CharSequence value) throws XMLStreamException { if (localName == null) throw new XMLStreamException("Local name cannot be null"); if (value == null) throw new XMLStreamException("Value cannot be null"); if (namespaceURI == null) throw new XMLStreamException("Namespace URI cannot be null"); writeAttributeOrNamespace(null, namespaceURI, localName, value); } // Implements XMLStreamWriter interface. public void writeAttribute(CharSequence prefix, CharSequence namespaceURI, CharSequence localName, CharSequence value) throws XMLStreamException { if (localName == null) throw new XMLStreamException("Local name cannot be null"); if (value == null) throw new XMLStreamException("Value cannot be null"); if (namespaceURI == null) throw new XMLStreamException("Namespace URI cannot be null"); if (prefix == null) throw new XMLStreamException("Prefix cannot be null"); writeAttributeOrNamespace(prefix, namespaceURI, localName, value); } // Implements XMLStreamWriter interface. public void writeNamespace(CharSequence prefix, CharSequence namespaceURI) throws XMLStreamException { if ((prefix == null) || (prefix.length() == 0) || _namespaces._xmlns.equals(prefix)) { prefix = _namespaces._defaultNsPrefix; } if (!_isElementOpen) // Check now as the actual writting is queued. throw new IllegalStateException("No open start element"); _namespaces.setPrefix(prefix, (namespaceURI == null) ? _namespaces._nullNsURI : namespaceURI, true); } // Implements XMLStreamWriter interface. public void writeDefaultNamespace(CharSequence namespaceURI) throws XMLStreamException { writeNamespace(_namespaces._defaultNsPrefix, namespaceURI); } // Implements XMLStreamWriter interface. public void writeComment(CharSequence data) throws XMLStreamException { if (_isElementOpen) closeOpenTag(); writeNoEscape(""); } // Implements XMLStreamWriter interface. public void writeProcessingInstruction(CharSequence target) throws XMLStreamException { writeProcessingInstruction(target, _noChar); } private final CharArray _noChar = new CharArray(""); // Implements XMLStreamWriter interface. public void writeProcessingInstruction(CharSequence target, CharSequence data) throws XMLStreamException { if (target == null) throw new XMLStreamException("Target cannot be null"); if (data == null) throw new XMLStreamException("Data cannot be null"); if (_isElementOpen) closeOpenTag(); writeNoEscape(""); } // Implements XMLStreamWriter interface. public void writeCData(CharSequence data) throws XMLStreamException { if (data == null) throw new XMLStreamException("Data cannot be null"); if (_isElementOpen) closeOpenTag(); writeNoEscape(""); } // Implements XMLStreamWriter interface. public void writeDTD(CharSequence dtd) throws XMLStreamException { if (dtd == null) throw new XMLStreamException("DTD cannot be null"); if (_nesting > 0) throw new XMLStreamException( "DOCTYPE declaration (DTD) when not in document root (prolog)"); writeNoEscape(dtd); } // Implements XMLStreamWriter interface. public void writeEntityRef(CharSequence name) throws XMLStreamException { write('&'); writeNoEscape(name); write(';'); } // Implements XMLStreamWriter interface. public void writeStartDocument() throws XMLStreamException { writeStartDocument(null, null); } // Implements XMLStreamWriter interface. public void writeStartDocument(CharSequence version) throws XMLStreamException { writeStartDocument(null, version); } // Implements XMLStreamWriter interface. public void writeStartDocument(CharSequence encoding, CharSequence version) throws XMLStreamException{ writeStartDocument(encoding, version, null); } public void writeStartDocument(CharSequence encoding, CharSequence version, Boolean standAlone) throws XMLStreamException { if (_nesting > 0) throw new XMLStreamException("Not in document root"); writeNoEscape(""); } // Implements XMLStreamWriter interface. public void writeCharacters(CharSequence text) throws XMLStreamException { if (_isElementOpen) closeOpenTag(); if (text == null) return; writeEscape(text); } // Implements XMLStreamWriter interface. public void writeCharacters(char[] text, int start, int length) throws XMLStreamException { _tmpCharArray.setArray(text, start, length); writeCharacters(_tmpCharArray); } private final CharArray _tmpCharArray = new CharArray(); // Implements XMLStreamWriter interface. public CharSequence getPrefix(CharSequence uri) throws XMLStreamException { return _namespaces.getPrefix(uri); } // Implements XMLStreamWriter interface. public void setPrefix(CharSequence prefix, CharSequence uri) throws XMLStreamException { _namespaces.setPrefix(prefix, (uri == null) ? _namespaces._nullNsURI : uri, false); } // Implements XMLStreamWriter interface. public void setDefaultNamespace(CharSequence uri) throws XMLStreamException { setPrefix(_namespaces._defaultNsPrefix, uri); } // Implements XMLStreamWriter interface. public Object getProperty(String name) throws IllegalArgumentException { if (name.equals(XMLOutputFactory.IS_REPAIRING_NAMESPACES)) { return new Boolean(_isRepairingNamespaces); } else if (name.equals(XMLOutputFactory.REPAIRING_PREFIX)) { return _repairingPrefix; } else if (name.equals(XMLOutputFactory.AUTOMATIC_EMPTY_ELEMENTS)) { return new Boolean(_automaticEmptyElements); } else if (name.equals(XMLOutputFactory.NO_EMPTY_ELEMENT_TAG)) { return new Boolean(_noEmptyElementTag); } else if (name.equals(XMLOutputFactory.INDENTATION)) { return _indentation; } else if (name.equals(XMLOutputFactory.LINE_SEPARATOR)) { return _lineSeparator; } else { throw new IllegalArgumentException("Property: " + name + " not supported"); } } // Writes a new start or empty element. private void writeNewElement(CharSequence prefix, CharSequence localName, CharSequence namespaceURI) throws XMLStreamException { // Close any open element and gets ready to write a new one. if (_isElementOpen) closeOpenTag(); if (_indentation != null) { writeNoEscape(_lineSeparator); _indentationLevel = _nesting; for (int i = 0; i < _indentationLevel; i++) { writeNoEscape(_indentation); } } write('<'); _isElementOpen = true; // Enters a new local scope. if (++_nesting >= _qNames.length) resizeElemStack(); _namespaces.push(); // Constructs qName. TextBuilder qName = _qNames[_nesting].clear(); // Writes prefix if any. if ((namespaceURI != null) && (!_namespaces._defaultNamespace.equals(namespaceURI))) { if (_isRepairingNamespaces) { // Repairs prefix. prefix = getRepairedPrefix(prefix, namespaceURI); } else if (prefix == null) { // Retrieves prefix. prefix = getPrefix(namespaceURI); if (prefix == null) throw new XMLStreamException("URI: " + namespaceURI + " not bound and repairing namespaces disabled"); } if (prefix.length() > 0) { qName.append(prefix); qName.append(':'); } } qName.append(localName); writeNoEscape(qName); } // Writes a new attribute. private void writeAttributeOrNamespace(CharSequence prefix, CharSequence namespaceURI, CharSequence localName, CharSequence value) throws XMLStreamException { if (!_isElementOpen) throw new IllegalStateException("No open start element"); write(' '); // Writes prefix if any. if ((namespaceURI != null) && (!_namespaces._defaultNamespace.equals(namespaceURI))) { if (_isRepairingNamespaces) { // Repairs prefix if current prefix is not correct. prefix = getRepairedPrefix(prefix, namespaceURI); } else if (prefix == null) { prefix = getPrefix(namespaceURI); if (prefix == null) throw new XMLStreamException("URI: " + namespaceURI + " not bound and repairing namespaces disabled"); } if (prefix.length() > 0) { writeNoEscape(prefix); write(':'); } } writeNoEscape(localName); write('='); write('"'); _isAttributeValue = true; writeEscape(value); _isAttributeValue = false; write('"'); } // Closes the current element (scope if empty element). private void closeOpenTag() throws XMLStreamException { // Writes namespaces now. writeNamespaces(); // Closes the tag. _isElementOpen = false; if (_isEmptyElement) { if (_noEmptyElementTag) { write('<'); write('/'); writeNoEscape(_qNames[_nesting]); write('>'); } else { // Use empty element tag. write('/'); write('>'); } _nesting--; _namespaces.pop(); _isEmptyElement = false; } else { write('>'); } } // Writes all namespaces, these include namespaces set but // not written in outer scope. private void writeNamespaces() throws XMLStreamException { int i0 = (_nesting > 1) ? _namespaces._namespacesCount[_nesting - 2] : NamespacesImpl.NBR_PREDEFINED_NAMESPACES; int i1 = _namespaces._namespacesCount[_nesting - 1]; int i2 = _namespaces._namespacesCount[_nesting]; for (int i = i0; i < i2; i++) { if (((_isRepairingNamespaces && (i < i1) && !_namespaces._prefixesWritten[i])) || ((i >= i1) && _namespaces._prefixesWritten[i])) { // Write namespace. // In repairing mode, removes redondancy. if (_isRepairingNamespaces) { CharArray prefix = _namespaces.getPrefix( _namespaces._namespaces[i], i); if (_namespaces._prefixes[i].equals(prefix)) continue; // Not necessary. } // Direct mode, just write them as requested (no check). // Writes namespace. if (_namespaces._prefixes[i].length() == 0) { // Default namespace. writeAttributeOrNamespace(null, null, _namespaces._xmlns, _namespaces._namespaces[i]); } else { writeAttributeOrNamespace(_namespaces._xmlns, _namespaces._xmlnsURI, _namespaces._prefixes[i], _namespaces._namespaces[i]); } } } } // Returns the prefix for the specified namespace. private CharSequence getRepairedPrefix(CharSequence prefix, CharSequence namespaceURI) throws XMLStreamException { CharArray prefixForURI = _namespaces.getPrefix(namespaceURI); if ((prefixForURI != null) && ((prefix == null) || prefixForURI.equals(prefix))) return prefixForURI; // No repair needed. if ((prefix == null) || (prefix.length() == 0)) { // Creates new prefix. prefix = _autoPrefix.clear().append(_repairingPrefix) .append(_autoNSCount++); } _namespaces.setPrefix(prefix, namespaceURI, true); // Map to namespace URI. return prefix; } private final TextBuilder _autoPrefix = new TextBuilder(); // Resizes element stack (same memory area as the writer). private void resizeElemStack() { final int oldLength = _qNames.length; final int newLength = oldLength * 2; // Resizes elements qNames stack. TextBuilder[] tmp = new TextBuilder[newLength]; System.arraycopy(_qNames, 0, tmp, 0, oldLength); _qNames = tmp; for (int i = oldLength; i < newLength; i++) { _qNames[i] = new TextBuilder(); } } // Writes methods. // private final void writeNoEscape(String str) throws XMLStreamException { write(str, 0, str.length(), false); } private final void writeNoEscape(TextBuilder tb) throws XMLStreamException { write(tb, 0, tb.length(), false); } private final void writeNoEscape(CharSequence csq) throws XMLStreamException { write(csq, 0, csq.length(), false); } private final void writeEscape(CharSequence csq) throws XMLStreamException { write(csq, 0, csq.length(), true); } private final void write(Object csq, int start, int length, boolean escapeMarkup) throws XMLStreamException { if (_index + length <= BUFFER_LENGTH) { // Enough buffer space. if (csq instanceof String) { ((String) csq).getChars(start, start + length, _buffer, _index); } else if (csq instanceof javolution.text.Text) { ((javolution.text.Text) csq).getChars(start, start + length, _buffer, _index); } else if (csq instanceof javolution.text.TextBuilder) { ((javolution.text.TextBuilder) csq).getChars(start, start + length, _buffer, _index); } else if (csq instanceof javolution.text.CharArray) { ((javolution.text.CharArray) csq).getChars(start, start + length, _buffer, _index); } else { getChars((CharSequence) csq, start, start + length, _buffer, _index); } if (escapeMarkup) { int end = _index + length; for (int i = _index; i < end; i++) { char c = _buffer[i]; if ((c >= '?') || !isEscaped(c)) continue; // Found character to escape. _index = i; flushBuffer(); writeDirectEscapedCharacters(_buffer, i, end); return; // Done (buffer is empty). } } _index += length; } else { // Not enough remaining space. if (length <= BUFFER_LENGTH) { // Enough space if buffer emptied. flushBuffer(); write(csq, start, length, escapeMarkup); } else { int half = length >> 1; write(csq, start, half, escapeMarkup); write(csq, start + half, length - half, escapeMarkup); } } } private static void getChars(CharSequence csq, int start, int end, char dest[], int destPos) { for (int i = start, j = destPos; i < end;) { dest[j++] = csq.charAt(i++); } } // The buffer must have been flushed prior to calling this method. private final void writeDirectEscapedCharacters(char[] chars, int start, int end) throws XMLStreamException { try { int blockStart = start; for (int i = start; i < end;) { char c = chars[i++]; if ((c >= '?') || !isEscaped(c)) continue; // Flush already read characters (excluding escaped one). int blockLength = i - blockStart - 1; if (blockLength > 0) { _writer.write(_buffer, blockStart, blockLength); } blockStart = i; switch (c) { case '<': _writer.write("<"); break; case '>': _writer.write(">"); break; case '\'': _writer.write("'"); break; case '"': _writer.write("""); break; case '&': _writer.write("&"); break; default: _writer.write("&#"); _writer.write((char) ('0' + c / 10)); _writer.write((char) ('0' + c % 10)); _writer.write(';'); } } // Flush the current block. int blockLength = end - blockStart; if (blockLength > 0) { _writer.write(_buffer, blockStart, blockLength); } } catch (IOException e) { throw new XMLStreamException(e); } } private boolean isEscaped(char c) { return ((c < ' ') && _isAttributeValue) || (c == '"' && _isAttributeValue) || (c == '<') || (c == '>') || (c == '&'); } private final void write(char c) throws XMLStreamException { if (_index == BUFFER_LENGTH) { flushBuffer(); } _buffer[_index++] = c; } private void flushBuffer() throws XMLStreamException { try { _writer.write(_buffer, 0, _index); } catch (IOException e) { throw new XMLStreamException(e); } finally { _index = 0; } } }




© 2015 - 2024 Weber Informatics LLC | Privacy Policy