/*
* Copyright (c) 2001-2004 World Wide Web Consortium,
* (Massachusetts Institute of Technology, Institut National de
* Recherche en Informatique et en Automatique, Keio University). All
* Rights Reserved. This program is distributed under the W3C's Software
* Intellectual Property License. This program is distributed in the
* hope that it will be useful, but WITHOUT ANY WARRANTY; without even
* the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
* PURPOSE.
* See W3C License http://www.w3.org/Consortium/Legal/ for more details.
*/
package org.w3c.domts;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.util.HashMap;
import java.util.Map;
import org.w3c.dom.DOMImplementation;
import org.w3c.dom.Document;
/**
* This class implements the generic parser and configuation
* abstract class for the DOM L3 implementations
*
* @author Curt Arnold
*/
public class LSDocumentBuilderFactory
extends DOMTestDocumentBuilderFactory {
private final Object parser;
private final Method parseURIMethod;
private final DOMImplementation impl;
/**
*
* Abstract class for a strategy to map a DocumentBuilderSetting
* to an action on LSParser.
*/
private static abstract class LSStrategy {
/**
* Constructor.
*/
protected LSStrategy() {
}
/**
* Applies setting to LSParser
*
* @param setting setting
* @param parser parser
* @throws DOMTestIncompatibleException if parser does not support setting
*/
public abstract void applySetting(DocumentBuilderSetting setting,
Object parser) throws
DOMTestIncompatibleException;
/**
* Gets state of setting for parser
*
* @param parser parser
* @return state of setting
*/
public abstract boolean hasSetting(Object parser);
}
/**
* Represents a fixed setting, for example, all Java implementations
* supported signed values.
*
*/
private static class LSFixedStrategy
extends LSStrategy {
private final boolean fixedValue;
/**
* Constructor
*
* @param settingName setting name
* @param fixedValue fixed value
*/
public LSFixedStrategy(boolean fixedValue) {
this.fixedValue = fixedValue;
}
/**
* Apply setting. Throws exception if requested setting
* does not match fixed value.
*/
public void applySetting(DocumentBuilderSetting setting, Object parser) throws
DOMTestIncompatibleException {
if (setting.getValue() != fixedValue) {
throw new DOMTestIncompatibleException(null, setting);
}
}
/**
* Gets fixed value for setting
*/
public boolean hasSetting(Object parser) {
return fixedValue;
}
}
/**
* A strategy for a setting that can be applied by setting a DOMConfiguration
* parameter.
*
*/
private static class LSParameterStrategy
extends LSStrategy {
private final String lsParameter;
private final boolean inverse;
/**
* Constructor
*
* @param lsParameter corresponding DOMConfiguration parameter
* @param inverse if true, DOMConfiguration value is the inverse
* of the setting value
*/
public LSParameterStrategy(String lsParameter, boolean inverse) {
this.lsParameter = lsParameter;
this.inverse = inverse;
}
protected static void setParameter(DocumentBuilderSetting setting,
Object parser,
String parameter,
Object value) throws
DOMTestIncompatibleException {
try {
Method domConfigMethod = parser.getClass().getMethod("getDomConfig",
new Class[0]);
Object domConfig = domConfigMethod.invoke(parser, new Object[0]);
Method setParameterMethod = domConfig.getClass().getMethod(
"setParameter", new Class[] {String.class, Object.class});
setParameterMethod.invoke(domConfig, new Object[] {parameter, value});
}
catch (InvocationTargetException ex) {
throw new DOMTestIncompatibleException(ex.getTargetException(), setting);
}
catch (Exception ex) {
throw new DOMTestIncompatibleException(ex, setting);
}
}
protected static Object getParameter(Object parser,
String parameter) throws Exception {
Method domConfigMethod = parser.getClass().getMethod("getDomConfig",
new Class[0]);
Object domConfig = domConfigMethod.invoke(parser, new Object[0]);
Method getParameterMethod = domConfig.getClass().getMethod("getParameter",
new Class[] {String.class});
return getParameterMethod.invoke(domConfig, new Object[] {parameter});
}
/**
* Apply setting
*/
public void applySetting(DocumentBuilderSetting setting, Object parser) throws
DOMTestIncompatibleException {
if (inverse) {
setParameter(setting, parser, lsParameter,
new Boolean(!setting.getValue()));
}
else {
setParameter(setting, parser, lsParameter, new Boolean(setting.getValue()));
}
}
/**
* Get value of setting
*/
public boolean hasSetting(Object parser) {
try {
if (inverse) {
return! ( (Boolean) getParameter(parser, lsParameter)).booleanValue();
}
else {
return ( (Boolean) getParameter(parser, lsParameter)).booleanValue();
}
}
catch (Exception ex) {
return false;
}
}
}
/**
* A strategy for the validation settings which require
* two DOMConfigurure parameters being set, 'validate' and 'schema-type'
*
*/
private static class LSValidateStrategy
extends LSParameterStrategy {
private final String schemaType;
/**
* Constructor
* @param schemaType schema type
*/
public LSValidateStrategy(String schemaType) {
super("validate", false);
this.schemaType = schemaType;
}
/**
* Apply setting
*/
public void applySetting(DocumentBuilderSetting setting, Object parser) throws
DOMTestIncompatibleException {
super.applySetting(setting, parser);
setParameter(null, parser, "schema-type", schemaType);
}
/**
* Get setting value
*/
public boolean hasSetting(Object parser) {
if (super.hasSetting(parser)) {
try {
String parserSchemaType = (String) getParameter(parser, "schema-type");
if (schemaType == null || schemaType.equals(parserSchemaType)) {
return true;
}
}
catch (Exception ex) {
}
}
return false;
}
}
/**
* Strategies for mapping DocumentBuilderSettings to
* actions on LSParser
*/
private static final Map strategies;
static {
strategies = new HashMap();
strategies.put("coalescing", new LSParameterStrategy("cdata-sections", true));
strategies.put("expandEntityReferences", new LSParameterStrategy("entities", true));
strategies.put("ignoringElementContentWhitespace",
new LSParameterStrategy("element-content-whitespace", true));
strategies.put("namespaceAware", new LSParameterStrategy("namespaces", false));
strategies.put("validating",
new LSValidateStrategy("http://www.w3.org/TR/REC-xml"));
strategies.put("schemaValidating",
new LSValidateStrategy("http://www.w3.org/2001/XMLSchema"));
strategies.put("ignoringComments", new LSParameterStrategy("comments", true));
strategies.put("signed", new LSFixedStrategy(true));
strategies.put("hasNullString", new LSFixedStrategy(true));
}
/**
* Creates a LS implementation of DOMTestDocumentBuilderFactory.
* @param settings array of settings, may be null.
* @throws DOMTestIncompatibleException
* Thrown if implementation does not support the specified settings
*/
public LSDocumentBuilderFactory(DocumentBuilderSetting[] settings) throws
DOMTestIncompatibleException {
super(settings);
try {
Class domImplRegistryClass = Class.forName(
"org.w3c.dom.bootstrap.DOMImplementationRegistry");
Method newInstanceMethod = domImplRegistryClass.getMethod("newInstance", (Class<?>) null);
Object domRegistry = newInstanceMethod.invoke(null, (Class<?>) null);
Method getDOMImplementationMethod = domImplRegistryClass.getMethod(
"getDOMImplementation", new Class[] {String.class});
impl = (DOMImplementation) getDOMImplementationMethod.invoke(domRegistry,
new Object[] {"LS"});
Method createLSParserMethod = impl.getClass().getMethod("createLSParser",
new Class[] {short.class, String.class});
parser = createLSParserMethod.invoke(impl,
new Object[] {new Short( (short) 1), null});
parseURIMethod = parser.getClass().getMethod("parseURI",
new Class[] {String.class});
}
catch (InvocationTargetException ex) {
throw new DOMTestIncompatibleException(ex.getTargetException(), null);
}
catch (Exception ex) {
throw new DOMTestIncompatibleException(ex, null);
}
if (settings != null) {
for (int i = 0; i < settings.length; i++) {
Object strategy = strategies.get(settings[i].getProperty());
if (strategy == null) {
throw new DOMTestIncompatibleException(null, settings[i]);
}
else {
( (LSStrategy) strategy).applySetting(settings[i], parser);
}
}
}
}
/**
* Create new instance of document builder factory
* reflecting specified settings
* @param newSettings new settings
* @return New instance
* @throws DOMTestIncompatibleException
* if settings are not supported by implementation
*/
public DOMTestDocumentBuilderFactory newInstance(
DocumentBuilderSetting[] newSettings) throws DOMTestIncompatibleException {
if (newSettings == null) {
return this;
}
DocumentBuilderSetting[] mergedSettings = mergeSettings(newSettings);
return new LSDocumentBuilderFactory(mergedSettings);
}
/**
* Loads specified URL
* @param url url to load
* @return DOM document
* @throws DOMTestLoadException if unable to load document
*/
public Document load(java.net.URL url) throws DOMTestLoadException {
try {
return (Document) parseURIMethod.invoke(parser,
new Object[] {url.toString()});
}
catch (InvocationTargetException ex) {
throw new DOMTestLoadException(ex.getTargetException());
}
catch (Exception ex) {
throw new DOMTestLoadException(ex);
}
}
/**
* Gets DOMImplementation
* @return DOM implementation, may be null
*/
public DOMImplementation getDOMImplementation() {
return impl;
}
/**
* Determines if the implementation supports the specified feature
* @param feature Feature
* @param version Version
* @return true if implementation supports the feature
*/
public boolean hasFeature(String feature, String version) {
return getDOMImplementation().hasFeature(feature, version);
}
private boolean hasProperty(String parameter) {
try {
return ( (Boolean) LSParameterStrategy.getParameter(parser, parameter)).
booleanValue();
}
catch (Exception ex) {
return true;
}
}
/**
* Indicates whether the implementation combines text and cdata nodes.
* @return true if coalescing
*/
public boolean isCoalescing() {
return!hasProperty("cdata-sections");
}
/**
* Indicates whether the implementation expands entity references.
* @return true if expanding entity references
*/
public boolean isExpandEntityReferences() {
return!hasProperty("entities");
}
/**
* Indicates whether the implementation ignores
* element content whitespace.
* @return true if ignoring element content whitespace
*/
public boolean isIgnoringElementContentWhitespace() {
return!hasProperty("element-content-whitespace");
}
/**
* Indicates whether the implementation is namespace aware.
* @return true if namespace aware
*/
public boolean isNamespaceAware() {
return hasProperty("namespaces");
}
/**
* Indicates whether the implementation is validating.
* @return true if validating
*/
public boolean isValidating() {
return hasProperty("validate");
}
}