Added: servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/SAXParserFactory.java URL: http://svn.apache.org/viewvc/servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/SAXParserFactory.java?rev=1227282&view=auto ============================================================================== --- servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/SAXParserFactory.java (added) +++ servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/SAXParserFactory.java Wed Jan 4 19:47:39 2012 @@ -0,0 +1,428 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// $Id: SAXParserFactory.java 884950 2009-11-27 18:46:18Z mrglavas $ + +package javax.xml.parsers; + +import javax.xml.validation.Schema; + +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. + * + * @author <a href="[email protected]">Jeff Suttor</a> + * @version $Revision: 884950 $, $Date: 2009-11-27 13:46:18 -0500 (Fri, 27 Nov 2009) $ + */ +public abstract class SAXParserFactory { + + /** + * <p>Should Parsers be validating?</p> + */ + private boolean validating = false; + + /** + * <p>Should Parsers be namespace aware?</p> + */ + private boolean namespaceAware = false; + + /** + * <p>Protected constructor to force use of {@link #newInstance()}.</p> + */ + 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. + * + * The jaxp.properties file is read only once by the JAXP implementation + * and it's values are then cached for future use. If the file does not exist + * when the first attempt is made to read from it, no further attempts are + * made to check for its existence. It is not possible to change the value + * of any property in jaxp.properties after it has been read for the first time. + * </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. + * + * + * + * <h2>Tip for Trouble-shooting</h2> + * <p>Setting the <code>jaxp.debug</code> system property will cause + * this method to print a lot of debug messages + * to <tt>System.err</tt> about what it is doing and where it is looking at.</p> + * + * <p> If you have problems loading {@link SAXParser}s, try:</p> + * <pre> + * java -Djaxp.debug=1 YourProgram .... + * </pre> + * + * + * @return A new instance of a SAXParserFactory. + * + * @exception FactoryConfigurationError if the implementation is + * not available or cannot be instantiated. + */ + + public static SAXParserFactory newInstance() { + try { + return (SAXParserFactory) FactoryFinder.find( + /* The default property name according to the JAXP spec */ + "javax.xml.parsers.SAXParserFactory", + /* The fallback implementation class name */ + "com.sun.org.apache.xerces.internal.jaxp.SAXParserFactoryImpl"); + } + catch (FactoryFinder.ConfigurationError e) { + throw new FactoryConfigurationError(e.getException(), e.getMessage()); + } + } + + /** + * @return A new instance of a SAXParserFactory. + * + * @exception FactoryConfigurationError if the implementation is + * not available or cannot be instantiated. + */ + public static SAXParserFactory newInstance(String factoryClassName, + ClassLoader classLoader) { + if (factoryClassName == null) { + throw new FactoryConfigurationError("factoryClassName cannot be null."); + } + if (classLoader == null) { + classLoader = SecuritySupport.getContextClassLoader(); + } + try { + return (SAXParserFactory) FactoryFinder.newInstance(factoryClassName, classLoader, false); + } + catch (FactoryFinder.ConfigurationError e) { + throw new FactoryConfigurationError(e.getException(), e.getMessage()); + } + } + + /** + * <p>Creates a new instance of a SAXParser using the currently + * configured factory parameters.</p> + * + * @return A new instance of a SAXParser. + * + * @exception ParserConfigurationException if a parser cannot + * be created which satisfies the requested configuration. + * @exception SAXException for SAX errors. + */ + + 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>. + * + * <p> + * Note that "the validation" here means + * <a href="http://www.w3.org/TR/REC-xml#proc-types";>a validating + * parser</a> as defined in the XML recommendation. + * In other words, it essentially just controls the DTD validation. + * (except the legacy two properties defined in JAXP 1.2. + * See <a href="#validationCompatibility">here</a> for more details.) + * </p> + * + * <p> + * To use modern schema languages such as W3C XML Schema or + * RELAX NG instead of DTD, you can configure your parser to be + * a non-validating parser by leaving the {@link #setValidating(boolean)} + * method <tt>false</tt>, then use the {@link #setSchema(Schema)} + * method to associate a schema to a parser. + * </p> + * + * @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; + } + + /** + * + * <p>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.saxproject.org/";>http://www.saxproject.org/</a></p> + * + * <p>All implementations are required to support the {@link javax.xml.XMLConstants#FEATURE_SECURE_PROCESSING} feature. + * When the feature is</p> + * <ul> + * <li> + * <code>true</code>: the implementation will limit XML processing to conform to implementation limits. + * Examples include entity expansion limits and XML Schema constructs that would consume large amounts of resources. + * If XML processing is limited for security reasons, it will be reported via a call to the registered + * {@link org.xml.sax.ErrorHandler#fatalError(SAXParseException exception)}. + * See {@link SAXParser} <code>parse</code> methods for handler specification. + * </li> + * <li> + * When the feature is <code>false</code>, the implementation will processing XML according to the XML specifications without + * regard to possible implementation limits. + * </li> + * </ul> + * + * @param name The name of the feature to be set. + * @param value The value of the feature to be set. + * + * @exception ParserConfigurationException if a parser cannot + * be created which satisfies the requested configuration. + * @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. + * @throws NullPointerException If the <code>name</code> parameter is null. + * + * @see org.xml.sax.XMLReader#setFeature + */ + public abstract void setFeature(String name, boolean value) + throws ParserConfigurationException, SAXNotRecognizedException, + SAXNotSupportedException; + + /** + * + * <p>Returns the particular property requested for in the underlying + * implementation of org.xml.sax.XMLReader.</p> + * + * @param name The name of the property to be retrieved. + * + * @return Value of the requested property. + * + * @exception ParserConfigurationException if a parser cannot be created which satisfies the requested configuration. + * @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; + + /** + * Gets the {@link Schema} object specified through + * the {@link #setSchema(Schema schema)} method. + * + * + * @throws UnsupportedOperationException + * For backward compatibility, when implementations for + * earlier versions of JAXP is used, this exception will be + * thrown. + * + * @return + * the {@link Schema} object that was last set through + * the {@link #setSchema(Schema)} method, or null + * if the method was not invoked since a {@link SAXParserFactory} + * is created. + * + * @since 1.5 + */ + public Schema getSchema() { + throw new UnsupportedOperationException( + "This parser does not support specification \"" + + this.getClass().getPackage().getSpecificationTitle() + + "\" version \"" + + this.getClass().getPackage().getSpecificationVersion() + + "\"" + ); + } + + /** + * <p>Set the {@link Schema} to be used by parsers created + * from this factory.</p> + * + * <p>When a {@link Schema} is non-null, a parser will use a validator + * created from it to validate documents before it passes information + * down to the application.</p> + * + * <p>When warnings/errors/fatal errors are found by the validator, the parser must + * handle them as if those errors were found by the parser itself. + * In other words, if the user-specified {@link org.xml.sax.ErrorHandler} + * is set, it must receive those errors, and if not, they must be + * treated according to the implementation specific + * default error handling rules. + * + * <p>A validator may modify the SAX event stream (for example by + * adding default values that were missing in documents), and a parser + * is responsible to make sure that the application will receive + * those modified event stream.</p> + * + * <p>Initially, <code>null</code> is set as the {@link Schema}.</p> + * + * <p>This processing will take effect even if + * the {@link #isValidating()} method returns <code>false</code>. + * + * <p>It is an error to use + * the <code>http://java.sun.com/xml/jaxp/properties/schemaSource</code> + * property and/or the <code>http://java.sun.com/xml/jaxp/properties/schemaLanguage</code> + * property in conjunction with a non-null {@link Schema} object. + * Such configuration will cause a {@link SAXException} + * exception when those properties are set on a {@link SAXParser}.</p> + * + * <h4>Note for implementors</h4> + * <p> + * A parser must be able to work with any {@link Schema} + * implementation. However, parsers and schemas are allowed + * to use implementation-specific custom mechanisms + * as long as they yield the result described in the specification. + * </p> + * + * @param schema <code>Schema</code> to use, <code>null</code> to remove a schema. + * + * @throws UnsupportedOperationException + * For backward compatibility, when implementations for + * earlier versions of JAXP is used, this exception will be + * thrown. + * + * @since 1.5 + */ + public void setSchema(Schema schema) { + throw new UnsupportedOperationException( + "This parser does not support specification \"" + + this.getClass().getPackage().getSpecificationTitle() + + "\" version \"" + + this.getClass().getPackage().getSpecificationVersion() + + "\"" + ); + } + + /** + * <p>Set state of XInclude processing.</p> + * + * <p>If XInclude markup is found in the document instance, should it be + * processed as specified in <a href="http://www.w3.org/TR/xinclude/";> + * XML Inclusions (XInclude) Version 1.0</a>.</p> + * + * <p>XInclude processing defaults to <code>false</code>.</p> + * + * @param state Set XInclude processing to <code>true</code> or + * <code>false</code> + * + * @throws UnsupportedOperationException + * For backward compatibility, when implementations for + * earlier versions of JAXP is used, this exception will be + * thrown. + * + * @since 1.5 + */ + public void setXIncludeAware(final boolean state) { + throw new UnsupportedOperationException( + "This parser does not support specification \"" + + this.getClass().getPackage().getSpecificationTitle() + + "\" version \"" + + this.getClass().getPackage().getSpecificationVersion() + + "\"" + ); + } + + /** + * <p>Get state of XInclude processing.</p> + * + * @return current state of XInclude processing + * + * @throws UnsupportedOperationException + * For backward compatibility, when implementations for + * earlier versions of JAXP is used, this exception will be + * thrown. + * + * @since 1.5 + */ + public boolean isXIncludeAware() { + throw new UnsupportedOperationException( + "This parser does not support specification \"" + + this.getClass().getPackage().getSpecificationTitle() + + "\" version \"" + + this.getClass().getPackage().getSpecificationVersion() + + "\"" + ); + } +} +
Copied: servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/SecuritySupport.java (from r1227192, servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/ScuritySupport.java) URL: http://svn.apache.org/viewvc/servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/SecuritySupport.java?p2=servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/SecuritySupport.java&p1=servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/ScuritySupport.java&r1=1227192&r2=1227282&rev=1227282&view=diff ============================================================================== --- servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/ScuritySupport.java (original) +++ servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/parsers/SecuritySupport.java Wed Jan 4 19:47:39 2012 @@ -35,7 +35,7 @@ import java.security.PrivilegedException * * Security related methods that only work on J2SE 1.2 and newer. */ -final class SecuritySupport { +final class SecuritySupport { private SecuritySupport() {} Modified: servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/transform/FactoryFinder.java URL: http://svn.apache.org/viewvc/servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/transform/FactoryFinder.java?rev=1227282&r1=1227281&r2=1227282&view=diff ============================================================================== --- servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/transform/FactoryFinder.java (original) +++ servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/transform/FactoryFinder.java Wed Jan 4 19:47:39 2012 @@ -84,7 +84,7 @@ final class FactoryFinder { * @param doFallback true if the current ClassLoader should be tried as * a fallback if the class is not found using cl */ - private static Object newInstance(String className, ClassLoader cl, + static Object newInstance(String className, ClassLoader cl, boolean doFallback) throws ConfigurationError { Added: servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/transform/TransformerFactory.java URL: http://svn.apache.org/viewvc/servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/transform/TransformerFactory.java?rev=1227282&view=auto ============================================================================== --- servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/transform/TransformerFactory.java (added) +++ servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/transform/TransformerFactory.java Wed Jan 4 19:47:39 2012 @@ -0,0 +1,363 @@ +/* + * Licensed to the Apache Software Foundation (ASF) under one or more + * contributor license agreements. See the NOTICE file distributed with + * this work for additional information regarding copyright ownership. + * The ASF licenses this file to You under the Apache License, Version 2.0 + * (the "License"); you may not use this file except in compliance with + * the License. You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +// $Id: TransformerFactory.java 884963 2009-11-27 19:11:59Z mrglavas $ + +package javax.xml.transform; + +/** + * <p>A TransformerFactory instance can be used to create + * {@link javax.xml.transform.Transformer} and + * {@link javax.xml.transform.Templates} objects.</p> + * + * <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> + * + * @author <a href="mailto:[email protected]";>Jeff Suttor</a> + */ +public abstract class TransformerFactory { + + /** + * Default constructor is protected on purpose. + */ + protected TransformerFactory() { } + + + /** + * <p>Get current state of canonicalization.</p> + * + * @return current state canonicalization control + */ + /* + public boolean getCanonicalization() { + return canonicalState; + } + */ + + /** + * <p>Set canonicalization control to <code>true</code> or + * </code>false</code>.</p> + * + * @param state of canonicalization + */ + /* + public void setCanonicalization(boolean state) { + canonicalState = state; + } + */ + + /** + * 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. + * + * The jaxp.properties file is read only once by the JAXP implementation + * and it's values are then cached for future use. If the file does not exist + * when the first attempt is made to read from it, no further attempts are + * made to check for its existence. It is not possible to change the value + * of any property in jaxp.properties after it has been read for the first time. + * </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 Thrown if the implementation + * 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 */ + "com.sun.org.apache.xalan.internal.xsltc.trax.TransformerFactoryImpl"); + } + catch (FactoryFinder.ConfigurationError e) { + throw new TransformerFactoryConfigurationError(e.getException(), e.getMessage()); + } + } + + /** + * @return new TransformerFactory instance, never null. + * + * @throws TransformerFactoryConfigurationError Thrown if the implementation + * is not available or cannot be instantiated. + */ + public static TransformerFactory newInstance(String factoryClassName, + ClassLoader classLoader) throws TransformerFactoryConfigurationError { + if (factoryClassName == null) { + throw new TransformerFactoryConfigurationError("factoryClassName cannot be null."); + } + if (classLoader == null) { + classLoader = SecuritySupport.getContextClassLoader(); + } + try { + return (TransformerFactory) FactoryFinder.newInstance(factoryClassName, classLoader, false); + } + catch (FactoryFinder.ConfigurationError e) { + throw new TransformerFactoryConfigurationError(e.getException(), e.getMessage()); + } + } + + /** + * <p>Process the <code>Source</code> into a <code>Transformer</code> + * <code>Object</code>. The <code>Source</code> is an XSLT document that + * conforms to <a href="http://www.w3.org/TR/xslt";> + * XSL Transformations (XSLT) Version 1.0</a>. Care must + * be taken not to use this <code>Transformer</code> in multiple + * <code>Thread</code>s running concurrently. + * Different <code>TransformerFactories</code> can be used concurrently by + * different <code>Thread</code>s.</p> + * + * @param source <code>Source </code> of XSLT document used to create + * <code>Transformer</code>. + * Examples of XML <code>Source</code>s include + * {@link javax.xml.transform.stream.StreamSource StreamSource}, + * {@link javax.xml.transform.sax.SAXSource SAXSource}, + * {@link javax.xml.transform.dom.DOMSource DOMSource} and + * {@link javax.xml.transform.stax.StAXSource StAXSource}. + * + * @return A <code>Transformer</code> object that may be used to perform + * a transformation in a single <code>Thread</code>, never + * <code>null</code>. + * + * @throws TransformerConfigurationException Thrown if there are errors when + * parsing the <code>Source</code> or it is not possible to create a + * <code>Transformer</code> instance. + * + * @see <a href="http://www.w3.org/TR/xslt";> + * XSL Transformations (XSLT) Version 1.0</a> + */ + public abstract Transformer newTransformer(Source source) + throws TransformerConfigurationException; + + /** + * <p>Create a new <code>Transformer</code> that performs a copy + * of the <code>Source</code> to the <code>Result</code>. + * i.e. the "<em>identity transform</em>".</p> + * + * @return A Transformer object that may be used to perform a transformation + * in a single thread, never null. + * + * @exception TransformerConfigurationException Thrown if it is not + * possible to create a <code>Transformer</code> instance. + */ + 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; + + /** + * <p>Get the stylesheet specification(s) associated with the + * XML <code>Source</code> document via the + * <a href="http://www.w3.org/TR/xml-stylesheet/";> + * xml-stylesheet processing instruction</a> 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.</p> + * + * @param source The XML source document. + * @param media The media attribute to be matched. May be null, in which + * case the preferred 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 <code>Source</code> <code>Object</code> suitable for passing + * to the <code>TransformerFactory</code>. + * + * @throws TransformerConfigurationException An <code>Exception</code> + * is thrown if an error occurs during parsing of the + * <code>source</code>. + * + * @see <a href="http://www.w3.org/TR/xml-stylesheet/";> + * Associating Style Sheets with XML documents Version 1.0</a> + */ + 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 document(), 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 ======= + + /** + * <p>Set a feature for this <code>TransformerFactory</code> and <code>Transformer</code>s + * or <code>Template</code>s created by this factory.</p> + * + * <p> + * Feature names are fully qualified {@link java.net.URI}s. + * Implementations may define their own features. + * An {@link TransformerConfigurationException} is thrown if this <code>TransformerFactory</code> or the + * <code>Transformer</code>s or <code>Template</code>s it creates cannot support the feature. + * It is possible for an <code>TransformerFactory</code> to expose a feature value but be unable to change its state. + * </p> + * + * <p>All implementations are required to support the {@link javax.xml.XMLConstants#FEATURE_SECURE_PROCESSING} feature. + * When the feature is:</p> + * <ul> + * <li> + * <code>true</code>: the implementation will limit XML processing to conform to implementation limits + * and behave in a secure fashion as defined by the implementation. + * Examples include resolving user defined style sheets and functions. + * If XML processing is limited for security reasons, it will be reported via a call to the registered + * {@link ErrorListener#fatalError(TransformerException exception)}. + * See {@link #setErrorListener(ErrorListener listener)}. + * </li> + * <li> + * <code>false</code>: the implementation will processing XML according to the XML specifications without + * regard to possible implementation limits. + * </li> + * </ul> + * + * @param name Feature name. + * @param value Is feature state <code>true</code> or <code>false</code>. + * + * @throws TransformerConfigurationException if this <code>TransformerFactory</code> + * or the <code>Transformer</code>s or <code>Template</code>s it creates cannot support this feature. + * @throws NullPointerException If the <code>name</code> parameter is null. + */ + public abstract void setFeature(String name, boolean value) + throws TransformerConfigurationException; + + /** + * Look up the value of a feature. + * + * <p> + * Feature names are fully qualified {@link java.net.URI}s. + * Implementations may define their own features. + * <code>false</code> is returned if this <code>TransformerFactory</code> or the + * <code>Transformer</code>s or <code>Template</code>s it creates cannot support the feature. + * It is possible for an <code>TransformerFactory</code> to expose a feature value but be unable to change its state. + * </p> + * + * @param name Feature name. + * + * @return The current state of the feature, <code>true</code> or <code>false</code>. + * + * @throws NullPointerException If the <code>name</code> parameter is null. + */ + 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. + * An <code>IllegalArgumentException</code> is thrown if the underlying + * implementation doesn't recognize the attribute. + * + * @param name The name of the attribute. + * @param value The value of the attribute. + */ + public abstract void setAttribute(String name, Object value); + + /** + * Allows the user to retrieve specific attributes on the underlying + * implementation. + * An <code>IllegalArgumentException</code> is thrown if the underlying + * implementation doesn't recognize the attribute. + * + * @param name The name of the attribute. + * @return value The value of the attribute. + */ + public abstract Object getAttribute(String name); + + /** + * Set the error event listener for the TransformerFactory, which + * is used for the processing of transformation instructions, + * and not for the transformation itself. + * An <code>IllegalArgumentException</code> is thrown if the + * <code>ErrorListener</code> listener is <code>null</code>. + * + * @param listener The new error listener. + */ + public abstract void setErrorListener(ErrorListener listener); + + /** + * Get the error event handler for the TransformerFactory. + * + * @return The current error handler, which should never be null. + */ + public abstract ErrorListener getErrorListener(); + +} + Modified: servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/validation/SchemaFactoryFinder.java URL: http://svn.apache.org/viewvc/servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/validation/SchemaFactoryFinder.java?rev=1227282&r1=1227281&r2=1227282&view=diff ============================================================================== --- servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/validation/SchemaFactoryFinder.java (original) +++ servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/javax/xml/validation/SchemaFactoryFinder.java Wed Jan 4 19:47:39 2012 @@ -29,6 +29,7 @@ import java.util.Enumeration; import java.util.Iterator; import java.util.NoSuchElementException; import java.util.Properties; +import javax.xml.XMLConstants; /** * Implementation of {@link SchemaFactory#newInstance(String)}. @@ -259,11 +260,11 @@ final class SchemaFactoryFinder { } // platform default - if (schemaLanguage.equals("http://www.w3.org/2001/XMLSchema";)) { - if (debug) debugPrintln("attempting to use the platform default XML Schema validator"); - return createInstance("org.apache.xerces.jaxp.validation.XMLSchemaFactory"); + if(schemaLanguage.equals("http://www.w3.org/2001/XMLSchema";)) { + if (debug) debugPrintln("attempting to use the platform default XML Schema 1.0 validator"); + return createInstance("com.sun.org.apache.xerces.internal.jaxp.validation.XMLSchemaFactory"); } - + if (debug) debugPrintln("all things were tried, but none was found. bailing out."); return null; } Modified: servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/org/xml/sax/helpers/XMLReaderFactory.java URL: http://svn.apache.org/viewvc/servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/org/xml/sax/helpers/XMLReaderFactory.java?rev=1227282&r1=1227281&r2=1227282&view=diff ============================================================================== --- servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/org/xml/sax/helpers/XMLReaderFactory.java (original) +++ servicemix/smx4/specs/trunk/jaxp-api-1.4/src/main/java/org/xml/sax/helpers/XMLReaderFactory.java Wed Jan 4 19:47:39 2012 @@ -201,7 +201,7 @@ final public class XMLReaderFactory // EXAMPLE: // className = "com.example.sax.XmlReader"; // or a $JAVA_HOME/jre/lib/*properties setting... - className = "org.apache.xerces.parsers.SAXParser"; + className = "com.sun.org.apache.xerces.internal.parsers.SAXParser"; // END DISTRIBUTION-SPECIFIC }
