source: Ballon/out/artifacts/geisa_artifact/WEB-INF/lib/mysql-connector-java-5.1.21/src/com/mysql/jdbc/JDBC4MysqlSQLXML.java @ 848

/*
 Copyright (c) 2002, 2010, Oracle and/or its affiliates. All rights reserved.
 

  The MySQL Connector/J is licensed under the terms of the GPLv2
  <http://www.gnu.org/licenses/old-licenses/gpl-2.0.html>, like most MySQL Connectors.
  There are special exceptions to the terms and conditions of the GPLv2 as it is applied to
  this software, see the FLOSS License Exception
  <http://www.mysql.com/about/legal/licensing/foss-exception.html>.

  This program is free software; you can redistribute it and/or modify it under the terms
  of the GNU General Public License as published by the Free Software Foundation; version 2
  of the License.

  This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY;
  without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  See the GNU General Public License for more details.

  You should have received a copy of the GNU General Public License along with this
  program; if not, write to the Free Software Foundation, Inc., 51 Franklin St, Fifth
  Floor, Boston, MA 02110-1301  USA

 */

package com.mysql.jdbc;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.InputStream;
import java.io.IOException;
import java.io.OutputStream;
import java.io.Reader;
import java.io.StringReader;
import java.io.StringWriter;
import java.io.UnsupportedEncodingException;
import java.io.Writer;
import java.sql.SQLException;
import java.sql.SQLFeatureNotSupportedException;
import java.sql.SQLXML;

import javax.xml.transform.Transformer;
import javax.xml.transform.TransformerFactory;
import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;
import javax.xml.parsers.FactoryConfigurationError;
import javax.xml.parsers.ParserConfigurationException;
import javax.xml.parsers.SAXParser;
import javax.xml.parsers.SAXParserFactory;
import javax.xml.stream.XMLInputFactory;
import javax.xml.stream.XMLOutputFactory;
import javax.xml.stream.XMLStreamException;
import javax.xml.stream.XMLStreamReader;
import javax.xml.transform.Result;
import javax.xml.transform.Source;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.stax.StAXResult;
import javax.xml.transform.stax.StAXSource;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.stream.StreamSource;

import org.w3c.dom.DOMException;
import org.w3c.dom.Document;
import org.xml.sax.Attributes;
import org.xml.sax.InputSource;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.SAXException;



public class JDBC4MysqlSQLXML implements SQLXML {

        private XMLInputFactory inputFactory;

        private XMLOutputFactory outputFactory;

        private String stringRep;

        private ResultSetInternalMethods owningResultSet;

        private int columnIndexOfXml;

        private boolean fromResultSet;

        private boolean isClosed = false;

        private boolean workingWithResult;

        private DOMResult asDOMResult;

        private SAXResult asSAXResult;

        private SimpleSaxToReader saxToReaderConverter;

        private StringWriter asStringWriter;

        private ByteArrayOutputStream asByteArrayOutputStream;

        private ExceptionInterceptor exceptionInterceptor;
        
        protected JDBC4MysqlSQLXML(ResultSetInternalMethods owner, int index, ExceptionInterceptor exceptionInterceptor) {
                this.owningResultSet = owner;
                this.columnIndexOfXml = index;
                this.fromResultSet = true;
                this.exceptionInterceptor = exceptionInterceptor;
        }

        protected JDBC4MysqlSQLXML(ExceptionInterceptor exceptionInterceptor) {
                this.fromResultSet = false;
                this.exceptionInterceptor = exceptionInterceptor;
        }

        public synchronized void free() throws SQLException {
                this.stringRep = null;
                this.asDOMResult = null;
                this.asSAXResult = null;
                this.inputFactory = null;
                this.outputFactory = null;
                this.owningResultSet = null;
                this.workingWithResult = false;
                this.isClosed = true;

        }

        public synchronized String getString() throws SQLException {
                checkClosed();
                checkWorkingWithResult();

                if (this.fromResultSet) {
                        return this.owningResultSet.getString(this.columnIndexOfXml);
                }

                return this.stringRep;
        }

        private synchronized void checkClosed() throws SQLException {
                if (this.isClosed) {
                        throw SQLError
                                        .createSQLException("SQLXMLInstance has been free()d", this.exceptionInterceptor);
                }
        }

        private synchronized void checkWorkingWithResult() throws SQLException {
                if (this.workingWithResult) {
                        throw SQLError
                                        .createSQLException(
                                                        "Can't perform requested operation after getResult() has been called to write XML data",
                                                        SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
                }
        }

        /**
         * Sets the XML value designated by this SQLXML instance to the given String
         * representation. The format of this String is defined by
         * org.xml.sax.InputSource, where the characters in the stream represent the
         * unicode code points for XML according to section 2 and appendix B of the
         * XML 1.0 specification. Although an encoding declaration other than
         * unicode may be present, the encoding of the String is unicode. The
         * behavior of this method is the same as ResultSet.updateString() when the
         * designated column of the ResultSet has a type java.sql.Types of SQLXML.
         * <p>
         * The SQL XML object becomes not writeable when this method is called and
         * may also become not readable depending on implementation.
         * 
         * @param value
         *            the XML value
         * @throws SQLException
         *             if there is an error processing the XML value. The getCause()
         *             method of the exception may provide a more detailed
         *             exception, for example, if the stream does not contain valid
         *             characters. An exception is thrown if the state is not
         *             writable.
         * @exception SQLFeatureNotSupportedException
         *                if the JDBC driver does not support this method
         * @since 1.6
         */

        public synchronized void setString(String str) throws SQLException {
                checkClosed();
                checkWorkingWithResult();

                this.stringRep = str;
                this.fromResultSet = false;
        }

        public synchronized boolean isEmpty() throws SQLException {
                checkClosed();
                checkWorkingWithResult();

                if (!this.fromResultSet) {
                        return this.stringRep == null || this.stringRep.length() == 0;
                }

                return false;
        }

        public synchronized InputStream getBinaryStream() throws SQLException {
                checkClosed();
                checkWorkingWithResult();

                return this.owningResultSet.getBinaryStream(this.columnIndexOfXml);
        }

        /**
         * Retrieves the XML value designated by this SQLXML instance as a
         * java.io.Reader object. The format of this stream is defined by
         * org.xml.sax.InputSource, where the characters in the stream represent the
         * unicode code points for XML according to section 2 and appendix B of the
         * XML 1.0 specification. Although an encoding declaration other than
         * unicode may be present, the encoding of the stream is unicode. The
         * behavior of this method is the same as ResultSet.getCharacterStream()
         * when the designated column of the ResultSet has a type java.sql.Types of
         * SQLXML.
         * <p>
         * The SQL XML object becomes not readable when this method is called and
         * may also become not writable depending on implementation.
         * 
         * @return a stream containing the XML data.
         * @throws SQLException
         *             if there is an error processing the XML value. The getCause()
         *             method of the exception may provide a more detailed
         *             exception, for example, if the stream does not contain valid
         *             characters. An exception is thrown if the state is not
         *             readable.
         * @exception SQLFeatureNotSupportedException
         *                if the JDBC driver does not support this method
         * @since 1.6
         */
        public synchronized Reader getCharacterStream() throws SQLException {
                checkClosed();
                checkWorkingWithResult();

                return this.owningResultSet.getCharacterStream(this.columnIndexOfXml);
        }

        /**
         * Returns a Source for reading the XML value designated by this SQLXML
         * instance. Sources are used as inputs to XML parsers and XSLT
         * transformers.
         * <p>
         * Sources for XML parsers will have namespace processing on by default. The
         * systemID of the Source is implementation dependent.
         * <p>
         * The SQL XML object becomes not readable when this method is called and
         * may also become not writable depending on implementation.
         * <p>
         * Note that SAX is a callback architecture, so a returned SAXSource should
         * then be set with a content handler that will receive the SAX events from
         * parsing. The content handler will receive callbacks based on the contents
         * of the XML.
         * 
         * <pre>
         * SAXSource saxSource = sqlxml.getSource(SAXSource.class);
         * XMLReader xmlReader = saxSource.getXMLReader();
         * xmlReader.setContentHandler(myHandler);
         * xmlReader.parse(saxSource.getInputSource());
         * </pre>
         * 
         * @param sourceClass
         *            The class of the source, or null. If the class is null, a
         *            vendor specifc Source implementation will be returned. The
         *            following classes are supported at a minimum:
         * 
         * (MySQL returns a SAXSource if sourceClass == null)
         * 
         * <pre>
         *    javax.xml.transform.dom.DOMSource - returns a DOMSource
         *    javax.xml.transform.sax.SAXSource - returns a SAXSource
         *    javax.xml.transform.stax.StAXSource - returns a StAXSource
         *    javax.xml.transform.stream.StreamSource - returns a StreamSource
         * </pre>
         * 
         * @return a Source for reading the XML value.
         * @throws SQLException
         *             if there is an error processing the XML value or if this
         *             feature is not supported. The getCause() method of the
         *             exception may provide a more detailed exception, for example,
         *             if an XML parser exception occurs. An exception is thrown if
         *             the state is not readable.
         * @exception SQLFeatureNotSupportedException
         *                if the JDBC driver does not support this method
         * @since 1.6
         */
        public synchronized Source getSource(Class clazz) throws SQLException {
                checkClosed();
                checkWorkingWithResult();

                // Note that we try and use streams here wherever possible
                // for the day that the server actually supports streaming
                // from server -> client (futureproofing)

                if (clazz == null || clazz.equals(SAXSource.class)) {

                        InputSource inputSource = null;

                        if (this.fromResultSet) {
                                inputSource = new InputSource(this.owningResultSet
                                                .getCharacterStream(this.columnIndexOfXml));
                        } else {
                                inputSource = new InputSource(new StringReader(this.stringRep));
                        }

                        return new SAXSource(inputSource);
                } else if (clazz.equals(DOMSource.class)) {
                        try {
                                DocumentBuilderFactory builderFactory = DocumentBuilderFactory
                                                .newInstance();
                                builderFactory.setNamespaceAware(true);
                                DocumentBuilder builder = builderFactory.newDocumentBuilder();

                                InputSource inputSource = null;

                                if (this.fromResultSet) {
                                        inputSource = new InputSource(this.owningResultSet
                                                        .getCharacterStream(this.columnIndexOfXml));
                                } else {
                                        inputSource = new InputSource(new StringReader(
                                                        this.stringRep));
                                }

                                return new DOMSource(builder.parse(inputSource));
                        } catch (Throwable t) {
                                SQLException sqlEx = SQLError.createSQLException(t
                                                .getMessage(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
                                sqlEx.initCause(t);
                                
                                throw sqlEx;
                        }

                } else if (clazz.equals(StreamSource.class)) {
                        Reader reader = null;

                        if (this.fromResultSet) {
                                reader = this.owningResultSet
                                                .getCharacterStream(this.columnIndexOfXml);
                        } else {
                                reader = new StringReader(this.stringRep);
                        }

                        return new StreamSource(reader);
                } else if (clazz.equals(StAXSource.class)) {
                        try {
                                Reader reader = null;

                                if (this.fromResultSet) {
                                        reader = this.owningResultSet
                                                        .getCharacterStream(this.columnIndexOfXml);
                                } else {
                                        reader = new StringReader(this.stringRep);
                                }

                                return new StAXSource(this.inputFactory
                                                .createXMLStreamReader(reader));
                        } catch (XMLStreamException ex) {
                                SQLException sqlEx = SQLError.createSQLException(ex
                                                .getMessage(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
                                sqlEx.initCause(ex);
                                
                                throw sqlEx;
                        }
                } else {
                        throw SQLError.createSQLException("XML Source of type \""
                                        + clazz.toString() + "\" Not supported.",
                                        SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
                }
        }

        /**
         * Retrieves a stream that can be used to write the XML value that this
         * SQLXML instance represents. The stream begins at position 0. The bytes of
         * the stream are interpreted according to appendix F of the XML 1.0
         * specification The behavior of this method is the same as
         * ResultSet.updateBinaryStream() when the designated column of the
         * ResultSet has a type java.sql.Types of SQLXML.
         * <p>
         * The SQL XML object becomes not writeable when this method is called and
         * may also become not readable depending on implementation.
         * 
         * @return a stream to which data can be written.
         * @throws SQLException
         *             if there is an error processing the XML value. An exception
         *             is thrown if the state is not writable.
         * @exception SQLFeatureNotSupportedException
         *                if the JDBC driver does not support this method
         * @since 1.6
         */
        public synchronized OutputStream setBinaryStream() throws SQLException {
                checkClosed();
                checkWorkingWithResult();

                this.workingWithResult = true;

                return setBinaryStreamInternal();
        }

        private synchronized OutputStream setBinaryStreamInternal()
                        throws SQLException {
                this.asByteArrayOutputStream = new ByteArrayOutputStream();

                return this.asByteArrayOutputStream;
        }

        /**
         * Retrieves a stream to be used to write the XML value that this SQLXML
         * instance represents. The format of this stream is defined by
         * org.xml.sax.InputSource, where the characters in the stream represent the
         * unicode code points for XML according to section 2 and appendix B of the
         * XML 1.0 specification. Although an encoding declaration other than
         * unicode may be present, the encoding of the stream is unicode. The
         * behavior of this method is the same as ResultSet.updateCharacterStream()
         * when the designated column of the ResultSet has a type java.sql.Types of
         * SQLXML.
         * <p>
         * The SQL XML object becomes not writeable when this method is called and
         * may also become not readable depending on implementation.
         * 
         * @return a stream to which data can be written.
         * @throws SQLException
         *             if there is an error processing the XML value. The getCause()
         *             method of the exception may provide a more detailed
         *             exception, for example, if the stream does not contain valid
         *             characters. An exception is thrown if the state is not
         *             writable.
         * @exception SQLFeatureNotSupportedException
         *                if the JDBC driver does not support this method
         * @since 1.6
         */
        public synchronized Writer setCharacterStream() throws SQLException {
                checkClosed();
                checkWorkingWithResult();

                this.workingWithResult = true;

                return setCharacterStreamInternal();
        }

        private synchronized Writer setCharacterStreamInternal()
                        throws SQLException {
                this.asStringWriter = new StringWriter();

                return this.asStringWriter;
        }

        /**
         * Returns a Result for setting the XML value designated by this SQLXML
         * instance.
         * <p>
         * The systemID of the Result is implementation dependent.
         * <p>
         * The SQL XML object becomes not writeable when this method is called and
         * may also become not readable depending on implementation.
         * <p>
         * Note that SAX is a callback architecture and the returned SAXResult has a
         * content handler assigned that will receive the SAX events based on the
         * contents of the XML. Call the content handler with the contents of the
         * XML document to assign the values.
         * 
         * <pre>
         * SAXResult saxResult = sqlxml.setResult(SAXResult.class);
         * ContentHandler contentHandler = saxResult.getXMLReader().getContentHandler();
         * contentHandler.startDocument();
         * // set the XML elements and attributes into the result
         * contentHandler.endDocument();
         * </pre>
         * 
         * @param resultClass
         *            The class of the result, or null. If resultClass is null, a
         *            vendor specific Result implementation will be returned. The
         *            following classes are supported at a minimum:
         * 
         * <pre>
         *    javax.xml.transform.dom.DOMResult - returns a DOMResult
         *    javax.xml.transform.sax.SAXResult - returns a SAXResult
         *    javax.xml.transform.stax.StAXResult - returns a StAXResult
         *    javax.xml.transform.stream.StreamResult - returns a StreamResult
         * </pre>
         * 
         * @return Returns a Result for setting the XML value.
         * @throws SQLException
         *             if there is an error processing the XML value or if this
         *             feature is not supported. The getCause() method of the
         *             exception may provide a more detailed exception, for example,
         *             if an XML parser exception occurs. An exception is thrown if
         *             the state is not writable.
         * @exception SQLFeatureNotSupportedException
         *                if the JDBC driver does not support this method
         * @since 1.6
         */
        public synchronized Result setResult(Class clazz) throws SQLException {
                checkClosed();
                checkWorkingWithResult();

                this.workingWithResult = true;
                this.asDOMResult = null;
                this.asSAXResult = null;
                this.saxToReaderConverter = null;
                this.stringRep = null;
                this.asStringWriter = null;
                this.asByteArrayOutputStream = null;

                if (clazz == null || clazz.equals(SAXResult.class)) {
                        this.saxToReaderConverter = new SimpleSaxToReader();

                        this.asSAXResult = new SAXResult(this.saxToReaderConverter);

                        return this.asSAXResult;
                } else if (clazz.equals(DOMResult.class)) {

                        this.asDOMResult = new DOMResult();
                        return this.asDOMResult;

                } else if (clazz.equals(StreamResult.class)) {
                        return new StreamResult(setCharacterStreamInternal());
                } else if (clazz.equals(StAXResult.class)) {
                        try {
                                if (this.outputFactory == null) {
                                        this.outputFactory = XMLOutputFactory.newInstance();
                                }

                                return new StAXResult(this.outputFactory
                                                .createXMLEventWriter(setCharacterStreamInternal()));
                        } catch (XMLStreamException ex) {
                                SQLException sqlEx = SQLError.createSQLException(ex
                                                .getMessage(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
                                sqlEx.initCause(ex);
                                
                                throw sqlEx;
                        }
                } else {
                        throw SQLError.createSQLException("XML Result of type \""
                                        + clazz.toString() + "\" Not supported.",
                                        SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
                }
        }

        private Reader binaryInputStreamStreamToReader(ByteArrayOutputStream out) {

                try {
                        // There's got to be an easier way to do this, but
                        // I don't feel like coding up Appendix F of the XML Spec
                        // myself, when there's a reusable way to do it, and we
                        // can warn folks away from BINARY xml streams that have
                        // to be parsed to determine the character encoding :P

                        String encoding = "UTF-8";

                        try {
                                ByteArrayInputStream bIn = new ByteArrayInputStream(out
                                                .toByteArray());
                                XMLStreamReader reader = this.inputFactory
                                                .createXMLStreamReader(bIn);

                                int eventType = 0;

                                while ((eventType = reader.next()) != XMLStreamReader.END_DOCUMENT) {
                                        if (eventType == XMLStreamReader.START_DOCUMENT) {
                                                String possibleEncoding = reader.getEncoding();

                                                if (possibleEncoding != null) {
                                                        encoding = possibleEncoding;
                                                }

                                                break;
                                        }
                                }
                        } catch (Throwable t) {
                                // ignore, dealt with later when the string can't be parsed
                                // into valid XML
                        }

                        return new StringReader(new String(out.toByteArray(), encoding));
                } catch (UnsupportedEncodingException badEnc) {
                        throw new RuntimeException(badEnc);
                }
        }

        protected String readerToString(Reader reader) throws SQLException {
                StringBuffer buf = new StringBuffer();
                
                int charsRead = 0;
                
                char[] charBuf = new char[512];
                
                try {
                        while ((charsRead = reader.read(charBuf)) != -1) {
                                buf.append(charBuf, 0, charsRead);
                        }
                } catch (IOException ioEx) {
                        SQLException sqlEx = SQLError.createSQLException(ioEx
                                        .getMessage(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
                        sqlEx.initCause(ioEx);
                        
                        throw sqlEx;
                }
                
                return buf.toString();
        }
        
        protected synchronized Reader serializeAsCharacterStream()
                        throws SQLException {
                checkClosed();
                if (this.workingWithResult) {
                        // figure out what kind of result
                        if (this.stringRep != null) {
                                return new StringReader(this.stringRep);
                        }

                        if (this.asDOMResult != null) {
                                return new StringReader(domSourceToString());
                        }

                        if (this.asStringWriter != null) { // stax result
                                return new StringReader(this.asStringWriter.toString());
                        }
                        
                        if (this.asSAXResult != null) {
                                return this.saxToReaderConverter.toReader();
                        }

                        if (this.asByteArrayOutputStream != null) {
                                return binaryInputStreamStreamToReader(this.asByteArrayOutputStream);
                        }
                }

                return this.owningResultSet.getCharacterStream(this.columnIndexOfXml);
        }

        protected String domSourceToString() throws SQLException {
                try {
                        DOMSource source = new DOMSource(this.asDOMResult.getNode());
                        Transformer identity = TransformerFactory.newInstance()
                                        .newTransformer();
                        StringWriter stringOut = new StringWriter();
                        Result result = new StreamResult(stringOut);
                        identity.transform(source, result);
        
                        return stringOut.toString();
                } catch (Throwable t) {
                        SQLException sqlEx = SQLError.createSQLException(t
                                        .getMessage(), SQLError.SQL_STATE_ILLEGAL_ARGUMENT, this.exceptionInterceptor);
                        sqlEx.initCause(t);
                        
                        throw sqlEx;
                }
        }
        
        protected synchronized String serializeAsString() throws SQLException {
                checkClosed();
                if (this.workingWithResult) {
                        // figure out what kind of result
                        if (this.stringRep != null) {
                                return this.stringRep;
                        }

                        if (this.asDOMResult != null) {
                                return domSourceToString();
                        }
                        
                        if (this.asStringWriter != null) { // stax result
                                return this.asStringWriter.toString();
                        }
                        
                        if (this.asSAXResult != null) {
                                return readerToString(this.saxToReaderConverter.toReader());
                        }

                        if (this.asByteArrayOutputStream != null) {
                                return readerToString(
                                                binaryInputStreamStreamToReader(this.asByteArrayOutputStream));
                        }
                }

                return this.owningResultSet.getString(this.columnIndexOfXml);
        }

        /*
         * The SimpleSaxToReader class is an adaptation of the SAX "Writer"
         * example from the Apache XercesJ-2 Project. The license for this
         * code is as follows:
         *
         * Licensed to the Apache Software Foundation (ASF) under one or more
         * contributor license agreements.  See the NOTICE file distributed with
         * this work for additional information regarding copyright ownership.
         * The ASF licenses this file to You under the Apache License, Version 2.0
         * (the "License"); you may not use this file except in compliance with
         * the License.  You may obtain a copy of the License at
         * 
         *      http://www.apache.org/licenses/LICENSE-2.0
         * 
         * Unless required by applicable law or agreed to in writing, software
         * distributed under the License is distributed on an "AS IS" BASIS,
         * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
         * See the License for the specific language governing permissions and
         * limitations under the License.
         */

        class SimpleSaxToReader extends DefaultHandler {
                StringBuffer buf = new StringBuffer();

                public void startDocument() throws SAXException {
                        buf.append("<?xml version='1.0' encoding='UTF-8'?>");
                }

                public void endDocument() throws SAXException {
                        // Do we need to override this?
                }

                public void startElement(String namespaceURI, String sName,
                                String qName, Attributes attrs) throws SAXException {

                        this.buf.append("<");
                        this.buf.append(qName);

                        if (attrs != null) {
                                for (int i = 0; i < attrs.getLength(); i++) {
                                        this.buf.append(" ");
                                        this.buf.append(attrs.getQName(i)).append("=\"");
                                        escapeCharsForXml(attrs.getValue(i), true);
                                        this.buf.append("\"");
                                }
                        }

                        this.buf.append(">");
                }

                public void characters(char buf[], int offset, int len)
                                throws SAXException {
                        if (!this.inCDATA) {
                                escapeCharsForXml(buf, offset, len, false);
                        } else {
                                this.buf.append(buf, offset, len);
                        }
                }

                public void ignorableWhitespace(char ch[], int start, int length)
                                throws SAXException {
                        characters(ch, start, length);
                }

                private boolean inCDATA = false;

                public void startCDATA() throws SAXException {
                        this.buf.append("<![CDATA[");
                        this.inCDATA = true;
                }

                public void endCDATA() throws SAXException {
                        this.inCDATA = false;
                        this.buf.append("]]>");
                }

                public void comment(char ch[], int start, int length)
                                throws SAXException {
                        // if (!fCanonical && fElementDepth > 0) {
                        this.buf.append("<!--");
                        for (int i = 0; i < length; ++i) {
                                this.buf.append(ch[start + i]);
                        }
                        this.buf.append("-->");
                        // }
                }

                Reader toReader() {
                        return new StringReader(this.buf.toString());
                }

                private void escapeCharsForXml(String str, boolean isAttributeData) {
                        if (str == null) {
                                return;
                        }

                        int strLen = str.length();

                        for (int i = 0; i < strLen; i++) {
                                escapeCharsForXml(str.charAt(i), isAttributeData);
                        }
                }

                private void escapeCharsForXml(char[] buf, int offset, int len,
                                boolean isAttributeData) {

                        if (buf == null) {
                                return;
                        }

                        for (int i = 0; i < len; i++) {
                                escapeCharsForXml(buf[offset + i], isAttributeData);
                        }
                }

                private void escapeCharsForXml(char c, boolean isAttributeData) {
                        switch (c) {
                        case '<': 
                                this.buf.append("&lt;");
                                break;
                        
                        case '>': 
                                this.buf.append("&gt;");
                                break;
                        
                        case '&':
                                this.buf.append("&amp;");
                                break;
                        
                        case '"': 

                                if (!isAttributeData) {
                                        this.buf.append("\"");
                                }
                                else {
                                        this.buf.append("&quot;");
                                }

                                break;
                
                        case '\r': 
                                this.buf.append("&#xD;");
                                break;
                        

                        default: 

                                if (((c >= 0x01 && c <= 0x1F && c != 0x09 && c != 0x0A) 
                                                || (c >= 0x7F && c <= 0x9F) || c == 0x2028)
                                                || isAttributeData && (c == 0x09 || c == 0x0A)) {
                                        this.buf.append("&#x");
                                        this.buf.append(Integer.toHexString(c).toUpperCase());
                                        this.buf.append(";");
                                }
                                else {
                                        this.buf.append(c);
                                }                       
                        }
                }
        }
}