Sign Up
Log In
Log In
or
Sign Up
Places
All Projects
Status Monitor
Collapse sidebar
Please login to access the resource
devel:ARM:Factory:Contrib:ILP32
netbeans-resolver
netbeans-resolver-6.7.1-nb.patch
Overview
Repositories
Revisions
Requests
Users
Attributes
Meta
File netbeans-resolver-6.7.1-nb.patch of Package netbeans-resolver
Index: libxml-commons-resolver1.1-java-1.2/src/org/apache/xml/resolver/NbCatalogManager.java =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ libxml-commons-resolver1.1-java-1.2/src/org/apache/xml/resolver/NbCatalogManager.java 2009-01-30 23:02:32.000000000 +0100 @@ -0,0 +1,840 @@ +// CatalogManager.java - Access CatalogManager.properties + +/* + * 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. + */ + +package org.apache.xml.resolver; + +import java.io.InputStream; + +import java.net.URL; +import java.net.MalformedURLException; + +import java.util.MissingResourceException; +import java.util.PropertyResourceBundle; +import java.util.ResourceBundle; +import java.util.StringTokenizer; +import java.util.Vector; + +import org.apache.xml.resolver.helpers.Debug; +import org.apache.xml.resolver.helpers.BootstrapResolver; +import org.apache.xml.resolver.Catalog; + +/** + * CatalogManager provides an interface to the catalog properties. + * + * <p>Properties can come from two places: from system properties or + * from a <i>CatalogManager.properties</i> file. This class provides a transparent + * interface to both, with system properties preferred over property file values.</p> + * + * <p>The following table summarizes the properties:</p> + * + * <table border="1"> + * <thead> + * <tr> + * <td>System Property</td> + * <td>CatalogManager.properties<br/>Property</td> + * <td>Description</td> + * </tr> + * </thead> + * <tbody> + * <tr> + * <td>xml.catalog.ignoreMissing</td> + * <td> </td> + * <td>If true, a missing <i>CatalogManager.properties</i> file or missing properties + * within that file will not generate warning messages. See also the + * <i>ignoreMissingProperties</i> method.</td> + * </tr> + * + * <tr> + * <td>xml.catalog.files</td> + * <td>catalogs</td> + * <td>The <emph>semicolon-delimited</emph> list of catalog files.</td> + * </tr> + * + * <tr> + * <td> </td> + * <td>relative-catalogs</td> + * <td>If false, relative catalog URIs are made absolute with respect to the base URI of + * the <i>CatalogManager.properties</i> file. This setting only applies to catalog + * URIs obtained from the <i>catalogs</i> property <emph>in the</emph> + * <i>CatalogManager.properties</i> file</td> + * </tr> + * + * <tr> + * <td>xml.catalog.verbosity</td> + * <td>verbosity</td> + * <td>If non-zero, the Catalog classes will print informative and debugging messages. + * The higher the number, the more messages.</td> + * </tr> + * + * <tr> + * <td>xml.catalog.prefer</td> + * <td>prefer</td> + * <td>Which identifier is preferred, "public" or "system"?</td> + * </tr> + * + * <tr> + * <td>xml.catalog.staticCatalog</td> + * <td>static-catalog</td> + * <td>Should a single catalog be constructed for all parsing, or should a different + * catalog be created for each parser?</td> + * </tr> + * + * <tr> + * <td>xml.catalog.allowPI</td> + * <td>allow-oasis-xml-catalog-pi</td> + * <td>If the source document contains "oasis-xml-catalog" processing instructions, + * should they be used?</td> + * </tr> + * + * <tr> + * <td>xml.catalog.className</td> + * <td>catalog-class-name</td> + * <td>If you're using the convenience classes + * <tt>org.apache.xml.resolver.tools.*</tt>), this setting + * allows you to specify an alternate class name to use for the underlying + * catalog.</td> + * </tr> + * </tbody> + * </table> + * + * @see Catalog + * + * @author Norman Walsh + * <a href="mailto:Norman.Walsh@Sun.COM">Norman.Walsh@Sun.COM</a> + * + * @version 1.0 + */ + +public class NbCatalogManager extends CatalogManager { + private static String pFiles = "xml.catalog.files"; + private static String pVerbosity = "xml.catalog.verbosity"; + private static String pPrefer = "xml.catalog.prefer"; + private static String pStatic = "xml.catalog.staticCatalog"; + private static String pAllowPI = "xml.catalog.allowPI"; + private static String pClassname = "xml.catalog.className"; + private static String pIgnoreMissing = "xml.catalog.ignoreMissing"; + + /** A static CatalogManager instance for sharing */ + private static NbCatalogManager staticManager = new NbCatalogManager(); + + /** The bootstrap resolver to use when loading XML Catalogs. */ + private BootstrapResolver bResolver = new BootstrapResolver(); + + /** Flag to ignore missing property files and/or properties */ + private boolean ignoreMissingProperties + = (System.getProperty(pIgnoreMissing) != null + || System.getProperty(pFiles) != null); + + /** Holds the resources after they are loaded from the file. */ + private ResourceBundle resources; + + /** The name of the CatalogManager properties file. */ + private String propertyFile = "CatalogManager.properties"; + + /** The location of the propertyFile */ + private URL propertyFileURI = null; + + /** Default catalog files list. */ + private String defaultCatalogFiles = "./xcatalog"; + + /** Current catalog files list. */ + private String catalogFiles = null; + + /** Did the catalogFiles come from the properties file? */ + private boolean fromPropertiesFile = false; + + /** Default verbosity level if there is no property setting for it. */ + private int defaultVerbosity = 1; + + /** Current verbosity level. */ + private Integer verbosity = null; + + /** Default preference setting. */ + private boolean defaultPreferPublic = true; + + /** Current preference setting. */ + private Boolean preferPublic = null; + + /** Default setting of the static catalog flag. */ + private boolean defaultUseStaticCatalog = true; + + /** Current setting of the static catalog flag. */ + private Boolean useStaticCatalog = null; + + /** The static catalog used by this manager. */ + private static Catalog staticCatalog = null; + + /** Default setting of the oasisXMLCatalogPI flag. */ + private boolean defaultOasisXMLCatalogPI = true; + + /** Current setting of the oasisXMLCatalogPI flag. */ + private Boolean oasisXMLCatalogPI = null; + + /** Default setting of the relativeCatalogs flag. */ + private boolean defaultRelativeCatalogs = true; + + /** Current setting of the relativeCatalogs flag. */ + private Boolean relativeCatalogs = null; + + /** Current catalog class name. */ + private String catalogClassName = null; + + /** The manager's debug object. Used for printing debugging messages. + * + * <p>This field is public so that objects that have access to this + * CatalogManager can use this debug object.</p> + */ + public Debug debug = null; + + /** Constructor. */ + public NbCatalogManager() { + debug = new Debug(); + // Note that we don't setDebug() here; we do that lazily. Either the + // user will set it explicitly, or we'll do it automagically if they + // read from the propertyFile for some other reason. That way, there's + // no attempt to read from the file before the caller has had a chance + // to avoid it. + } + + /** + * Constructor that specifies an explicit property file. + * @param propertyFile path to poperty file (e.g. com/resources/CatalogManager). + * <code>null</code> means that no property file is consulted at all. + */ + public NbCatalogManager(String propertyFile) { + this.propertyFile = propertyFile; + + debug = new Debug(); + // Note that we don't setDebug() here; we do that lazily. Either the + // user will set it explicitly, or we'll do it automagically if they + // read from the propertyFile for some other reason. That way, there's + // no attempt to read from the file before the caller has had a chance + // to avoid it. + } + + /** Set the bootstrap resolver.*/ + public void setBootstrapResolver(BootstrapResolver resolver) { + bResolver = resolver; + } + + /** Get the bootstrap resolver.*/ + public BootstrapResolver getBootstrapResolver() { + return bResolver; + } + + /** + * Load the properties from the propertyFile and build the + * resources from it. + */ + private synchronized void readProperties() { + if (propertyFile == null) return; + try { + propertyFileURI = NbCatalogManager.class.getResource("/"+propertyFile); + InputStream in = + NbCatalogManager.class.getResourceAsStream("/"+propertyFile); + if (in==null) { + if (!ignoreMissingProperties) { + debug.message(2, "Cannot find "+propertyFile); + // there's no reason to give this warning more than once + ignoreMissingProperties = true; + } + return; + } + resources = new PropertyResourceBundle(in); + } catch (MissingResourceException mre) { + if (!ignoreMissingProperties) { + System.err.println("Cannot read "+propertyFile); + } + } catch (java.io.IOException e) { + if (!ignoreMissingProperties) { + System.err.println("Failure trying to read "+propertyFile); + } + } + + // This is a bit of a hack. After we've successfully read the properties, + // use them to set the default debug level, if the user hasn't already set + // the default debug level. + if (verbosity == null) { + try { + String verbStr = resources.getString("verbosity"); + int verb = Integer.parseInt(verbStr.trim()); + debug.setDebug(verb); + verbosity = new Integer(verb); + } catch (Exception e) { + // nop + } + } + } + + /** + * Allow access to the static CatalogManager + */ + public static CatalogManager getStaticManager() { + return staticManager; + } + + /** + * How are missing properties handled? + * + * <p>If true, missing or unreadable property files will + * not be reported. Otherwise, a message will be sent to System.err. + * </p> + */ + public boolean getIgnoreMissingProperties() { + return ignoreMissingProperties; + } + + /** + * How should missing properties be handled? + * + * <p>If ignore is true, missing or unreadable property files will + * not be reported. Otherwise, a message will be sent to System.err. + * </p> + */ + public void setIgnoreMissingProperties(boolean ignore) { + ignoreMissingProperties = ignore; + } + + /** + * How are missing properties handled? + * + * <p>If ignore is true, missing or unreadable property files will + * not be reported. Otherwise, a message will be sent to System.err. + * </p> + * + * @deprecated No longer static; use get/set methods. + */ + public void ignoreMissingProperties(boolean ignore) { + setIgnoreMissingProperties(ignore); + } + + /** + * Obtain the verbosity setting from the properties. + * + * @return The verbosity level from the propertyFile or the + * defaultVerbosity. + */ + private int queryVerbosity () { + String defaultVerbStr = Integer.toString(defaultVerbosity); + + String verbStr = System.getProperty(pVerbosity); + + if (verbStr == null) { + if (resources==null) readProperties(); + if (resources != null) { + try { + verbStr = resources.getString("verbosity"); + } catch (MissingResourceException e) { + verbStr = defaultVerbStr; + } + } else { + verbStr = defaultVerbStr; + } + } + + int verb = defaultVerbosity; + + try { + verb = Integer.parseInt(verbStr.trim()); + } catch (Exception e) { + System.err.println("Cannot parse verbosity: \"" + verbStr + "\""); + } + + // This is a bit of a hack. After we've successfully got the verbosity, + // we have to use it to set the default debug level, + // if the user hasn't already set the default debug level. + if (verbosity == null) { + debug.setDebug(verb); + verbosity = new Integer(verb); + } + + return verb; + } + + /** + * What is the current verbosity? + */ + public int getVerbosity() { + if (verbosity == null) { + verbosity = new Integer(queryVerbosity()); + } + + return verbosity.intValue(); + } + + /** + * Set the current verbosity. + */ + public void setVerbosity (int verbosity) { + this.verbosity = new Integer(verbosity); + debug.setDebug(verbosity); + } + + /** + * What is the current verbosity? + * + * @deprecated No longer static; use get/set methods. + */ + public int verbosity () { + return getVerbosity(); + } + + /** + * Obtain the relativeCatalogs setting from the properties. + * + * @return The relativeCatalogs setting from the propertyFile or the + * defaultRelativeCatalogs. + */ + private boolean queryRelativeCatalogs () { + if (resources==null) readProperties(); + + if (resources==null) return defaultRelativeCatalogs; + + try { + String allow = resources.getString("relative-catalogs"); + return (allow.equalsIgnoreCase("true") + || allow.equalsIgnoreCase("yes") + || allow.equalsIgnoreCase("1")); + } catch (MissingResourceException e) { + return defaultRelativeCatalogs; + } + } + + /** + * Get the relativeCatalogs setting. + * + * <p>This property is used when the catalogFiles property is + * interrogated. If true, then relative catalog entry file names + * are returned. If false, relative catalog entry file names are + * made absolute with respect to the properties file before returning + * them.</p> + * + * <p>This property <emph>only applies</emph> when the catalog files + * come from a properties file. If they come from a system property or + * the default list, they are never considered relative. (What would + * they be relative to?)</p> + * + * <p>In the properties, a value of 'yes', 'true', or '1' is considered + * true, anything else is false.</p> + * + * @return The relativeCatalogs setting from the propertyFile or the + * defaultRelativeCatalogs. + */ + public boolean getRelativeCatalogs () { + if (relativeCatalogs == null) { + relativeCatalogs = new Boolean(queryRelativeCatalogs()); + } + + return relativeCatalogs.booleanValue(); + } + + /** + * Set the relativeCatalogs setting. + * + * @see #getRelativeCatalogs() + */ + public void setRelativeCatalogs (boolean relative) { + relativeCatalogs = new Boolean(relative); + } + + /** + * Get the relativeCatalogs setting. + * + * @deprecated No longer static; use get/set methods. + */ + public boolean relativeCatalogs () { + return getRelativeCatalogs(); + } + + /** + * Obtain the list of catalog files from the properties. + * + * @return A semicolon delimited list of catlog file URIs + */ + private String queryCatalogFiles () { + String catalogList = System.getProperty(pFiles); + fromPropertiesFile = false; + + if (catalogList == null) { + if (resources == null) readProperties(); + if (resources != null) { + try { + catalogList = resources.getString("catalogs"); + fromPropertiesFile = true; + } catch (MissingResourceException e) { + System.err.println(propertyFile + ": catalogs not found."); + catalogList = null; + } + } + } + + if (catalogList == null) { + catalogList = defaultCatalogFiles; + } + + return catalogList; + } + + /** + * Return the current list of catalog files. + * + * @return A vector of the catalog file names or null if no catalogs + * are available in the properties. + */ + public Vector getCatalogFiles() { + if (catalogFiles == null) { + catalogFiles = queryCatalogFiles(); + } + + StringTokenizer files = new StringTokenizer(catalogFiles, ";"); + Vector catalogs = new Vector(); + while (files.hasMoreTokens()) { + String catalogFile = files.nextToken(); + URL absURI = null; + + if (fromPropertiesFile && !relativeCatalogs()) { + try { + absURI = new URL(propertyFileURI, catalogFile); + catalogFile = absURI.toString(); + } catch (MalformedURLException mue) { + absURI = null; + } + } + + catalogs.add(catalogFile); + } + + return catalogs; + } + + /** + * Set the list of catalog files. + */ + public void setCatalogFiles(String fileList) { + catalogFiles = fileList; + fromPropertiesFile = false; + } + + /** + * Return the current list of catalog files. + * + * @return A vector of the catalog file names or null if no catalogs + * are available in the properties. + * + * @deprecated No longer static; use get/set methods. + */ + public Vector catalogFiles() { + return getCatalogFiles(); + } + + /** + * Obtain the preferPublic setting from the properties. + * + * <p>In the properties, a value of 'public' is true, + * anything else is false.</p> + * + * @return True if prefer is public or the + * defaultPreferSetting. + */ + private boolean queryPreferPublic () { + String prefer = System.getProperty(pPrefer); + + if (prefer == null) { + if (resources==null) readProperties(); + if (resources==null) return defaultPreferPublic; + try { + prefer = resources.getString("prefer"); + } catch (MissingResourceException e) { + return defaultPreferPublic; + } + } + + if (prefer == null) { + return defaultPreferPublic; + } + + return (prefer.equalsIgnoreCase("public")); + } + + /** + * Return the current prefer public setting. + * + * @return True if public identifiers are preferred. + */ + public boolean getPreferPublic () { + if (preferPublic == null) { + preferPublic = new Boolean(queryPreferPublic()); + } + return preferPublic.booleanValue(); + } + + /** + * Set the prefer public setting. + */ + public void setPreferPublic (boolean preferPublic) { + this.preferPublic = new Boolean(preferPublic); + } + + /** + * Return the current prefer public setting. + * + * @return True if public identifiers are preferred. + * + * @deprecated No longer static; use get/set methods. + */ + public boolean preferPublic () { + return getPreferPublic(); + } + + /** + * Obtain the static-catalog setting from the properties. + * + * <p>In the properties, a value of 'yes', 'true', or '1' is considered + * true, anything else is false.</p> + * + * @return The static-catalog setting from the propertyFile or the + * defaultUseStaticCatalog. + */ + private boolean queryUseStaticCatalog () { + String staticCatalog = System.getProperty(pStatic); + + if (staticCatalog == null) { + if (resources==null) readProperties(); + if (resources==null) return defaultUseStaticCatalog; + try { + staticCatalog = resources.getString("static-catalog"); + } catch (MissingResourceException e) { + return defaultUseStaticCatalog; + } + } + + if (staticCatalog == null) { + return defaultUseStaticCatalog; + } + + return (staticCatalog.equalsIgnoreCase("true") + || staticCatalog.equalsIgnoreCase("yes") + || staticCatalog.equalsIgnoreCase("1")); + } + + /** + * Get the current use static catalog setting. + */ + public boolean getUseStaticCatalog() { + if (useStaticCatalog == null) { + useStaticCatalog = new Boolean(queryUseStaticCatalog()); + } + + return useStaticCatalog.booleanValue(); + } + + /** + * Set the use static catalog setting. + */ + public void setUseStaticCatalog(boolean useStatic) { + useStaticCatalog = new Boolean(useStatic); + } + + /** + * Get the current use static catalog setting. + * + * @deprecated No longer static; use get/set methods. + */ + public boolean staticCatalog() { + return getUseStaticCatalog(); + } + + /** + * Get a new catalog instance. + * + * This method always returns a new instance of the underlying catalog class. + */ + public Catalog getPrivateCatalog() { + Catalog catalog = staticCatalog; + + if (useStaticCatalog == null) { + useStaticCatalog = new Boolean(getUseStaticCatalog()); + } + + if (catalog == null || !useStaticCatalog.booleanValue()) { + + try { + String catalogClassName = getCatalogClassName(); + + if (catalogClassName == null) { + catalog = new Catalog(); + } else { + try { + catalog = (Catalog) Class.forName(catalogClassName).newInstance(); + } catch (ClassNotFoundException cnfe) { + debug.message(1,"Catalog class named '" + + catalogClassName + + "' could not be found. Using default."); + catalog = new Catalog(); + } catch (ClassCastException cnfe) { + debug.message(1,"Class named '" + + catalogClassName + + "' is not a Catalog. Using default."); + catalog = new Catalog(); + } + } + + catalog.setCatalogManager(this); + catalog.setupReaders(); + catalog.loadSystemCatalogs(); + } catch (Exception ex) { + ex.printStackTrace(); + } + + if (useStaticCatalog.booleanValue()) { + staticCatalog = catalog; + } + } + + return catalog; + } + + /** + * Get a catalog instance. + * + * If this manager uses static catalogs, the same static catalog will + * always be returned. Otherwise a new catalog will be returned. + */ + public Catalog getCatalog() { + Catalog catalog = staticCatalog; + + if (useStaticCatalog == null) { + useStaticCatalog = new Boolean(getUseStaticCatalog()); + } + + if (catalog == null || !useStaticCatalog.booleanValue()) { + catalog = getPrivateCatalog(); + if (useStaticCatalog.booleanValue()) { + staticCatalog = catalog; + } + } + + return catalog; + } + + /** + * <p>Obtain the oasisXMLCatalogPI setting from the properties.</p> + * + * <p>In the properties, a value of 'yes', 'true', or '1' is considered + * true, anything else is false.</p> + * + * @return The oasisXMLCatalogPI setting from the propertyFile or the + * defaultOasisXMLCatalogPI. + */ + public boolean queryAllowOasisXMLCatalogPI () { + String allow = System.getProperty(pAllowPI); + + if (allow == null) { + if (resources==null) readProperties(); + if (resources==null) return defaultOasisXMLCatalogPI; + try { + allow = resources.getString("allow-oasis-xml-catalog-pi"); + } catch (MissingResourceException e) { + return defaultOasisXMLCatalogPI; + } + } + + if (allow == null) { + return defaultOasisXMLCatalogPI; + } + + return (allow.equalsIgnoreCase("true") + || allow.equalsIgnoreCase("yes") + || allow.equalsIgnoreCase("1")); + } + + /** + * Get the current XML Catalog PI setting. + */ + public boolean getAllowOasisXMLCatalogPI () { + if (oasisXMLCatalogPI == null) { + oasisXMLCatalogPI = new Boolean(queryAllowOasisXMLCatalogPI()); + } + + return oasisXMLCatalogPI.booleanValue(); + } + + /** + * Set the XML Catalog PI setting + */ + public void setAllowOasisXMLCatalogPI(boolean allowPI) { + oasisXMLCatalogPI = new Boolean(allowPI); + } + + /** + * Get the current XML Catalog PI setting. + * + * @deprecated No longer static; use get/set methods. + */ + public boolean allowOasisXMLCatalogPI() { + return getAllowOasisXMLCatalogPI(); + } + + /** + * Obtain the Catalog class name setting from the properties. + * + */ + public String queryCatalogClassName () { + String className = System.getProperty(pClassname); + + if (className == null) { + if (resources==null) readProperties(); + if (resources==null) return null; + try { + return resources.getString("catalog-class-name"); + } catch (MissingResourceException e) { + return null; + } + } + + return className; + } + + /** + * Get the current Catalog class name. + */ + public String getCatalogClassName() { + if (catalogClassName == null) { + catalogClassName = queryCatalogClassName(); + } + + return catalogClassName; + } + + /** + * Set the Catalog class name. + */ + public void setCatalogClassName(String className) { + catalogClassName = className; + } + + /** + * Get the current Catalog class name. + * + * @deprecated No longer static; use get/set methods. + */ + public String catalogClassName() { + return getCatalogClassName(); + } +} Index: libxml-commons-resolver1.1-java-1.2/src/org/apache/xml/resolver/tools/NbCatalogResolver.java =================================================================== --- /dev/null 1970-01-01 00:00:00.000000000 +0000 +++ libxml-commons-resolver1.1-java-1.2/src/org/apache/xml/resolver/tools/NbCatalogResolver.java 2009-01-30 23:02:49.000000000 +0100 @@ -0,0 +1,316 @@ +// CatalogResolver.java - A SAX EntityResolver/JAXP URI Resolver + +/* + * 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. + */ + +package org.apache.xml.resolver.tools; + +import java.io.IOException; +import java.io.InputStream; +import java.net.URL; +import java.net.MalformedURLException; + +import org.xml.sax.SAXException; +import org.xml.sax.XMLReader; +import org.xml.sax.InputSource; +import org.xml.sax.EntityResolver; + +import javax.xml.transform.sax.SAXSource; +import javax.xml.transform.Source; +import javax.xml.transform.URIResolver; +import javax.xml.transform.TransformerException; +import javax.xml.parsers.ParserConfigurationException; +import javax.xml.parsers.SAXParserFactory; + +import org.apache.xml.resolver.Catalog; +import org.apache.xml.resolver.CatalogManager; +import org.apache.xml.resolver.NbCatalogManager; +import org.apache.xml.resolver.helpers.FileURL; + +/** + * A SAX EntityResolver/JAXP URIResolver that uses catalogs. + * + * <p>This class implements both a SAX EntityResolver and a JAXP URIResolver. + * </p> + * + * <p>This resolver understands OASIS TR9401 catalogs, XCatalogs, and the + * current working draft of the OASIS Entity Resolution Technical + * Committee specification.</p> + * + * @see Catalog + * @see org.xml.sax.EntityResolver + * @see javax.xml.transform.URIResolver + * + * @author Norman Walsh + * <a href="mailto:Norman.Walsh@Sun.COM">Norman.Walsh@Sun.COM</a> + * + * @version 1.0 + */ +public class NbCatalogResolver implements EntityResolver, URIResolver { + /** Make the parser Namespace aware? */ + public boolean namespaceAware = true; + + /** Make the parser validating? */ + public boolean validating = false; + + /** The underlying catalog */ + private Catalog catalog = null; + + /** The catalog manager */ + private CatalogManager catalogManager = NbCatalogManager.getStaticManager(); + + /** Constructor */ + public NbCatalogResolver() { + initializeCatalogs(false); + } + + /** Constructor */ + public NbCatalogResolver(boolean privateCatalog) { + initializeCatalogs(privateCatalog); + } + + /** Constructor */ + public NbCatalogResolver(NbCatalogManager manager) { + catalogManager = manager; + initializeCatalogs(!catalogManager.getUseStaticCatalog()); + } + + /** Initialize catalog */ + private void initializeCatalogs(boolean privateCatalog) { + catalog = catalogManager.getCatalog(); + } + + /** Return the underlying catalog */ + public Catalog getCatalog() { + return catalog; + } + + /** + * Implements the guts of the <code>resolveEntity</code> method + * for the SAX interface. + * + * <p>Presented with an optional public identifier and a system + * identifier, this function attempts to locate a mapping in the + * catalogs.</p> + * + * <p>If such a mapping is found, it is returned. If no mapping is + * found, null is returned.</p> + * + * @param publicId The public identifier for the entity in question. + * This may be null. + * + * @param systemId The system identifier for the entity in question. + * XML requires a system identifier on all external entities, so this + * value is always specified. + * + * @return The resolved identifier (a URI reference). + */ + public String getResolvedEntity (String publicId, String systemId) { + String resolved = null; + + if (catalog == null) { + catalogManager.debug.message(1, "Catalog resolution attempted with null catalog; ignored"); + return null; + } + + if (systemId != null) { + try { + resolved = catalog.resolveSystem(systemId); + } catch (MalformedURLException me) { + catalogManager.debug.message(1, "Malformed URL exception trying to resolve", + publicId); + resolved = null; + } catch (IOException ie) { + catalogManager.debug.message(1, "I/O exception trying to resolve", publicId); + resolved = null; + } + } + + if (resolved == null) { + if (publicId != null) { + try { + resolved = catalog.resolvePublic(publicId, systemId); + } catch (MalformedURLException me) { + catalogManager.debug.message(1, "Malformed URL exception trying to resolve", + publicId); + } catch (IOException ie) { + catalogManager.debug.message(1, "I/O exception trying to resolve", publicId); + } + } + + if (resolved != null) { + catalogManager.debug.message(2, "Resolved public", publicId, resolved); + } + } else { + catalogManager.debug.message(2, "Resolved system", systemId, resolved); + } + + return resolved; + } + + /** + * Implements the <code>resolveEntity</code> method + * for the SAX interface. + * + * <p>Presented with an optional public identifier and a system + * identifier, this function attempts to locate a mapping in the + * catalogs.</p> + * + * <p>If such a mapping is found, the resolver attempts to open + * the mapped value as an InputSource and return it. Exceptions are + * ignored and null is returned if the mapped value cannot be opened + * as an input source.</p> + * + * <p>If no mapping is found (or an error occurs attempting to open + * the mapped value as an input source), null is returned and the system + * will use the specified system identifier as if no entityResolver + * was specified.</p> + * + * @param publicId The public identifier for the entity in question. + * This may be null. + * + * @param systemId The system identifier for the entity in question. + * XML requires a system identifier on all external entities, so this + * value is always specified. + * + * @return An InputSource for the mapped identifier, or null. + */ + public InputSource resolveEntity (String publicId, String systemId) { + String resolved = getResolvedEntity(publicId, systemId); + + if (resolved != null) { + InputSource iSource = new InputSource(resolved); + iSource.setPublicId(publicId); + return iSource; + } + + return null; + } + /** JAXP URIResolver API */ + public Source resolve(String href, String base) + throws TransformerException { + + String uri = href; + String fragment = null; + int hashPos = href.indexOf("#"); + if (hashPos >= 0) { + uri = href.substring(0, hashPos); + fragment = href.substring(hashPos+1); + } + + String result = null; + + try { + result = catalog.resolveURI(href); + } catch (Exception e) { + // nop; + } + + if (result == null) { + try { + URL url = null; + + if (base==null) { + url = new URL(uri); + result = url.toString(); + } else { + URL baseURL = new URL(base); + url = (href.length()==0 ? baseURL : new URL(baseURL, uri)); + result = url.toString(); + } + } catch (java.net.MalformedURLException mue) { + // try to make an absolute URI from the current base + String absBase = makeAbsolute(base); + if (!absBase.equals(base)) { + // don't bother if the absBase isn't different! + return resolve(href, absBase); + } else { + throw new TransformerException("Malformed URL " + + href + "(base " + base + ")", + mue); + } + } + } + + catalogManager.debug.message(2, "Resolved URI", href, result); + + SAXSource source = new SAXSource(); + source.setInputSource(new InputSource(result)); + setEntityResolver(source); + return source; + } + + /** + * <p>Establish an entityResolver for newly resolved URIs.</p> + * + * <p>This is called from the URIResolver to set an EntityResolver + * on the SAX parser to be used for new XML documents that are + * encountered as a result of the document() function, xsl:import, + * or xsl:include. This is done because the XSLT processor calls + * out to the SAXParserFactory itself to create a new SAXParser to + * parse the new document. The new parser does not automatically + * inherit the EntityResolver of the original (although arguably + * it should). See below:</p> + * + * <tt>"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"</tt> + * + * <p>...quoted from page 118 of the Java API for XML + * Processing 1.1 specification</p> + * + */ + private void setEntityResolver(SAXSource source) throws TransformerException { + XMLReader reader = source.getXMLReader(); + if (reader == null) { + SAXParserFactory spFactory = SAXParserFactory.newInstance(); + spFactory.setNamespaceAware(true); + try { + reader = spFactory.newSAXParser().getXMLReader(); + } + catch (ParserConfigurationException ex) { + throw new TransformerException(ex); + } + catch (SAXException ex) { + throw new TransformerException(ex); + } + } + reader.setEntityResolver(this); + source.setXMLReader(reader); + } + + /** Attempt to construct an absolute URI */ + private String makeAbsolute(String uri) { + if (uri == null) { + uri = ""; + } + + try { + URL url = new URL(uri); + return url.toString(); + } catch (MalformedURLException mue) { + try { + URL fileURL = FileURL.makeURL(uri); + return fileURL.toString(); + } catch (MalformedURLException mue2) { + // bail + return uri; + } + } + } +}
Locations
Projects
Search
Status Monitor
Help
OpenBuildService.org
Documentation
API Documentation
Code of Conduct
Contact
Support
@OBShq
Terms
openSUSE Build Service is sponsored by
The Open Build Service is an
openSUSE project
.
Sign Up
Log In
Places
Places
All Projects
Status Monitor
