/***
* ASM XML Adapter
* Copyright (c) 2004, Eugene Kuleshov
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. Neither the name of the copyright holders nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
* THE POSSIBILITY OF SUCH DAMAGE.
*/
package org.objectweb.asm.xml;
import java.io.BufferedOutputStream;
import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.OutputStreamWriter;
import java.io.Writer;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import java.util.zip.ZipOutputStream;
import javax.xml.transform.Source;
import javax.xml.transform.Templates;
import javax.xml.transform.TransformerConfigurationException;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactory;
import javax.xml.transform.sax.SAXResult;
import javax.xml.transform.sax.SAXSource;
import javax.xml.transform.sax.SAXTransformerFactory;
import javax.xml.transform.sax.TransformerHandler;
import javax.xml.transform.stream.StreamSource;
import org.objectweb.asm.ClassReader;
import org.xml.sax.Attributes;
import org.xml.sax.ContentHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.XMLReader;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.helpers.AttributesImpl;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.XMLReaderFactory;
/**
* Processor is a command line tool that can be used for bytecode waving
* directed by XSL transformation. <p> In order to use a concrete XSLT engine,
* system property <tt>javax.xml.transform.TransformerFactory</tt> must be set
* to one of the following values.
*
* <blockquote> <table border="1" cellspacing="0" cellpadding="3"> <tr> <td>jd.xslt</td>
* <td>jd.xml.xslt.trax.TransformerFactoryImpl</td> </tr>
*
* <tr> <td>Saxon</td> <td>net.sf.saxon.TransformerFactoryImpl</td> </tr>
*
* <tr> <td>Caucho</td> <td>com.caucho.xsl.Xsl</td> </tr>
*
* <tr> <td>Xalan interpeter</td> <td>org.apache.xalan.processor.TransformerFactory</td>
* </tr>
*
* <tr> <td>Xalan xsltc</td> <td>org.apache.xalan.xsltc.trax.TransformerFactoryImpl</td>
* </tr> </table> </blockquote>
*
* @author Eugene Kuleshov
*/
public class Processor {
public static final int BYTECODE = 1;
public static final int MULTI_XML = 2;
public static final int SINGLE_XML = 3;
private static final String SINGLE_XML_NAME = "classes.xml";
private int inRepresentation;
private int outRepresentation;
private InputStream input = null;
private OutputStream output = null;
private Source xslt = null;
private boolean computeMax;
private int n = 0;
public Processor(
int inRepresenation,
int outRepresentation,
InputStream input,
OutputStream output,
Source xslt)
{
this.inRepresentation = inRepresenation;
this.outRepresentation = outRepresentation;
this.input = input;
this.output = output;
this.xslt = xslt;
this.computeMax = true;
}
public int process() throws TransformerException, IOException, SAXException
{
ZipInputStream zis = new ZipInputStream(input);
final ZipOutputStream zos = new ZipOutputStream(output);
final OutputStreamWriter osw = new OutputStreamWriter(zos);
Thread.currentThread()
.setContextClassLoader(getClass().getClassLoader());
TransformerFactory tf = TransformerFactory.newInstance();
if (!tf.getFeature(SAXSource.FEATURE)
|| !tf.getFeature(SAXResult.FEATURE))
return 0;
SAXTransformerFactory saxtf = (SAXTransformerFactory) tf;
Templates templates = null;
if (xslt != null) {
templates = saxtf.newTemplates(xslt);
}
// configuring outHandlerFactory
// ///////////////////////////////////////////////////////
EntryElement entryElement = getEntryElement(zos);
ContentHandler outDocHandler = null;
switch (outRepresentation) {
case BYTECODE:
outDocHandler = new OutputSlicingHandler(new ASMContentHandlerFactory(zos,
computeMax),
entryElement,
false);
break;
case MULTI_XML:
outDocHandler = new OutputSlicingHandler(new SAXWriterFactory(osw,
true),
entryElement,
true);
break;
case SINGLE_XML:
ZipEntry outputEntry = new ZipEntry(SINGLE_XML_NAME);
zos.putNextEntry(outputEntry);
outDocHandler = new SAXWriter(osw, false);
break;
}
// configuring inputDocHandlerFactory
// /////////////////////////////////////////////////
ContentHandler inDocHandler = null;
if (templates == null) {
inDocHandler = outDocHandler;
} else {
inDocHandler = new InputSlicingHandler("class",
outDocHandler,
new TransformerHandlerFactory(saxtf,
templates,
outDocHandler));
}
ContentHandlerFactory inDocHandlerFactory = new SubdocumentHandlerFactory(inDocHandler);
if (inDocHandler != null && inRepresentation != SINGLE_XML) {
inDocHandler.startDocument();
inDocHandler.startElement("",
"classes",
"classes",
new AttributesImpl());
}
int i = 0;
ZipEntry ze = null;
while ((ze = zis.getNextEntry()) != null) {
update(ze.getName(), n++);
if (isClassEntry(ze)) {
processEntry(zis, ze, inDocHandlerFactory);
} else {
OutputStream os = entryElement.openEntry(getName(ze));
copyEntry(zis, os);
entryElement.closeEntry();
}
i++;
}
if (inDocHandler != null && inRepresentation != SINGLE_XML) {
inDocHandler.endElement("", "classes", "classes");
inDocHandler.endDocument();
}
if (outRepresentation == SINGLE_XML) {
zos.closeEntry();
}
zos.flush();
zos.close();
return i;
}
private void copyEntry(InputStream is, OutputStream os) throws IOException {
if (outRepresentation == SINGLE_XML)
return;
byte[] buff = new byte[2048];
int i;
while ((i = is.read(buff)) != -1) {
os.write(buff, 0, i);
}
}
private boolean isClassEntry(ZipEntry ze) {
String name = ze.getName();
return inRepresentation == SINGLE_XML && name.equals(SINGLE_XML_NAME)
|| name.endsWith(".class") || name.endsWith(".class.xml");
}
private void processEntry(
final ZipInputStream zis,
ZipEntry ze,
ContentHandlerFactory handlerFactory)
{
ContentHandler handler = handlerFactory.createContentHandler();
try {
// if (CODE2ASM.equals(command)) { // read bytecode and process it
// // with TraceClassVisitor
// ClassReader cr = new ClassReader(readEntry(zis, ze));
// cr.accept(new TraceClassVisitor(null, new PrintWriter(os)),
// false);
// }
boolean singleInputDocument = inRepresentation == SINGLE_XML;
if (inRepresentation == BYTECODE) { // read bytecode and process it
// with handler
ClassReader cr = new ClassReader(readEntry(zis, ze));
cr.accept(new SAXClassAdapter(handler, singleInputDocument),
false);
} else { // read XML and process it with handler
XMLReader reader = XMLReaderFactory.createXMLReader();
reader.setContentHandler(handler);
reader.parse(new InputSource(singleInputDocument
? (InputStream) new ProtectedInputStream(zis)
: new ByteArrayInputStream(readEntry(zis, ze))));
}
} catch (Exception ex) {
update(ze.getName(), 0);
update(ex, 0);
}
}
private EntryElement getEntryElement(ZipOutputStream zos) {
if (outRepresentation == SINGLE_XML) {
return new SingleDocElement(zos);
}
return new ZipEntryElement(zos);
}
// private ContentHandlerFactory getHandlerFactory(
// OutputStream os,
// SAXTransformerFactory saxtf,
// Templates templates)
// {
// ContentHandlerFactory factory = null;
// if (templates == null) {
// if (outputRepresentation == BYTECODE) { // factory used to write
// // bytecode
// factory = new ASMContentHandlerFactory(os, computeMax);
// } else { // factory used to write XML
// factory = new SAXWriterFactory(os, true);
// }
// } else {
// if (outputRepresentation == BYTECODE) { // factory used to transform
// // and then write bytecode
// factory = new ASMTransformerHandlerFactory(saxtf,
// templates,
// os,
// computeMax);
// } else { // factory used to transformand then write XML
// factory = new TransformerHandlerFactory(saxtf,
// templates,
// os,
// outputRepresentation == SINGLE_XML);
// }
// }
// return factory;
// }
private String getName(ZipEntry ze) {
String name = ze.getName();
if (isClassEntry(ze)) {
if (inRepresentation != BYTECODE && outRepresentation == BYTECODE) {
name = name.substring(0, name.length() - 4); // .class.xml to
// .class
} else if (inRepresentation == BYTECODE
&& outRepresentation != BYTECODE)
{
name = name.concat(".xml"); // .class to .class.xml
}
// } else if( CODE2ASM.equals( command)) {
// name = name.substring( 0, name.length()-6).concat( ".asm");
}
return name;
}
private byte[] readEntry(ZipInputStream zis, ZipEntry ze)
throws IOException
{
long size = ze.getSize();
if (size > -1) {
byte[] buff = new byte[(int) size];
int k = 0;
int n;
while(( n = zis.read(buff, k, buff.length-k)) > 0) {
k += n;
}
return buff;
}
ByteArrayOutputStream bos = new ByteArrayOutputStream();
byte[] buff = new byte[4096];
int i;
while ((i = zis.read(buff)) != -1) {
bos.write(buff, 0, i);
}
return bos.toByteArray();
}
/*
* (non-Javadoc)
*
* @see java.util.Observer#update(java.util.Observable, java.lang.Object)
*/
protected void update(Object arg, int n) {
if (arg instanceof Throwable) {
((Throwable) arg).printStackTrace();
} else {
if ((n % 100) == 0) {
System.err.println(n + " " + arg);
}
}
}
public static void main(String[] args) throws Exception {
if (args.length < 2) {
showUsage();
return;
}
int inRepresentation = getRepresentation(args[0]);
int outRepresentation = getRepresentation(args[1]);
InputStream is = System.in;
OutputStream os = new BufferedOutputStream(System.out);
Source xslt = null;
// boolean computeMax = true;
for (int i = 2; i < args.length; i++) {
if ("-in".equals(args[i])) {
is = new FileInputStream(args[++i]);
} else if ("-out".equals(args[i])) {
os = new BufferedOutputStream(new FileOutputStream(args[++i]));
} else if ("-xslt".equals(args[i])) {
xslt = new StreamSource(new FileInputStream(args[++i]));
// } else if( "-computemax".equals( args[ i].toLowerCase())) {
// computeMax = true;
} else {
showUsage();
return;
}
}
if (inRepresentation == 0 || outRepresentation == 0) {
showUsage();
return;
}
Processor m = new Processor(inRepresentation,
outRepresentation,
is,
os,
xslt);
long l1 = System.currentTimeMillis();
int n = m.process();
long l2 = System.currentTimeMillis();
System.err.println(n);
System.err.println("" + (l2 - l1) + "ms " + (1000f * n / (l2 - l1))
+ " resources/sec");
}
private static int getRepresentation(String s) {
if ("code".equals(s)) {
return BYTECODE;
} else if ("xml".equals(s)) {
return MULTI_XML;
} else if ("singlexml".equals(s)) {
return SINGLE_XML;
}
return 0;
}
private static void showUsage() {
System.err.println("Usage: Main <in format> <out format> [-in <input jar>] [-out <output jar>] [-xslt <xslt file>]");
System.err.println(" when -in or -out is omitted sysin and sysout would be used");
System.err.println(" <in format> and <out format> - code | xml | singlexml");
}
/**
* IputStream wrapper class used to protect input streams from being closed
* by some stupid XML parsers.
*/
private static final class ProtectedInputStream extends InputStream {
private final InputStream is;
private ProtectedInputStream(InputStream is) {
super();
this.is = is;
}
public final void close() throws IOException {
}
public final int read() throws IOException {
return is.read();
}
public final int read(byte[] b, int off, int len) throws IOException {
return is.read(b, off, len);
}
public final int available() throws IOException {
return is.available();
}
}
/**
* A {@link ContentHandlerFactory ContentHandlerFactory} is used to create
* {@link org.xml.sax.ContentHandler ContentHandler} instances for concrete
* context.
*/
private static interface ContentHandlerFactory {
/**
* Creates an instance of the content handler.
*
* @return content handler
*/
ContentHandler createContentHandler();
}
/**
* SAXWriterFactory
*/
private static final class SAXWriterFactory implements
ContentHandlerFactory
{
private Writer w;
private boolean optimizeEmptyElements;
public SAXWriterFactory(Writer w, boolean optimizeEmptyElements) {
this.w = w;
this.optimizeEmptyElements = optimizeEmptyElements;
}
public final ContentHandler createContentHandler() {
return new SAXWriter(w, optimizeEmptyElements);
}
}
/**
* ASMContentHandlerFactory
*/
private static final class ASMContentHandlerFactory implements
ContentHandlerFactory
{
private OutputStream os;
private boolean computeMax;
public ASMContentHandlerFactory(OutputStream os, boolean computeMax) {
this.os = os;
this.computeMax = computeMax;
}
public final ContentHandler createContentHandler() {
return new ASMContentHandler(os, computeMax);
}
}
/**
* TransformerHandlerFactory
*/
private static final class TransformerHandlerFactory implements
ContentHandlerFactory
{
private SAXTransformerFactory saxtf;
private Templates templates;
private ContentHandler outputHandler;
public TransformerHandlerFactory(
SAXTransformerFactory saxtf,
Templates templates,
ContentHandler outputHandler)
{
this.saxtf = saxtf;
this.templates = templates;
this.outputHandler = outputHandler;
}
public final ContentHandler createContentHandler() {
try {
TransformerHandler handler = saxtf.newTransformerHandler(templates);
handler.setResult(new SAXResult(outputHandler));
return handler;
} catch (TransformerConfigurationException ex) {
throw new RuntimeException(ex.toString());
}
}
}
/**
* SubdocumentHandlerFactory
*/
private final static class SubdocumentHandlerFactory implements
ContentHandlerFactory
{
private ContentHandler subdocumentHandler;
public SubdocumentHandlerFactory(ContentHandler subdocumentHandler) {
this.subdocumentHandler = subdocumentHandler;
}
public final ContentHandler createContentHandler() {
return subdocumentHandler;
}
}
/**
* A {@link org.xml.sax.ContentHandler ContentHandler} and
* {@link org.xml.sax.ext.LexicalHandler LexicalHandler} that serializes XML
* from SAX 2.0 events into {@link java.io.Writer Writer}.
*
* <i><blockquote> This implementation does not support namespaces, entity
* definitions (uncluding DTD), CDATA and text elements. </blockquote></i>
*/
private final static class SAXWriter extends DefaultHandler implements
LexicalHandler
{
private static final char[] OFF = " ".toCharArray();
private Writer w;
private boolean optimizeEmptyElements;
private boolean openElement = false;
private int ident = 0;
/**
* Creates <code>SAXWriter</code>.
*
* @param w writer
* @param optimizeEmptyElements if set to <code>true</code>, short
* XML syntax will be used for empty elements
*/
public SAXWriter(Writer w, boolean optimizeEmptyElements) {
this.w = w;
this.optimizeEmptyElements = optimizeEmptyElements;
}
public final void startElement(
String ns,
String localName,
String qName,
Attributes atts) throws SAXException
{
try {
closeElement();
writeIdent();
w.write("<".concat(qName));
if (atts != null && atts.getLength() > 0)
writeAttributes(atts);
if (!optimizeEmptyElements) {
w.write(">\n");
} else {
openElement = true;
}
ident += 2;
} catch (IOException ex) {
throw new SAXException(ex);
}
}
public final void endElement(String ns, String localName, String qName)
throws SAXException
{
ident -= 2;
try {
if (openElement) {
w.write("/>\n");
openElement = false;
} else {
writeIdent();
w.write("</" + qName + ">\n");
}
} catch (IOException ex) {
throw new SAXException(ex);
}
}
public final void endDocument() throws SAXException {
try {
w.flush();
} catch (IOException ex) {
throw new SAXException(ex);
}
}
public final void comment(char[] ch, int off, int len)
throws SAXException
{
try {
closeElement();
writeIdent();
w.write("<!-- ");
w.write(ch, off, len);
w.write(" -->\n");
} catch (IOException ex) {
throw new SAXException(ex);
}
}
public final void startDTD(String arg0, String arg1, String arg2)
throws SAXException
{
}
public final void endDTD() throws SAXException {
}
public final void startEntity(String arg0) throws SAXException {
}
public final void endEntity(String arg0) throws SAXException {
}
public final void startCDATA() throws SAXException {
}
public final void endCDATA() throws SAXException {
}
private final void writeAttributes(Attributes atts) throws IOException {
StringBuffer sb = new StringBuffer();
int len = atts.getLength();
for (int i = 0; i < len; i++) {
sb.append(" ")
.append(atts.getLocalName(i))
.append("=\"")
.append(esc(atts.getValue(i)))
.append("\"");
}
w.write(sb.toString());
}
/**
* Encode string with escaping.
*
* @param str string to encode.
* @return encoded string
*/
private final String esc(String str) {
StringBuffer sb = new StringBuffer(str.length());
for (int i = 0; i < str.length(); i++) {
char ch = str.charAt(i);
switch (ch) {
case '&':
sb.append("&");
break;
case '<':
sb.append("<");
break;
case '>':
sb.append(">");
break;
case '\"':
sb.append(""");
break;
default:
if (ch > 0x7f) {
sb.append("&#")
.append(Integer.toString(ch))
.append(';');
} else {
sb.append(ch);
}
}
}
return sb.toString();
}
private final void writeIdent() throws IOException {
int n = ident;
while (n > 0) {
if (n > OFF.length) {
w.write(OFF);
n -= OFF.length;
} else {
w.write(OFF, 0, n);
n = 0;
}
}
}
private final void closeElement() throws IOException {
if (openElement) {
w.write(">\n");
}
openElement = false;
}
}
/**
* A {@link org.xml.sax.ContentHandler ContentHandler} that splits XML
* documents into smaller chunks. Each chunk is processed by the nested
* {@link org.xml.sax.ContentHandler ContentHandler} obtained from
* {@link java.net.ContentHandlerFactory ContentHandlerFactory}. This is
* useful for running XSLT engine against large XML document that will
* hardly fit into the memory all together. <p> TODO use complete path for
* subdocumentRoot
*/
private final static class InputSlicingHandler extends DefaultHandler {
private String subdocumentRoot;
private ContentHandler rootHandler;
private ContentHandlerFactory subdocumentHandlerFactory;
private boolean subdocument = false;
private ContentHandler subdocumentHandler;
/**
* Constructs a new {@link InputSlicingHandler SubdocumentHandler}
* object.
*
* @param subdocumentRoot name/path to the root element of the
* subdocument
* @param rootHandler content handler for the entire document
* (subdocument envelope).
* @param subdocumentHandlerFactory a
* {@link ContentHandlerFactory ContentHandlerFactory} used to
* create {@link ContentHandler ContentHandler} instances for
* subdocuments.
*/
public InputSlicingHandler(
String subdocumentRoot,
ContentHandler rootHandler,
ContentHandlerFactory subdocumentHandlerFactory)
{
this.subdocumentRoot = subdocumentRoot;
this.rootHandler = rootHandler;
this.subdocumentHandlerFactory = subdocumentHandlerFactory;
}
public final void startElement(
String namespaceURI,
String localName,
String qName,
Attributes list) throws SAXException
{
if (subdocument) {
subdocumentHandler.startElement(namespaceURI,
localName,
qName,
list);
} else if (localName.equals(subdocumentRoot)) {
subdocumentHandler = subdocumentHandlerFactory.createContentHandler();
subdocumentHandler.startDocument();
subdocumentHandler.startElement(namespaceURI,
localName,
qName,
list);
subdocument = true;
} else if (rootHandler != null) {
rootHandler.startElement(namespaceURI, localName, qName, list);
}
}
public final void endElement(
String namespaceURI,
String localName,
String qName) throws SAXException
{
if (subdocument) {
subdocumentHandler.endElement(namespaceURI, localName, qName);
if (localName.equals(subdocumentRoot)) {
subdocumentHandler.endDocument();
subdocument = false;
}
} else if (rootHandler != null) {
rootHandler.endElement(namespaceURI, localName, qName);
}
}
public final void startDocument() throws SAXException {
if (rootHandler != null) {
rootHandler.startDocument();
}
}
public final void endDocument() throws SAXException {
if (rootHandler != null) {
rootHandler.endDocument();
}
}
public final void characters(char[] buff, int offset, int size)
throws SAXException
{
if (subdocument) {
subdocumentHandler.characters(buff, offset, size);
} else if (rootHandler != null) {
rootHandler.characters(buff, offset, size);
}
}
}
/**
* A {@link org.xml.sax.ContentHandler ContentHandler} that splits XML
* documents into smaller chunks. Each chunk is processed by the nested
* {@link org.xml.sax.ContentHandler ContentHandler} obtained from
* {@link java.net.ContentHandlerFactory ContentHandlerFactory}. This is
* useful for running XSLT engine against large XML document that will
* hardly fit into the memory all together. <p> TODO use complete path for
* subdocumentRoot
*/
private static final class OutputSlicingHandler extends DefaultHandler {
private String subdocumentRoot;
private ContentHandlerFactory subdocumentHandlerFactory;
private EntryElement entryElement;
private boolean isXml;
private boolean subdocument = false;
private ContentHandler subdocumentHandler;
/**
* Constructs a new {@link OutputSlicingHandler SubdocumentHandler}
* object.
*
* @param subdocumentHandlerFactory a
* {@link ContentHandlerFactory ContentHandlerFactory} used to
* create {@link ContentHandler ContentHandler} instances for
* subdocuments.
* @param entryElement TODO.
* @param isXml TODO.
*/
public OutputSlicingHandler(
ContentHandlerFactory subdocumentHandlerFactory,
EntryElement entryElement,
boolean isXml)
{
this.subdocumentRoot = "class";
this.subdocumentHandlerFactory = subdocumentHandlerFactory;
this.entryElement = entryElement;
this.isXml = isXml;
}
public final void startElement(
String namespaceURI,
String localName,
String qName,
Attributes list) throws SAXException
{
if (subdocument) {
subdocumentHandler.startElement(namespaceURI,
localName,
qName,
list);
} else if (localName.equals(subdocumentRoot)) {
String name = list.getValue("name");
if (name == null || name.length() == 0)
throw new SAXException("Class element without name attribute.");
try {
entryElement.openEntry(isXml
? name.concat(".class.xml")
: name.concat(".class"));
} catch (IOException ex) {
throw new SAXException(ex.toString(), ex);
}
subdocumentHandler = subdocumentHandlerFactory.createContentHandler();
subdocumentHandler.startDocument();
subdocumentHandler.startElement(namespaceURI,
localName,
qName,
list);
subdocument = true;
}
}
public final void endElement(
String namespaceURI,
String localName,
String qName) throws SAXException
{
if (subdocument) {
subdocumentHandler.endElement(namespaceURI, localName, qName);
if (localName.equals(subdocumentRoot)) {
subdocumentHandler.endDocument();
subdocument = false;
try {
entryElement.closeEntry();
} catch (IOException ex) {
throw new SAXException(ex.toString(), ex);
}
}
}
}
public final void startDocument() throws SAXException {
}
public final void endDocument() throws SAXException {
}
public final void characters(char[] buff, int offset, int size)
throws SAXException
{
if (subdocument) {
subdocumentHandler.characters(buff, offset, size);
}
}
}
private static interface EntryElement {
OutputStream openEntry(String name) throws IOException;
void closeEntry() throws IOException;
}
private static final class SingleDocElement implements EntryElement {
private OutputStream os;
public SingleDocElement(OutputStream os) {
this.os = os;
}
public OutputStream openEntry(String name) throws IOException {
return os;
}
public void closeEntry() throws IOException {
os.flush();
}
}
private static final class ZipEntryElement implements EntryElement {
private ZipOutputStream zos;
public ZipEntryElement(ZipOutputStream zos) {
this.zos = zos;
}
public OutputStream openEntry(String name) throws IOException {
ZipEntry entry = new ZipEntry(name);
zos.putNextEntry(entry);
return zos;
}
public void closeEntry() throws IOException {
zos.flush();
zos.closeEntry();
}
}
}