/*
* The Apache Software License, Version 1.1
*
*
* Copyright (c) 1999 The Apache Software Foundation. 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. The end-user documentation included with the redistribution,
* if any, must include the following acknowledgment:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowledgment may appear in the software itself,
* if and wherever such third-party acknowledgments normally appear.
*
* 4. The names "Xalan" and "Apache Software Foundation" must
* not be used to endorse or promote products derived from this
* software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache",
* nor may "Apache" appear in their name, without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``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 THE APACHE SOFTWARE FOUNDATION 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.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation and was
* originally based on software copyright (c) 1999, Lotus
* Development Corporation., http://www.lotus.com. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.xalan.xslt;
import org.w3c.dom.Node;
import java.io.OutputStream;
import java.io.Writer;
import org.xml.sax.DocumentHandler;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.helpers.ParserAdapter;
import javax.xml.transform.Result;
import javax.xml.transform.stream.StreamResult;
import javax.xml.transform.dom.DOMResult;
import javax.xml.transform.sax.SAXResult;
/**
* <meta name="usage" content="general"/>
* Contains the result of a transformation that you perform with the
* XSLTProcessor process() method or one of the StylesheetRoot process() methods.
* Create an instance of this class to provide the process() method a container
* for the transformation result tree.
* You can use a file name or URL, character stream, byte stream, DOM Node, or SAX DocumentHandler
* to instantiate an XSLTResultTarget object.
*
* @see XSLTProcessor#process(XSLTInputSource, XSLTInputSource, XSLTResultTarget)
* @see StylesheetRoot
* @deprecated This compatibility layer will be removed in later releases.
*/
public class XSLTResultTarget //implements Result //extends StreamResult
{
private StreamResult sr = null;
private SAXResult saxResult = null;
private DOMResult dr = null;
/**
* Zero-argument default constructor -- Before you can use the new XSLTResultTarget object in a transformation,
* you must define the output container by setting its FileName, CharacterStrea, ByteStream, or Node property.
*
* @see #setFileName(String)
* @see #setCharacterStream(Writer)
* @see #setByteStream(OutputStream)
* @see #setNode(Node)
* @see #setDocumentHandler(DocumentHandler)
* @see #setEncoding(String)
*/
public XSLTResultTarget ()
{
sr = new StreamResult();
}
/**
* Create a new output target with a file name -- the equivalent of creating an output target
* with the zero-argument constructor and setting the new object's FileName property.
*
* @param fileName Identifies the file that will contain the transformation result (must be a valid system file name).
*
* @see #setFileName(String)
* @see #setCharacterStream(Writer)
* @see #setByteStream(OutputStream)
* @see #setNode(Node)
* @see #setDocumentHandler(DocumentHandler)
* @see #setEncoding(String)
*/
public XSLTResultTarget (String fileName) // File?
{
sr = new StreamResult();
sr.setSystemId(fileName);
}
/**
* Create a new output target with a byte stream -- the equivalent of creating an output target
* with the zero-argument constructor and setting the new object's ByteStream property.
*
* @param byteStream The raw byte stream that will contain the transformation result.
*
* @see #setByteStream(OutputStream)
* @see #setFileName(String)
* @see #setCharacterStream(Writer)
* @see #setNode(Node)
* @see #setDocumentHandler(DocumentHandler)
* @see #setEncoding(String)
*/
public XSLTResultTarget (OutputStream byteStream)
{
sr = new StreamResult();
sr.setOutputStream(byteStream);
}
/**
* Create a new output target with a character stream -- the equivalent of creating an output target
* with the zero-argument constructor and setting the new object's CharacterStream property.
*
* @param characterStream The character stream where the transformation result is written.
*
* @see #setCharacterStream(Writer)
* @see #setByteStream(OutputStream)
* @see #setFileName(String)
* @see #setNode(Node)
* @see #setDocumentHandler(DocumentHandler)
* @see #setEncoding(String)
*/
public XSLTResultTarget (Writer characterStream)
{
sr = new StreamResult();
sr.setWriter(characterStream);
}
/**
* Create a new output target with a DOM Node -- the equivalent of creating an output target
* with the zero-argument constructor and setting the new object's Node property.
*
* @param node The DOM Node that will contain the transformation result.
*
* @see #setNode(Node)
* @see #setCharacterStream(Writer)
* @see #setByteStream(OutputStream)
* @see #setFileName(String)
* @see #setDocumentHandler(DocumentHandler)
* @see #setEncoding(String)
*/
public XSLTResultTarget (Node n)
{
dr = new DOMResult();
dr.setNode(n);
}
/**
* Create a new output target with a SAX Document handler, which
* will handle result events -- the equivalent of creating an output target with the
* zero-argument constructor and setting the new object's DocyumentHandler property.
*
* @param handler The SAX Document handler to which the result is written.
*
* @see #setDocumentHandler(DocumentHandler)
* @see #setNode(Node)
* @see #setCharacterStream(Writer)
* @see #setByteStream(OutputStream)
* @see #setFileName(String)
* @see #setEncoding(String)
*/
public XSLTResultTarget(DocumentHandler handler)
{
saxResult = new SAXResult();
setDocumentHandler(handler);
}
/**
* Set the file name or URL where the transformation result will be written.
*
* @param fileName The system identifier as a string.
*
* @see #XSLTResultTarget(String)
* @see #getFileName
*/
public void setFileName (String fileName) // File?
{
if (sr == null)
sr = new StreamResult();
sr.setSystemId(fileName);
}
/**
* Get the file name where the results are or will be written, or null if none was supplied.
*
* @return The file name or URL.
*
* @see #XSLTResultTarget(String)
* @see #setFileName(String)
*/
public String getFileName ()
{
if (sr != null)
return sr.getSystemId();
else
return null;
}
/**
* Set the character encoding, if known.
*
* @param encoding The character encoding.
*/
public void setEncoding (String encoding)
{
this.encoding = encoding;
}
/**
* Get the character encoding that was used.
*
* @return The encoding, or null if none was supplied.
*/
public String getEncoding ()
{
return encoding;
}
private String encoding;
/**
* Set a SAX DocumentHandler to process the result tree events.
* You can process events as they occur
* rather than waiting for the transformation to be completed.
*
* @param handler The SAX DocumentHandler to process result tree events.
*
* @see #XSLTResultTarget(DocumentHandler)
* @see #getDocumentHandler()
*/
public void setDocumentHandler (DocumentHandler handler)
{
this.formatterListener = handler;
if (handler instanceof XSLTEngineImpl)
saxResult.setHandler(((XSLTEngineImpl)handler).getTransformer().getContentHandler());
if (handler instanceof ParserAdapter)
{
if (saxResult == null)
saxResult = new SAXResult();
saxResult.setHandler(((ParserAdapter)handler).getContentHandler());
}
}
/**
* Get the SAX DocumentHandler that processes the result tree events.
* You can use the DocumentHandler to process events as they occur
* rather than waiting for the transformation to be completed.
*
* @return The SAX DocumentHandler that processes result tree events.
*
* @see #XSLTResultTarget(DocumentHandler)
* @see #setDocumentHandler(DocumentHandler)
*/
public DocumentHandler getDocumentHandler ()
{
return formatterListener;
}
private DocumentHandler formatterListener = null;
/**
* Set the node that will contain the result DOM tree. In practice,
* the node should be a {@link org.w3c.dom.Document} node,
* a {@link org.w3c.dom.DocumentFragment} node, or a
* {@link org.w3c.dom.Element} node. In other words, a node
* that accepts children.
*
* @param node The node to which the transformation
* will be appended.
*/
public void setNode(Node node) {
if (dr == null)
dr = new DOMResult();
dr.setNode(node);
}
/**
* Get the node that will contain the result DOM tree.
* If no node was set via setNode, the node will be
* set by the transformation, and may be obtained from
* this method once the transformation is complete.
*
* @return The node to which the transformation
* will be appended.
*/
public Node getNode() {
if (dr != null)
return dr.getNode();
else
return null;
}
/**
* Set the byte stream to contain the transformation result.
*
* @param byteStream A byte stream that will contain the transformation result.
*
* @see #XSLTResultTarget(OutputStream)
* @see #setByteStream(OutputStream)
*/
public void setByteStream(OutputStream byteStrm) {
if (sr == null)
sr = new StreamResult();
sr.setOutputStream(byteStrm);
}
/**
* Get the byte stream that contains or will contain the transformation result.
*
* @return The byte stream, or null if none was supplied.
*
* @see #XSLTResultTarget(OutputStream)
* @see #setByteStream(OutputStream)
*/
public OutputStream getByteStream() {
if (sr != null)
return sr.getOutputStream();
else
return null;
}
/**
* Set the system identifier for this Result.
*
* <p>If the Result is not to be written to a file, the system identifier is optional.
* The application may still want to provide one, however, for use in error messages
* and warnings, or to resolve relative output identifiers.</p>
*
* @param systemId The system identifier as a URI string.
*/
public void setSystemId(String systemID)
{
if (sr != null)
sr.setSystemId(systemID);
else if (dr != null)
dr.setSystemId(systemID);
else if (saxResult != null)
saxResult.setSystemId(systemID);
}
/**
* Get the system identifier that was set with setSystemId.
*
* @return The system identifier that was set with setSystemId,
* or null if setSystemId was not called.
*/
public String getSystemId()
{
if (sr != null)
return sr.getSystemId();
else if (dr != null)
dr.getSystemId();
else if (saxResult != null)
saxResult.getSystemId();
return null;
}
/**
* Set the writer that is to receive the result. Normally,
* a stream should be used rather than a writer, so that
* the transformer may use instructions contained in the
* transformation instructions to control the encoding. However,
* there are times when it is useful to write to a writer,
* such as when using a StringWriter.
*
* @param writer A valid Writer reference.
*/
public void setCharacterStream(Writer writer) {
if (sr == null)
sr = new StreamResult();
sr.setWriter(writer);
}
/**
* Get the character stream that was set with setWriter.
*
* @return The character stream that was set with setWriter, or null
* if setWriter or the Writer constructor was not called.
*/
public Writer getCharacterStream() {
if (sr != null)
return sr.getWriter();
else
return null;
}
/**
* Get the Result object associated with this XSLTResultTarget object .
*
* @return The Result object associated with this XSLTResultTarget object
*
*/
public Result getResultObject()
{
if (sr != null)
return sr;
else if (dr != null)
return dr;
else
return saxResult;
}
}