/*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*
* This software is open source.
* See the bottom of this file for the licence.
*/
package org.dom4j.jaxb;
import java.io.
File;
import java.io.
FileInputStream;
import java.io.
FileNotFoundException;
import java.io.
FileOutputStream;
import java.io.
IOException;
import java.io.
InputStream;
import java.io.
InputStreamReader;
import java.io.
OutputStream;
import java.io.
Reader;
import java.io.
Writer;
import java.net.
URL;
import java.nio.charset.
Charset;
import java.util.
HashMap;
import java.util.
Iterator;
import java.util.
Map;
import org.dom4j.
Document;
import org.dom4j.
DocumentException;
import org.dom4j.io.
ElementModifier;
import org.dom4j.io.
OutputFormat;
import org.dom4j.io.
SAXModifier;
import org.dom4j.io.
XMLWriter;
import org.xml.sax.
InputSource;
/**
* Reads an XML document using SAX and writes its content to the provided
* {@link org.dom4j.io.XMLWriter}. Modifications must be provided by {@link
* org.dom4j.jaxb.JAXBObjectModifier} objects, which are called prior to writing
* the XML fragment they are registered for.
*
* @author Wonne Keysers (Realsoftware.be)
*
* @see org.dom4j.io.SAXModifier
*/
public class
JAXBModifier extends
JAXBSupport {
private
SAXModifier modifier;
private
XMLWriter xmlWriter;
private boolean
pruneElements;
private
OutputFormat outputFormat;
private
HashMap modifiers = new
HashMap();
/**
* Creates a new JAXBModifier for the given JAXB context path. This is the
* Java package where JAXB can find the generated XML classes. This package
* MUST contain jaxb.properties!
*
* @param contextPath
* JAXB context path to be used
*
* @see javax.xml.bind.JAXBContext
*/
public
JAXBModifier(
String contextPath) {
super(
contextPath);
this.
outputFormat = new
OutputFormat();
}
/**
* Creates a new JAXBModifier for the given JAXB context path, using the
* given {@link java.lang.ClassLoader}. This is the Java package where JAXB
* can find the generated XML classes. This package MUST contain
* jaxb.properties!
*
* @param contextPath
* JAXB context path to be used
* @param classloader
* the classloader to use
*
* @see javax.xml.bind.JAXBContext
*/
public
JAXBModifier(
String contextPath,
ClassLoader classloader) {
super(
contextPath,
classloader);
this.
outputFormat = new
OutputFormat();
}
/**
* Creates a new JAXBModifier for the given JAXB context path. The specified
* {@link org.dom4j.io.OutputFormat}will be used while writing the XML
* stream.
*
* @param contextPath
* JAXB context path to be used
* @param outputFormat
* the DOM4J {@link org.dom4j.io.OutputFormat}to be used
*
* @see javax.xml.bind.JAXBContext
*/
public
JAXBModifier(
String contextPath,
OutputFormat outputFormat) {
super(
contextPath);
this.
outputFormat =
outputFormat;
}
/**
* Creates a new JAXBModifier for the given JAXB context path, using the
* specified {@link java.lang.Classloader}. The specified {@link
* org.dom4j.io.OutputFormat} will be used while writing the XML stream.
*
* @param contextPath
* JAXB context path to be used
* @param classloader
* the class loader to be used to load JAXB
* @param outputFormat
* the DOM4J {@link org.dom4j.io.OutputFormat}to be used
*
* @see javax.xml.bind.JAXBContext
*/
public
JAXBModifier(
String contextPath,
ClassLoader classloader,
OutputFormat outputFormat) {
super(
contextPath,
classloader);
this.
outputFormat =
outputFormat;
}
/**
* Parses the specified {@link java.io.File}with SAX
*
* @param source
* the file to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public
Document modify(
File source) throws
DocumentException,
IOException {
return
installModifier().
modify(
source);
}
/**
* Parses the specified {@link java.io.File}with SAX, using the given
* {@link java.nio.charset.Charset}.
*
* @param source
* the file to parse
* @param charset
* the character set to use
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public
Document modify(
File source,
Charset charset)
throws
DocumentException,
IOException {
try {
Reader reader = new
InputStreamReader(new
FileInputStream(
source),
charset);
return
installModifier().
modify(
reader);
} catch (
JAXBRuntimeException ex) {
Throwable cause =
ex.
getCause();
throw new
DocumentException(
cause.
getMessage(),
cause);
} catch (
FileNotFoundException ex) {
throw new
DocumentException(
ex.
getMessage(),
ex);
}
}
/**
* Parses the specified {@link org.xml.sax.InputSource}with SAX.
*
* @param source
* the input source to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public
Document modify(
InputSource source) throws
DocumentException,
IOException {
try {
return
installModifier().
modify(
source);
} catch (
JAXBRuntimeException ex) {
Throwable cause =
ex.
getCause();
throw new
DocumentException(
cause.
getMessage(),
cause);
}
}
/**
* Parses the specified {@link java.io.InputStream}with SAX.
*
* @param source
* the inputstream to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public
Document modify(
InputStream source) throws
DocumentException,
IOException {
try {
return
installModifier().
modify(
source);
} catch (
JAXBRuntimeException ex) {
Throwable cause =
ex.
getCause();
throw new
DocumentException(
cause.
getMessage(),
cause);
}
}
/**
* Parses the specified {@link java.io.InputStream}with SAX.
*
* @param source
* the inputstream to parse
* @param systemId
* the URI of the given inputstream
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public
Document modify(
InputStream source,
String systemId)
throws
DocumentException,
IOException {
try {
return
installModifier().
modify(
source);
} catch (
JAXBRuntimeException ex) {
Throwable cause =
ex.
getCause();
throw new
DocumentException(
cause.
getMessage(),
cause);
}
}
/**
* Parses the specified {@link java.io.Reader}with SAX.
*
* @param r
* the reader to use for parsing
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public
Document modify(
Reader r) throws
DocumentException,
IOException {
try {
return
installModifier().
modify(
r);
} catch (
JAXBRuntimeException ex) {
Throwable cause =
ex.
getCause();
throw new
DocumentException(
cause.
getMessage(),
cause);
}
}
/**
* Parses the specified {@link java.io.Reader}with SAX.
*
* @param source
* the reader to parse
* @param systemId
* the URI of the given reader
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public
Document modify(
Reader source,
String systemId)
throws
DocumentException,
IOException {
try {
return
installModifier().
modify(
source);
} catch (
JAXBRuntimeException ex) {
Throwable cause =
ex.
getCause();
throw new
DocumentException(
cause.
getMessage(),
cause);
}
}
/**
* Parses the the given URL or filename.
*
* @param url
* the URL or filename to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public
Document modify(
String url) throws
DocumentException,
IOException {
try {
return
installModifier().
modify(
url);
} catch (
JAXBRuntimeException ex) {
Throwable cause =
ex.
getCause();
throw new
DocumentException(
cause.
getMessage(),
cause);
}
}
/**
* Parses the the given URL.
*
* @param source
* the URL to parse
*
* @return the resulting DOM4J document
*
* @throws DocumentException
* when an error occurs while parsing
* @throws IOException
* when an error occurs while writing to the {@link
* org.dom4j.io.XMLWriter}
*/
public
Document modify(
URL source) throws
DocumentException,
IOException {
try {
return
installModifier().
modify(
source);
} catch (
JAXBRuntimeException ex) {
Throwable cause =
ex.
getCause();
throw new
DocumentException(
cause.
getMessage(),
cause);
}
}
/**
* Sets the Output to write the (modified) xml document to.
*
* @param file
* the {@link java.io.File}to write to
*
* @throws IOException
* when the file cannot be found or when the outputformat
*/
public void
setOutput(
File file) throws
IOException {
createXMLWriter().
setOutputStream(new
FileOutputStream(
file));
}
/**
* Sets the Output to write the (modified) xml document to.
*
* @param outputStream
* the {@link java.io.OutputStream}to write to
*
* @throws IOException
* when an error occurs
*/
public void
setOutput(
OutputStream outputStream) throws
IOException {
createXMLWriter().
setOutputStream(
outputStream);
}
/**
* Sets the Output to write the (modified) xml document to.
*
* @param writer
* the {@link java.io.Writer}to write to
*
* @throws IOException
* when an error occurs
*/
public void
setOutput(
Writer writer) throws
IOException {
createXMLWriter().
setWriter(
writer);
}
/**
* Adds the {@link JAXBObjectModifier}to be called when the specified xml
* path is encounted while parsing the source.
*
* @param path
* the element path to listen for
* @param mod
* the modifier to register
*/
public void
addObjectModifier(
String path,
JAXBObjectModifier mod) {
modifiers.
put(
path,
mod);
}
/**
* Removes the {@link JAXBObjectModifier}from the event based processor,
* for the specified element path.
*
* @param path
* the xml path to remove the modifier for
*/
public void
removeObjectModifier(
String path) {
modifiers.
remove(
path);
getModifier().
removeModifier(
path);
}
/**
* Removes all registered {@link JAXBObjectModifier}instances from the
* event based processor.
*/
public void
resetObjectModifiers() {
modifiers.
clear();
getModifier().
resetModifiers();
}
/**
* Returns true when the modified {@link org.dom4j.Document}is not kept in
* memory.
*
* @return Returns true if elements are pruned.
*/
public boolean
isPruneElements() {
return
pruneElements;
}
/**
* Define whether the modified {@link org.dom4j.Document}must only be
* written to the output and pruned from the DOM4J tree.
*
* @param pruneElements
* When true, elements will not be kept in memory
*/
public void
setPruneElements(boolean
pruneElements) {
this.
pruneElements =
pruneElements;
}
private
SAXModifier installModifier() throws
IOException {
modifier = new
SAXModifier(
isPruneElements());
modifier.
resetModifiers();
Iterator modifierIt =
modifiers.
entrySet().
iterator();
while (
modifierIt.
hasNext()) {
Map.
Entry entry = (
Map.
Entry)
modifierIt.
next();
ElementModifier mod = new
JAXBElementModifier(this,
(
JAXBObjectModifier)
entry.
getValue());
getModifier().
addModifier((
String)
entry.
getKey(),
mod);
}
modifier.
setXMLWriter(
getXMLWriter());
return
modifier;
}
private
SAXModifier getModifier() {
if (this.
modifier == null) {
modifier = new
SAXModifier(
isPruneElements());
}
return
modifier;
}
private
XMLWriter getXMLWriter() {
return
xmlWriter;
}
private
XMLWriter createXMLWriter() throws
IOException {
if (this.
xmlWriter == null) {
xmlWriter = new
XMLWriter(
outputFormat);
}
return
xmlWriter;
}
private class
JAXBElementModifier implements
ElementModifier {
private
JAXBModifier jaxbModifier;
private
JAXBObjectModifier objectModifier;
public
JAXBElementModifier(
JAXBModifier jaxbModifier,
JAXBObjectModifier objectModifier) {
this.
jaxbModifier =
jaxbModifier;
this.
objectModifier =
objectModifier;
}
public org.dom4j.
Element modifyElement(org.dom4j.
Element element)
throws
Exception {
javax.xml.bind.
Element originalObject =
jaxbModifier
.
unmarshal(
element);
javax.xml.bind.
Element modifiedObject =
objectModifier
.
modifyObject(
originalObject);
return
jaxbModifier.
marshal(
modifiedObject);
}
}
}
/*
* Redistribution and use of this software and associated documentation
* ("Software"), with or without modification, are permitted provided that the
* following conditions are met:
*
* 1. Redistributions of source code must retain copyright statements and
* notices. Redistributions must also contain a copy of this document.
*
* 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. The name "DOM4J" must not be used to endorse or promote products derived
* from this Software without prior written permission of MetaStuff, Ltd. For
* written permission, please contact dom4j-info@metastuff.com.
*
* 4. Products derived from this Software may not be called "DOM4J" nor may
* "DOM4J" appear in their names without prior written permission of MetaStuff,
* Ltd. DOM4J is a registered trademark of MetaStuff, Ltd.
*
* 5. Due credit should be given to the DOM4J Project - http://www.dom4j.org
*
* THIS SOFTWARE IS PROVIDED BY METASTUFF, LTD. AND CONTRIBUTORS ``AS IS'' AND
* ANY EXPRESSED 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 METASTUFF, LTD. OR ITS 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.
*
* Copyright 2001-2005 (C) MetaStuff, Ltd. All Rights Reserved.
*/