/****************************************************************************/
/* File: ConfigurationProxy.java */
/* Author: F. Georges */
/* Company: H2O Consulting */
/* Date: */
/* Tags: */
/* Copyright (c) 2013 Florent Georges (see end of file.) */
/* ------------------------------------------------------------------------ */
package org.expath.pkg.saxon.tools;
import java.util.Collection;
import java.util.Iterator;
import java.util.List;
import java.util.Properties;
import java.util.Set;
import javax.xml.transform.ErrorListener;
import javax.xml.transform.Source;
import javax.xml.transform.TransformerException;
import javax.xml.transform.TransformerFactoryConfigurationError;
import javax.xml.transform.URIResolver;
import net.sf.saxon.Configuration;
import net.sf.saxon.event.FilterFactory;
import net.sf.saxon.event.PipelineConfiguration;
import net.sf.saxon.event.Receiver;
import net.sf.saxon.event.SequenceReceiver;
import net.sf.saxon.expr.PendingUpdateList;
import net.sf.saxon.expr.XPathContext;
import net.sf.saxon.expr.instruct.Debugger;
import net.sf.saxon.expr.instruct.DocumentInstr;
import net.sf.saxon.expr.instruct.ElementCreator;
import net.sf.saxon.expr.instruct.SlotManager;
import net.sf.saxon.expr.instruct.UserFunction;
import net.sf.saxon.expr.parser.Location;
import net.sf.saxon.expr.parser.PathMap.PathMapRoot;
import net.sf.saxon.functions.FunctionLibraryList;
import net.sf.saxon.functions.IntegratedFunctionLibrary;
import net.sf.saxon.functions.VendorFunctionLibrary;
import net.sf.saxon.lib.*;
import net.sf.saxon.om.*;
import net.sf.saxon.query.StaticQueryContext;
import net.sf.saxon.serialize.charcode.CharacterSetFactory;
import net.sf.saxon.trans.CompilerInfo;
import net.sf.saxon.trans.DynamicLoader;
import net.sf.saxon.trans.Mode;
import net.sf.saxon.trans.XPathException;
import net.sf.saxon.tree.util.DocumentNumberAllocator;
import net.sf.saxon.type.MissingComponentException;
import net.sf.saxon.type.SchemaDeclaration;
import net.sf.saxon.type.SchemaException;
import net.sf.saxon.type.SchemaType;
import net.sf.saxon.type.SimpleType;
import net.sf.saxon.type.ValidationException;
import org.xml.sax.XMLReader;
/**
*
* @author Florent Georges
*/
@Deprecated
public class ConfigurationProxy
extends Configuration
{
public ConfigurationProxy(Configuration config)
{
myConfig = config;
}
@Override
public synchronized void reuseStyleParser(XMLReader parser)
{
myConfig.reuseStyleParser(parser);
}
@Override
public String getStyleParserClass()
{
System.err.println("WTF?");
if ( myConfig == null ) {
return super.getStyleParserClass();
}
return myConfig.getStyleParserClass();
}
@Override
public synchronized XMLReader getStyleParser() throws TransformerFactoryConfigurationError {
System.err.println("WTF? yo");
if ( myConfig == null ) {
return super.getStyleParser();
}
return myConfig.getStyleParser();
}
@Override
public SimpleType validateAttribute(StructuredQName name, CharSequence value, int validation) throws ValidationException, MissingComponentException {
if ( myConfig == null ) {
return super.validateAttribute(name, value, validation);
}
return myConfig.validateAttribute(name, value, validation);
}
@Override
public NodeInfo unravel(Source source) {
if ( myConfig == null ) {
return super.unravel(source);
}
return myConfig.unravel(source);
}
@Override
public void setXMLVersion(int version) {
if ( myConfig == null ) {
super.setXMLVersion(version);
return;
}
myConfig.setXMLVersion(version);
}
@Override
public void setXIncludeAware(boolean state) {
if ( myConfig == null ) {
super.setXIncludeAware(state);
return;
}
myConfig.setXIncludeAware(state);
}
@Override
public void setVersionWarning(boolean warn) {
if ( myConfig == null ) {
super.setVersionWarning(warn);
return;
}
myConfig.setVersionWarning(warn);
}
@Override
public void setValidationWarnings(boolean warn) {
if ( myConfig == null ) {
super.setValidationWarnings(warn);
return;
}
myConfig.setValidationWarnings(warn);
}
@Override
public void setValidation(boolean validation) {
if ( myConfig == null ) {
super.setValidation(validation);
return;
}
myConfig.setValidation(validation);
}
@Override
public void setURIResolver(URIResolver resolver) {
if ( myConfig == null ) {
super.setURIResolver(resolver);
return;
}
myConfig.setURIResolver(resolver);
}
@Override
public void setTreeModel(int treeModel) {
if ( myConfig == null ) {
super.setTreeModel(treeModel);
return;
}
myConfig.setTreeModel(treeModel);
}
@Override
public void setTraceListenerClass(String className) {
if ( myConfig == null ) {
super.setTraceListenerClass(className);
return;
}
myConfig.setTraceListenerClass(className);
}
@Override
public void setTraceListener(TraceListener traceListener) {
if ( myConfig == null ) {
super.setTraceListener(traceListener);
return;
}
myConfig.setTraceListener(traceListener);
}
@Override
public void setTiming(boolean timing) {
if ( myConfig == null ) {
super.setTiming(timing);
return;
}
myConfig.setTiming(timing);
}
@Override
public void setStyleParserClass(String parser) {
if ( myConfig == null ) {
super.setStyleParserClass(parser);
return;
}
myConfig.setStyleParserClass(parser);
}
@Override
public void setStripsWhiteSpace(int kind) {
if ( myConfig == null ) {
super.setStripsWhiteSpace(kind);
return;
}
myConfig.setStripsWhiteSpace(kind);
}
@Override
public void setStripsAllWhiteSpace(boolean stripsAllWhiteSpace) {
if ( myConfig == null ) {
super.setStripsAllWhiteSpace(stripsAllWhiteSpace);
return;
}
myConfig.setStripsAllWhiteSpace(stripsAllWhiteSpace);
}
@Override
public void setSourceResolver(SourceResolver resolver) {
if ( myConfig == null ) {
super.setSourceResolver(resolver);
return;
}
myConfig.setSourceResolver(resolver);
}
@Override
public void setSourceParserClass(String sourceParserClass) {
if ( myConfig == null ) {
super.setSourceParserClass(sourceParserClass);
return;
}
myConfig.setSourceParserClass(sourceParserClass);
}
@Override
public void setSerializerFactory(SerializerFactory factory) {
if ( myConfig == null ) {
super.setSerializerFactory(factory);
return;
}
myConfig.setSerializerFactory(factory);
}
@Override
public void setSchemaValidationMode(int validationMode) {
if ( myConfig == null ) {
super.setSchemaValidationMode(validationMode);
return;
}
myConfig.setSchemaValidationMode(validationMode);
}
@Override
public void setRecoveryPolicy(int recoveryPolicy) {
if ( myConfig == null ) {
super.setRecoveryPolicy(recoveryPolicy);
return;
}
myConfig.setRecoveryPolicy(recoveryPolicy);
}
@Override
public void setProcessor(Object processor) {
if ( myConfig == null ) {
super.setProcessor(processor);
return;
}
myConfig.setProcessor(processor);
}
@Override
public void setParameterizedURIResolver() {
if ( myConfig == null ) {
super.setParameterizedURIResolver();
return;
}
myConfig.setParameterizedURIResolver();
}
@Override
public void setOutputURIResolver(OutputURIResolver outputURIResolver) {
if ( myConfig == null ) {
super.setOutputURIResolver(outputURIResolver);
return;
}
myConfig.setOutputURIResolver(outputURIResolver);
}
@Override
public void setNamePool(NamePool targetNamePool) {
if ( myConfig == null ) {
super.setNamePool(targetNamePool);
return;
}
myConfig.setNamePool(targetNamePool);
}
@Override
public void setModuleURIResolver(String className) throws TransformerException {
if ( myConfig == null ) {
super.setModuleURIResolver(className);
return;
}
myConfig.setModuleURIResolver(className);
}
@Override
public void setModuleURIResolver(ModuleURIResolver resolver) {
if ( myConfig == null ) {
super.setModuleURIResolver(resolver);
return;
}
myConfig.setModuleURIResolver(resolver);
}
@Override
public void setMessageEmitterClass(String messageReceiverClassName) {
if ( myConfig == null ) {
super.setMessageEmitterClass(messageReceiverClassName);
return;
}
myConfig.setMessageEmitterClass(messageReceiverClassName);
}
@Override
public void setLocalizerFactory(LocalizerFactory factory) {
if ( myConfig == null ) {
super.setLocalizerFactory(factory);
return;
}
myConfig.setLocalizerFactory(factory);
}
@Override
public void setLineNumbering(boolean lineNumbering) {
if ( myConfig == null ) {
super.setLineNumbering(lineNumbering);
return;
}
myConfig.setLineNumbering(lineNumbering);
}
@Override
public void setExpandAttributeDefaults(boolean expand) {
if ( myConfig == null ) {
super.setExpandAttributeDefaults(expand);
return;
}
myConfig.setExpandAttributeDefaults(expand);
}
@Override
public void setErrorListener(ErrorListener listener) {
if ( myConfig == null ) {
super.setErrorListener(listener);
return;
}
myConfig.setErrorListener(listener);
}
@Override
public void setDynamicLoader(DynamicLoader dynamicLoader) {
if ( myConfig == null ) {
super.setDynamicLoader(dynamicLoader);
return;
}
myConfig.setDynamicLoader(dynamicLoader);
}
@Override
public void setDocumentNumberAllocator(DocumentNumberAllocator allocator) {
if ( myConfig == null ) {
super.setDocumentNumberAllocator(allocator);
return;
}
myConfig.setDocumentNumberAllocator(allocator);
}
@Override
public void setDefaultSerializationProperties(Properties props) {
if ( myConfig == null ) {
super.setDefaultSerializationProperties(props);
return;
}
myConfig.setDefaultSerializationProperties(props);
}
@Override
public void setDefaultLanguage(String language) {
if ( myConfig == null ) {
super.setDefaultLanguage(language);
return;
}
myConfig.setDefaultLanguage(language);
}
@Override
public void setDefaultCountry(String country) {
if ( myConfig == null ) {
super.setDefaultCountry(country);
return;
}
myConfig.setDefaultCountry(country);
}
@Override
public void setDefaultCollection(String uri) {
if ( myConfig == null ) {
super.setDefaultCollection(uri);
return;
}
myConfig.setDefaultCollection(uri);
}
@Override
public void setDebugger(Debugger debugger) {
if ( myConfig == null ) {
super.setDebugger(debugger);
return;
}
myConfig.setDebugger(debugger);
}
@Override
public void setConfigurationProperty(String name, Object value) {
if ( myConfig == null ) {
super.setConfigurationProperty(name, value);
return;
}
myConfig.setConfigurationProperty(name, value);
}
@Override
public void setCompileWithTracing(boolean trace) {
if ( myConfig == null ) {
super.setCompileWithTracing(trace);
return;
}
myConfig.setCompileWithTracing(trace);
}
@Override
public void setCollectionURIResolver(CollectionURIResolver resolver) {
if ( myConfig == null ) {
super.setCollectionURIResolver(resolver);
return;
}
myConfig.setCollectionURIResolver(resolver);
}
@Override
public void setCollationURIResolver(CollationURIResolver resolver) {
if ( myConfig == null ) {
super.setCollationURIResolver(resolver);
return;
}
myConfig.setCollationURIResolver(resolver);
}
@Override
public void sealNamespace(String namespace) {
if ( myConfig == null ) {
super.sealNamespace(namespace);
return;
}
myConfig.sealNamespace(namespace);
}
@Override
public synchronized void reuseSourceParser(XMLReader parser) {
if ( myConfig == null ) {
super.reuseSourceParser(parser);
return;
}
myConfig.reuseSourceParser(parser);
}
@Override
public Source resolveSource(Source source, Configuration config) throws XPathException {
if ( myConfig == null ) {
return super.resolveSource(source, config);
}
return myConfig.resolveSource(source, config);
}
@Override
public void reportFatalError(XPathException err) {
if ( myConfig == null ) {
super.reportFatalError(err);
return;
}
myConfig.reportFatalError(err);
}
@Override
public void registerExternalObjectModel(ExternalObjectModel model) {
if ( myConfig == null ) {
super.registerExternalObjectModel(model);
return;
}
myConfig.registerExternalObjectModel(model);
}
@Override
public void registerExtensionFunction(ExtensionFunctionDefinition function) {
if ( myConfig == null ) {
super.registerExtensionFunction(function);
return;
}
myConfig.registerExtensionFunction(function);
}
@Override
public String readSchema(PipelineConfiguration pipe, String baseURI, String schemaLocation, String expected) throws SchemaException {
if ( myConfig == null ) {
return super.readSchema(pipe, baseURI, schemaLocation, expected);
}
return myConfig.readSchema(pipe, baseURI, schemaLocation, expected);
}
@Override
public void readMultipleSchemas(PipelineConfiguration pipe, String baseURI, Collection schemaLocations, String expected) throws SchemaException {
if ( myConfig == null ) {
super.readMultipleSchemas(pipe, baseURI, schemaLocations, expected);
return;
}
myConfig.readMultipleSchemas(pipe, baseURI, schemaLocations, expected);
}
@Override
public String readInlineSchema(NodeInfo root, String expected, ErrorListener errorListener) throws SchemaException {
if ( myConfig == null ) {
return super.readInlineSchema(root, expected, errorListener);
}
return myConfig.readInlineSchema(root, expected, errorListener);
}
@Override
public UserFunction newUserFunction(boolean memoFunction) {
if ( myConfig == null ) {
return super.newUserFunction(memoFunction);
}
return myConfig.newUserFunction(memoFunction);
}
@Override
public StaticQueryContext newStaticQueryContext() {
if ( myConfig == null ) {
return super.newStaticQueryContext();
}
return myConfig.newStaticQueryContext();
}
@Override
public PendingUpdateList newPendingUpdateList() {
if ( myConfig == null ) {
return super.newPendingUpdateList();
}
return myConfig.newPendingUpdateList();
}
@Override
public NodeInfo makeUnconstructedElement(ElementCreator instr, XPathContext context) throws XPathException {
if ( myConfig == null ) {
return super.makeUnconstructedElement(instr, context);
}
return myConfig.makeUnconstructedElement(instr, context);
}
@Override
public NodeInfo makeUnconstructedDocument(DocumentInstr instr, XPathContext context) throws XPathException {
if ( myConfig == null ) {
return super.makeUnconstructedDocument(instr, context);
}
return myConfig.makeUnconstructedDocument(instr, context);
}
@Override
public URIResolver makeURIResolver(String className) throws TransformerException {
if ( myConfig == null ) {
return super.makeURIResolver(className);
}
return myConfig.makeURIResolver(className);
}
@Override
public TraceListener makeTraceListener(String className) throws XPathException {
if ( myConfig == null ) {
return super.makeTraceListener(className);
}
return myConfig.makeTraceListener(className);
}
@Override
public TraceListener makeTraceListener() throws XPathException {
if ( myConfig == null ) {
return super.makeTraceListener();
}
return myConfig.makeTraceListener();
}
@Override
public Receiver makeStreamingTransformer(XPathContext context, Mode mode) throws XPathException {
if ( myConfig == null ) {
return super.makeStreamingTransformer(context, mode);
}
return myConfig.makeStreamingTransformer(context, mode);
}
@Override
public SlotManager makeSlotManager() {
if ( myConfig == null ) {
return super.makeSlotManager();
}
return myConfig.makeSlotManager();
}
@Override
public PipelineConfiguration makePipelineConfiguration() {
if ( myConfig == null ) {
return super.makePipelineConfiguration();
}
return myConfig.makePipelineConfiguration();
}
@Override
public XMLReader makeParser(String className) throws TransformerFactoryConfigurationError {
if ( myConfig == null ) {
return super.makeParser(className);
}
return myConfig.makeParser(className);
}
@Override
public Numberer makeNumberer(String language, String country) {
if ( myConfig == null ) {
return super.makeNumberer(language, country);
}
return myConfig.makeNumberer(language, country);
}
@Override
public Receiver makeEmitter(String clarkName, Properties props) throws XPathException {
if ( myConfig == null ) {
return super.makeEmitter(clarkName, props);
}
return myConfig.makeEmitter(clarkName, props);
}
@Override
public FilterFactory makeDocumentProjector(PathMapRoot map) {
if ( myConfig == null ) {
return super.makeDocumentProjector(map);
}
return myConfig.makeDocumentProjector(map);
}
@Override
public void loadSchema(String absoluteURI) throws SchemaException {
if ( myConfig == null ) {
super.loadSchema(absoluteURI);
return;
}
myConfig.loadSchema(absoluteURI);
}
@Override
public boolean isXIncludeAware() {
if ( myConfig == null ) {
return super.isXIncludeAware();
}
return myConfig.isXIncludeAware();
}
@Override
public boolean isVersionWarning() {
if ( myConfig == null ) {
return super.isVersionWarning();
}
return myConfig.isVersionWarning();
}
@Override
public boolean isValidationWarnings() {
if ( myConfig == null ) {
return super.isValidationWarnings();
}
return myConfig.isValidationWarnings();
}
@Override
public boolean isValidation() {
if ( myConfig == null ) {
return super.isValidation();
}
return myConfig.isValidation();
}
@Override
public boolean isTiming() {
if ( myConfig == null ) {
return super.isTiming();
}
return myConfig.isTiming();
}
@Override
public boolean isStripsAllWhiteSpace() {
if ( myConfig == null ) {
return super.isStripsAllWhiteSpace();
}
return myConfig.isStripsAllWhiteSpace();
}
@Override
public boolean isSchemaAvailable(String targetNamespace) {
if ( myConfig == null ) {
return super.isSchemaAvailable(targetNamespace);
}
return myConfig.isSchemaAvailable(targetNamespace);
}
@Override
public boolean isLineNumbering() {
if ( myConfig == null ) {
return super.isLineNumbering();
}
return myConfig.isLineNumbering();
}
@Override
public boolean isLicensedFeature(int feature) {
if ( myConfig == null ) {
return super.isLicensedFeature(feature);
}
return myConfig.isLicensedFeature(feature);
}
@Override
public boolean isExpandAttributeDefaults() {
if ( myConfig == null ) {
return super.isExpandAttributeDefaults();
}
return myConfig.isExpandAttributeDefaults();
}
@Override
public boolean isCompileWithTracing() {
if ( myConfig == null ) {
return super.isCompileWithTracing();
}
return myConfig.isCompileWithTracing();
}
@Override
public boolean isCompatible(Configuration other) {
if ( myConfig == null ) {
return super.isCompatible(other);
}
return myConfig.isCompatible(other);
}
@Override
public void importComponents(Source source) throws XPathException {
if ( myConfig == null ) {
super.importComponents(source);
return;
}
myConfig.importComponents(source);
}
@Override
public int getXsdVersion() {
if ( myConfig == null ) {
return super.getXsdVersion();
}
return myConfig.getXsdVersion();
}
@Override
public int getXMLVersion() {
if ( myConfig == null ) {
return super.getXMLVersion();
}
return myConfig.getXMLVersion();
}
@Override
public VendorFunctionLibrary getVendorFunctionLibrary() {
if ( myConfig == null ) {
return super.getVendorFunctionLibrary();
}
return myConfig.getVendorFunctionLibrary();
}
@Override
public URIResolver getURIResolver() {
if ( myConfig == null ) {
return super.getURIResolver();
}
return myConfig.getURIResolver();
}
@Override
public int getTreeModel() {
if ( myConfig == null ) {
return super.getTreeModel();
}
return myConfig.getTreeModel();
}
@Override
public String getTraceListenerClass() {
if ( myConfig == null ) {
return super.getTraceListenerClass();
}
return myConfig.getTraceListenerClass();
}
@Override
public TraceListener getTraceListener() {
if ( myConfig == null ) {
return super.getTraceListener();
}
return myConfig.getTraceListener();
}
@Override
public StandardURIResolver getSystemURIResolver() {
if ( myConfig == null ) {
return super.getSystemURIResolver();
}
return myConfig.getSystemURIResolver();
}
@Override
public int getStripsWhiteSpace() {
if ( myConfig == null ) {
return super.getStripsWhiteSpace();
}
return myConfig.getStripsWhiteSpace();
}
@Override
public ModuleURIResolver getStandardModuleURIResolver() {
if ( myConfig == null ) {
return super.getStandardModuleURIResolver();
}
return myConfig.getStandardModuleURIResolver();
}
@Override
public SourceResolver getSourceResolver() {
if ( myConfig == null ) {
return super.getSourceResolver();
}
return myConfig.getSourceResolver();
}
@Override
public String getSourceParserClass() {
if ( myConfig == null ) {
return super.getSourceParserClass();
}
return myConfig.getSourceParserClass();
}
@Override
public synchronized XMLReader getSourceParser() throws TransformerFactoryConfigurationError {
if ( myConfig == null ) {
return super.getSourceParser();
}
return myConfig.getSourceParser();
}
@Override
public SerializerFactory getSerializerFactory() {
if ( myConfig == null ) {
return super.getSerializerFactory();
}
return myConfig.getSerializerFactory();
}
@Override
public int getSchemaValidationMode() {
if ( myConfig == null ) {
return super.getSchemaValidationMode();
}
return myConfig.getSchemaValidationMode();
}
@Override
public SchemaType getSchemaType(StructuredQName name) {
if ( myConfig == null ) {
return super.getSchemaType(name);
}
return myConfig.getSchemaType(name);
}
@Override
public int getRecoveryPolicy() {
if ( myConfig == null ) {
return super.getRecoveryPolicy();
}
return myConfig.getRecoveryPolicy();
}
@Override
public String getProductTitle() {
if ( myConfig == null ) {
return super.getProductTitle();
}
return myConfig.getProductTitle();
}
@Override
public Object getProcessor() {
if ( myConfig == null ) {
return super.getProcessor();
}
return myConfig.getProcessor();
}
@Override
public ParseOptions getParseOptions() {
if ( myConfig == null ) {
return super.getParseOptions();
}
return myConfig.getParseOptions();
}
@Override
public OutputURIResolver getOutputURIResolver() {
if ( myConfig == null ) {
return super.getOutputURIResolver();
}
return myConfig.getOutputURIResolver();
}
@Override
public NamePool getNamePool() {
if ( myConfig == null ) {
return super.getNamePool();
}
return myConfig.getNamePool();
}
@Override
public ModuleURIResolver getModuleURIResolver() {
if ( myConfig == null ) {
return super.getModuleURIResolver();
}
return myConfig.getModuleURIResolver();
}
@Override
public String getMessageEmitterClass() {
if ( myConfig == null ) {
return super.getMessageEmitterClass();
}
return myConfig.getMessageEmitterClass();
}
@Override
public LocalizerFactory getLocalizerFactory() {
if ( myConfig == null ) {
return super.getLocalizerFactory();
}
return myConfig.getLocalizerFactory();
}
@Override
public IntegratedFunctionLibrary getIntegratedFunctionLibrary() {
if ( myConfig == null ) {
return super.getIntegratedFunctionLibrary();
}
return myConfig.getIntegratedFunctionLibrary();
}
@Override
public Object getInstance(String className, ClassLoader classLoader) throws XPathException {
if ( myConfig == null ) {
return super.getInstance(className, classLoader);
}
return myConfig.getInstance(className, classLoader);
}
@Override
public Set getImportedNamespaces() {
if ( myConfig == null ) {
return super.getImportedNamespaces();
}
return myConfig.getImportedNamespaces();
}
@Override
public DocumentPool getGlobalDocumentPool() {
if ( myConfig == null ) {
return super.getGlobalDocumentPool();
}
return myConfig.getGlobalDocumentPool();
}
@Override
public List<ExternalObjectModel> getExternalObjectModels() {
if ( myConfig == null ) {
return super.getExternalObjectModels();
}
return myConfig.getExternalObjectModels();
}
@Override
public ExternalObjectModel getExternalObjectModel(Class nodeClass) {
if ( myConfig == null ) {
return super.getExternalObjectModel(nodeClass);
}
return myConfig.getExternalObjectModel(nodeClass);
}
@Override
public ExternalObjectModel getExternalObjectModel(String uri) {
if ( myConfig == null ) {
return super.getExternalObjectModel(uri);
}
return myConfig.getExternalObjectModel(uri);
}
@Override
public Iterator getExtensionsOfType(SchemaType type) {
if ( myConfig == null ) {
return super.getExtensionsOfType(type);
}
return myConfig.getExtensionsOfType(type);
}
@Override
public SequenceReceiver getElementValidator(SequenceReceiver receiver, ParseOptions validationOptions, Location location) throws XPathException {
if ( myConfig == null ) {
return super.getElementValidator(receiver, validationOptions, location);
}
return myConfig.getElementValidator(receiver, validationOptions, location);
}
@Override
public SchemaDeclaration getElementDeclaration(int fingerprint) {
if ( myConfig == null ) {
return super.getElementDeclaration(fingerprint);
}
return myConfig.getElementDeclaration(fingerprint);
}
@Override
public String getEditionCode() {
if ( myConfig == null ) {
return super.getEditionCode();
}
return myConfig.getEditionCode();
}
@Override
public DynamicLoader getDynamicLoader() {
if ( myConfig == null ) {
return super.getDynamicLoader();
}
return myConfig.getDynamicLoader();
}
@Override
public Receiver getDocumentValidator(Receiver receiver, String systemId, ParseOptions validationOptions) {
if ( myConfig == null ) {
return super.getDocumentValidator(receiver, systemId, validationOptions);
}
return myConfig.getDocumentValidator(receiver, systemId, validationOptions);
}
@Override
public DocumentNumberAllocator getDocumentNumberAllocator() {
if ( myConfig == null ) {
return super.getDocumentNumberAllocator();
}
return myConfig.getDocumentNumberAllocator();
}
@Override
public CompilerInfo getDefaultXsltCompilerInfo() {
if ( myConfig == null ) {
return super.getDefaultXsltCompilerInfo();
}
return myConfig.getDefaultXsltCompilerInfo();
}
@Override
public StaticQueryContext getDefaultStaticQueryContext() {
if ( myConfig == null ) {
return super.getDefaultStaticQueryContext();
}
return myConfig.getDefaultStaticQueryContext();
}
@Override
public Properties getDefaultSerializationProperties() {
if ( myConfig == null ) {
return super.getDefaultSerializationProperties();
}
return myConfig.getDefaultSerializationProperties();
}
@Override
public String getDefaultLanguage() {
if ( myConfig == null ) {
return super.getDefaultLanguage();
}
return myConfig.getDefaultLanguage();
}
@Override
public String getDefaultCountry() {
if ( myConfig == null ) {
return super.getDefaultCountry();
}
return myConfig.getDefaultCountry();
}
@Override
public String getDefaultCollection() {
if ( myConfig == null ) {
return super.getDefaultCollection();
}
return myConfig.getDefaultCollection();
}
@Override
public Debugger getDebugger() {
if ( myConfig == null ) {
return super.getDebugger();
}
return myConfig.getDebugger();
}
@Override
public XPathContext getConversionContext() {
if ( myConfig == null ) {
return super.getConversionContext();
}
return myConfig.getConversionContext();
}
@Override
public Object getConfigurationProperty(String name) {
if ( myConfig == null ) {
return super.getConfigurationProperty(name);
}
return myConfig.getConfigurationProperty(name);
}
@Override
public CollectionURIResolver getCollectionURIResolver() {
if ( myConfig == null ) {
return super.getCollectionURIResolver();
}
return myConfig.getCollectionURIResolver();
}
@Override
public CollationURIResolver getCollationURIResolver() {
if ( myConfig == null ) {
return super.getCollationURIResolver();
}
return myConfig.getCollationURIResolver();
}
@Override
public Class getClass(String className, boolean tracing, ClassLoader classLoader) throws XPathException {
if ( myConfig == null ) {
return super.getClass();
}
return myConfig.getClass(className, tracing, classLoader);
}
@Override
public CharacterSetFactory getCharacterSetFactory() {
if ( myConfig == null ) {
return super.getCharacterSetFactory();
}
return myConfig.getCharacterSetFactory();
}
@Override
public SchemaDeclaration getAttributeDeclaration(int fingerprint) {
if ( myConfig == null ) {
return super.getAttributeDeclaration(fingerprint);
}
return myConfig.getAttributeDeclaration(fingerprint);
}
@Override
public Receiver getAnnotationStripper(Receiver destination) {
if ( myConfig == null ) {
return super.getAnnotationStripper(destination);
}
return myConfig.getAnnotationStripper(destination);
}
@Override
public void exportComponents(Receiver out) throws XPathException {
if ( myConfig == null ) {
super.exportComponents(out);
return;
}
myConfig.exportComponents(out);
}
@Override
public void displayLicenseMessage() {
if ( myConfig == null ) {
super.displayLicenseMessage();
return;
}
myConfig.displayLicenseMessage();
}
@Override
public void checkTypeDerivationIsOK(SchemaType derived, SchemaType base, int block) throws SchemaException {
if ( myConfig == null ) {
super.checkTypeDerivationIsOK(derived, base, block);
return;
}
myConfig.checkTypeDerivationIsOK(derived, base, block);
}
@Override
public DocumentInfo buildDocument(Source source, ParseOptions parseOptions) throws XPathException {
if ( myConfig == null ) {
return super.buildDocument(source, parseOptions);
}
return myConfig.buildDocument(source, parseOptions);
}
@Override
public DocumentInfo buildDocument(Source source) throws XPathException {
if ( myConfig == null ) {
return super.buildDocument(source);
}
return myConfig.buildDocument(source);
}
@Override
public void addSchemaSource(Source schemaSource, ErrorListener errorListener) throws SchemaException {
if ( myConfig == null ) {
super.addSchemaSource(schemaSource, errorListener);
return;
}
myConfig.addSchemaSource(schemaSource, errorListener);
}
@Override
public void addSchemaSource(Source schemaSource) throws SchemaException {
if ( myConfig == null ) {
super.addSchemaSource(schemaSource);
return;
}
myConfig.addSchemaSource(schemaSource);
}
@Override
public void addExtensionBinders(FunctionLibraryList list) {
if ( myConfig == null ) {
super.addExtensionBinders(list);
return;
}
myConfig.addExtensionBinders(list);
}
private final Configuration myConfig;
}
/* ------------------------------------------------------------------------ */
/* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS COMMENT. */
/* */
/* The contents of this file are subject to the Mozilla Public License */
/* Version 1.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.mozilla.org/MPL/. */
/* */
/* Software distributed under the License is distributed on an "AS IS" */
/* basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See */
/* the License for the specific language governing rights and limitations */
/* under the License. */
/* */
/* The Original Code is: all this file. */
/* */
/* The Initial Developer of the Original Code is Florent Georges. */
/* */
/* Contributor(s): none. */
/* ------------------------------------------------------------------------ */