Bommels05/commons-xml
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Initial revision

Browse Source 
git-svn-id: https://svn.apache.org/repos/asf/xml/commons/trunk@225907 13f79535-47bb-0310-9956-ffa450edef68
This commit is contained in:
edwingo 2001-05-22 01:01:03 +00:00
parent c507350d30
commit cb24b2ecfa
36 changed files with 5514 additions and 0 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

246
java/external/src/javax/xml/parsers/DocumentBuilder.java vendored Normal file
View File

@ -0,0 +1,246 @@
/**
* $Id$
*
* Copyright (c) 1998-2000 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.parsers;
import java.io.InputStream;
import java.io.IOException;
import java.io.File;
import org.xml.sax.Parser;
import org.xml.sax.HandlerBase;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.w3c.dom.Document;
import org.w3c.dom.DOMImplementation;
/**
* Defines the API to obtain DOM Document instances from an XML
* document. Using this class, an application programmer can obtain a
* {@link org.w3c.dom.Document} from XML.<p>
*
* An instance of this class can be obtained from the
* {@link javax.xml.parsers.DocumentBuilderFactory#newDocumentBuilder()
* DocumentBuilderFactory.newDocumentBuilder} method. Once
* an instance of this class is obtained, XML can be parsed from a
* variety of input sources. These input sources are InputStreams,
* Files, URLs, and SAX InputSources.<p>
*
* Note that this class reuses several classes from the SAX API. This
* does not require that the implementor of the underlying DOM
* implementation use a SAX parser to parse XML document into a
* <code>Document</code>. It merely requires that the implementation
* communicate with the application using these existing APIs. <p>
*
* An implementation of <code>DocumentBuilder</code> is <em>NOT</em>
* guaranteed to behave as per the specification if it is used concurrently by
* two or more threads. It is recommended to have one instance of the
* <code>DocumentBuilder</code> per thread or it is upto the application to
* make sure about the use of <code>DocumentBuilder</code> from more than one
* thread.
*
* @since JAXP 1.0
* @version 1.0
*/
public abstract class DocumentBuilder {
protected DocumentBuilder () {
}
/**
* Parse the content of the given <code>InputStream</code> as an XML
* document and return a new DOM {@link org.w3c.dom.Document} object.
*
* @param is InputStream containing the content to be parsed.
* @exception IOException If any IO errors occur.
* @exception SAXException If any parse errors occur.
* @exception IllegalArgumentException If the InputStream is null
* @see org.xml.sax.DocumentHandler
*/
public Document parse(InputStream is)
throws SAXException, IOException
{
if (is == null) {
throw new IllegalArgumentException("InputStream cannot be null");
}
InputSource in = new InputSource(is);
return parse(in);
}
/**
* Parse the content of the given <code>InputStream</code> as an XML
* document and return a new DOM {@link org.w3c.dom.Document} object.
*
* @param is InputStream containing the content to be parsed.
* @param systemId Provide a base for resolving relative URIs.
* @exception IOException If any IO errors occur.
* @exception SAXException If any parse errors occur.
* @exception IllegalArgumentException If the InputStream is null.
* @see org.xml.sax.DocumentHandler
* @return A new DOM Document object.
*/
public Document parse(InputStream is, String systemId)
throws SAXException, IOException
{
if (is == null) {
throw new IllegalArgumentException("InputStream cannot be null");
}
InputSource in = new InputSource(is);
in.setSystemId(systemId);
return parse(in);
}
/**
* Parse the content of the given URI as an XML document
* and return a new DOM {@link org.w3c.dom.Document} object.
*
* @param uri The location of the content to be parsed.
* @exception IOException If any IO errors occur.
* @exception SAXException If any parse errors occur.
* @exception IllegalArgumentException If the URI is null.
* @see org.xml.sax.DocumentHandler
* @return A new DOM Document object.
*/
public Document parse(String uri)
throws SAXException, IOException
{
if (uri == null) {
throw new IllegalArgumentException("URI cannot be null");
}
InputSource in = new InputSource(uri);
return parse(in);
}
/**
* Parse the content of the given file as an XML document
* and return a new DOM {@link org.w3c.dom.Document} object.
*
* @param f The file containing the XML to parse.
* @exception IOException If any IO errors occur.
* @exception SAXException If any parse errors occur.
* @exception IllegalArgumentException If the file is null.
* @see org.xml.sax.DocumentHandler
* @return A new DOM Document object.
*/
public Document parse(File f)
throws SAXException, IOException
{
if (f == null) {
throw new IllegalArgumentException("File cannot be null");
}
String uri = "file:" + f.getAbsolutePath();
if (File.separatorChar == '\\') {
uri = uri.replace('\\', '/');
}
InputSource in = new InputSource(uri);
return parse(in);
}
/**
* Parse the content of the given input source as an XML document
* and return a new DOM {@link org.w3c.dom.Document} object.
*
* @param is InputSource containing the content to be parsed.
* @exception IOException If any IO errors occur.
* @exception SAXException If any parse errors occur.
* @exception IllegalArgumentException If the InputSource is null.
* @see org.xml.sax.DocumentHandler
* @return A new DOM Document object.
*/
public abstract Document parse(InputSource is)
throws SAXException, IOException;
/**
* Indicates whether or not this parser is configured to
* understand namespaces.
*
* @return true if this parser is configured to understand
* namespaces; false otherwise.
*/
public abstract boolean isNamespaceAware();
/**
* Indicates whether or not this parser is configured to
* validate XML documents.
*
* @return true if this parser is configured to validate
* XML documents; false otherwise.
*/
public abstract boolean isValidating();
/**
* Specify the {@link org.xml.sax.EntityResolver} to be used to resolve
* entities present in the XML document to be parsed. Setting
* this to <code>null</code> will result in the underlying
* implementation using it's own default implementation and
* behavior.
*
* @param er The <code>EntityResolver</code> to be used to resolve entities
* present in the XML document to be parsed.
*/
public abstract void setEntityResolver(org.xml.sax.EntityResolver er);
/**
* Specify the {@link org.xml.sax.ErrorHandler} to be used to report
* errors present in the XML document to be parsed. Setting
* this to <code>null</code> will result in the underlying
* implementation using it's own default implementation and
* behavior.
*
* @param eh The <code>ErrorHandler</code> to be used to report errors
* present in the XML document to be parsed.
*/
public abstract void setErrorHandler(org.xml.sax.ErrorHandler eh);
/**
* Obtain a new instance of a DOM {@link org.w3c.dom.Document} object
* to build a DOM tree with. An alternative way to create a DOM
* Document object is to use the
* {@link #getDOMImplementation() getDOMImplementation}
* method to get a DOM Level 2 DOMImplementation object and then use
* DOM Level 2 methods on that object to create a DOM Document object.
*
* @return A new instance of a DOM Document object.
*/
public abstract Document newDocument();
/**
* Obtain an instance of a {@link org.w3c.dom.DOMImplementation} object.
*
* @return A new instance of a <code>DOMImplementation</code>.
*/
public abstract DOMImplementation getDOMImplementation();
}

306
java/external/src/javax/xml/parsers/DocumentBuilderFactory.java vendored Normal file
View File

@ -0,0 +1,306 @@
/**
* $Id$
*
* Copyright (c) 1998-2000 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.parsers;
import java.io.InputStream;
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;
import java.io.BufferedReader;
import java.io.InputStreamReader;
/**
* Defines a factory API that enables applications to obtain a
* parser that produces DOM object trees from XML documents.
*
* An implementation of the <code>DocumentBuilderFactory</code> class is
* <em>NOT</em> guaranteed to be thread safe. It is up to the user application
* to make sure about the use of the <code>DocumentBuilderFactory</code> from
* more than one thread. Alternatively the application can have one instance
* of the <code>DocumentBuilderFactory</code> per thread.
* An application can use the same instance of the factory to obtain one or
* more instances of the <code>DocumentBuilder</code> provided the instance
* of the factory isn't being used in more than one thread at a time.
*
* @since JAXP 1.0
* @version 1.0
*/
public abstract class DocumentBuilderFactory {
private boolean validating = false;
private boolean namespaceAware = false;
private boolean whitespace = false;
private boolean expandEntityRef = true;
private boolean ignoreComments = false;
private boolean coalescing = false;
protected DocumentBuilderFactory () {
}
/**
* Obtain a new instance of a
* <code>DocumentBuilderFactory</code>. This static method creates
* a new factory instance.
* This method uses the following ordered lookup procedure to determine
* the <code>DocumentBuilderFactory</code> implementation class to
* load:
* <ul>
* <li>
* Use the <code>javax.xml.parsers.DocumentBuilderFactory</code> system
* property.
* </li>
* <li>
* Use the properties file "lib/jaxp.properties" in the JRE directory.
* This configuration file is in standard <code>java.util.Properties
* </code> format and contains the fully qualified name of the
* implementation class with the key being the system property defined
* above.
* </li>
* <li>
* Use the Services API (as detailed in the JAR specification), if
* available, to determine the classname. The Services API will look
* for a classname in the file
* <code>META-INF/services/javax.xml.parsers.DocumentBuilderFactory</code>
* in jars available to the runtime.
* </li>
* <li>
* Platform default <code>DocumentBuilderFactory</code> instance.
* </li>
* </ul>
*
* Once an application has obtained a reference to a
* <code>DocumentBuilderFactory</code> it can use the factory to
* configure and obtain parser instances.
*
* @exception FactoryConfigurationError if the implementation is not
* available or cannot be instantiated.
*/
public static DocumentBuilderFactory newInstance()
throws FactoryConfigurationError
{
try {
return (DocumentBuilderFactory) FactoryFinder.find(
/* The default property name according to the JAXP spec */
"javax.xml.parsers.DocumentBuilderFactory",
/* The fallback implementation class name */
"org.apache.crimson.jaxp.DocumentBuilderFactoryImpl");
} catch (FactoryFinder.ConfigurationError e) {
throw new FactoryConfigurationError(e.getException(),
e.getMessage());
}
}
/**
* Creates a new instance of a {@link javax.xml.parsers.DocumentBuilder}
* using the currently configured parameters.
*
* @exception ParserConfigurationException if a DocumentBuilder
* cannot be created which satisfies the configuration requested.
* @return A new instance of a DocumentBuilder.
*/
public abstract DocumentBuilder newDocumentBuilder()
throws ParserConfigurationException;
/**
* Specifies that the parser produced by this code will
* provide support for XML namespaces. By default the value of this is set
* to <code>false</code>
*
* @param awareness true if the parser produced will provide support
* for XML namespaces; false otherwise.
*/
public void setNamespaceAware(boolean awareness) {
this.namespaceAware = awareness;
}
/**
* Specifies that the parser produced by this code will
* validate documents as they are parsed. By default the value of this
* is set to <code>false</code>.
*
* @param validating true if the parser produced will validate documents
* as they are parsed; false otherwise.
*/
public void setValidating(boolean validating) {
this.validating = validating;
}
/**
* Specifies that the parsers created by this factory must eliminate
* whitespace in element content (sometimes known loosely as
* 'ignorable whitespace') when parsing XML documents (see XML Rec
* 2.10). Note that only whitespace which is directly contained within
* element content that has an element only content model (see XML
* Rec 3.2.1) will be eliminated. Due to reliance on the content model
* this setting requires the parser to be in validating mode. By default
* the value of this is set to <code>false</code>.
*
* @param whitespace true if the parser created must eliminate whitespace
* in the element content when parsing XML documents;
* false otherwise.
*/
public void setIgnoringElementContentWhitespace(boolean whitespace) {
this.whitespace = whitespace;
}
/**
* Specifies that the parser produced by this code will
* expand entity reference nodes. By default the value of this is set to
* <code>true</code>
*
* @param expandEntityRef true if the parser produced will expand entity
* reference nodes; false otherwise.
*/
public void setExpandEntityReferences(boolean expandEntityRef) {
this.expandEntityRef = expandEntityRef;
}
/**
* Specifies that the parser produced by this code will
* ignore comments. By default the value of this is set to <code>false
* </code>
*/
public void setIgnoringComments(boolean ignoreComments) {
this.ignoreComments = ignoreComments;
}
/**
* Specifies that the parser produced by this code will
* convert CDATA nodes to Text nodes and append it to the
* adjacent (if any) text node. By default the value of this is set to
* <code>false</code>
*
* @param coalescing true if the parser produced will convert CDATA nodes
* to Text nodes and append it to the adjacent (if any)
* text node; false otherwise.
*/
public void setCoalescing(boolean coalescing) {
this.coalescing = coalescing;
}
/**
* Indicates whether or not the factory is configured to produce
* parsers which are namespace aware.
*
* @return true if the factory is configured to produce parsers which
* are namespace aware; false otherwise.
*/
public boolean isNamespaceAware() {
return namespaceAware;
}
/**
* Indicates whether or not the factory is configured to produce
* parsers which validate the XML content during parse.
*
* @return true if the factory is configured to produce parsers
* which validate the XML content during parse; false otherwise.
*/
public boolean isValidating() {
return validating;
}
/**
* Indicates whether or not the factory is configured to produce
* parsers which ignore ignorable whitespace in element content.
*
* @return true if the factory is configured to produce parsers
* which ignore ignorable whitespace in element content;
* false otherwise.
*/
public boolean isIgnoringElementContentWhitespace() {
return whitespace;
}
/**
* Indicates whether or not the factory is configured to produce
* parsers which expand entity reference nodes.
*
* @return true if the factory is configured to produce parsers
* which expand entity reference nodes; false otherwise.
*/
public boolean isExpandEntityReferences() {
return expandEntityRef;
}
/**
* Indicates whether or not the factory is configured to produce
* parsers which ignores comments.
*
* @return true if the factory is configured to produce parsers
* which ignores comments; false otherwise.
*/
public boolean isIgnoringComments() {
return ignoreComments;
}
/**
* Indicates whether or not the factory is configured to produce
* parsers which converts CDATA nodes to Text nodes and appends it to
* the adjacent (if any) Text node.
*
* @return true if the factory is configured to produce parsers
* which converts CDATA nodes to Text nodes and appends it to
* the adjacent (if any) Text node; false otherwise.
*/
public boolean isCoalescing() {
return coalescing;
}
/**
* Allows the user to set specific attributes on the underlying
* implementation.
* @param name The name of the attribute.
* @param value The value of the attribute.
* @exception IllegalArgumentException thrown if the underlying
* implementation doesn't recognize the attribute.
*/
public abstract void setAttribute(String name, Object value)
throws IllegalArgumentException;
/**
* Allows the user to retrieve specific attributes on the underlying
* implementation.
* @param name The name of the attribute.
* @return value The value of the attribute.
* @exception IllegalArgumentException thrown if the underlying
* implementation doesn't recognize the attribute.
*/
public abstract Object getAttribute(String name)
throws IllegalArgumentException;
}

125
java/external/src/javax/xml/parsers/FactoryConfigurationError.java vendored Normal file
View File

@ -0,0 +1,125 @@
/*
* $Id$
*
* Copyright (c) 1998-1999 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.parsers;
/**
* Thrown when a problem with configuration with the Parser Factories
* exists. This error will typically be thrown when the class of a
* parser factory specified in the system properties cannot be found
* or instantiated.
*
* @since JAXP 1.0
* @version 1.0
*/
public class FactoryConfigurationError extends Error {
private Exception exception;
/**
* Create a new <code>FactoryConfigurationError</code> with no
* detail mesage.
*/
public FactoryConfigurationError() {
super();
this.exception = null;
}
/**
* Create a new <code>FactoryConfigurationError</code> with
* the <code>String </code> specified as an error message.
*
* @param msg The error message for the exception.
*/
public FactoryConfigurationError(String msg) {
super(msg);
this.exception = null;
}
/**
* Create a new <code>FactoryConfigurationError</code> with a
* given <code>Exception</code> base cause of the error.
*
* @param e The exception to be encapsulated in a
* FactoryConfigurationError.
*/
public FactoryConfigurationError(Exception e) {
super(e.toString());
this.exception = e;
}
/**
* Create a new <code>FactoryConfigurationError</code> with the
* given <code>Exception</code> base cause and detail message.
*
* @param e The exception to be encapsulated in a
* FactoryConfigurationError
* @param msg The detail message.
* @param e The exception to be wrapped in a FactoryConfigurationError
*/
public FactoryConfigurationError(Exception e, String msg) {
super(msg);
this.exception = e;
}
/**
* Return the message (if any) for this error . If there is no
* message for the exception and there is an encapsulated
* exception then the message of that exception, if it exists will be
* returned. Else the name of the encapsulated exception will be
* returned.
*
* @return The error message.
*/
public String getMessage () {
String message = super.getMessage ();
if (message == null && exception != null) {
return exception.getMessage();
}
return message;
}
/**
* Return the actual exception (if any) that caused this exception to
* be raised.
*
* @return The encapsulated exception, or null if there is none.
*/
public Exception getException () {
return exception;
}
}

231
java/external/src/javax/xml/parsers/FactoryFinder.java vendored Normal file
View File

@ -0,0 +1,231 @@
/*
* $Id$
*
* Copyright (c) 1998-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.parsers;
import java.io.InputStream;
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;
import java.io.BufferedReader;
import java.io.InputStreamReader;
/**
* This class is duplicated for each JAXP subpackage so keep it in
* sync. It is package private.
*
* This code is designed to implement the JAXP 1.1 spec pluggability
* feature and is designed to run on JDK version 1.1 and later including
* JVMs that perform early linking like the Microsoft JVM in IE 5. Note
* however that it must be compiled on a JDK version 1.2 or later system
* since it calls Thread#getContextClassLoader(). The code also runs both
* as part of an unbundled jar file and when bundled as part of the JDK.
*/
class FactoryFinder {
/** Temp debug code - this will be removed after we test everything
*/
private static boolean debug = false;
static {
// Use try/catch block to support applets
try {
debug = System.getProperty("jaxp.debug") != null;
} catch (Exception x) {
}
}
private static void debugPrintln(String msg) {
if (debug) {
System.err.println("JAXP: " + msg);
}
}
/**
* Figure out which ClassLoader to use. For JDK 1.2 and later use the
* context ClassLoader if possible. Note: we defer linking the class
* that calls an API only in JDK 1.2 until runtime so that we can catch
* LinkageError so that this code will run in older non-Sun JVMs such
* as the Microsoft JVM in IE.
*/
private static ClassLoader findClassLoader()
throws ConfigurationError
{
ClassLoader classLoader;
try {
// Construct the name of the concrete class to instantiate
Class clazz = Class.forName(FactoryFinder.class.getName()
+ "$ClassLoaderFinderConcrete");
ClassLoaderFinder clf = (ClassLoaderFinder) clazz.newInstance();
classLoader = clf.getContextClassLoader();
} catch (LinkageError le) {
// Assume that we are running JDK 1.1, use the current ClassLoader
classLoader = FactoryFinder.class.getClassLoader();
} catch (ClassNotFoundException x) {
// This case should not normally happen. MS IE can throw this
// instead of a LinkageError the second time Class.forName() is
// called so assume that we are running JDK 1.1 and use the
// current ClassLoader
classLoader = FactoryFinder.class.getClassLoader();
} catch (Exception x) {
// Something abnormal happened so throw an error
throw new ConfigurationError(x.toString(), x);
}
return classLoader;
}
/**
* Create an instance of a class using the specified ClassLoader
*/
private static Object newInstance(String className,
ClassLoader classLoader)
throws ConfigurationError
{
try {
Class spiClass;
if (classLoader == null) {
spiClass = Class.forName(className);
} else {
spiClass = classLoader.loadClass(className);
}
return spiClass.newInstance();
} catch (ClassNotFoundException x) {
throw new ConfigurationError(
"Provider " + className + " not found", x);
} catch (Exception x) {
throw new ConfigurationError(
"Provider " + className + " could not be instantiated: " + x,
x);
}
}
/**
* Finds the implementation Class object in the specified order. Main
* entry point.
* @return Class object of factory, never null
*
* @param factoryId Name of the factory to find, same as
* a property name
* @param fallbackClassName Implementation class name, if nothing else
* is found. Use null to mean no fallback.
*
* Package private so this code can be shared.
*/
static Object find(String factoryId, String fallbackClassName)
throws ConfigurationError
{
ClassLoader classLoader = findClassLoader();
// Use the system property first
try {
String systemProp =
System.getProperty( factoryId );
if( systemProp!=null) {
debugPrintln("found system property" + systemProp);
return newInstance(systemProp, classLoader);
}
} catch (SecurityException se) {
}
// try to read from $java.home/lib/xml.properties
try {
String javah=System.getProperty( "java.home" );
String configFile = javah + File.separator +
"lib" + File.separator + "jaxp.properties";
File f=new File( configFile );
if( f.exists()) {
Properties props=new Properties();
props.load( new FileInputStream(f));
String factoryClassName = props.getProperty(factoryId);
debugPrintln("found java.home property " + factoryClassName);
return newInstance(factoryClassName, classLoader);
}
} catch(Exception ex ) {
if( debug ) ex.printStackTrace();
}
String serviceId = "META-INF/services/" + factoryId;
// try to find services in CLASSPATH
try {
InputStream is=null;
if (classLoader == null) {
is=ClassLoader.getSystemResourceAsStream( serviceId );
} else {
is=classLoader.getResourceAsStream( serviceId );
}
if( is!=null ) {
debugPrintln("found " + serviceId);
BufferedReader rd =
new BufferedReader(new InputStreamReader(is));
String factoryClassName = rd.readLine();
rd.close();
if (factoryClassName != null &&
! "".equals(factoryClassName)) {
debugPrintln("loaded from services: " + factoryClassName);
return newInstance(factoryClassName, classLoader);
}
}
} catch( Exception ex ) {
if( debug ) ex.printStackTrace();
}
if (fallbackClassName == null) {
throw new ConfigurationError(
"Provider for " + factoryId + " cannot be found", null);
}
debugPrintln("loaded from fallback value: " + fallbackClassName);
return newInstance(fallbackClassName, classLoader);
}
static class ConfigurationError extends Error {
private Exception exception;
/**
* Construct a new instance with the specified detail string and
* exception.
*/
ConfigurationError(String msg, Exception x) {
super(msg);
this.exception = x;
}
Exception getException() {
return exception;
}
}
/*
* The following nested classes allow getContextClassLoader() to be
* called only on JDK 1.2 and yet run in older JDK 1.1 JVMs
*/
private static abstract class ClassLoaderFinder {
abstract ClassLoader getContextClassLoader();
}
static class ClassLoaderFinderConcrete extends ClassLoaderFinder {
ClassLoader getContextClassLoader() {
return Thread.currentThread().getContextClassLoader();
}
}
}

46
java/external/src/javax/xml/parsers/ParserConfigurationException.java vendored Normal file
View File

@ -0,0 +1,46 @@
/*
* $Id$
*
* Copyright (c) 1998-1999 Sun Microsystems, Inc. All Rights Reserved.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.parsers;
/**
* Indicates a serious configuration error.
*
* @since JAXP 1.0
* @version 1.0
*/
public class ParserConfigurationException extends Exception {
/**
* Create a new <code>ParserConfigurationException</code> with no
* detail mesage.
*/
public ParserConfigurationException() {
super();
}
/**
* Create a new <code>ParserConfigurationException</code> with
* the <code>String</code> specified as an error message.
*
* @param msg The error message for the exception.
*/
public ParserConfigurationException(String msg) {
super(msg);
}
}

431
java/external/src/javax/xml/parsers/SAXParser.java vendored Normal file
View File

@ -0,0 +1,431 @@
/*
* $Id$
*
* Copyright (c) 1998-1999 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.parsers;
import java.io.InputStream;
import java.io.IOException;
import java.io.File;
import org.xml.sax.Parser;
import org.xml.sax.XMLReader;
import org.xml.sax.HandlerBase;
import org.xml.sax.helpers.DefaultHandler;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
/**
* Defines the API that wraps an {@link org.xml.sax.XMLReader}
* implementation class. In JAXP 1.0, this class wrapped the
* {@link org.xml.sax.Parser} interface, however this interface was
* replaced by the {@link org.xml.sax.XMLReader}. For ease
* of transition, this class continues to support the same name
* and interface as well as supporting new methods.
*
* An instance of this class can be obtained from the
* {@link javax.xml.parsers.SAXParserFactory#newSAXParser()} method.
* Once an instance of this class is obtained, XML can be parsed from
* a variety of input sources. These input sources are InputStreams,
* Files, URLs, and SAX InputSources.<p>
*
* This static method creates a new factory instance based
* on a system property setting or uses the platform default
* if no property has been defined.<p>
*
* The system property that controls which Factory implementation
* to create is named <code>&quot;javax.xml.parsers.SAXParserFactory&quot;</code>.
* This property names a class that is a concrete subclass of this
* abstract class. If no property is defined, a platform default
* will be used.</p>
*
* As the content is parsed by the underlying parser, methods of the
* given {@link org.xml.sax.HandlerBase} or the
* {@link org.xml.sax.helpers.DefaultHandler} are called.<p>
*
* Implementors of this class which wrap an underlying implementation
* can consider using the {@link org.xml.sax.helpers.ParserAdapter}
* class to initially adapt their SAX1 impelemntation to work under
* this revised class.<p>
*
* An implementation of <code>SAXParser</code> is <em>NOT</em>
* guaranteed to behave as per the specification if it is used concurrently by
* two or more threads. It is recommended to have one instance of the
* <code>SAXParser</code> per thread or it is upto the application to
* make sure about the use of <code>SAXParser</code> from more than one
* thread.
*
* @since JAXP 1.0
* @version 1.0
*/
public abstract class SAXParser {
protected SAXParser () {
}
/**
* Parse the content of the given {@link java.io.InputStream}
* instance as XML using the specified {@link org.xml.sax.HandlerBase}.
* <i> Use of the DefaultHandler version of this method is recommended as
* the HandlerBase class has been deprecated in SAX 2.0</i>
*
* @param is InputStream containing the content to be parsed.
* @param hb The SAX HandlerBase to use.
* @exception IOException If any IO errors occur.
* @exception IllegalArgumentException If the given InputStream is null.
* @see org.xml.sax.DocumentHandler
*/
public void parse(InputStream is, HandlerBase hb)
throws SAXException, IOException
{
if (is == null) {
throw new IllegalArgumentException("InputStream cannot be null");
}
InputSource input = new InputSource(is);
this.parse(input, hb);
}
/**
* Parse the content of the given {@link java.io.InputStream}
* instance as XML using the specified {@link org.xml.sax.HandlerBase}.
* <i> Use of the DefaultHandler version of this method is recommended as
* the HandlerBase class has been deprecated in SAX 2.0</i>
*
* @param is InputStream containing the content to be parsed.
* @param hb The SAX HandlerBase to use.
* @param systemId The systemId which is needed for resolving relative URIs.
* @exception IOException If any IO errors occur.
* @exception IllegalArgumentException If the given InputStream is null.
* @see org.xml.sax.DocumentHandler
* version of this method instead.
*/
public void parse(InputStream is, HandlerBase hb, String systemId)
throws SAXException, IOException
{
if (is == null) {
throw new IllegalArgumentException("InputStream cannot be null");
}
InputSource input = new InputSource(is);
input.setSystemId(systemId);
this.parse(input, hb);
}
/**
* Parse the content of the given {@link java.io.InputStream}
* instance as XML using the specified
* {@link org.xml.sax.helpers.DefaultHandler}.
*
* @param is InputStream containing the content to be parsed.
* @param dh The SAX DefaultHandler to use.
* @exception IOException If any IO errors occur.
* @exception IllegalArgumentException If the given InputStream is null.
* @see org.xml.sax.DocumentHandler
*/
public void parse(InputStream is, DefaultHandler dh)
throws SAXException, IOException
{
if (is == null) {
throw new IllegalArgumentException("InputStream cannot be null");
}
InputSource input = new InputSource(is);
this.parse(input, dh);
}
/**
* Parse the content of the given {@link java.io.InputStream}
* instance as XML using the specified
* {@link org.xml.sax.helpers.DefaultHandler}.
*
* @param is InputStream containing the content to be parsed.
* @param dh The SAX DefaultHandler to use.
* @param systemId The systemId which is needed for resolving relative URIs.
* @exception IOException If any IO errors occur.
* @exception IllegalArgumentException If the given InputStream is null.
* @see org.xml.sax.DocumentHandler
* version of this method instead.
*/
public void parse(InputStream is, DefaultHandler dh, String systemId)
throws SAXException, IOException
{
if (is == null) {
throw new IllegalArgumentException("InputStream cannot be null");
}
InputSource input = new InputSource(is);
input.setSystemId(systemId);
this.parse(input, dh);
}
/**
* Parse the content described by the giving Uniform Resource
* Identifier (URI) as XML using the specified
* {@link org.xml.sax.HandlerBase}.
* <i> Use of the DefaultHandler version of this method is recommended as
* the <code>HandlerBase</code> class has been deprecated in SAX 2.0</i>
*
* @param uri The location of the content to be parsed.
* @param hb The SAX HandlerBase to use.
* @exception IOException If any IO errors occur.
* @exception IllegalArgumentException If the uri is null.
* @see org.xml.sax.DocumentHandler
*/
public void parse(String uri, HandlerBase hb)
throws SAXException, IOException
{
if (uri == null) {
throw new IllegalArgumentException("uri cannot be null");
}
InputSource input = new InputSource(uri);
this.parse(input, hb);
}
/**
* Parse the content described by the giving Uniform Resource
* Identifier (URI) as XML using the specified
* {@link org.xml.sax.helpers.DefaultHandler}.
*
* @param uri The location of the content to be parsed.
* @param dh The SAX DefaultHandler to use.
* @exception IOException If any IO errors occur.
* @exception IllegalArgumentException If the uri is null.
* @see org.xml.sax.DocumentHandler
*/
public void parse(String uri, DefaultHandler dh)
throws SAXException, IOException
{
if (uri == null) {
throw new IllegalArgumentException("uri cannot be null");
}
InputSource input = new InputSource(uri);
this.parse(input, dh);
}
/**
* Parse the content of the file specified as XML using the
* specified {@link org.xml.sax.HandlerBase}.
* <i> Use of the DefaultHandler version of this method is recommended as
* the HandlerBase class has been deprecated in SAX 2.0</i>
*
* @param f The file containing the XML to parse
* @param hb The SAX HandlerBase to use.
* @exception IOException If any IO errors occur.
* @exception IllegalArgumentException If the File object is null.
* @see org.xml.sax.DocumentHandler
*/
public void parse(File f, HandlerBase hb)
throws SAXException, IOException
{
if (f == null) {
throw new IllegalArgumentException("File cannot be null");
}
String uri = "file:" + f.getAbsolutePath();
if (File.separatorChar == '\\') {
uri = uri.replace('\\', '/');
}
InputSource input = new InputSource(uri);
this.parse(input, hb);
}
/**
* Parse the content of the file specified as XML using the
* specified {@link org.xml.sax.helpers.DefaultHandler}.
*
* @param f The file containing the XML to parse
* @param dh The SAX DefaultHandler to use.
* @exception IOException If any IO errors occur.
* @exception IllegalArgumentException If the File object is null.
* @see org.xml.sax.DocumentHandler
*/
public void parse(File f, DefaultHandler dh)
throws SAXException, IOException
{
if (f == null) {
throw new IllegalArgumentException("File cannot be null");
}
String uri = "file:" + f.getAbsolutePath();
if (File.separatorChar == '\\') {
uri = uri.replace('\\', '/');
}
InputSource input = new InputSource(uri);
this.parse(input, dh);
}
/**
* Parse the content given {@link org.xml.sax.InputSource}
* as XML using the specified
* {@link org.xml.sax.HandlerBase}.
* <i> Use of the DefaultHandler version of this method is recommended as
* the HandlerBase class has been deprecated in SAX 2.0</i>
*
* @param is The InputSource containing the content to be parsed.
* @param hb The SAX HandlerBase to use.
* @exception IOException If any IO errors occur.
* @exception IllegalArgumentException If the InputSource is null.
* @see org.xml.sax.DocumentHandler
*/
public void parse(InputSource is, HandlerBase hb)
throws SAXException, IOException
{
if (is == null) {
throw new IllegalArgumentException("InputSource cannot be null");
}
Parser parser = this.getParser();
if (hb != null) {
parser.setDocumentHandler(hb);
parser.setEntityResolver(hb);
parser.setErrorHandler(hb);
parser.setDTDHandler(hb);
}
parser.parse(is);
}
/**
* Parse the content given {@link org.xml.sax.InputSource}
* as XML using the specified
* {@link org.xml.sax.helpers.DefaultHandler}.
*
* @param is The InputSource containing the content to be parsed.
* @param dh The SAX DefaultHandler to use.
* @exception IOException If any IO errors occur.
* @exception IllegalArgumentException If the InputSource is null.
* @see org.xml.sax.DocumentHandler
*/
public void parse(InputSource is, DefaultHandler dh)
throws SAXException, IOException
{
if (is == null) {
throw new IllegalArgumentException("InputSource cannot be null");
}
XMLReader reader = this.getXMLReader();
if (dh != null) {
reader.setContentHandler(dh);
reader.setEntityResolver(dh);
reader.setErrorHandler(dh);
reader.setDTDHandler(dh);
}
reader.parse(is);
}
/**
* Returns the SAX parser that is encapsultated by the
* implementation of this class.
*
* @return The SAX parser that is encapsultated by the
* implementation of this class.
*/
public abstract org.xml.sax.Parser getParser() throws SAXException;
/**
* Returns the {@link org.xml.sax.XMLReader} that is encapsulated by the
* implementation of this class.
*
* @return The XMLReader that is encapsulated by the
* implementation of this class.
*/
public abstract org.xml.sax.XMLReader getXMLReader() throws SAXException;
/**
* Indicates whether or not this parser is configured to
* understand namespaces.
*
* @return true if this parser is configured to
* understand namespaces; false otherwise.
*/
public abstract boolean isNamespaceAware();
/**
* Indicates whether or not this parser is configured to
* validate XML documents.
*
* @return true if this parser is configured to
* validate XML documents; false otherwise.
*/
public abstract boolean isValidating();
/**
* Sets the particular property in the underlying implementation of
* {@link org.xml.sax.XMLReader}.
* A list of the core features and properties can be found at
* <a href="http://www.megginson.com/SAX/Java/features.html"> http://www.megginson.com/SAX/Java/features.html </a>
*
* @param name The name of the property to be set.
* @param value The value of the property to be set.
* @exception SAXNotRecognizedException When the underlying XMLReader does
* not recognize the property name.
*
* @exception SAXNotSupportedException When the underlying XMLReader
* recognizes the property name but doesn't support the
* property.
*
* @see org.xml.sax.XMLReader#setProperty
*/
public abstract void setProperty(String name, Object value)
throws SAXNotRecognizedException, SAXNotSupportedException;
/**
*
* Returns the particular property requested for in the underlying
* implementation of {@link org.xml.sax.XMLReader}.
*
* @param name The name of the property to be retrieved.
* @return Value of the requested property.
*
* @exception SAXNotRecognizedException When the underlying XMLReader does
* not recognize the property name.
*
* @exception SAXNotSupportedException When the underlying XMLReader
* recognizes the property name but doesn't support the
* property.
*
* @see org.xml.sax.XMLReader#getProperty
*/
public abstract Object getProperty(String name)
throws SAXNotRecognizedException, SAXNotSupportedException;
}

214
java/external/src/javax/xml/parsers/SAXParserFactory.java vendored Normal file
View File

@ -0,0 +1,214 @@
/*
* $Id$
*
* Copyright (c) 1998-2000 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.parsers;
import org.xml.sax.Parser;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.SAXNotSupportedException;
/**
* Defines a factory API that enables applications to configure and
* obtain a SAX based parser to parse XML documents.<p>
* An implementation of the <code>SAXParserFactory</code> class is
* <em>NOT</em> guaranteed to be thread safe. It is up to the user application
* to make sure about the use of the <code>SAXParserFactory</code> from
* more than one thread. Alternatively the application can have one instance
* of the <code>SAXParserFactory</code> per thread.
* An application can use the same instance of the factory to obtain one or
* more instances of the <code>SAXParser</code> provided the instance
* of the factory isn't being used in more than one thread at a time.
*
* @since JAXP 1.0
* @version 1.0
*/
public abstract class SAXParserFactory {
private boolean validating = false;
private boolean namespaceAware= false;
protected SAXParserFactory () {
}
/**
* Obtain a new instance of a <code>SAXParserFactory</code>. This
* static method creates a new factory instance
* This method uses the following ordered lookup procedure to determine
* the <code>SAXParserFactory</code> implementation class to
* load:
* <ul>
* <li>
* Use the <code>javax.xml.parsers.SAXParserFactory</code> system
* property.
* </li>
* <li>
* Use the properties file "lib/jaxp.properties" in the JRE directory.
* This configuration file is in standard <code>java.util.Properties
* </code> format and contains the fully qualified name of the
* implementation class with the key being the system property defined
* above.
* </li>
* <li>
* Use the Services API (as detailed in the JAR specification), if
* available, to determine the classname. The Services API will look
* for a classname in the file
* <code>META-INF/services/javax.xml.parsers.SAXParserFactory</code>
* in jars available to the runtime.
* </li>
* <li>
* Platform default <code>SAXParserFactory</code> instance.
* </li>
* </ul>
*
* Once an application has obtained a reference to a
* <code>SAXParserFactory</code> it can use the factory to
* configure and obtain parser instances.
*
* @return A new instance of a SAXParserFactory.
*
* @exception FactoryConfigurationError if the implementation is
* not available or cannot be instantiated.
*/
public static SAXParserFactory newInstance()
throws FactoryConfigurationError
{
try {
return (SAXParserFactory) FactoryFinder.find(
/* The default property name according to the JAXP spec */
"javax.xml.parsers.SAXParserFactory",
/* The fallback implementation class name */
"org.apache.crimson.jaxp.SAXParserFactoryImpl");
} catch (FactoryFinder.ConfigurationError e) {
throw new FactoryConfigurationError(e.getException(),
e.getMessage());
}
}
/**
* Creates a new instance of a SAXParser using the currently
* configured factory parameters.
*
* @return A new instance of a SAXParser.
*
* @exception ParserConfigurationException if a parser cannot
* be created which satisfies the requested configuration.
*/
public abstract SAXParser newSAXParser()
throws ParserConfigurationException, SAXException;
/**
* Specifies that the parser produced by this code will
* provide support for XML namespaces. By default the value of this is set
* to <code>false</code>.
*
* @param awareness true if the parser produced by this code will
* provide support for XML namespaces; false otherwise.
*/
public void setNamespaceAware(boolean awareness)
{
this.namespaceAware = awareness;
}
/**
* Specifies that the parser produced by this code will
* validate documents as they are parsed. By default the value of this is
* set to <code>false</code>.
*
* @param validating true if the parser produced by this code will
* validate documents as they are parsed; false otherwise.
*/
public void setValidating(boolean validating)
{
this.validating = validating;
}
/**
* Indicates whether or not the factory is configured to produce
* parsers which are namespace aware.
*
* @return true if the factory is configured to produce
* parsers which are namespace aware; false otherwise.
*/
public boolean isNamespaceAware() {
return namespaceAware;
}
/**
* Indicates whether or not the factory is configured to produce
* parsers which validate the XML content during parse.
*
* @return true if the factory is configured to produce parsers which validate
* the XML content during parse; false otherwise.
*/
public boolean isValidating() {
return validating;
}
/**
*
* Sets the particular feature in the underlying implementation of
* org.xml.sax.XMLReader.
* A list of the core features and properties can be found at
* <a href="http://www.megginson.com/SAX/Java/features.html"> http://www.megginson.com/SAX/Java/features.html </a>
*
* @param name The name of the feature to be set.
* @param value The value of the feature to be set.
* @exception SAXNotRecognizedException When the underlying XMLReader does
* not recognize the property name.
*
* @exception SAXNotSupportedException When the underlying XMLReader
* recognizes the property name but doesn't support the
* property.
*
* @see org.xml.sax.XMLReader#setFeature
*/
public abstract void setFeature(String name, boolean value)
throws ParserConfigurationException, SAXNotRecognizedException,
SAXNotSupportedException;
/**
*
* Returns the particular property requested for in the underlying
* implementation of org.xml.sax.XMLReader.
*
* @param name The name of the property to be retrieved.
* @return Value of the requested property.
*
* @exception SAXNotRecognizedException When the underlying XMLReader does
* not recognize the property name.
*
* @exception SAXNotSupportedException When the underlying XMLReader
* recognizes the property name but doesn't support the
* property.
*
* @see org.xml.sax.XMLReader#getProperty
*/
public abstract boolean getFeature(String name)
throws ParserConfigurationException, SAXNotRecognizedException,
SAXNotSupportedException;
}

31
java/external/src/javax/xml/parsers/package.html vendored Normal file
View File

@ -0,0 +1,31 @@
<HTML><HEAD>
<!--
$Id$
This software is the confidential and proprietary information of Sun
Microsystems, Inc. ("Confidential Information"). You shall not
disclose such Confidential Information and shall use it only in
accordance with the terms of the license agreement you entered into
with Sun.
SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
THIS SOFTWARE OR ITS DERIVATIVES.
Copyright 1998-1999 by Sun Microsystems Inc. All rights reserved.
-->
</HEAD><BODY>
Provides classes allowing the processing of XML documents. Two types
of plugable parsers are supported:
<ul>
<li>SAX (Simple API for XML)
<li>DOM (Document Object Model)
</ul>
</BODY></HTML>

101
java/external/src/javax/xml/transform/ErrorListener.java vendored Normal file
View File

@ -0,0 +1,101 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
/**
* <p>To provide customized error handling, implement this interface and
* use the setErrorListener method to register an instance of the implmentation
* with the {@link javax.xml.transform.Transformer}. The Transformer then reports
* all errors and warnings through this interface.</p>
*
* <p>If an application does <em>not</em>
* register an ErrorListener, errors are reported to System.err.</p>
*
* <p>For transformation errors, a Transformer must use this interface
* instead of throwing an exception: it is up to the application
* to decide whether to throw an exception for different types of
* errors and warnings. Note however that the Transformer is not required
* to continue with the transformation after a call to fatalError.</p>
*
* <p>Transformers may use this mechanism to report XML parsing errors
* as well as transformation errors.</p>
*/
public interface ErrorListener {
/**
* Receive notification of a warning.
*
* <p>{@link javax.xml.transform.Transformer} can use this method to report
* conditions that are not errors or fatal errors. The default behaviour
* is to take no action.</p>
*
* <p>After invoking this method, the Transformer must continue with
* the transformation. It should still be possible for the
* application to process the document through to the end.</p>
*
* @param exception The warning information encapsulated in a
* transformer exception.
*
* @throws javax.xml.transform.TransformerException if the application
* chooses to discontinue the transformation.
*
* @see javax.xml.transform.TransformerException
*/
public abstract void warning(TransformerException exception)
throws TransformerException;
/**
* Receive notification of a recoverable error.
*
* <p>The transformer must continue to try and provide normal transformation
* after invoking this method. It should still be possible for the
* application to process the document through to the end if no other errors
* are encountered.</p>
*
* @param exception The error information encapsulated in a
* transformer exception.
*
* @throws javax.xml.transform.TransformerException if the application
* chooses to discontinue the transformation.
*
* @see javax.xml.transform.TransformerException
*/
public abstract void error(TransformerException exception)
throws TransformerException;
/**
* Receive notification of a non-recoverable error.
*
* <p>The transformer must continue to try and provide normal transformation
* after invoking this method. It should still be possible for the
* application to process the document through to the end if no other errors
* are encountered, but there is no guarantee that the output will be
* useable.</p>
*
* @param exception The error information encapsulated in a
* transformer exception.
*
* @throws javax.xml.transform.TransformerException if the application
* chooses to discontinue the transformation.
*
* @see javax.xml.transform.TransformerException
*/
public abstract void fatalError(TransformerException exception)
throws TransformerException;
}

231
java/external/src/javax/xml/transform/FactoryFinder.java vendored Normal file
View File

@ -0,0 +1,231 @@
/*
* $Id$
*
* Copyright (c) 1998-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
import java.io.InputStream;
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;
import java.io.BufferedReader;
import java.io.InputStreamReader;
/**
* This class is duplicated for each JAXP subpackage so keep it in
* sync. It is package private.
*
* This code is designed to implement the JAXP 1.1 spec pluggability
* feature and is designed to run on JDK version 1.1 and later including
* JVMs that perform early linking like the Microsoft JVM in IE 5. Note
* however that it must be compiled on a JDK version 1.2 or later system
* since it calls Thread#getContextClassLoader(). The code also runs both
* as part of an unbundled jar file and when bundled as part of the JDK.
*/
class FactoryFinder {
/** Temp debug code - this will be removed after we test everything
*/
private static boolean debug = false;
static {
// Use try/catch block to support applets
try {
debug = System.getProperty("jaxp.debug") != null;
} catch (Exception x) {
}
}
private static void debugPrintln(String msg) {
if (debug) {
System.err.println("JAXP: " + msg);
}
}
/**
* Figure out which ClassLoader to use. For JDK 1.2 and later use the
* context ClassLoader if possible. Note: we defer linking the class
* that calls an API only in JDK 1.2 until runtime so that we can catch
* LinkageError so that this code will run in older non-Sun JVMs such
* as the Microsoft JVM in IE.
*/
private static ClassLoader findClassLoader()
throws ConfigurationError
{
ClassLoader classLoader;
try {
// Construct the name of the concrete class to instantiate
Class clazz = Class.forName(FactoryFinder.class.getName()
+ "$ClassLoaderFinderConcrete");
ClassLoaderFinder clf = (ClassLoaderFinder) clazz.newInstance();
classLoader = clf.getContextClassLoader();
} catch (LinkageError le) {
// Assume that we are running JDK 1.1, use the current ClassLoader
classLoader = FactoryFinder.class.getClassLoader();
} catch (ClassNotFoundException x) {
// This case should not normally happen. MS IE can throw this
// instead of a LinkageError the second time Class.forName() is
// called so assume that we are running JDK 1.1 and use the
// current ClassLoader
classLoader = FactoryFinder.class.getClassLoader();
} catch (Exception x) {
// Something abnormal happened so throw an error
throw new ConfigurationError(x.toString(), x);
}
return classLoader;
}
/**
* Create an instance of a class using the specified ClassLoader
*/
private static Object newInstance(String className,
ClassLoader classLoader)
throws ConfigurationError
{
try {
Class spiClass;
if (classLoader == null) {
spiClass = Class.forName(className);
} else {
spiClass = classLoader.loadClass(className);
}
return spiClass.newInstance();
} catch (ClassNotFoundException x) {
throw new ConfigurationError(
"Provider " + className + " not found", x);
} catch (Exception x) {
throw new ConfigurationError(
"Provider " + className + " could not be instantiated: " + x,
x);
}
}
/**
* Finds the implementation Class object in the specified order. Main
* entry point.
* @return Class object of factory, never null
*
* @param factoryId Name of the factory to find, same as
* a property name
* @param fallbackClassName Implementation class name, if nothing else
* is found. Use null to mean no fallback.
*
* Package private so this code can be shared.
*/
static Object find(String factoryId, String fallbackClassName)
throws ConfigurationError
{
ClassLoader classLoader = findClassLoader();
// Use the system property first
try {
String systemProp =
System.getProperty( factoryId );
if( systemProp!=null) {
debugPrintln("found system property" + systemProp);
return newInstance(systemProp, classLoader);
}
} catch (SecurityException se) {
}
// try to read from $java.home/lib/xml.properties
try {
String javah=System.getProperty( "java.home" );
String configFile = javah + File.separator +
"lib" + File.separator + "jaxp.properties";
File f=new File( configFile );
if( f.exists()) {
Properties props=new Properties();
props.load( new FileInputStream(f));
String factoryClassName = props.getProperty(factoryId);
debugPrintln("found java.home property " + factoryClassName);
return newInstance(factoryClassName, classLoader);
}
} catch(Exception ex ) {
if( debug ) ex.printStackTrace();
}
String serviceId = "META-INF/services/" + factoryId;
// try to find services in CLASSPATH
try {
InputStream is=null;
if (classLoader == null) {
is=ClassLoader.getSystemResourceAsStream( serviceId );
} else {
is=classLoader.getResourceAsStream( serviceId );
}
if( is!=null ) {
debugPrintln("found " + serviceId);
BufferedReader rd =
new BufferedReader(new InputStreamReader(is));
String factoryClassName = rd.readLine();
rd.close();
if (factoryClassName != null &&
! "".equals(factoryClassName)) {
debugPrintln("loaded from services: " + factoryClassName);
return newInstance(factoryClassName, classLoader);
}
}
} catch( Exception ex ) {
if( debug ) ex.printStackTrace();
}
if (fallbackClassName == null) {
throw new ConfigurationError(
"Provider for " + factoryId + " cannot be found", null);
}
debugPrintln("loaded from fallback value: " + fallbackClassName);
return newInstance(fallbackClassName, classLoader);
}
static class ConfigurationError extends Error {
private Exception exception;
/**
* Construct a new instance with the specified detail string and
* exception.
*/
ConfigurationError(String msg, Exception x) {
super(msg);
this.exception = x;
}
Exception getException() {
return exception;
}
}
/*
* The following nested classes allow getContextClassLoader() to be
* called only on JDK 1.2 and yet run in older JDK 1.1 JVMs
*/
private static abstract class ClassLoaderFinder {
abstract ClassLoader getContextClassLoader();
}
static class ClassLoaderFinderConcrete extends ClassLoaderFinder {
ClassLoader getContextClassLoader() {
return Thread.currentThread().getContextClassLoader();
}
}
}

179
java/external/src/javax/xml/transform/OutputKeys.java vendored Normal file
View File

@ -0,0 +1,179 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
/**
* Provides string constants that can be used to set
* output properties for a Transformer, or to retrieve
* output properties from a Transformer or Templates object.
* <p>A properties in this class are read-only.</p>
*
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation</a>
*/
public class OutputKeys {
/**
* Default constructor is private on purpose. This class is
* only for static variable access, and should never be constructed.
*/
private OutputKeys() {}
/**
* method = "xml" | "html" | "text" | <var>expanded name</var>.
*
* <p>The method attribute identifies the overall method that
* should be used for outputting the result tree. Other non-namespaced
* values may be used, such as "xhtml", but, if accepted, the handling
* of such values is implementation defined. If any of the method values
* are not accepted and are not namespace qualified,
* then {@link javax.xml.transform.Transformer#setOutputProperty}
* or {@link javax.xml.transform.Transformer#setOutputProperties} will
* throw a {@link java.lang.IllegalArgumentException}.</p>
*
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation</a>
*/
public static final String METHOD = "method";
/**
* version = <var>nmtoken</var>.
*
* <p><code>version</code> specifies the version of the output
* method.</p>
* <p>When the output method is "xml", the version value specifies the
* version of XML to be used for outputting the result tree. The default
* value for the xml output method is 1.0. When the output method is
* "html", the version value indicates the version of the HTML.
* The default value for the xml output method is 4.0, which specifies
* that the result should be output as HTML conforming to the HTML 4.0
* Recommendation [HTML]. If the output method is "text", the version
* property is ignored.</p>
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation</a>
*/
public static final String VERSION = "version";
/**
* encoding = <var>string</var>.
*
* <p><code>encoding</code> specifies the preferred character
* encoding that the Transformer should use to encode sequences of
* characters as sequences of bytes. The value of the attribute should be
* treated case-insensitively. The value must only contain characters in
* the range #x21 to #x7E (i.e., printable ASCII characters). The value
* should either be a <code>charset</code> registered with the Internet
* Assigned Numbers Authority <a href="#IANA">[IANA]</a>,
* <a href="#RFC2278">[RFC2278]</a> or start with <code>X-</code>.</p>
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation</a>
*/
public static final String ENCODING = "encoding";
/**
* omit-xml-declaration = "yes" | "no".
*
* <p><code>omit-xml-declaration</code> specifies whether the XSLT
* processor should output an XML declaration; the value must be
* <code>yes</code> or <code>no</code>.</p>
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation</a>
*/
public static final String OMIT_XML_DECLARATION = "omit-xml-declaration";
/**
* standalone = "yes" | "no".
*
* <p><code>standalone</code> specifies whether the Transformer
* should output a standalone document declaration; the value must be
* <code>yes</code> or <code>no</code>.</p>
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation</a>
*/
public static final String STANDALONE = "standalone";
/**
* doctype-public = <var>string</var>.
* <p>See the documentation for the {@link #DOCTYPE_SYSTEM} property
* for a description of what the value of the key should be.</p>
*
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation</a>
*/
public static final String DOCTYPE_PUBLIC = "doctype-public";
/**
* doctype-system = <var>string</var>.
* <p><code>doctype-public</code> specifies the public identifier
* to be used in the document type declaration.</p>
* <p>If the doctype-system property is specified, the xml output method
* should output a document type declaration immediately before the first
* element. The name following &lt;!DOCTYPE should be the name of the first
* element. If doctype-public property is also specified, then the xml
* output method should output PUBLIC followed by the public identifier
* and then the system identifier; otherwise, it should output SYSTEM
* followed by the system identifier. The internal subset should be empty.
* The doctype-public attribute should be ignored unless the doctype-system
* attribute is specified.</p>
* <p>If the doctype-public or doctype-system attributes are specified,
* then the html output method should output a document type declaration
* immediately before the first element. The name following &lt;!DOCTYPE
* should be HTML or html. If the doctype-public attribute is specified,
* then the output method should output PUBLIC followed by the specified
* public identifier; if the doctype-system attribute is also specified,
* it should also output the specified system identifier following the
* public identifier. If the doctype-system attribute is specified but
* the doctype-public attribute is not specified, then the output method
* should output SYSTEM followed by the specified system identifier.</p>
*
* <p><code>doctype-system</code> specifies the system identifier
* to be used in the document type declaration.</p>
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation</a>
*/
public static final String DOCTYPE_SYSTEM = "doctype-system";
/**
* cdata-section-elements = <var>expanded names</var>.
*
* <p><code>cdata-section-elements</code> specifies a whitespace delimited
* list of the names of elements whose text node children should be output
* using CDATA sections.</p>
*
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation.</a>
*/
public static final String CDATA_SECTION_ELEMENTS =
"cdata-section-elements";
/**
* indent = "yes" | "no".
*
* <p><code>indent</code> specifies whether the Transformer may
* add additional whitespace when outputting the result tree; the value
* must be <code>yes</code> or <code>no</code>. </p>
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation</a>
*/
public static final String INDENT = "indent";
/**
* media-type = <var>string</var>.
*
* <p><code>media-type</code> specifies the media type (MIME
* content type) of the data that results from outputting the result
* tree. The <code>charset</code> parameter should not be specified
* explicitly; instead, when the top-level media type is
* <code>text</code>, a <code>charset</code> parameter should be added
* according to the character encoding actually used by the output
* method. </p>
* @see <a href="http://www.w3.org/TR/xslt#output">section 16 of the XSL Transformations (XSLT) W3C Recommendation</a>
*/
public static final String MEDIA_TYPE = "media-type";
}

83
java/external/src/javax/xml/transform/Result.java vendored Normal file
View File

@ -0,0 +1,83 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
import java.lang.String;
import java.io.OutputStream;
import java.io.Writer;
/**
* An object that implements this interface contains the information
* needed to build a transformation result tree.
*/
public interface Result {
/**
* The name of the processing instruction that is sent if the
* result tree disables output escaping.
*
* <p>Normally, result tree serialization escapes & and < (and
* possibly other characters) when outputting text nodes.
* This ensures that the output is well-formed XML. However,
* it is sometimes convenient to be able to produce output that is
* almost, but not quite well-formed XML; for example,
* the output may include ill-formed sections that will
* be transformed into well-formed XML by a subsequent non-XML aware
* process. If a processing instruction is sent with this name,
* serialization should be output without any escaping. </p>
*
* <p>Result DOM trees may also have PI_DISABLE_OUTPUT_ESCAPING and
* PI_ENABLE_OUTPUT_ESCAPING inserted into the tree.</p>
*
* @see <a href="http://www.w3.org/TR/xslt#disable-output-escaping">disable-output-escaping in XSLT Specification</a>
*/
public static final String PI_DISABLE_OUTPUT_ESCAPING =
"javax.xml.transform.disable-output-escaping";
/**
* The name of the processing instruction that is sent
* if the result tree enables output escaping at some point after having
* received a PI_DISABLE_OUTPUT_ESCAPING processing instruction.
*
* @see <a href="http://www.w3.org/TR/xslt#disable-output-escaping">disable-output-escaping in XSLT Specification</a>
*/
public static final String PI_ENABLE_OUTPUT_ESCAPING =
"javax.xml.transform.enable-output-escaping";
/**
* 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);
/**
* 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();
}

52
java/external/src/javax/xml/transform/Source.java vendored Normal file
View File

@ -0,0 +1,52 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
import java.lang.String;
import java.io.InputStream;
import java.io.Reader;
/**
* An object that implements this interface contains the information
* needed to act as source input (XML source or transformation instructions).
*/
public interface Source {
/**
* Set the system identifier for this Source.
*
* <p>The system identifier is optional if the source does not
* get its data from a URL, but it may still be useful to provide one.
* The application can use a system identifier, for example, to resolve
* relative URIs and to include in error messages and warnings.</p>
*
* @param systemId The system identifier as a URL string.
*/
public void setSystemId(String 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();
}

89
java/external/src/javax/xml/transform/SourceLocator.java vendored Normal file
View File

@ -0,0 +1,89 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
/**
* This interface is primarily for the purposes of reporting where
* an error occurred in the XML source or transformation instructions.
*/
public interface SourceLocator {
/**
* Return the public identifier for the current document event.
*
* <p>The return value is the public identifier of the document
* entity or of the external parsed entity in which the markup that
* triggered the event appears.</p>
*
* @return A string containing the public identifier, or
* null if none is available.
* @see #getSystemId
*/
public String getPublicId();
/**
* Return the system identifier for the current document event.
*
* <p>The return value is the system identifier of the document
* entity or of the external parsed entity in which the markup that
* triggered the event appears.</p>
*
* <p>If the system identifier is a URL, the parser must resolve it
* fully before passing it to the application.</p>
*
* @return A string containing the system identifier, or null
* if none is available.
* @see #getPublicId
*/
public String getSystemId();
/**
* Return the line number where the current document event ends.
*
* <p><strong>Warning:</strong> The return value from the method
* is intended only as an approximation for the sake of error
* reporting; it is not intended to provide sufficient information
* to edit the character content of the original XML document.</p>
*
* <p>The return value is an approximation of the line number
* in the document entity or external parsed entity where the
* markup that triggered the event appears.</p>
*
* @return The line number, or -1 if none is available.
* @see #getColumnNumber
*/
public int getLineNumber();
/**
* Return the character position where the current document event ends.
*
* <p><strong>Warning:</strong> The return value from the method
* is intended only as an approximation for the sake of error
* reporting; it is not intended to provide sufficient information
* to edit the character content of the original XML document.</p>
*
* <p>The return value is an approximation of the column number
* in the document entity or external parsed entity where the
* markup that triggered the event appears.</p>
*
* @return The column number, or -1 if none is available.
* @see #getLineNumber
*/
public int getColumnNumber();
}

76
java/external/src/javax/xml/transform/Templates.java vendored Normal file
View File

@ -0,0 +1,76 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
import java.util.Properties;
import javax.xml.transform.TransformerException;
/**
* An object that implements this interface is the runtime representation of processed
* transformation instructions.
*
* <p>Templates must be threadsafe for a given instance
* over multiple threads running concurrently, and may
* be used multiple times in a given session.</p>
*/
public interface Templates {
/**
* Create a new transformation context for this Templates object.
*
* @return A valid non-null instance of a Transformer.
*
* @throws TransformerConfigurationException if a Transformer can not be created.
*/
Transformer newTransformer() throws TransformerConfigurationException;
/**
* Get the static properties for xsl:output. The object returned will
* be a clone of the internal values. Accordingly, it can be mutated
* without mutating the Templates object, and then handed in to
* {@link javax.xml.transform.Transformer#setOutputProperties}.
*
* <p>The properties returned should contain properties set by the stylesheet,
* and these properties are "defaulted" by default properties specified by
* <a href="http://www.w3.org/TR/xslt#output">section 16 of the
* XSL Transformations (XSLT) W3C Recommendation</a>. The properties that
* were specifically set by the stylesheet should be in the base
* Properties list, while the XSLT default properties that were not
* specifically set should be in the "default" Properties list. Thus,
* getOutputProperties().getProperty(String key) will obtain any
* property in that was set by the stylesheet, <em>or</em> the default
* properties, while
* getOutputProperties().get(String key) will only retrieve properties
* that were explicitly set in the stylesheet.</p>
*
* <p>For XSLT,
* <a href="http://www.w3.org/TR/xslt#attribute-value-templates">Attribute
* Value Templates</a> attribute values will
* be returned unexpanded (since there is no context at this point). The
* namespace prefixes inside Attribute Value Templates will be unexpanded,
* so that they remain valid XPath values. (For XSLT 1.0, this is not
* a problem since Attribute Value Templates are not allowed for xsl:output
* attributes. However, the will be allowed in versions after 1.1.)</p>
*
* @return A Properties object, never null.
*/
Properties getOutputProperties();
}

246
java/external/src/javax/xml/transform/Transformer.java vendored Normal file
View File

@ -0,0 +1,246 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
import java.util.Properties;
/**
* An instance of this abstract class can transform a
* source tree into a result tree.
*
* <p>An instance of this class can be obtained with the <code>
* {@link TransformerFactory#newTransformer TransformerFactory.newTransformer}
* method. This instance may then be used to process XML from a
* variety of sources and write the transformation output to a
* variety of sinks.</p>
*
* <p>An object of this class may not be used in multiple threads
* running concurrently. Different Transformers may be used
* concurrently by different threads.</p>
*
* <p>A <code>Transformer</code> may be used multiple times. Parameters and
* output properties are preserved across transformations.</p>
*/
public abstract class Transformer {
/**
* Default constructor is protected on purpose.
*/
protected Transformer() {}
/**
* Process the source tree to the output result.
* @param xmlSource The input for the source tree.
* @param outputTarget The output target.
*
* @throws TransformerException If an unrecoverable error occurs
* during the course of the transformation.
*/
public abstract void transform(Source xmlSource, Result outputTarget)
throws TransformerException;
/**
* Add a parameter for the transformation.
*
* <p>Pass a qualified name as a two-part string, the namespace URI
* enclosed in curly braces ({}), followed by the local name. If the
* name has a null URL, the String only contain the local name. An
* application can safely check for a non-null URI by testing to see if the first
* character of the name is a '{' character.</p>
* <p>For example, if a URI and local name were obtained from an element
* defined with &lt;xyz:foo xmlns:xyz="http://xyz.foo.com/yada/baz.html"/&gt;,
* then the qualified name would be "{http://xyz.foo.com/yada/baz.html}foo". Note that
* no prefix is used.</p>
*
* @param name The name of the parameter, which may begin with a namespace URI
* in curly braces ({}).
* @param value The value object. This can be any valid Java object. It is
* up to the processor to provide the proper object coersion or to simply
* pass the object on for use in an extension.
*/
public abstract void setParameter(String name, Object value);
/**
* Get a parameter that was explicitly set with setParameter
* or setParameters.
*
* <p>This method does not return a default parameter value, which
* cannot be determined until the node context is evaluated during
* the transformation process.
*
* @return A parameter that has been set with setParameter.
*/
public abstract Object getParameter(String name);
/**
* Clear all parameters set with setParameter.
*/
public abstract void clearParameters();
/**
* Set an object that will be used to resolve URIs used in
* document().
*
* <p>If the resolver argument is null, the URIResolver value will
* be cleared, and the default behavior will be used.</p>
*
* @param resolver An object that implements the URIResolver interface,
* or null.
*/
public abstract void setURIResolver(URIResolver resolver);
/**
* Get an object that will be used to resolve URIs used in
* document(), etc.
*
* @return An object that implements the URIResolver interface,
* or null.
*/
public abstract URIResolver getURIResolver();
/**
* Set the output properties for the transformation. These
* properties will override properties set in the Templates
* with xsl:output.
*
* <p>If argument to this function is null, any properties
* previously set are removed, and the value will revert to the value
* defined in the templates object.</p>
*
* <p>Pass a qualified property key name as a two-part string, the namespace URI
* enclosed in curly braces ({}), followed by the local name. If the
* name has a null URL, the String only contain the local name. An
* application can safely check for a non-null URI by testing to see if the first
* character of the name is a '{' character.</p>
* <p>For example, if a URI and local name were obtained from an element
* defined with &lt;xyz:foo xmlns:xyz="http://xyz.foo.com/yada/baz.html"/&gt;,
* then the qualified name would be "{http://xyz.foo.com/yada/baz.html}foo". Note that
* no prefix is used.</p>
*
* @param oformat A set of output properties that will be
* used to override any of the same properties in affect
* for the transformation.
*
* @see javax.xml.transform.OutputKeys
* @see java.util.Properties
*
* @throws IllegalArgumentException if any of the argument keys are not
* recognized and are not namespace qualified.
*/
public abstract void setOutputProperties(Properties oformat)
throws IllegalArgumentException;
/**
* Get a copy of the output properties for the transformation.
*
* <p>The properties returned should contain properties set by the user,
* and properties set by the stylesheet, and these properties
* are "defaulted" by default properties specified by <a href="http://www.w3.org/TR/xslt#output">section 16 of the
* XSL Transformations (XSLT) W3C Recommendation</a>. The properties that
* were specifically set by the user or the stylesheet should be in the base
* Properties list, while the XSLT default properties that were not
* specifically set should be the default Properties list. Thus,
* getOutputProperties().getProperty(String key) will obtain any
* property in that was set by {@link #setOutputProperty},
* {@link #setOutputProperties}, in the stylesheet, <em>or</em> the default
* properties, while
* getOutputProperties().get(String key) will only retrieve properties
* that were explicitly set by {@link #setOutputProperty},
* {@link #setOutputProperties}, or in the stylesheet.</p>
*
* <p>Note that mutation of the Properties object returned will not
* effect the properties that the transformation contains.</p>
*
* <p>If any of the argument keys are not recognized and are not
* namespace qualified, the property will be ignored. In other words the
* behaviour is not orthogonal with setOutputProperties.</p>
*
* @returns A copy of the set of output properties in effect
* for the next transformation.
*
* @see javax.xml.transform.OutputKeys
* @see java.util.Properties
*/
public abstract Properties getOutputProperties();
/**
* Set an output property that will be in effect for the
* transformation.
*
* <p>Pass a qualified property name as a two-part string, the namespace URI
* enclosed in curly braces ({}), followed by the local name. If the
* name has a null URL, the String only contain the local name. An
* application can safely check for a non-null URI by testing to see if the first
* character of the name is a '{' character.</p>
* <p>For example, if a URI and local name were obtained from an element
* defined with &lt;xyz:foo xmlns:xyz="http://xyz.foo.com/yada/baz.html"/&gt;,
* then the qualified name would be "{http://xyz.foo.com/yada/baz.html}foo". Note that
* no prefix is used.</p>
*
* <p>The Properties object that was passed to {@link #setOutputProperties} won't
* be effected by calling this method.</p>
*
* @param name A non-null String that specifies an output
* property name, which may be namespace qualified.
* @param value The non-null string value of the output property.
*
* @throws IllegalArgumentException If the property is not supported, and is
* not qualified with a namespace.
*
* @see javax.xml.transform.OutputKeys
*/
public abstract void setOutputProperty(String name, String value)
throws IllegalArgumentException;
/**
* Get an output property that is in effect for the
* transformation. The property specified may be a property
* that was set with setOutputProperty, or it may be a
* property specified in the stylesheet.
*
* @param name A non-null String that specifies an output
* property name, which may be namespace qualified.
*
* @return The string value of the output property, or null
* if no property was found.
*
* @throws IllegalArgumentException If the property is not supported.
*
* @see javax.xml.transform.OutputKeys
*/
public abstract String getOutputProperty(String name)
throws IllegalArgumentException;
/**
* Set the error event listener in effect for the transformation.
*
* @param listener The new error listener.
* @throws IllegalArgumentException if listener is null.
*/
public abstract void setErrorListener(ErrorListener listener)
throws IllegalArgumentException;
/**
* Get the error event handler in effect for the transformation.
*
* @return The current error handler, which should never be null.
*/
public abstract ErrorListener getErrorListener();
}

96
java/external/src/javax/xml/transform/TransformerConfigurationException.java vendored Normal file
View File

@ -0,0 +1,96 @@
/*
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
/**
* Indicates a serious configuration error.
*/
public class TransformerConfigurationException extends TransformerException {
/**
* Create a new <code>TransformerConfigurationException</code> with no
* detail mesage.
*/
public TransformerConfigurationException() {
super("Configuration Error");
}
/**
* Create a new <code>TransformerConfigurationException</code> with
* the <code>String </code> specified as an error message.
*
* @param msg The error message for the exception.
*/
public TransformerConfigurationException(String msg) {
super(msg);
}
/**
* Create a new <code>TransformerConfigurationException</code> with a
* given <code>Exception</code> base cause of the error.
*
* @param e The exception to be encapsulated in a
* TransformerConfigurationException.
*/
public TransformerConfigurationException(Throwable e) {
super(e);
}
/**
* Create a new <code>TransformerConfigurationException</code> with the
* given <code>Exception</code> base cause and detail message.
*
* @param e The exception to be encapsulated in a
* TransformerConfigurationException
* @param msg The detail message.
* @param e The exception to be wrapped in a TransformerConfigurationException
*/
public TransformerConfigurationException(String msg, Throwable e) {
super(msg, e);
}
/**
* Create a new TransformerConfigurationException from a message and a Locator.
*
* <p>This constructor is especially useful when an application is
* creating its own exception from within a DocumentHandler
* callback.</p>
*
* @param message The error or warning message.
* @param locator The locator object for the error or warning.
*/
public TransformerConfigurationException(String message,
SourceLocator locator) {
super(message, locator);
}
/**
* Wrap an existing exception in a TransformerConfigurationException.
*
* @param message The error or warning message, or null to
* use the message from the embedded exception.
* @param locator The locator object for the error or warning.
* @param e Any exception.
*/
public TransformerConfigurationException(String message,
SourceLocator locator,
Throwable e) {
super(message, locator, e);
}
}

365
java/external/src/javax/xml/transform/TransformerException.java vendored Normal file
View File

@ -0,0 +1,365 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
import java.lang.reflect.Method;
import java.lang.IllegalAccessException;
import java.lang.reflect.InvocationTargetException;
import javax.xml.transform.SourceLocator;
/**
* This class specifies an exceptional condition that occured
* during the transformation process.
*/
public class TransformerException extends Exception {
/** Field locator specifies where the error occured */
SourceLocator locator;
/**
* Method getLocator retrieves an instance of a SourceLocator
* object that specifies where an error occured.
*
* @return A SourceLocator object, or null if none was specified.
*/
public SourceLocator getLocator() {
return locator;
}
/**
* Method setLocator sets an instance of a SourceLocator
* object that specifies where an error occured.
*
* @param location A SourceLocator object, or null to clear the location.
*/
public void setLocator(SourceLocator location) {
locator = location;
}
/** Field containedException specifies a wrapped exception. May be null. */
Throwable containedException;
/**
* This method retrieves an exception that this exception wraps.
*
* @return An Throwable object, or null.
* @see #getCause
*/
public Throwable getException() {
return containedException;
}
/**
* Returns the cause of this throwable or <code>null</code> if the
* cause is nonexistent or unknown. (The cause is the throwable that
* caused this throwable to get thrown.)
*/
public Throwable getCause() {
return ((containedException == this)
? null
: containedException);
}
/**
* Initializes the <i>cause</i> of this throwable to the specified value.
* (The cause is the throwable that caused this throwable to get thrown.)
*
* <p>This method can be called at most once. It is generally called from
* within the constructor, or immediately after creating the
* throwable. If this throwable was created
* with {@link #TransformerException(Throwable)} or
* {@link #TransformerException(String,Throwable)}, this method cannot be called
* even once.
*
* @param cause the cause (which is saved for later retrieval by the
* {@link #getCause()} method). (A <tt>null</tt> value is
* permitted, and indicates that the cause is nonexistent or
* unknown.)
* @return a reference to this <code>Throwable</code> instance.
* @throws IllegalArgumentException if <code>cause</code> is this
* throwable. (A throwable cannot
* be its own cause.)
* @throws IllegalStateException if this throwable was
* created with {@link #TransformerException(Throwable)} or
* {@link #TransformerException(String,Throwable)}, or this method has already
* been called on this throwable.
*/
public synchronized Throwable initCause(Throwable cause) {
if (this.containedException != null) {
throw new IllegalStateException("Can't overwrite cause");
}
if (cause == this) {
throw new IllegalArgumentException(
"Self-causation not permitted");
}
this.containedException = cause;
return this;
}
/**
* Create a new TransformerException.
*
* @param message The error or warning message.
*/
public TransformerException(String message) {
super(message);
this.containedException = null;
this.locator = null;
}
/**
* Create a new TransformerException wrapping an existing exception.
*
* @param e The exception to be wrapped.
*/
public TransformerException(Throwable e) {
super(e.toString());
this.containedException = e;
this.locator = null;
}
/**
* Wrap an existing exception in a TransformerException.
*
* <p>This is used for throwing processor exceptions before
* the processing has started.</p>
*
* @param message The error or warning message, or null to
* use the message from the embedded exception.
* @param e Any exception
*/
public TransformerException(String message, Throwable e) {
super(((message == null) || (message.length() == 0))
? e.toString()
: message);
this.containedException = e;
this.locator = null;
}
/**
* Create a new TransformerException from a message and a Locator.
*
* <p>This constructor is especially useful when an application is
* creating its own exception from within a DocumentHandler
* callback.</p>
*
* @param message The error or warning message.
* @param locator The locator object for the error or warning.
*/
public TransformerException(String message, SourceLocator locator) {
super(message);
this.containedException = null;
this.locator = locator;
}
/**
* Wrap an existing exception in a TransformerException.
*
* @param message The error or warning message, or null to
* use the message from the embedded exception.
* @param locator The locator object for the error or warning.
* @param e Any exception
*/
public TransformerException(String message, SourceLocator locator,
Throwable e) {
super(message);
this.containedException = e;
this.locator = locator;
}
/**
* Get the error message with location information
* appended.
*
* @return A <code>String</code> representing the error message with
* location information appended.
*/
public String getMessageAndLocation() {
StringBuffer sbuffer = new StringBuffer();
String message = super.getMessage();
if (null != message) {
sbuffer.append(message);
}
if (null != locator) {
String systemID = locator.getSystemId();
int line = locator.getLineNumber();
int column = locator.getColumnNumber();
if (null != systemID) {
sbuffer.append("; SystemID: ");
sbuffer.append(systemID);
}
if (0 != line) {
sbuffer.append("; Line#: ");
sbuffer.append(line);
}
if (0 != column) {
sbuffer.append("; Column#: ");
sbuffer.append(column);
}
}
return sbuffer.toString();
}
/**
* Get the location information as a string.
*
* @return A string with location info, or null
* if there is no location information.
*/
public String getLocationAsString() {
if (null != locator) {
StringBuffer sbuffer = new StringBuffer();
String systemID = locator.getSystemId();
int line = locator.getLineNumber();
int column = locator.getColumnNumber();
if (null != systemID) {
sbuffer.append("; SystemID: ");
sbuffer.append(systemID);
}
if (0 != line) {
sbuffer.append("; Line#: ");
sbuffer.append(line);
}
if (0 != column) {
sbuffer.append("; Column#: ");
sbuffer.append(column);
}
return sbuffer.toString();
} else {
return null;
}
}
/**
* Print the the trace of methods from where the error
* originated. This will trace all nested exception
* objects, as well as this object.
*/
public void printStackTrace() {
printStackTrace(new java.io.PrintWriter(System.err, true));
}
/**
* Print the the trace of methods from where the error
* originated. This will trace all nested exception
* objects, as well as this object.
* @param s The stream where the dump will be sent to.
*/
public void printStackTrace(java.io.PrintStream s) {
printStackTrace(new java.io.PrintWriter(s));
}
/**
* Print the the trace of methods from where the error
* originated. This will trace all nested exception
* objects, as well as this object.
* @param s The writer where the dump will be sent to.
*/
public void printStackTrace(java.io.PrintWriter s) {
if (s == null) {
s = new java.io.PrintWriter(System.err, true);
}
try {
String locInfo = getLocationAsString();
if (null != locInfo) {
s.println(locInfo);
}
super.printStackTrace(s);
} catch (Throwable e) {}
Throwable exception = getException();
for (int i = 0; (i < 10) && (null != exception); i++) {
s.println("---------");
try {
if (exception instanceof TransformerException) {
String locInfo =
((TransformerException) exception)
.getLocationAsString();
if (null != locInfo) {
s.println(locInfo);
}
}
exception.printStackTrace(s);
} catch (Throwable e) {
s.println("Could not print stack trace...");
}
try {
Method meth =
((Object) exception).getClass().getMethod("getException",
null);
if (null != meth) {
Throwable prev = exception;
exception = (Throwable) meth.invoke(exception, null);
if (prev == exception) {
break;
}
} else {
exception = null;
}
} catch (InvocationTargetException ite) {
exception = null;
} catch (IllegalAccessException iae) {
exception = null;
} catch (NoSuchMethodException nsme) {
exception = null;
}
}
}
}

259
java/external/src/javax/xml/transform/TransformerFactory.java vendored Normal file
View File

@ -0,0 +1,259 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.BufferedReader;
import java.util.Properties;
import java.util.Enumeration;
import java.lang.reflect.Method;
import java.lang.reflect.InvocationTargetException;
/**
* A TransformerFactory instance can be used to create
* {@link javax.xml.transform.Transformer} and
* {@link javax.xml.transform.Templates} objects.
*
* <p>The system property that determines which Factory implementation to
* create is named <code>"javax.xml.transform.TransformerFactory"</code>.
* This property names a concrete subclass of the
* <code>TransformerFactory</code> abstract class. If the property is not
* defined, a platform default is be used.</p>
*
* An implementation of the <code>TransformerFactory</code> class is
* <em>NOT</em> guaranteed to be thread safe. It is up to the user application
* to make sure about the use of the <code>TransformerFactory</code> from
* more than one thread. Alternatively the application can have one instance
* of the <code>TransformerFactory</code> per thread.
* An application can use the same instance of the factory to obtain one or
* more instances of a <code>Transformer</code> or <code>Templates</code>
* provided the instance of the factory isn't being used in more than one
* thread at a time.
*/
public abstract class TransformerFactory {
/**
* Default constructor is protected on purpose.
*/
protected TransformerFactory() {}
/**
* Obtain a new instance of a <code>TransformerFactory</code>.
* This static method creates a new factory instance
* This method uses the following ordered lookup procedure to determine
* the <code>TransformerFactory</code> implementation class to
* load:
* <ul>
* <li>
* Use the <code>javax.xml.transform.TransformerFactory</code> system
* property.
* </li>
* <li>
* Use the properties file "lib/jaxp.properties" in the JRE directory.
* This configuration file is in standard <code>java.util.Properties
* </code> format and contains the fully qualified name of the
* implementation class with the key being the system property defined
* above.
* </li>
* <li>
* Use the Services API (as detailed in the JAR specification), if
* available, to determine the classname. The Services API will look
* for a classname in the file
* <code>META-INF/services/javax.xml.transform.TransformerFactory</code>
* in jars available to the runtime.
* </li>
* <li>
* Platform default <code>TransformerFactory</code> instance.
* </li>
* </ul>
*
* Once an application has obtained a reference to a <code>
* TransformerFactory</code> it can use the factory to configure
* and obtain parser instances.
*
* @return new TransformerFactory instance, never null.
*
* @throws TransformerFactoryConfigurationError
* if the implmentation is not available or cannot be instantiated.
*/
public static TransformerFactory newInstance()
throws TransformerFactoryConfigurationError
{
try {
return (TransformerFactory) FactoryFinder.find(
/* The default property name according to the JAXP spec */
"javax.xml.transform.TransformerFactory",
/* The fallback implementation class name */
"org.apache.xalan.processor.TransformerFactoryImpl");
} catch (FactoryFinder.ConfigurationError e) {
throw new TransformerFactoryConfigurationError(e.getException(),
e.getMessage());
}
}
/**
* Process the Source into a Transformer object. Care must
* be given not to use this object in multiple threads running concurrently.
* Different TransformerFactories can be used concurrently by different
* threads.
*
* @param source An object that holds a URI, input stream, etc.
*
* @return A Transformer object that may be used to perform a transformation
* in a single thread, never null.
*
* @exception TransformerConfigurationException May throw this during the parse
* when it is constructing the Templates object and fails.
*/
public abstract Transformer newTransformer(Source source)
throws TransformerConfigurationException;
/**
* Create a new Transformer object that performs a copy
* of the source to the result.
*
* @param source An object that holds a URI, input stream, etc.
*
* @return A Transformer object that may be used to perform a transformation
* in a single thread, never null.
*
* @exception TransformerConfigurationException May throw this during
* the parse when it is constructing the
* Templates object and fails.
*/
public abstract Transformer newTransformer()
throws TransformerConfigurationException;
/**
* Process the Source into a Templates object, which is a
* a compiled representation of the source. This Templates object
* may then be used concurrently across multiple threads. Creating
* a Templates object allows the TransformerFactory to do detailed
* performance optimization of transformation instructions, without
* penalizing runtime transformation.
*
* @param source An object that holds a URL, input stream, etc.
*
* @return A Templates object capable of being used for transformation purposes,
* never null.
*
* @exception TransformerConfigurationException May throw this during the parse when it
* is constructing the Templates object and fails.
*/
public abstract Templates newTemplates(Source source)
throws TransformerConfigurationException;
/**
* Get the stylesheet specification(s) associated
* via the xml-stylesheet processing instruction (see
* http://www.w3.org/TR/xml-stylesheet/) with the document
* document specified in the source parameter, and that match
* the given criteria. Note that it is possible to return several
* stylesheets, in which case they are applied as if they were
* a list of imports or cascades in a single stylesheet.
*
* @param source The XML source document.
* @param media The media attribute to be matched. May be null, in which
* case the prefered templates will be used (i.e. alternate = no).
* @param title The value of the title attribute to match. May be null.
* @param charset The value of the charset attribute to match. May be null.
*
* @return A Source object suitable for passing to the TransformerFactory.
*
* @throws TransformerConfigurationException.
*/
public abstract Source getAssociatedStylesheet(
Source source, String media, String title, String charset)
throws TransformerConfigurationException;
/**
* Set an object that is used by default during the transformation
* to resolve URIs used in xsl:import, or xsl:include.
*
* @param resolver An object that implements the URIResolver interface,
* or null.
*/
public abstract void setURIResolver(URIResolver resolver);
/**
* Get the object that is used by default during the transformation
* to resolve URIs used in document(), xsl:import, or xsl:include.
*
* @return The URIResolver that was set with setURIResolver.
*/
public abstract URIResolver getURIResolver();
//======= CONFIGURATION METHODS =======
/**
* Look up the value of a feature.
*
* <p>The feature name is any absolute URI.</p>
* @param name The feature name, which is an absolute URI.
* @return The current state of the feature (true or false).
*/
public abstract boolean getFeature(String name);
/**
* Allows the user to set specific attributes on the underlying
* implementation. An attribute in this context is defined to
* be an option that the implementation provides.
*
* @param name The name of the attribute.
* @param value The value of the attribute.
* @throws IllegalArgumentException thrown if the underlying
* implementation doesn't recognize the attribute.
*/
public abstract void setAttribute(String name, Object value)
throws IllegalArgumentException;
/**
* Allows the user to retrieve specific attributes on the underlying
* implementation.
* @param name The name of the attribute.
* @return value The value of the attribute.
* @throws IllegalArgumentException thrown if the underlying
* implementation doesn't recognize the attribute.
*/
public abstract Object getAttribute(String name)
throws IllegalArgumentException;
/**
* Set the error event listener for the TransformerFactory, which
* is used for the processing of transformation instructions,
* and not for the transformation itself.
*
* @param listener The new error listener.
* @throws IllegalArgumentException if listener is null.
*/
public abstract void setErrorListener(ErrorListener listener)
throws IllegalArgumentException;
/**
* Get the error event handler for the TransformerFactory.
*
* @return The current error handler, which should never be null.
*/
public abstract ErrorListener getErrorListener();
}

112
java/external/src/javax/xml/transform/TransformerFactoryConfigurationError.java vendored Normal file
View File

@ -0,0 +1,112 @@
/*
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
/**
* Thrown when a problem with configuration with the Transformer Factories
* exists. This error will typically be thrown when the class of a
* transformation factory specified in the system properties cannot be found
* or instantiated.
*/
public class TransformerFactoryConfigurationError extends Error {
private Exception exception;
/**
* Create a new <code>TransformerFactoryConfigurationError</code> with no
* detail mesage.
*/
public TransformerFactoryConfigurationError() {
super();
this.exception = null;
}
/**
* Create a new <code>TransformerFactoryConfigurationError</code> with
* the <code>String</code> specified as an error message.
*
* @param msg The error message for the exception.
*/
public TransformerFactoryConfigurationError(String msg) {
super(msg);
this.exception = null;
}
/**
* Create a new <code>TransformerFactoryConfigurationError</code> with a
* given <code>Exception</code> base cause of the error.
*
* @param e The exception to be encapsulated in a
* TransformerFactoryConfigurationError.
*/
public TransformerFactoryConfigurationError(Exception e) {
super(e.toString());
this.exception = e;
}
/**
* Create a new <code>TransformerFactoryConfigurationError</code> with the
* given <code>Exception</code> base cause and detail message.
*
* @param e The exception to be encapsulated in a
* TransformerFactoryConfigurationError
* @param msg The detail message.
* @param e The exception to be wrapped in a TransformerFactoryConfigurationError
*/
public TransformerFactoryConfigurationError(Exception e, String msg) {
super(msg);
this.exception = e;
}
/**
* Return the message (if any) for this error . If there is no
* message for the exception and there is an encapsulated
* exception then the message of that exception will be returned.
*
* @return The error message.
*/
public String getMessage() {
String message = super.getMessage();
if ((message == null) && (exception != null)) {
return exception.getMessage();
}
return message;
}
/**
* Return the actual exception (if any) that caused this exception to
* be raised.
*
* @return The encapsulated exception, or null if there is none.
*/
public Exception getException() {
return exception;
}
}

43
java/external/src/javax/xml/transform/URIResolver.java vendored Normal file
View File

@ -0,0 +1,43 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform;
/**
* <p>An object that implements this interface that can be called by the processor
* to turn a URI used in document(), xsl:import, or xsl:include into a Source object.
*/
public interface URIResolver {
/**
* Called by the processor when it encounters
* an xsl:include, xsl:import, or document() function.
*
* @param href An href attribute, which may be relative or absolute.
* @param base The base URI in effect when the href attribute
* was encountered.
*
* @return A Source object, or null if the href cannot be resolved,
* and the processor should try to resolve the URI itself.
*
* @throws TransformerException if an error occurs when trying to
* resolve the URI.
*/
public Source resolve(String href, String base)
throws TransformerException;
}

43
java/external/src/javax/xml/transform/dom/DOMLocator.java vendored Normal file
View File

@ -0,0 +1,43 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform.dom;
import javax.xml.transform.SourceLocator;
import org.w3c.dom.Node;
/**
* Indicates the position of a node in a source DOM, intended
* primarily for error reporting. To use a DOMLocator, the receiver of an
* error must downcast the {@link javax.xml.transform.SourceLocator}
* object returned by an exception. A {@link javax.xml.transform.Transformer}
* may use this object for purposes other than error reporting, for instance,
* to indicate the source node that originated a result node.
*/
public interface DOMLocator extends SourceLocator {
/**
* Return the node where the event occurred.
*
* @return The node that is the location for the event.
*/
public Node getOriginatingNode();
}

142
java/external/src/javax/xml/transform/dom/DOMResult.java vendored Normal file
View File

@ -0,0 +1,142 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform.dom;
import javax.xml.transform.*;
import java.lang.String;
import java.io.OutputStream;
import java.io.Writer;
import org.w3c.dom.Node;
/**
* Acts as a holder for a transformation result tree, in the
* form of a Document Object Model (DOM) tree. If no output DOM source is set,
* the transformation will create a Document node as the holder
* for the result of the transformation, which may be retrieved
* with getNode.
*/
public class DOMResult implements Result {
/** If {@link javax.xml.transform.TransformerFactory#getFeature}
* returns true when passed this value as an argument,
* the Transformer supports Result output of this type.
*/
public static final String FEATURE =
"http://javax.xml.transform.dom.DOMResult/feature";
/**
* Zero-argument default constructor.
*/
public DOMResult() {}
/**
* Use a DOM node to create a new output target. 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 n The DOM node that will contain the result tree.
*/
public DOMResult(Node node) {
setNode(node);
}
/**
* Create a new output target with a DOM node. 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 DOM node that will contain the result tree.
* @param systemID The system identifier which may be used in association
* with this node.
*/
public DOMResult(Node node, String systemID) {
setNode(node);
setSystemId(systemID);
}
/**
* 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) {
this.node = 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() {
return node;
}
/**
* Method setSystemId Set the systemID that may be used in association
* with the node.
*
* @param systemId The system identifier as a URI string.
*/
public void setSystemId(String systemId) {
this.systemId = 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() {
return systemId;
}
//////////////////////////////////////////////////////////////////////
// Internal state.
//////////////////////////////////////////////////////////////////////
/**
* The node to which the transformation will be appended.
*/
private Node node;
/**
* The systemID that may be used in association
* with the node.
*/
private String systemId;
}

131
java/external/src/javax/xml/transform/dom/DOMSource.java vendored Normal file
View File

@ -0,0 +1,131 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform.dom;
import javax.xml.transform.*;
import java.lang.String;
import java.io.OutputStream;
import java.io.Writer;
import org.w3c.dom.Node;
/**
* Acts as a holder for a transformation Source tree in the
* form of a Document Object Model (DOM) tree.
*
* @see <a href="http://www.w3.org/TR/DOM-Level-2">Document Object Model (DOM) Level 2 Specification</a>
*/
public class DOMSource implements Source {
/** If {@link javax.xml.transform.TransformerFactory#getFeature}
* returns true when passed this value as an argument,
* the Transformer supports Source input of this type.
*/
public static final String FEATURE =
"http://javax.xml.transform.dom.DOMSource/feature";
/**
* Zero-argument default constructor. If this is used, and
* no DOM source is set, then the Transformer will
* create an empty source Document using
* {@link javax.xml.parsers.DocumentBuilder#newDocument}.
*/
public DOMSource() {}
/**
* Create a new input source with a DOM node. The operation
* will be applied to the subtree rooted at this node. In XSLT,
* a "/" pattern still means the root of the tree (not the subtree),
* and the evaluation of global variables and parameters is done
* from the root node also.
*
* @param n The DOM node that will contain the Source tree.
*/
public DOMSource(Node n) {
setNode(n);
}
/**
* Create a new input source with a DOM node, and with the
* system ID also passed in as the base URI.
*
* @param node The DOM node that will contain the Source tree.
* @param systemID Specifies the base URI associated with node.
*/
public DOMSource(Node node, String systemID) {
setNode(node);
setSystemId(systemID);
}
/**
* Set the node that will represents a Source DOM tree.
*
* @param node The node that is to be transformed.
*/
public void setNode(Node node) {
this.node = node;
}
/**
* Get the node that represents a Source DOM tree.
*
* @return The node that is to be transformed.
*/
public Node getNode() {
return node;
}
/**
* Set the base ID (URL or system ID) from where URLs
* will be resolved.
*
* @param baseID Base URL for this DOM tree.
*/
public void setSystemId(String baseID) {
this.baseID = baseID;
}
/**
* Get the base ID (URL or system ID) from where URLs
* will be resolved.
*
* @return Base URL for this DOM tree.
*/
public String getSystemId() {
return this.baseID;
}
//////////////////////////////////////////////////////////////////////
// Internal state.
//////////////////////////////////////////////////////////////////////
/**
* Field node
*/
private Node node;
/**
* The base ID (URL or system ID) from where URLs
* will be resolved.
*/
String baseID;
}

36
java/external/src/javax/xml/transform/dom/package.html vendored Normal file
View File

@ -0,0 +1,36 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>javax.xml.transform.dom</title>
</head>
<body>
<p>This package implements DOM-specific transformation APIs.</p>
<p>The {@link javax.xml.transform.dom.DOMSource} class allows the
client of the implementation of this API to specify a DOM
{@link org.w3c.dom.Node} as the source of the input tree. The model of
how the Transformer deals with the DOM tree in terms of mismatches with the
<A href="http://www.w3.org/TR/xslt#data-model">XSLT data model</A> or
other data models is beyond the scope of this document. Any of the nodes
derived from {@link org.w3c.dom.Node} are legal input.</p>
<p>The {@link javax.xml.transform.dom.DOMResult} class allows
a {@link org.w3c.dom.Node} to be specified to which result DOM nodes will
be appended. If an output node is not specified, the transformer will use
{@link javax.xml.parsers.DocumentBuilder#newDocument} to create an
output {@link org.w3c.dom.Document} node. If a node is specified, it
should be one of the following: {@link org.w3c.dom.Document},
{@link org.w3c.dom.Element}, or
{@link org.w3c.dom.DocumentFragment}. Specification of any other node
type is implementation dependent and undefined by this API. If the result is a
{@link org.w3c.dom.Document}, the output of the transformation must have
a single element root to set as the document element.</p>
<p>The {@link javax.xml.transform.dom.DOMLocator} node may be passed
to {@link javax.xml.transform.TransformerException} objects, and
retrieved by trying to cast the result of the
{@link javax.xml.transform.TransformerException#getLocator()} method.
The implementation has no responsibility to use a DOMLocator instead of a
{@link javax.xml.transform.SourceLocator} (though line numbers and the
like do not make much sense for a DOM), so the result of getLocator must always
be tested with an instanceof. </p>
</body>
</html>

258
java/external/src/javax/xml/transform/overview.html vendored Normal file
View File

@ -0,0 +1,258 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title></title>
</head>
<body>
<h2>Transformation API For XML </h2>
<h3>Introduction</h3>
<p>This overview describes the set of APIs contained in
javax.xml.transform. For the sake of brevity, these interfaces are referred to
as TrAX (Transformations for XML). </p>
<p>There is a broad need for Java applications to be able to transform XML
and related tree-shaped data structures. In fact, XML is not normally very
useful to an application without going through some sort of transformation,
unless the semantic structure is used directly as data. Almost all XML-related
applications need to perform transformations. Transformations may be described
by Java code, Perl code, <A href="http://www.w3.org/TR/xslt">XSLT</A>
Stylesheets, other types of script, or by proprietary formats. The inputs, one
or multiple, to a transformation, may be a URL, XML stream, a DOM tree, SAX
Events, or a proprietary format or data structure. The output types are the
pretty much the same types as the inputs, but different inputs may need to be
combined with different outputs.</p>
<p>The great challenge of a transformation API is how to deal with all the
possible combinations of inputs and outputs, without becoming specialized for
any of the given types.</p>
<p>The Java community will greatly benefit from a common API that will
allow them to understand and apply a single model, write to consistent
interfaces, and apply the transformations polymorphically. TrAX attempts to
define a model that is clean and generic, yet fills general application
requirements across a wide variety of uses. </p>
<h3>General Terminology</h3>
<p>This section will explain some general terminology used in this
document. Technical terminology will be explained in the Model section. In many
cases, the general terminology overlaps with the technical terminology.</p>
<ul>
<li>
<p>
<b>Tree</b>
<br>This term, as used within this document, describes an
abstract structure that consists of nodes or events that may be produced by
XML. A Tree physically may be a DOM tree, a series of well balanced parse
events (such as those coming from a SAX2 ContentHander), a series of requests
(the result of which can describe a tree), or a stream of marked-up
characters.</p>
</li>
<li>
<p>
<b>Source Tree(s)</b>
<br>One or more trees that are the inputs to the
transformation.</p>
</li>
<li>
<p>
<b>Result Tree(s)</b>
<br>One or more trees that are the output of the
transformation.</p>
</li>
<li>
<p>
<b>Transformation</b>
<br>The processor of consuming a stream or tree to produce
another stream or tree.</p>
</li>
<li>
<p>
<b>Identity (or Copy) Transformation</b>
<br>The process of transformation from a source to a result,
making as few structural changes as possible and no informational changes. The
term is somewhat loosely used, as the process is really a copy. from one
"format" (such as a DOM tree, stream, or set of SAX events) to
another.</p>
</li>
<li>
<p>
<b>Serialization</b>
<br>The process of taking a tree and turning it into a stream. In
some sense, a serialization is a specialized transformation.</p>
</li>
<li>
<p>
<b>Parsing</b>
<br>The process of taking a stream and turning it into a tree. In
some sense, parsing is a specialized transformation.</p>
</li>
<li>
<p>
<b>Transformer</b>
<br>A Transformer is the object that executes the transformation.
</p>
</li>
<li>
<p>
<b>Transformation instructions</b>
<br>Describes the transformation. A form of code, script, or
simply a declaration or series of declarations.</p>
</li>
<li>
<p>
<b>Stylesheet</b>
<br>The same as "transformation instructions," except it is
likely to be used in conjunction with <A href="http://www.w3.org/TR/xslt">XSLT</A>.</p>
</li>
<li>
<p>
<b>Templates</b>
<br>Another form of "transformation instructions." In the TrAX
interface, this term is used to describe processed or compiled transformation
instructions. The Source flows through a Templates object to be formed into the
Result.</p>
</li>
<li>
<p>
<b>Processor</b>
<br>A general term for the thing that may both process the
transformation instructions, and perform the transformation.</p>
</li>
<li>
<p>
<b>DOM</b>
<br>Document Object Model, specifically referring to the
<A href="#http://www.w3.org/TR/DOM-Level-2%20">Document Object Model
(DOM) Level 2 Specification</A>.</p>
</li>
<li>
<p>
<b>SAX</b>
<br>Simple API for XML, specifically referring to the
<A href="#http://www.megginson.com/SAX/SAX2">SAX 2.0
release</A>.</p>
</li>
</ul>
<h3>Model</h3>
<p>The section defines the abstract model for TrAX, apart from the details
of the interfaces.</p>
<p>A TRaX <A href="#pattern-TransformerFactory">TransformerFactory</A> is an object
that processes transformation instructions, and produces
<A href="#pattern-Templates">Templates</A> (in the technical
terminology). A <A href="#pattern-Templates">Templates</A>
object provides a <A href="#pattern-Transformer">Transformer</A>, which transforms one or
more <A href="#pattern-Source">Source</A>s into one or more
<A href="#pattern-Result">Result</A>s.</p>
<p>To use the TRaX interface, you create a
<A href="#pattern-TransformerFactory">TransformerFactory</A>,
which may directly provide a <A href="#pattern-Transformers">Transformers</A>, or which can provide
<A href="#pattern-Templates">Templates</A> from a variety of
<A href="#pattern-Source">Source</A>s. The
<A href="#pattern-Templates">Templates</A> object is a processed
or compiled representation of the transformation instructions, and provides a
<A href="#pattern-Transformer">Transformer</A>. The
<A href="#pattern-Transformer">Transformer</A> processes a
<A href="#pattern-Transformer">Source</A> according to the
instructions found in the <A href="#pattern-Templates">Templates</A>, and produces a
<A href="#pattern-Result">Result</A>.</p>
<p>The process of transformation from a tree, either in the form of an
object model, or in the form of parse events, into a stream, is known as
<code>serialization</code>. We believe this is the most suitable term for
this process, despite the overlap with Java object serialization.</p>
<H3>TRaX Patterns</H3>
<ul>
<p>
<b><a name="pattern-Processor">Processor</a></b>
<br>
<br>
<i>Intent: </i>Generic concept for the
set of objects that implement the TrAX interfaces.<br>
<i>Responsibilities: </i>Create compiled transformation instructions, transform
sources, and manage transformation parameters and
properties.<br>
<i>Thread safety: </i>Only the Templates object can be
used concurrently in multiple threads. The rest of the processor does not do
synchronized blocking, and so may not be used to perform multiple concurrent
operations. Different Processors can be used concurrently by different
threads.</p>
<p>
<b><a name="pattern-TransformerFactory">TransformerFactory</a></b>
<br>
<br>
<i>Intent: </i>Serve as a vendor-neutral Processor interface for
<A href="http://www.w3.org/TR/xslt">XSLT</A> and similar
processors.<br>
<i>Responsibilities: </i>Serve as a factory for a concrete
implementation of an TransformerFactory, serve as a direct factory for
Transformer objects, serve as a factory for Templates objects, and manage
processor specific features.<br>
<i>Thread safety: </i>A
TransformerFactory may not perform mulitple concurrent
operations.</p>
<p>
<b><a name="pattern-Templates">Templates</a></b>
<br>
<br>
<i>Intent: </i>The
runtime representation of the transformation instructions.<br>
<i>Responsibilities: </i>A data bag for transformation instructions; act as a factory
for Transformers.<br>
<i>Thread safety: </i>Threadsafe for concurrent
usage over multiple threads once construction is complete.</p>
<p>
<b><a name="pattern-Transformer">Transformer</a></b>
<br>
<br>
<i>Intent: </i>Act as a per-thread
execution context for transformations, act as an interface for performing the
transformation.<br>
<i>Responsibilities: </i>Perform the
transformation.<br>
<i>Thread safety: </i>Only one instance per thread
is safe.<br>
<i>Notes: </i>The Transformer is bound to the Templates
object that created it.</p>
<p>
<b><a name="pattern-Source">Source</a></b>
<br>
<br>
<i>Intent: </i>Serve as a
single vendor-neutral object for multiple types of input.<br>
<i>Responsibilities: </i>Act as simple data holder for System IDs, DOM nodes, streams,
etc.<br>
<i>Thread safety: </i>Threadsafe concurrently over multiple
threads for read-only operations; must be synchronized for edit
operations.</p>
<p>
<b><a name="pattern-Result">Result</a></b>
<br>
<br>
<i>Potential alternate name: </i>ResultTarget<br>
<i>Intent: </i>Serve
as a single object for multiple types of output, so there can be simple process
method signatures.<br>
<i>Responsibilities: </i>Act as simple data holder for
output stream, DOM node, ContentHandler, etc.<br>
<i>Thread safety: </i>Threadsafe concurrently over multiple threads for read-only,
must be synchronized for edit.</p>
</ul>
</body>
</html>

177
java/external/src/javax/xml/transform/package.html vendored Normal file
View File

@ -0,0 +1,177 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>javax.xml.transform</title>
</head>
<body>
<p>This package defines the generic APIs for processing transformation
instructions, and performing a transformation from source to result. These
interfaces have no dependencies on SAX or the DOM standard, and try to make as
few assumptions as possible about the details of the source and result of a
transformation. It achieves this by defining
{@link javax.xml.transform.Source} and
{@link javax.xml.transform.Result} interfaces.</p>
<p>To define concrete classes for the user, the API defines specializations
of the interfaces found at the root level. These interfaces are found in
{@link javax.xml.transform.sax}, {@link javax.xml.transform.dom},
and {@link javax.xml.transform.stream}.</p>
<h3>Creating Objects</h3>
<p>The API allows a concrete
{@link javax.xml.transform.TransformerFactory} object to be created from
the static function
{@link javax.xml.transform.TransformerFactory#newInstance}.
<h3>Specification of Inputs and Outputs</h3>
<p>This API defines two interface objects called
{@link javax.xml.transform.Source} and
{@link javax.xml.transform.Result}. In order to pass Source and Result
objects to the interfaces, concrete classes must be used.
Three concrete representations are defined for each of these
objects:
{@link javax.xml.transform.stream.StreamSource} and
{@link javax.xml.transform.stream.StreamResult},
{@link javax.xml.transform.sax.SAXSource} and
{@link javax.xml.transform.sax.SAXResult}, and
{@link javax.xml.transform.dom.DOMSource} and
{@link javax.xml.transform.dom.DOMResult}. Each of these objects defines
a FEATURE string (which is i the form of a URL), which can be passed into
{@link javax.xml.transform.TransformerFactory#getFeature} to see if the
given type of Source or Result object is supported. For instance, to test if a
DOMSource and a StreamResult is supported, you can apply the following
test.</p>
<code>
<pre> TransformerFactory tfactory = TransformerFactory.newInstance();
if (tfactory.getFeature(DOMSource.FEATURE) &amp;&amp; tfactory.getFeature(StreamResult.FEATURE))
{
...
}</pre>
</code>
<h3>
<a name="qname-delimiter">Qualified Name Representation</a>
</h3>
<p>
<A href="http://www.w3.org/TR/REC-xml-names">Namespaces</A>
present something of a problem area when dealing with XML objects. Qualified
Names appear in XML markup as prefixed names. But the prefixes themselves do
not hold identity. Rather, it is the URIs that they contextually map to that
hold the identity. Therefore, when passing a Qualified Name like "xyz:foo"
among Java programs, one must provide a means to map "xyz" to a namespace.
</p>
<p>One solution has been to create a "QName" object that holds the
namespace URI, as well as the prefix and local name, but this is not always an
optimal solution, as when, for example, you want to use unique strings as keys
in a dictionary object. Not having a string representation also makes it
difficult to specify a namespaced identity outside the context of an XML
document.</p>
<p>In order to pass namespaced values to transformations, for instance
as a set of properties to the Serializer, this specification defines that a
String "qname" object parameter be passed as two-part string, the namespace URI
enclosed in curly braces ({}), followed by the local name. If the qname has a
null URI, then the String object only contains the local name. An application
can safely check for a non-null URI by testing to see if the first character of
the name is a '{' character.</p>
<p>For example, if a URI and local name were obtained from an element
defined with &lt;xyz:foo xmlns:xyz="http://xyz.foo.com/yada/baz.html"/&gt;,
then the Qualified Name would be "{http://xyz.foo.com/yada/baz.html}foo".
Note that the prefix is lost.</p>
<h3>Result Tree Serialization</h3>
<p>Serialization of the result tree to a stream can be controlled with
the {@link javax.xml.transform.Transformer#setOutputProperties} and the
{@link javax.xml.transform.Transformer#setOutputProperty} methods.
Strings that match the <A href="http://www.w3.org/TR/xslt#output">XSLT
specification for xsl:output attributes</A> can be referenced from the
{@link javax.xml.transform.OutputKeys} class. Other strings can be
specified as well. If the transformer does not recognize an output key, a
{@link java.lang.IllegalArgumentException} is thrown, unless the
key name is <A href="#qname-delimiter">namespace qualified</A>. Output key names that are
qualified by a namespace are ignored or passed on to the serializer
mechanism.</p>
<p>If all that is desired is the simple identity transformation of a
source to a result, then {@link javax.xml.transform.TransformerFactory}
provides a
{@link javax.xml.transform.TransformerFactory#newTransformer()} method
with no arguments. This method creates a Transformer that effectively copies
the source to the result. This method may be used to create a DOM from SAX
events or to create an XML or HTML stream from a DOM or SAX events. </p>
<h3>Exceptions and Error Reporting</h3>
<p>The transformation API throw three types of specialized exceptions. A
{@link javax.xml.transform.TransformerFactoryConfigurationError} is parallel to
the {@link javax.xml.parsers.FactoryConfigurationError}, and is thrown
when a configuration problem with the TransformerFactory exists. This error
will typically be thrown when the transformation factory class specified with
the "javax.xml.transform.TransformerFactory" system property cannot be found or
instantiated.</p>
<p>A {@link javax.xml.transform.TransformerConfigurationException}
may be thrown if for any reason a Transformer can not be created. A
TransformerConfigurationException may be thrown if there is a syntax error in
the transformation instructions, for example when
{@link javax.xml.transform.TransformerFactory#newTransformer} is
called.</p>
<p>{@link javax.xml.transform.TransformerException} is a general
exception that occurs during the course of a transformation. A transformer
exception may wrap another exception, and if any of the
{@link javax.xml.transform.TransformerException#printStackTrace()}
methods are called on it, it will produce a list of stack dumps, starting from
the most recent. The transformer exception also provides a
{@link javax.xml.transform.SourceLocator} object which indicates where
in the source tree or transformation instructions the error occurred.
{@link javax.xml.transform.TransformerException#getMessageAndLocation()}
may be called to get an error message with location info, and
{@link javax.xml.transform.TransformerException#getLocationAsString()}
may be called to get just the location string.</p>
<p>Transformation warnings and errors are normally first sent to a
{@link javax.xml.transform.ErrorListener}, at which point the
implementor may decide to report the error or warning, and may decide to throw
an exception for a non-fatal error. The error listener may be set via
{@link javax.xml.transform.TransformerFactory#setErrorListener} for
reporting errors that have to do with syntax errors in the transformation
instructions, or via
{@link javax.xml.transform.Transformer#setErrorListener} to report
errors that occur during the transformation. The error listener on both objects
should always be valid and non-null, whether set by the user or a default
implementation provided by the processor.</p>
<h3>Resolution of URIs within a transformation</h3>
<p>The API provides a way for URIs referenced from within the stylesheet
instructions or within the transformation to be resolved by the calling
application. This can be done by creating a class that implements the
{@link javax.xml.transform.URIResolver} interface, with its one method,
{@link javax.xml.transform.URIResolver#resolve}, and use this class to
set the URI resolution for the transformation instructions or transformation
with {@link javax.xml.transform.TransformerFactory#setURIResolver} or
{@link javax.xml.transform.Transformer#setURIResolver}. The
<code>URIResolver.resolve</code> method takes two String arguments, the URI found in the
stylesheet instructions or built as part of the transformation process, and the
base URI in effect when the URI passed as the first argument was encountered.
The returned {@link javax.xml.transform.Source} object must be usable by
the transformer, as specified in its implemented features.</p>
</body>
</html>

141
java/external/src/javax/xml/transform/sax/SAXResult.java vendored Normal file
View File

@ -0,0 +1,141 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform.sax;
import javax.xml.transform.*;
import java.lang.String;
import java.io.OutputStream;
import java.io.Writer;
import org.xml.sax.ContentHandler;
import org.xml.sax.ext.DeclHandler;
import org.xml.sax.ext.LexicalHandler;
/**
* Acts as an holder for a transformation Result.
*/
public class SAXResult implements Result {
/**
* If {@link javax.xml.transform.TransformerFactory#getFeature}
* returns true when passed this value as an argument,
* the Transformer supports Result output of this type.
*/
public static final String FEATURE =
"http://javax.xml.transform.sax.SAXResult/feature";
/**
* Zero-argument default constructor.
*/
public SAXResult() {}
/**
* Create a SAXResult that targets a SAX2 {@link org.xml.sax.ContentHandler}.
*
* @param handler Must be a non-null ContentHandler reference.
*/
public SAXResult(ContentHandler handler) {
setHandler(handler);
}
/**
* Set the target to be a SAX2 {@link org.xml.sax.ContentHandler}.
*
* @param handler Must be a non-null ContentHandler reference.
*/
public void setHandler(ContentHandler handler) {
this.handler = handler;
}
/**
* Get the {@link org.xml.sax.ContentHandler} that is the Result.
*
* @return The ContentHandler that is to be transformation output.
*/
public ContentHandler getHandler() {
return handler;
}
/**
* Set the SAX2 {@link org.xml.sax.ext.LexicalHandler} for the output.
*
* <p>This is needed to handle XML comments and the like. If the
* lexical handler is not set, an attempt should be made by the
* transformer to cast the {@link org.xml.sax.ContentHandler} to a
* <code>LexicalHandler</code>.</p>
*
* @param handler A non-null <code>LexicalHandler</code> for
* handling lexical parse events.
*/
public void setLexicalHandler(LexicalHandler handler) {
this.lexhandler = handler;
}
/**
* Get a SAX2 {@link org.xml.sax.ext.LexicalHandler} for the output.
*
* @return A <code>LexicalHandler</code>, or null.
*/
public LexicalHandler getLexicalHandler() {
return lexhandler;
}
/**
* Method setSystemId Set the systemID that may be used in association
* with the {@link org.xml.sax.ContentHandler}.
*
* @param systemId The system identifier as a URI string.
*/
public void setSystemId(String systemId) {
this.systemId = 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() {
return systemId;
}
//////////////////////////////////////////////////////////////////////
// Internal state.
//////////////////////////////////////////////////////////////////////
/**
* The handler for parse events.
*/
private ContentHandler handler;
/**
* The handler for lexical events.
*/
private LexicalHandler lexhandler;
/**
* The systemID that may be used in association
* with the node.
*/
private String systemId;
}

192
java/external/src/javax/xml/transform/sax/SAXSource.java vendored Normal file
View File

@ -0,0 +1,192 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform.sax;
import javax.xml.transform.Source;
import javax.xml.transform.stream.StreamSource;
import java.lang.String;
import java.io.OutputStream;
import java.io.Writer;
import org.xml.sax.XMLReader;
import org.xml.sax.ext.DeclHandler;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.InputSource;
/**
* Acts as an holder for SAX-style Source.
*/
public class SAXSource implements Source {
/**
* If {@link javax.xml.transform.TransformerFactory#getFeature}
* returns true when passed this value as an argument,
* the Transformer supports Source input of this type.
*/
public static final String FEATURE =
"http://javax.xml.transform.sax.SAXSource/feature";
/**
* Zero-argument default constructor. If this constructor
* is used, and no other method is called, the
* {@link javax.xml.transform.Transformer}
* assumes an empty input tree, with a default root node.
*/
public SAXSource() {}
/**
* Create a <code>SAXSource</code>, using an {@link org.xml.sax.XMLReader}
* and a SAX InputSource. The {@link javax.xml.transform.Transformer}
* or {@link javax.xml.transform.sax.SAXTransformerFactory} will set itself
* to be the reader's {@link org.xml.sax.ContentHandler}, and then will call
* reader.parse(inputSource).
*
* @param reader An XMLReader to be used for the parse.
* @param inputSource A SAX input source reference that must be non-null
* and that will be passed to the reader parse method.
*/
public SAXSource(XMLReader reader, InputSource inputSource) {
this.reader = reader;
this.inputSource = inputSource;
}
/**
* Create a <code>SAXSource</code>, using a SAX <code>InputSource</code>.
* The {@link javax.xml.transform.Transformer} or
* {@link javax.xml.transform.sax.SAXTransformerFactory} creates a
* reader via {@link org.xml.sax.helpers.XMLReaderFactory}
* (if setXMLReader is not used), sets itself as
* the reader's {@link org.xml.sax.ContentHandler}, and calls
* reader.parse(inputSource).
*
* @param inputSource An input source reference that must be non-null
* and that will be passed to the parse method of the reader.
*/
public SAXSource(InputSource inputSource) {
this.inputSource = inputSource;
}
/**
* Set the XMLReader to be used for the Source.
*
* @param reader A valid XMLReader or XMLFilter reference.
*/
public void setXMLReader(XMLReader reader) {
this.reader = reader;
}
/**
* Get the XMLReader to be used for the Source.
*
* @return A valid XMLReader or XMLFilter reference, or null.
*/
public XMLReader getXMLReader() {
return reader;
}
/**
* Set the SAX InputSource to be used for the Source.
*
* @param inputSource A valid InputSource reference.
*/
public void setInputSource(InputSource inputSource) {
this.inputSource = inputSource;
}
/**
* Get the SAX InputSource to be used for the Source.
*
* @return A valid InputSource reference, or null.
*/
public InputSource getInputSource() {
return inputSource;
}
/**
* Set the system identifier for this Source. If an input source
* has already been set, it will set the system ID or that
* input source, otherwise it will create a new input source.
*
* <p>The system identifier is optional if there is a byte stream
* or a character stream, but it is still useful to provide one,
* since the application can use it to resolve relative URIs
* and can include it in error messages and warnings (the parser
* will attempt to open a connection to the URI only if
* no byte stream or character stream is specified).</p>
*
* @param systemId The system identifier as a URI string.
*/
public void setSystemId(String systemId) {
if (null == inputSource) {
inputSource = new InputSource(systemId);
} else {
inputSource.setSystemId(systemId);
}
}
/**
* Get the base ID (URI or system ID) from where URIs
* will be resolved.
*
* @return Base URL for the Source, or null.
*/
public String getSystemId() {
return (null != inputSource)
? inputSource.getSystemId()
: null;
}
/** The XMLReader to be used for the source tree input. May be null. */
private XMLReader reader;
/** The SAX InputSource to be used for the source tree input. Should not be null. */
private InputSource inputSource;
/**
* Attempt to obtain a SAX InputSource object from a TrAX Source
* object.
*
* @param source Must be a non-null Source reference.
*
* @return An InputSource, or null if Source can not be converted.
*/
public static InputSource sourceToInputSource(Source source) {
if (source instanceof SAXSource) {
return ((SAXSource) source).getInputSource();
} else if (source instanceof StreamSource) {
StreamSource ss = (StreamSource) source;
InputSource isource = new InputSource(ss.getSystemId());
isource.setByteStream(ss.getInputStream());
isource.setCharacterStream(ss.getReader());
isource.setPublicId(ss.getPublicId());
return isource;
} else {
return null;
}
}
}

149
java/external/src/javax/xml/transform/sax/SAXTransformerFactory.java vendored Normal file
View File

@ -0,0 +1,149 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform.sax;
import javax.xml.transform.*;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXNotSupportedException;
import org.xml.sax.SAXNotRecognizedException;
import org.xml.sax.XMLReader;
import org.xml.sax.XMLFilter;
/**
* This class extends TransformerFactory to provide SAX-specific
* factory methods. It provides two types of ContentHandlers,
* one for creating Transformers, the other for creating Templates
* objects.
*
* <p>If an application wants to set the ErrorHandler or EntityResolver
* for an XMLReader used during a transformation, it should use a URIResolver
* to return the SAXSource which provides (with getXMLReader) a reference to
* the XMLReader.</p>
*/
public abstract class SAXTransformerFactory extends TransformerFactory {
/** If {@link javax.xml.transform.TransformerFactory#getFeature}
* returns true when passed this value as an argument,
* the TransformerFactory returned from
* {@link javax.xml.transform.TransformerFactory#newInstance} may
* be safely cast to a SAXTransformerFactory.
*/
public static final String FEATURE =
"http://javax.xml.transform.sax.SAXTransformerFactory/feature";
/** If {@link javax.xml.transform.TransformerFactory#getFeature}
* returns true when passed this value as an argument,
* the {@link #newXMLFilter(Source src)}
* and {@link #newXMLFilter(Templates templates)} methods are supported.
*/
public static final String FEATURE_XMLFILTER =
"http://javax.xml.transform.sax.SAXTransformerFactory/feature/xmlfilter";
/**
* The default constructor is protected on purpose.
*/
protected SAXTransformerFactory() {}
/**
* Get a TransformerHandler object that can process SAX
* ContentHandler events into a Result, based on the transformation
* instructions specified by the argument.
*
* @param src The Source of the transformation instructions.
*
* @return TransformerHandler ready to transform SAX events.
*
* @throws TransformerConfigurationException If for some reason the
* TransformerHandler can not be created.
*/
public abstract TransformerHandler newTransformerHandler(Source src)
throws TransformerConfigurationException;
/**
* Get a TransformerHandler object that can process SAX
* ContentHandler events into a Result, based on the Templates argument.
*
* @param templates The compiled transformation instructions.
*
* @return TransformerHandler ready to transform SAX events.
*
* @throws TransformerConfigurationException If for some reason the
* TransformerHandler can not be created.
*/
public abstract TransformerHandler newTransformerHandler(
Templates templates) throws TransformerConfigurationException;
/**
* Get a TransformerHandler object that can process SAX
* ContentHandler events into a Result. The transformation
* is defined as an identity (or copy) transformation, for example
* to copy a series of SAX parse events into a DOM tree.
*
* @return A non-null reference to a TransformerHandler, that may
* be used as a ContentHandler for SAX parse events.
*
* @throws TransformerConfigurationException If for some reason the
* TransformerHandler cannot be created.
*/
public abstract TransformerHandler newTransformerHandler()
throws TransformerConfigurationException;
/**
* Get a TemplatesHandler object that can process SAX
* ContentHandler events into a Templates object.
*
* @return A non-null reference to a TransformerHandler, that may
* be used as a ContentHandler for SAX parse events.
*
* @throws TransformerConfigurationException If for some reason the
* TemplatesHandler cannot be created.
*/
public abstract TemplatesHandler newTemplatesHandler()
throws TransformerConfigurationException;
/**
* Create an XMLFilter that uses the given Source as the
* transformation instructions.
*
* @param src The Source of the transformation instructions.
*
* @return An XMLFilter object, or null if this feature is not supported.
*
* @throws TransformerConfigurationException If for some reason the
* TemplatesHandler cannot be created.
*/
public abstract XMLFilter newXMLFilter(Source src)
throws TransformerConfigurationException;
/**
* Create an XMLFilter, based on the Templates argument..
*
* @param templates The compiled transformation instructions.
*
* @return An XMLFilter object, or null if this feature is not supported.
*
* @throws TransformerConfigurationException If for some reason the
* TemplatesHandler cannot be created.
*/
public abstract XMLFilter newXMLFilter(Templates templates)
throws TransformerConfigurationException;
}

63
java/external/src/javax/xml/transform/sax/TemplatesHandler.java vendored Normal file
View File

@ -0,0 +1,63 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform.sax;
import javax.xml.transform.*;
import org.xml.sax.ContentHandler;
import org.xml.sax.ext.LexicalHandler;
/**
* A SAX ContentHandler that may be used to process SAX
* parse events (parsing transformation instructions) into a Templates object.
*
* <p>Note that TemplatesHandler does not need to implement LexicalHandler.</p>
*/
public interface TemplatesHandler extends ContentHandler {
/**
* When a TemplatesHandler object is used as a ContentHandler
* for the parsing of transformation instructions, it creates a Templates object,
* which the caller can get once the SAX events have been completed.
*
* @return The Templates object that was created during
* the SAX event process, or null if no Templates object has
* been created.
*
*/
public Templates getTemplates();
/**
* Set the base ID (URI or system ID) for the Templates object
* created by this builder. This must be set in order to
* resolve relative URIs in the stylesheet. This must be
* called before the startDocument event.
*
* @param baseID Base URI for this stylesheet.
*/
public void setSystemId(String systemID);
/**
* Get the base ID (URI or system ID) from where relative
* URLs will be resolved.
* @return The systemID that was set with {@link #setSystemId}.
*/
public String getSystemId();
}

70
java/external/src/javax/xml/transform/sax/TransformerHandler.java vendored Normal file
View File

@ -0,0 +1,70 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform.sax;
import java.util.Properties;
import javax.xml.transform.Result;
import javax.xml.transform.URIResolver;
import javax.xml.transform.TransformerException;
import javax.xml.transform.Transformer;
import org.xml.sax.ContentHandler;
import org.xml.sax.ext.LexicalHandler;
import org.xml.sax.DTDHandler;
/**
* A TransformerHandler
* listens for SAX ContentHandler parse events and transforms
* them to a Result.
*/
public interface TransformerHandler
extends ContentHandler, LexicalHandler, DTDHandler {
/**
* Enables the user of the TransformerHandler to set the
* to set the Result for the transformation.
*
* @param result A Result instance, should not be null.
*
* @throws IllegalArgumentException if result is invalid for some reason.
*/
public void setResult(Result result) throws IllegalArgumentException;
/**
* Set the base ID (URI or system ID) from where relative
* URLs will be resolved.
* @param systemID Base URI for the source tree.
*/
public void setSystemId(String systemID);
/**
* Get the base ID (URI or system ID) from where relative
* URLs will be resolved.
* @return The systemID that was set with {@link #setSystemId}.
*/
public String getSystemId();
/**
* Get the Transformer associated with this handler, which
* is needed in order to set parameters and output properties.
*/
public Transformer getTransformer();
}

69
java/external/src/javax/xml/transform/sax/package.html vendored Normal file
View File

@ -0,0 +1,69 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>javax.xml.transform.sax</title>
</head>
<body>
<p>This package implements SAX2-specific transformation APIs. It provides
classes which allow input from {@link org.xml.sax.ContentHandler}
events, and also classes that produce org.xml.sax.ContentHandler events. It
also provides methods to set the input source as an
{@link org.xml.sax.XMLReader}, or to use a
{@link org.xml.sax.InputSource} as the source. It also allows the
creation of a {@link org.xml.sax.XMLFilter}, which enables
transformations to "pull" from other transformations, and lets the transformer
to be used polymorphically as an {@link org.xml.sax.XMLReader}.</p>
<p>The {@link javax.xml.transform.sax.SAXSource} class allows the
setting of an {@link org.xml.sax.XMLReader} to be used for "pulling"
parse events, and an {@link org.xml.sax.InputSource} that may be used to
specify the SAX source.</p>
<p>The {@link javax.xml.transform.sax.SAXResult} class allows the
setting of a {@link org.xml.sax.ContentHandler} to be the receiver of
SAX2 events from the transformation.
<p>The {@link javax.xml.transform.sax.SAXTransformerFactory} extends
{@link javax.xml.transform.TransformerFactory} to provide factory
methods for creating {@link javax.xml.transform.sax.TemplatesHandler},
{@link javax.xml.transform.sax.TransformerHandler}, and
{@link org.xml.sax.XMLReader} instances.</p>
<p>To obtain a {@link javax.xml.transform.sax.SAXTransformerFactory},
the caller must cast the {@link javax.xml.transform.TransformerFactory}
instance returned from
{@link javax.xml.transform.TransformerFactory#newInstance}.
<p>The {@link javax.xml.transform.sax.TransformerHandler} interface
allows a transformation to be created from SAX2 parse events, which is a "push"
model rather than the "pull" model that normally occurs for a transformation.
Normal parse events are received through the
{@link org.xml.sax.ContentHandler} interface, lexical events such as
startCDATA and endCDATA are received through the
{@link org.xml.sax.ext.LexicalHandler} interface, and events that signal
the start or end of disabling output escaping are received via
{@link org.xml.sax.ContentHandler#processingInstruction}, with the
target parameter being
{@link javax.xml.transform.Result#PI_DISABLE_OUTPUT_ESCAPING} and
{@link javax.xml.transform.Result#PI_ENABLE_OUTPUT_ESCAPING}. If
parameters, output properties, or other features need to be set on the
Transformer handler, a {@link javax.xml.transform.Transformer} reference
will need to be obtained from
{@link javax.xml.transform.sax.TransformerHandler#getTransformer}, and
the methods invoked from that reference.
<p>The {@link javax.xml.transform.sax.TemplatesHandler} interface
allows the creation of {@link javax.xml.transform.Templates} objects
from SAX2 parse events. Once the {@link org.xml.sax.ContentHandler}
events are complete, the Templates object may be obtained from
{@link javax.xml.transform.sax.TemplatesHandler#getTemplates}. Note that
{@link javax.xml.transform.sax.TemplatesHandler#setSystemId} should
normally be called in order to establish a base system ID from which relative
URLs may be resolved.
<p>The
{@link javax.xml.transform.sax.SAXTransformerFactory#newXMLFilter}
method allows the creation of a {@link org.xml.sax.XMLFilter}, which
encapsulates the SAX2 notion of a "pull" transformation. The following
illustrates several transformations chained together. Each filter points to a
parent {@link org.xml.sax.XMLReader}, and the final transformation is
caused by invoking {@link org.xml.sax.XMLReader#parse} on the final
reader in the chain.</p>
</body>
</html>

189
java/external/src/javax/xml/transform/stream/StreamResult.java vendored Normal file
View File

@ -0,0 +1,189 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform.stream;
import javax.xml.transform.*;
import java.lang.String;
import java.io.OutputStream;
import java.io.Writer;
import java.io.File;
/**
* Acts as an holder for a transformation result,
* which may be XML, plain Text, HTML, or some other form of markup.
*
*/
public class StreamResult implements Result {
/** If {@link javax.xml.transform.TransformerFactory#getFeature}
* returns true when passed this value as an argument,
* the Transformer supports Result output of this type.
*/
public static final String FEATURE =
"http://javax.xml.transform.stream.StreamResult/feature";
/**
* Zero-argument default constructor.
*/
public StreamResult() {}
/**
* Construct a StreamResult from a byte stream. Normally,
* a stream should be used rather than a reader, so that
* the transformer may use instructions contained in the
* transformation instructions to control the encoding.
*
* @param outputStream A valid OutputStream reference.
*/
public StreamResult(OutputStream outputStream) {
setOutputStream(outputStream);
}
/**
* Construct a StreamResult from a character stream. Normally,
* a stream should be used rather than a reader, 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 character
* stream, such as when using a StringWriter.
*
* @param writer A valid Writer reference.
*/
public StreamResult(Writer writer) {
setWriter(writer);
}
/**
* Construct a StreamResult from a URL.
*
* @param systemId Must be a String that conforms to the URI syntax.
*/
public StreamResult(String systemId) {
this.systemId = systemId;
}
/**
* Construct a StreamResult from a File.
*
* @param f Must a non-null File reference.
*/
public StreamResult(File f) {
setSystemId(f);
}
/**
* Set the ByteStream that is to be written to. Normally,
* a stream should be used rather than a reader, so that
* the transformer may use instructions contained in the
* transformation instructions to control the encoding.
*
* @param outputStream A valid OutputStream reference.
*/
public void setOutputStream(OutputStream outputStream) {
this.outputStream = outputStream;
}
/**
* Get the byte stream that was set with setOutputStream.
*
* @return The byte stream that was set with setOutputStream, or null
* if setOutputStream or the ByteStream constructor was not called.
*/
public OutputStream getOutputStream() {
return outputStream;
}
/**
* 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 setWriter(Writer writer) {
this.writer = 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 getWriter() {
return writer;
}
/**
* Set the systemID that may be used in association
* with the byte or character stream, or, if neither is set, use
* this value as a writeable URI (probably a file name).
*
* @param systemId The system identifier as a URI string.
*/
public void setSystemId(String systemId) {
this.systemId = systemId;
}
/**
* Set the system ID from a File reference.
*
* @param f Must a non-null File reference.
*/
public void setSystemId(File f) {
this.systemId = "file:///" + f.getAbsolutePath();
}
/**
* 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() {
return systemId;
}
//////////////////////////////////////////////////////////////////////
// Internal state.
//////////////////////////////////////////////////////////////////////
/**
* The systemID that may be used in association
* with the byte or character stream, or, if neither is set, use
* this value as a writeable URI (probably a file name).
*/
private String systemId;
/**
* The byte stream that is to be written to.
*/
private OutputStream outputStream;
/**
* The character stream that is to be written to.
*/
private Writer writer;
}

262
java/external/src/javax/xml/transform/stream/StreamSource.java vendored Normal file
View File

@ -0,0 +1,262 @@
/**
* $Id$
*
* Copyright (c) 2000-2001 Sun Microsystems, Inc. All Rights Reserved.
*
* This software is the confidential and proprietary information of Sun
* Microsystems, Inc. ("Confidential Information"). You shall not
* disclose such Confidential Information and shall use it only in
* accordance with the terms of the license agreement you entered into
* with Sun.
*
* SUN MAKES NO REPRESENTATIONS OR WARRANTIES ABOUT THE SUITABILITY OF THE
* SOFTWARE, EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
* IMPLIED WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR
* PURPOSE, OR NON-INFRINGEMENT. SUN SHALL NOT BE LIABLE FOR ANY DAMAGES
* SUFFERED BY LICENSEE AS A RESULT OF USING, MODIFYING OR DISTRIBUTING
* THIS SOFTWARE OR ITS DERIVATIVES.
*/
package javax.xml.transform.stream;
import javax.xml.transform.Source;
import java.io.InputStream;
import java.io.Reader;
import java.io.File;
/**
* Acts as an holder for a transformation Source in the form
* of a stream of XML markup.
*
*/
public class StreamSource implements Source {
/** If {@link javax.xml.transform.TransformerFactory#getFeature}
* returns true when passed this value as an argument,
* the Transformer supports Source input of this type.
*/
public static final String FEATURE =
"http://javax.xml.transform.stream.StreamSource/feature";
/**
* Zero-argument default constructor. If this constructor
* is used, and no other method is called, the transformer
* will assume an empty input tree, with a default root node.
*/
public StreamSource() {}
/**
* Construct a StreamSource from a byte stream. Normally,
* a stream should be used rather than a reader, so
* the XML parser can resolve character encoding specified
* by the XML declaration.
*
* <p>If this constructor is used to process a stylesheet, normally
* setSystemId should also be called, so that relative URI references
* can be resolved.</p>
*
* @param inputStream A valid InputStream reference to an XML stream.
*/
public StreamSource(InputStream inputStream) {
setInputStream(inputStream);
}
/**
* Construct a StreamSource from a byte stream. Normally,
* a stream should be used rather than a reader, so that
* the XML parser can resolve character encoding specified
* by the XML declaration.
*
* <p>This constructor allows the systemID to be set in addition
* to the input stream, which allows relative URIs
* to be processed.</p>
*
* @param inputStream A valid InputStream reference to an XML stream.
* @param systemId Must be a String that conforms to the URI syntax.
*/
public StreamSource(InputStream inputStream, String systemId) {
setInputStream(inputStream);
setSystemId(systemId);
}
/**
* Construct a StreamSource from a character reader. Normally,
* a stream should be used rather than a reader, so that
* the XML parser can resolve character encoding specified
* by the XML declaration. However, in many cases the encoding
* of the input stream is already resolved, as in the case of
* reading XML from a StringReader.
*
* @param reader A valid Reader reference to an XML character stream.
*/
public StreamSource(Reader reader) {
setReader(reader);
}
/**
* Construct a StreamSource from a character reader. Normally,
* a stream should be used rather than a reader, so that
* the XML parser may resolve character encoding specified
* by the XML declaration. However, in many cases the encoding
* of the input stream is already resolved, as in the case of
* reading XML from a StringReader.
*
* @param reader A valid Reader reference to an XML character stream.
* @param systemId Must be a String that conforms to the URI syntax.
*/
public StreamSource(Reader reader, String systemId) {
setReader(reader);
setSystemId(systemId);
}
/**
* Construct a StreamSource from a URL.
*
* @param systemId Must be a String that conforms to the URI syntax.
*/
public StreamSource(String systemId) {
this.systemId = systemId;
}
/**
* Construct a StreamSource from a File.
*
* @param f Must a non-null File reference.
*/
public StreamSource(File f) {
this.systemId = "file:///" + f.getAbsolutePath();
}
/**
* Set the byte stream to be used as input. Normally,
* a stream should be used rather than a reader, so that
* the XML parser can resolve character encoding specified
* by the XML declaration.
*
* <p>If this Source object is used to process a stylesheet, normally
* setSystemId should also be called, so that relative URL references
* can be resolved.</p>
*
* @param inputStream A valid InputStream reference to an XML stream.
*/
public void setInputStream(InputStream inputStream) {
this.inputStream = inputStream;
}
/**
* Get the byte stream that was set with setByteStream.
*
* @return The byte stream that was set with setByteStream, or null
* if setByteStream or the ByteStream constructor was not called.
*/
public InputStream getInputStream() {
return inputStream;
}
/**
* Set the input to be a character reader. Normally,
* a stream should be used rather than a reader, so that
* the XML parser can resolve character encoding specified
* by the XML declaration. However, in many cases the encoding
* of the input stream is already resolved, as in the case of
* reading XML from a StringReader.
*
* @param reader A valid Reader reference to an XML CharacterStream.
*/
public void setReader(Reader reader) {
this.reader = reader;
}
/**
* Get the character stream that was set with setReader.
*
* @return The character stream that was set with setReader, or null
* if setReader or the Reader constructor was not called.
*/
public Reader getReader() {
return reader;
}
/**
* Set the public identifier for this Source.
*
* <p>The public identifier is always optional: if the application
* writer includes one, it will be provided as part of the
* location information.</p>
*
* @param publicId The public identifier as a string.
*/
public void setPublicId(String publicId) {
this.publicId = publicId;
}
/**
* Get the public identifier that was set with setPublicId.
*
* @return The public identifier that was set with setPublicId, or null
* if setPublicId was not called.
*/
public String getPublicId() {
return publicId;
}
/**
* Set the system identifier for this Source.
*
* <p>The system identifier is optional if there is a byte stream
* or a character stream, but it is still useful to provide one,
* since the application can use it to resolve relative URIs
* and can include it in error messages and warnings (the parser
* will attempt to open a connection to the URI only if
* there is no byte stream or character stream specified).</p>
*
* @param systemId The system identifier as a URL string.
*/
public void setSystemId(String systemId) {
this.systemId = 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() {
return systemId;
}
/**
* Set the system ID from a File reference.
*
* @param f Must a non-null File reference.
*/
public void setSystemId(File f) {
this.systemId = "file:///" + f.toString();
}
//////////////////////////////////////////////////////////////////////
// Internal state.
//////////////////////////////////////////////////////////////////////
/**
* The public identifier for this input source, or null.
*/
private String publicId;
/**
* The system identifier as a URL string, or null.
*/
private String systemId;
/**
* The byte stream for this Source, or null.
*/
private InputStream inputStream;
/**
* The character stream for this Source, or null.
*/
private Reader reader;
}

30
java/external/src/javax/xml/transform/stream/package.html vendored Normal file
View File

@ -0,0 +1,30 @@
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">
<html>
<head>
<META http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>javax.xml.transform.stream</title>
</head>
<body>
<p>This package implements stream- and URI- specific transformation APIs.
</p>
<p>The {@link javax.xml.transform.stream.StreamSource} class
provides methods for specifying {@link java.io.InputStream} input,
{@link java.io.Reader} input, and URL input in the form of strings. Even
if an input stream or reader is specified as the source,
{@link javax.xml.transform.stream.StreamSource#setSystemId} should still
be called, so that the transformer can know from where it should resolve
relative URIs. The public identifier is always optional: if the application
writer includes one, it will be provided as part of the
{@link javax.xml.transform.SourceLocator} information.</p>
<p>The {@link javax.xml.transform.stream.StreamResult} class
provides methods for specifying {@link java.io.OutputStream},
{@link java.io.Writer}, or an output system ID, as the output of the
transformation result.</p>
<p>Normally streams should be used rather than readers or writers, for
both the Source and Result, since readers and writers already have the encoding
established to and from the internal Unicode format. However, there are times
when it is useful to write to a character stream, such as when using a
StringWriter in order to write to a String, or in the case of reading source
XML from a StringReader.</p>
</body>
</html>