public XMLWriter(Writer writer,
    String encoding) 
{
        this( writer, encoding, DumbEscapeHandler.theInstance );
}

 public XMLWriter(Writer writer,
    String encoding,
    CharacterEscapeHandler _escapeHandler) 
{
        init(writer,encoding);
        this.escapeHandler = _escapeHandler;
}

Create a new XML writer.

Write to the writer provided.

Parameters:

writer - The output destination, or null to use standard output.

encoding - If non-null string is specified, it is written as a part of the XML declaration.

 public  void characters(String data) throws SAXException 
{
        try {
            if (!startTagIsClosed) {
                write(' >");
                startTagIsClosed = true;
            }
            char ch[] = data.toCharArray();
            characters(ch, 0, ch.length);
        } catch( IOException e ) {
            throw new SAXException(e);
        }
}

Write a string of character data, with XML escaping.

This is a convenience method that takes an XML String, converts it to a character array, then invokes #characters(char[], int, int) .

 public  void characters(char[] ch,
    int start,
    int len) throws SAXException 
{
        try {
            if (!startTagIsClosed) {
                write(' >");
                startTagIsClosed = true;
            }
            if(inCDATA)
                output.write(ch,start,len);
            else
                writeEsc(ch, start, len, false);
            super.characters(ch, start, len);
        } catch( IOException e ) {
            throw new SAXException(e);
        }
}

Write character data. Pass the event on down the filter chain for further processing.

 public  void comment(char[] ch,
    int start,
    int length) throws SAXException 
{
        try {
            output.write("< !--");
            output.write(ch,start,length);
            output.write("-- >");
        } catch (IOException e) {
            throw new SAXException(e);
        }
}

 public  void dataElement(String localName,
    String content) throws SAXException 
{
        dataElement("", localName, "", EMPTY_ATTS, content);
}

Write an element with character data content but no attributes or Namespace URI.

This is a convenience method to write a complete element with character data content, including the start tag and end tag. The method provides an empty string for the Namespace URI, and empty string for the qualified name, and an empty attribute list.

This method invokes #startElement(String, String, String, Attributes) , followed by #characters(String) , followed by #endElement(String, String, String) .

 public  void dataElement(String uri,
    String localName,
    String content) throws SAXException 
{
        dataElement(uri, localName, "", EMPTY_ATTS, content);
}

Write an element with character data content but no attributes.

This is a convenience method to write a complete element with character data content, including the start tag and end tag. This method provides an empty string for the qname and an empty attribute list.

This method invokes #startElement(String, String, String, Attributes) , followed by #characters(String) , followed by #endElement(String, String, String) .

 public  void dataElement(String uri,
    String localName,
    String qName,
    Attributes atts,
    String content) throws SAXException 
{
        startElement(uri, localName, qName, atts);
        characters(content);
        endElement(uri, localName, qName);
}

Write an element with character data content.

This is a convenience method to write a complete element with character data content, including the start tag and end tag.

This method invokes #startElement(String, String, String, Attributes) , followed by #characters(String) , followed by #endElement(String, String, String) .

 public  void endCDATA() throws SAXException 
{
        try {
            inCDATA = false;
            write("]] >");
        } catch (IOException e) {
            throw new SAXException(e);
        }
}

 public  void endDTD() throws SAXException 
{

}

 public  void endDocument() throws SAXException 
{
        try {
            if (!startTagIsClosed) {
                write("/ >");
                startTagIsClosed = true;
            }
            write('\n");
            super.endDocument();
            try {
                flush();
            } catch (IOException e) {
                throw new SAXException(e);
            }
        } catch( IOException e ) {
            throw new SAXException(e);
        }
}

Write a newline at the end of the document. Pass the event on down the filter chain for further processing.

 public  void endElement(String localName) throws SAXException 
{
        endElement("", localName, "");
}

End an element without a Namespace URI or qname.

This method will supply an empty string for the qName and an empty string for the Namespace URI. It invokes #endElement(String, String, String) directly.

 public  void endElement(String uri,
    String localName) throws SAXException 
{
        endElement(uri, localName, "");
}

End an element without a qname.

This method will supply an empty string for the qName. It invokes #endElement(String, String, String) directly.

 public  void endElement(String uri,
    String localName,
    String qName) throws SAXException 
{
        try {
            if (startTagIsClosed) {
                write("< /");
                writeName(uri, localName, qName, true);
                write(' >");
            } else {
                write("/ >");
                startTagIsClosed = true;
            }
            if (elementLevel == 1) {
                write('\n");
            }
            super.endElement(uri, localName, qName);
//            nsSupport.popContext();
            elementLevel--;
        } catch( IOException e ) {
            throw new SAXException(e);
        }
}

Write an end tag. Pass the event on down the filter chain for further processing.

 public  void endEntity(String name) throws SAXException 
{

}

 public  void flush() throws IOException 
{
        output.flush();
}

Flush the output.

This method flushes the output stream. It is especially useful when you need to make certain that the entire document has been written to output but do not want to _commit the output stream.

This method is invoked automatically by the endDocument method after writing a document.

 public  void ignorableWhitespace(char[] ch,
    int start,
    int length) throws SAXException 
{
        try {
            writeEsc(ch, start, length, false);
            super.ignorableWhitespace(ch, start, length);
        } catch( IOException e ) {
            throw new SAXException(e);
        }
}

Write ignorable whitespace. Pass the event on down the filter chain for further processing.

 public  void processingInstruction(String target,
    String data) throws SAXException 
{
        try {
            if (!startTagIsClosed) {
                write(' >");
                startTagIsClosed = true;
            }
            write("< ?");
            write(target);
            write(' ");
            write(data);
            write("? >");
            if (elementLevel <  1) {
                write('\n");
            }
            super.processingInstruction(target, data);
        } catch( IOException e ) {
            throw new SAXException(e);
        }
}

Write a processing instruction. Pass the event on down the filter chain for further processing.

 public  void reset() 
{
        elementLevel = 0;
        startTagIsClosed = true;
}

Reset the writer.

This method is especially useful if the writer throws an exception before it is finished, and you want to reuse the writer for a new document. It is usually a good idea to invoke flush before resetting the writer, to make sure that no output is lost.

This method is invoked automatically by the startDocument method before writing a new document.

Note: this method will not clear the prefix or URI information in the writer or the selected output writer.

 public  void setEncoding(String encoding) 
{
        this.encoding = encoding;
}

 public  void setHeader(String _header) 
{
        this.header = _header;
}

Sets the header string. This string will be written right after the xml declaration without any escaping. Useful for generating a boiler-plate DOCTYPE decl, PIs, and comments.

 public  void setOutput(Writer writer,
    String _encoding) 
{
        if (writer == null) {
            output = new OutputStreamWriter(System.out);
        } else {
            output = writer;
        }
        encoding = _encoding;
}

Set a new output destination for the document.

 public  void setXmlDecl(boolean _writeXmlDecl) 
{
        this.writeXmlDecl = _writeXmlDecl;
}

Set whether the writer should print out the XML declaration (<?xml version='1.0' ... ?>).

This option is set to true by default.

 public  void startCDATA() throws SAXException 
{
        try {
            if (!startTagIsClosed) {
                write(' >");
                startTagIsClosed = true;
            }
            write("< ![CDATA[");
            inCDATA = true;
        } catch (IOException e) {
            new SAXException(e);
        }
}

 public  void startDTD(String name,
    String publicId,
    String systemId) throws SAXException 
{

}

 public  void startDocument() throws SAXException 
{
        try {
            reset();
            if(writeXmlDecl) {
                String e="";
                if(encoding!=null)
                    e = " encoding=\""+encoding+"\"";
                write("< ?xml version=\"1.0\""+e+" standalone=\"yes\"? >\n");
            }
            if(header!=null)
                write(header);
            super.startDocument();
        } catch( IOException e ) {
            throw new SAXException(e);
        }
}

Write the XML declaration at the beginning of the document. Pass the event on down the filter chain for further processing.

 public  void startElement(String localName) throws SAXException 
{
        startElement("", localName, "", EMPTY_ATTS);
}

Start a new element without a qname, attributes or a Namespace URI.

This method will provide an empty string for the Namespace URI, and empty string for the qualified name, and a default empty attribute list. It invokes #startElement(String, String, String, Attributes)} directly.

 public  void startElement(String uri,
    String localName) throws SAXException 
{
        startElement(uri, localName, "", EMPTY_ATTS);
}

Start a new element without a qname or attributes.

This method will provide a default empty attribute list and an empty string for the qualified name. It invokes #startElement(String, String, String, Attributes) directly.

 public  void startElement(String uri,
    String localName,
    String qName,
    Attributes atts) throws SAXException 
{
        try {
            if (!startTagIsClosed) {
                write(" >");
            }
            elementLevel++;
//            nsSupport.pushContext();
            write('< ");
            writeName(uri, localName, qName, true);
            writeAttributes(atts);
            // declare namespaces specified by the startPrefixMapping methods
            if(!locallyDeclaredPrefix.isEmpty()) {
                Iterator itr = locallyDeclaredPrefix.entrySet().iterator();
                while(itr.hasNext()) {
                    Map.Entry e = (Map.Entry)itr.next();
                    String p = (String)e.getKey();
                    String u = (String)e.getValue();
                    if (u == null) {
                        u = "";
                    }
                    write(' ");
                    if ("".equals(p)) {
                        write("xmlns=\"");
                    } else {
                        write("xmlns:");
                        write(p);
                        write("=\"");
                    }
                    char ch[] = u.toCharArray();
                    writeEsc(ch, 0, ch.length, true);
                    write('\"");
                }
                locallyDeclaredPrefix.clear();  // clear the contents
            }
//            if (elementLevel == 1) {
//                forceNSDecls();
//            }
//            writeNSDecls();
            super.startElement(uri, localName, qName, atts);
            startTagIsClosed = false;
        } catch( IOException e ) {
            throw new SAXException(e);
        }
}

Write a start tag. Pass the event on down the filter chain for further processing.

 public  void startEntity(String name) throws SAXException 
{

}

 public  void startPrefixMapping(String prefix,
    String uri) throws SAXException 
{
              
        locallyDeclaredPrefix.put(prefix,uri);
}