aSaxon-B-9-0-0-8sources.api.Saxon.Api.Configuration.cs Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of commons-xmlbeans Show documentation
Show all versions of commons-xmlbeans Show documentation
The Apache Commons Codec package contains simple encoder and decoders for
various formats such as Base64 and Hexadecimal. In addition to these
widely used encoders and decoders, the codec package also maintains a
collection of phonetic encoding utilities.
The newest version!
using System;
using System.IO;
using System.Xml;
using System.Collections;
using System.Collections.Specialized;
using System.Reflection;
using System.Globalization;
using javax.xml.transform;
using javax.xml.transform.stream;
using JBoolean = java.lang.Boolean;
using JConfiguration = net.sf.saxon.Configuration;
using JVersion = net.sf.saxon.Version;
using JDocumentWrapper = net.sf.saxon.dotnet.DocumentWrapper;
using AugmentedSource = net.sf.saxon.AugmentedSource;
using StructuredQName = net.sf.saxon.om.StructuredQName;
using Whitespace = net.sf.saxon.value.Whitespace;
using StaticQueryContext = net.sf.saxon.query.StaticQueryContext;
using net.sf.saxon.om;
using net.sf.saxon.pull;
using net.sf.saxon.dotnet;
namespace Saxon.Api {
///
/// The Processor class serves three purposes: it allows global Saxon configuration
/// options to be set; it acts as a factory for generating XQuery, XPath, and XSLT
/// compilers; and it owns certain shared resources such as the Saxon NamePool and
/// compiled schemas. This is the first object that a Saxon application should create. Once
/// established, a Processor may be used in multiple threads.
///
[Serializable]
public class Processor {
//Transformation data variables
internal JConfiguration config;
private SchemaManager schemaManager = null;
///
/// Create a new Processor
///
public Processor() {
config = new JConfiguration();
config.setURIResolver(new DotNetURIResolver(new XmlUrlResolver()));
config.setCollectionURIResolver(new DotNetCollectionURIResolver());
}
///
/// Create a Processor, indicating whether it is to be schema-aware.
///
/// Set to true if the Processor is to be schema-aware.
/// This requires the Saxon-SA product to be installed, with a valid license key.
public Processor(bool schemaAware) : this(schemaAware, false) { }
///
/// Create a Processor, indicating whether it is to be schema-aware.
///
/// Set to true if the Processor is to be schema-aware.
/// This requires the Saxon-SA product to be installed, with a valid license key.
/// This option has no effect at this release.
public Processor(bool schemaAware, bool loadLocally) {
if (schemaAware) {
//if (loadLocally) {
// Assembly asm = Assembly.Load("saxon8sa");
//} else {
// try {
// int[] v = JVersion.getStructuredVersionNumber();
// AssemblyName asn = new AssemblyName();
// asn.Name = "saxon8sa";
// asn.Version = new Version(v[0], v[1], v[2], v[3]);
// //asn.Version = new Version(JVersion.getMajorVersion(), JVersion.getMinorVersion());
// asn.SetPublicKeyToken(new byte[] { 0xe1, 0xfd, 0xd0, 0x02, 0xd5, 0x08, 0x3f, 0xe6 });
// asn.CultureInfo = new CultureInfo("");
// Assembly asm = Assembly.Load(asn);
// // try to load the saxon8sa.dll assembly
// //Assembly asm = Assembly.Load("saxon8sa, Ver=" + JVersion.getProductVersion() + ".0.1, " +
// // @"SN=e1fdd002d5083fe6, Loc=neutral");
// } catch (Exception e) {
// Console.WriteLine("Cannot load Saxon-SA software (assembly saxon8sa.dll version " +
// JVersion.getProductVersion() + ".0.1)");
// throw e;
// }
//}
config = JConfiguration.makeSchemaAwareConfiguration(null,
DotNetPlatform.getSaxonSaFullyQualifiedClassName());
schemaManager = new SchemaManager(config);
} else {
config = new JConfiguration();
}
config.setURIResolver(new DotNetURIResolver(new XmlUrlResolver()));
config.setCollectionURIResolver(new DotNetCollectionURIResolver());
}
///
/// Get the full name of the Saxon product version implemented by this Processor
///
public string ProductTitle {
get { return JVersion.getProductTitle(); }
}
///
/// Get the Saxon product version number (for example, "8.8.1")
///
public string ProductVersion {
get { return JVersion.getProductVersion(); }
}
///
/// Indicates whether the Processor is schema-aware
///
public bool IsSchemaAware {
get { return config.isSchemaAware(JConfiguration.XML_SCHEMA); }
}
///
/// Gets the SchemaManager for the Processor. Returns null
/// if the Processor is not schema-aware.
///
public SchemaManager SchemaManager {
get { return schemaManager; }
}
///
/// An XmlResolver, which will be used while compiling and running queries,
/// XPath expressions, and stylesheets, if no other XmlResolver is nominated
///
///
/// By default an XmlUrlResolver is used. This means that the responsibility
/// for resolving and dereferencing URIs rests with the .NET platform, not with the
/// GNU Classpath.
/// When Saxon invokes a user-written XmlResolver , the GetEntity method
/// may return any of: a System.IO.Stream ; a System.IO.TextReader ; or a
/// java.xml.transform.Source .
///
public XmlResolver XmlResolver {
get {
return ((DotNetURIResolver)config.getURIResolver()).getXmlResolver();
}
set {
config.setURIResolver(new DotNetURIResolver(value));
}
}
///
/// Create a new DocumentBuilder , which may be used to build XDM documents from
/// a variety of sources.
///
/// A new DocumentBuilder
public DocumentBuilder NewDocumentBuilder() {
DocumentBuilder builder = new DocumentBuilder(this);
builder.XmlResolver = XmlResolver;
return builder;
}
///
/// Create a new XQueryCompiler, which may be used to compile XQuery queries.
///
///
/// The returned XQueryCompiler retains a live link to the Processor, and
/// may be affected by subsequent changes to the Processor.
///
/// A new XQueryCompiler
public XQueryCompiler NewXQueryCompiler() {
return new XQueryCompiler(this);
}
///
/// Create a new XsltCompiler, which may be used to compile XSLT stylesheets.
///
///
/// The returned XsltCompiler retains a live link to the Processor, and
/// may be affected by subsequent changes to the Processor.
///
/// A new XsltCompiler
public XsltCompiler NewXsltCompiler() {
return new XsltCompiler(config);
}
///
/// Create a new XPathCompiler, which may be used to compile XPath expressions.
///
///
/// The returned XPathCompiler retains a live link to the Processor, and
/// may be affected by subsequent changes to the Processor.
///
/// A new XPathCompiler
public XPathCompiler NewXPathCompiler() {
return new XPathCompiler(config);
}
///
/// The XML version used in this Processor (for example, this determines what characters
/// are permitted in a name)
///
///
/// The value must be 1.0 or 1.1, as a decimal . The default version is currently 1.0, but may
/// change in the future.
///
public decimal XmlVersion {
get {
return (config.getXMLVersion() == JConfiguration.XML10 ? 1.0m : 1.1m);
}
set {
if (value == 1.0m) {
config.setXMLVersion(JConfiguration.XML10);
} else if (value == 1.1m) {
config.setXMLVersion(JConfiguration.XML11);
} else {
throw new ArgumentException("Invalid XML version: " + value);
}
}
}
///
/// Register a named collection. A collection is identified by a URI (the collection URI),
/// and its content is represented by an IEnumerable that enumerates the contents
/// of the collection. The values delivered by this enumeration are Uri values, which
/// can be mapped to nodes using the registered XmlResolver .
///
/// The URI used to identify the collection in a call
/// of the XPath collection() function. The default collection is registered
/// by supplying null as the value of this argument (this is the collection returned
/// when the XPath collection() function is called with no arguments).
/// An enumerable object that represents the contents of the
/// collection, as a sequence of document URIs. The enumerator returned by this
/// IEnumerable object must return instances of the Uri class.
///
/// Collections should be stable: that is, two calls to retrieve the same collection URI
/// should return the same sequence of document URIs. This requirement is imposed by the
/// W3C specifications, but in the case of a user-defined collection it is not enforced by
/// the Saxon product.
/// A collection may be "unregistered" by providing null as the value of the
/// contents argument. A collection may be replaced by specifying the URI of an existing
/// collection.
/// Collections registered with a processor are available to all queries and stylesheets
/// running under the control that processor. Collections should not normally be registered
/// while queries and transformations are in progress.
///
///
public void RegisterCollection(Uri collectionUri, IEnumerable contents) {
String u = (collectionUri == null ? null : collectionUri.ToString());
DotNetCollectionURIResolver resolver =
(DotNetCollectionURIResolver)config.getCollectionURIResolver();
resolver.registerCollection(u, contents);
}
///
/// The underlying Configuration object in the Saxon implementation
///
///
/// This property provides access to internal methods in the Saxon engine that are
/// not specifically exposed in the .NET API. In general these methods should be
/// considered to be less stable than the classes in the Saxon.Api namespace.
/// The internal methods follow
/// Java naming conventions rather than .NET conventions.
/// Information about the returned object (and the objects it provides access to)
/// is included in the Saxon JavaDoc docmentation, available
/// online.
///
///
public net.sf.saxon.Configuration Implementation {
get { return config; }
}
///
/// Set a configuration property
///
///
/// This method provides the ability to set named properties of the configuration.
/// The property names are set as strings, whose values can be found in the Java
/// class net.sf.saxon.FeatureKeys . The property values are set as objects
/// whose type depends on the property.
///
/// The property name
/// The property value
public void SetProperty(String name, Object value) {
if (value is bool) {
value = ((bool)value ? JBoolean.TRUE : JBoolean.FALSE);
}
config.setConfigurationProperty(name, value);
}
}
///
/// The DocumentBuilder class enables XDM documents to be built from various sources.
/// The class is always instantiated using the NewDocumentBuilder method
/// on the Processor object.
///
[Serializable]
public class DocumentBuilder {
private Processor processor;
private JConfiguration config;
private XmlResolver xmlResolver;
private SchemaValidationMode validation;
private bool dtdValidation;
private bool lineNumbering;
private WhitespacePolicy whitespacePolicy;
private Uri baseUri;
private QName topLevelElement;
internal DocumentBuilder(Processor processor) {
this.processor = processor;
this.config = processor.Implementation;
}
///
/// An XmlResolver, which will be used to resolve URIs of documents being loaded
/// and of references to external entities within those documents.
///
///
/// By default an XmlUrlResolver is used. This means that the responsibility
/// for resolving and dereferencing URIs rests with the .NET platform (and not with the
/// GNU Classpath).
/// When Saxon invokes a user-written XmlResolver , the GetEntity method
/// may return any of: a System.IO.Stream ; a System.IO.TextReader ; or a
/// java.xml.transform.Source .
///
public XmlResolver XmlResolver {
get {
return xmlResolver;
}
set {
xmlResolver = value;
}
}
///
/// Determines whether line numbering is enabled for documents loaded using this
/// DocumentBuilder .
///
///
/// By default, line numbering is disabled.
/// Line numbering is not available for all kinds of source: in particular,
/// it is not available when loading from an existing XmlDocument.
/// The resulting line numbers are accessible to applications using the
/// extension function saxon:line-number() applied to a node.
/// Line numbers are maintained only for element nodes; the line number
/// returned for any other node will be that of the most recent element.
///
public bool IsLineNumbering {
get {
return lineNumbering;
}
set {
lineNumbering = value;
}
}
///
/// Determines whether schema validation is applied to documents loaded using this
/// DocumentBuilder , and if so, whether it is strict or lax.
///
///
/// By default, no schema validation takes place.
/// This option requires the schema-aware version of the Saxon product (Saxon-SA).
///
public SchemaValidationMode SchemaValidationMode {
get {
return validation;
}
set {
validation = value;
}
}
///
/// The required name of the top level element in a document instance being validated
/// against a schema.
///
///
/// If this property is set, and if schema validation is requested, then validation will
/// fail unless the outermost element of the document has the required name.
/// This option requires the schema-aware version of the Saxon product (Saxon-SA).
///
public QName TopLevelElementName {
get {
return topLevelElement;
}
set {
topLevelElement = value;
}
}
///
/// Determines whether DTD validation is applied to documents loaded using this
/// DocumentBuilder .
///
///
///
/// By default, no DTD validation takes place.
///
///
public bool DtdValidation {
get {
return dtdValidation;
}
set {
dtdValidation = value;
}
}
///
/// Determines the whitespace stripping policy applied when loading a document
/// using this DocumentBuilder .
///
///
/// By default, whitespace text nodes appearing in element-only content
/// are stripped, and all other whitespace text nodes are retained.
///
public WhitespacePolicy WhitespacePolicy {
get {
return whitespacePolicy;
}
set {
whitespacePolicy = value;
}
}
///
/// The base URI of a document loaded using this DocumentBuilder .
/// This is used for resolving any relative URIs appearing
/// within the document, for example in references to DTDs and external entities.
///
///
/// This information is required when the document is loaded from a source that does not
/// provide an intrinsic URI, notably when loading from a Stream or a TextReader.
///
public Uri BaseUri {
get { return baseUri; }
set { baseUri = value; }
}
///
/// Load an XML document, retrieving it via a URI.
///
///
/// Note that the type Uri requires an absolute URI.
/// The URI is dereferenced using the registered XmlResolver .
/// This method takes no account of any fragment part in the URI.
/// The role passed to the GetEntity method of the XmlResolver
/// is "application/xml", and the required return type is System.IO.Stream .
/// The document located via the URI is parsed using the System.Xml parser.
/// Note that the Microsoft System.Xml parser does not report whether attributes are
/// defined in the DTD as being of type ID and IDREF . This is true whether or not
/// DTD-based validation is enabled. This means that such attributes are not accessible to the
/// id() and idref() functions.
///
/// The URI identifying the location where the document can be
/// found. This will also be used as the base URI of the document (regardless
/// of the setting of the BaseUri property).
/// An XdmNode . This will be
/// the document node at the root of the tree of the resulting in-memory document.
///
public XdmNode Build(Uri uri) {
baseUri = uri;
Stream inn = (Stream)XmlResolver.GetEntity(uri, "application/xml", Type.GetType("System.IO.Stream"));
XdmNode outt = Build(inn);
inn.Close();
return outt;
}
///
/// Load an XML document supplied as raw (lexical) XML on a Stream.
///
///
/// The document is parsed using the System.Xml parser.
/// Before calling this method, the BaseUri property must be set to identify the
/// base URI of this document, used for resolving any relative URIs contained within it.
/// Note that the Microsoft System.Xml parser does not report whether attributes are
/// defined in the DTD as being of type ID and IDREF . This is true whether or not
/// DTD-based validation is enabled. This means that such attributes are not accessible to the
/// id() and idref() functions.
///
/// The Stream containing the XML source to be parsed
/// An XdmNode , the document node at the root of the tree of the resulting
/// in-memory document
///
public XdmNode Build(Stream input) {
if (baseUri == null) {
throw new ArgumentException("No base URI suppplied");
}
Source source = new StreamSource(new DotNetInputStream(input));
source.setSystemId(baseUri.ToString());
source = augmentSource(source);
StaticQueryContext env = new StaticQueryContext(config);
//env.setURIResolver(new DotNetURIResolver(xmlResolver));
DocumentInfo doc = env.buildDocument(source);
return (XdmNode)XdmValue.Wrap(doc);
}
private Source augmentSource(Source source) {
if (validation != SchemaValidationMode.None) {
source = AugmentedSource.makeAugmentedSource(source);
if (validation == SchemaValidationMode.Strict) {
((AugmentedSource)source).setSchemaValidationMode(Validation.STRICT);
} else {
((AugmentedSource)source).setSchemaValidationMode(Validation.LAX);
}
}
if (topLevelElement != null) {
source = AugmentedSource.makeAugmentedSource(source);
((AugmentedSource)source).setTopLevelElement(
new StructuredQName(
topLevelElement.Prefix, topLevelElement.Uri, topLevelElement.LocalName));
}
if (whitespacePolicy != WhitespacePolicy.PreserveAll) {
source = AugmentedSource.makeAugmentedSource(source);
if (whitespacePolicy == WhitespacePolicy.StripIgnorable) {
((AugmentedSource)source).setStripSpace(Whitespace.IGNORABLE);
} else {
((AugmentedSource)source).setStripSpace(Whitespace.ALL);
}
}
if (lineNumbering) {
source = AugmentedSource.makeAugmentedSource(source);
((AugmentedSource)source).setLineNumbering(true);
}
if (dtdValidation) {
source = AugmentedSource.makeAugmentedSource(source);
((AugmentedSource)source).setDTDValidationMode(Validation.STRICT);
}
return source;
}
///
/// Load an XML document, delivered using an XmlReader.
///
///
/// The XmlReader is responsible for parsing the document; this method builds a tree
/// representation of the document (in an internal Saxon format) and returns its document node.
/// The XmlReader is not required to perform validation but it must expand any entity references.
/// Saxon uses the properties of the XmlReader as supplied.
/// Use of a plain XmlTextReader is discouraged, because it does not expand entity
/// references. This should only be used if you know in advance that the document will contain
/// no entity references (or perhaps if your query or stylesheet is not interested in the content
/// of text and attribute nodes). Instead, with .NET 1.1 use an XmlValidatingReader (with ValidationType
/// set to None ). The constructor for XmlValidatingReader is obsolete in .NET 2.0,
/// but the same effect can be achieved by using the Create method of XmlReader with
/// appropriate XmlReaderSettings
/// Conformance with the W3C specifications requires that the Normalization property
/// of an XmlTextReader should be set to true . However, Saxon does not insist
/// on this.
/// If the XmlReader performs schema validation, Saxon will ignore any resulting type
/// information. Type information can only be obtained by using Saxon's own schema validator, which
/// will be run if the SchemaValidationMode property is set to Strict or Lax
/// Note that the Microsoft System.Xml parser does not report whether attributes are
/// defined in the DTD as being of type ID and IDREF . This is true whether or not
/// DTD-based validation is enabled. This means that such attributes are not accessible to the
/// id() and idref() functions.
///
/// The XMLReader that supplies the parsed XML source
/// An XdmNode , the document node at the root of the tree of the resulting
/// in-memory document
///
public XdmNode Build(XmlReader reader) {
PullProvider pp = new DotNetPullProvider(reader);
pp.setPipelineConfiguration(config.makePipelineConfiguration());
// pp = new PullTracer(pp); /* diagnostics */
Source source = new PullSource(pp);
source.setSystemId(reader.BaseURI);
source = augmentSource(source);
DocumentInfo doc = new StaticQueryContext(config).buildDocument(source);
return (XdmNode)XdmValue.Wrap(doc);
}
///
/// Load an XML DOM document, supplied as an XmlNode , into a Saxon XdmNode.
///
///
///
/// The returned document will contain only the subtree rooted at the supplied node.
///
///
/// This method copies the DOM tree to create a Saxon tree. See the Wrap method for
/// an alternative that creates a wrapper the DOM tree, allowing it to be modified in situ.
///
///
/// The DOM Node to be copied to form a Saxon tree
/// An XdmNode , the document node at the root of the tree of the resulting
/// in-memory document
///
public XdmNode Build(XmlNode source) {
return Build(new XmlNodeReader(source));
}
///
/// Wrap an XML DOM document, supplied as an XmlNode , as a Saxon XdmNode.
///
///
///
/// This method must be applied at the level of the Document Node. Unlike the
/// Build method, the original DOM is not copied. This saves memory and
/// time, but it also means that it is not possible to perform operations such as
/// whitespace stripping and schema validation.
///
///
/// The DOM document node to be wrapped
/// An XdmNode , the Saxon document node at the root of the tree of the resulting
/// in-memory document
///
public XdmNode Wrap(XmlDocument doc) {
String baseu = (baseUri == null ? null : baseUri.ToString());
JDocumentWrapper wrapper = new JDocumentWrapper(doc, baseu, config);
return (XdmNode)XdmValue.Wrap(wrapper);
}
}
///
/// Enumeration identifying the various Schema validation modes
///
public enum SchemaValidationMode {
/// No validation
None,
/// Strict validation
Strict,
/// Lax validation
Lax
}
///
/// Enumeration identifying the various Whitespace stripping policies
///
public enum WhitespacePolicy {
/// No whitespace is stripped
PreserveAll,
/// Whitespace text nodes appearing in element-only content are stripped
StripIgnorable,
/// All whitespace text nodes are stripped
StripAll
}
}
//
// 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 Michael H. Kay.
//
// Portions created by (your name) are Copyright (C) (your legal entity). All Rights Reserved.
//
// Contributor(s): none.
//