/// <summary>
/// Evaluate the expression, returning the result as an <c>XdmValue</c> (that is,
/// a sequence of nodes and/or atomic values).
/// </summary>
/// <remarks>
/// Although a singleton result <i>may</i> be represented as an <c>XdmItem</c>, there is
/// no guarantee that this will always be the case. If you know that the expression will return at
/// most one node or atomic value, it is best to use the <c>EvaluateSingle</c> method, which
/// does guarantee that an <c>XdmItem</c> (or null) will be returned.
/// </remarks>
/// <returns>
/// An <c>XdmValue</c> representing the results of the expression.
/// </returns>
public XdmValue Evaluate()
{
JValueRepresentation value = JSequenceExtent.makeSequenceExtent(
exp.iterate(dynamicContext));
return(XdmValue.Wrap(value));
}
/// <summary>
/// Wrap an XML DOM document, supplied as an <c>XmlNode</c>, as a Saxon XdmNode.
/// </summary>
/// <remarks>
/// <para>
/// This method must be applied at the level of the Document Node. Unlike the
/// <c>Build</c> 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.
/// </para>
/// </remarks>
/// <param name="doc">The DOM document node to be wrapped</param>
/// <returns>An <c>XdmNode</c>, the Saxon document node at the root of the tree of the resulting
/// in-memory document
/// </returns>
public XdmNode Wrap(XmlDocument doc)
{
String baseu = (baseUri == null ? null : baseUri.ToString());
JDocumentWrapper wrapper = new JDocumentWrapper(doc, baseu, config);
return((XdmNode)XdmValue.Wrap(wrapper));
}
/// <summary>
/// Compile and execute an expression supplied as a <c>String</c>, with a given context item, where
/// the expression is expected to return a single item as its result.
/// </summary>
/// <param name="expression">A string containing the source text of the XPath expression</param>
/// <param name="contextItem">The context item to be used for evaluation of the XPath expression.
/// May be null, in which case the expression is evaluated without any context item.</param>
/// <returns>If the XPath expression returns a singleton, then the the <c>XdmItem</c>
/// which is the result of evaluating the XPath expression. If the expression returns an empty sequence,
/// then null. If the expression returns a sequence containing more than one item, then the first
/// item in the result.</returns>
/// <exception cref="StaticError">
/// Throws a <c>Saxon.Api.StaticError</c> if there is any static error in the XPath expression.
/// This includes both syntax errors, semantic errors such as references to undeclared functions or
/// variables, and statically-detected type errors.
/// </exception>
/// <exception cref="DynamicError">
/// Throws a <c>Saxon.Api.DynamicError</c> if there is any dynamic error during evaluation of the XPath expression.
/// This includes, for example, referring to the context item if no context item was supplied.
/// </exception>
public XdmItem EvaluateSingle(String expression, XdmItem contextItem)
{
try
{
JXdmItem value = compiler.evaluateSingle(expression, contextItem == null ? null : XdmItem.FromXdmItemItemToJXdmItem(contextItem));
return(value == null ? null : (XdmItem)XdmValue.Wrap(value.getUnderlyingValue()));
}
catch (JSaxonApiException err)
{
if (err.getCause() is JXPathException)
{
JXPathException xpathException = (JXPathException)err.getCause();
if (xpathException.isStaticError())
{
throw new StaticError(err);
}
else
{
throw new DynamicError(err.getMessage());
}
}
else
{
throw new StaticError(err);
}
}
}
/// <summary>
/// Get the sequence of items in the form of an <c>IList</c>
/// </summary>
/// <returns>
/// The list of items making up this value. Each item in the list
/// will be an object of type <c>XdmItem</c>
/// </returns>
public IList GetList()
{
if (value == null)
{
return(new ArrayList());
}
else if (value is Item)
{
ArrayList list = new ArrayList(1);
list.Add((NodeInfo)value);
return(list);
}
else
{
ArrayList list = new ArrayList();
SequenceIterator iter = ((Value)value).iterate(null);
while (true)
{
Item jitem = iter.next();
if (jitem == null)
{
break;
}
list.Add((XdmItem)XdmValue.Wrap(jitem));
}
return(list);
}
}
/// <summary>
/// Evaluate the query, returning the result as an <c>XdmItem</c> (that is,
/// a single node or atomic value).
/// </summary>
/// <returns>
/// An <c>XdmItem</c> representing the result of the query, or null if the query
/// returns an empty sequence. If the query returns a sequence of more than one item,
/// any items after the first are ignored.
/// </returns>
/// <exception cref="DynamicError">Throws a DynamicError if any run-time failure
/// occurs while evaluating the expression.</exception>
public XdmItem EvaluateSingle()
{
try {
return((XdmItem)XdmValue.Wrap(exp.iterator(context).next()));
} catch (JXPathException err) {
throw new DynamicError(err);
}
}
// Build a document from a given stream, with the base URI supplied
// as an extra argument
internal XdmNode Build(TextReader input, Uri baseUri)
{
Source source;
if (processor.GetProperty("http://saxon.sf.net/feature/preferJaxpParser") == "true")
{
source = new StreamSource(new DotNetReader(input), baseUri.ToString());
source = AugmentedSource.makeAugmentedSource(source);
((AugmentedSource)source).setEntityResolver(new DotNetURIResolver(XmlResolver));
}
else
{
XmlReaderSettings settings = new XmlReaderSettings();
settings.ProhibitDtd = false; // must expand entity references
//((XmlTextReader)parser).Normalization = true;
switch (whitespacePolicy)
{
case WhitespacePolicy.PreserveAll:
settings.IgnoreWhitespace = false;
//((XmlTextReader)parser).WhitespaceHandling = WhitespaceHandling.All;
break;
case WhitespacePolicy.StripAll:
settings.IgnoreWhitespace = true;
//((XmlTextReader)parser).WhitespaceHandling = WhitespaceHandling.None;
break;
case WhitespacePolicy.StripIgnorable:
settings.IgnoreWhitespace = true;
//((XmlTextReader)parser).WhitespaceHandling = WhitespaceHandling.Significant;
break;
}
if (xmlResolver != null)
{
settings.XmlResolver = xmlResolver;
}
settings.ValidationType = (dtdValidation ? ValidationType.DTD : ValidationType.None);
XmlReader parser = XmlReader.Create(input, settings, baseUri.ToString());
source = new PullSource(new DotNetPullProvider(parser));
source.setSystemId(baseUri.ToString());
}
source = augmentSource(source);
DocumentInfo doc = null;
try
{
doc = config.buildDocument(source);
}
catch (net.sf.saxon.trans.XPathException e)
{
throw new StaticError(e);
}
return((XdmNode)XdmValue.Wrap(doc));
}
/// <summary>
/// Evaluate the XPath expression, returning the result as an <c>XdmItem</c> (that is,
/// a single node or atomic value).
/// </summary>
/// <returns>
/// An <c>XdmItem</c> representing the result of the expression, or null if the expression
/// returns an empty sequence. If the expression returns a sequence of more than one item,
/// any items after the first are ignored.
/// </returns>
public XdmItem EvaluateSingle()
{
net.sf.saxon.om.Item i = exp.evaluateSingle(dynamicContext);
if (i == null)
{
return(null);
}
return((XdmItem)XdmValue.Wrap(i));
}
/// <summary>
/// Evaluate the expression, returning the result as an <c>XdmValue</c> (that is,
/// a sequence of nodes and/or atomic values).
/// </summary>
/// <remarks>
/// Although a singleton result <i>may</i> be represented as an <c>XdmItem</c>, there is
/// no guarantee that this will always be the case. If you know that the expression will return at
/// most one node or atomic value, it is best to use the <c>EvaluateSingle</c> method, which
/// does guarantee that an <c>XdmItem</c> (or null) will be returned.
/// </remarks>
/// <returns>
/// An <c>XdmValue</c> representing the results of the expression.
/// </returns>
public XdmValue Evaluate()
{
JXPathContextMajor context = new JXPathContextMajor(contextItem, config);
context.setStackFrame(env.getStackFrameMap(), variableValues);
JValueRepresentation value = JSequenceExtent.makeSequenceExtent(exp.iterate(context));
return(XdmValue.Wrap(value));
}
/// <summary>
/// Evaluate the expression, returning the result as an <c>XdmValue</c> (that is,
/// a sequence of nodes, atomic values, and possibly function items such as maps and arrays).
/// </summary>
/// <remarks>
/// Although a singleton result <i>may</i> be represented as an <c>XdmItem</c>, there is
/// no guarantee that this will always be the case. If you know that the expression will return at
/// most one node or atomic value, it is best to use the <c>EvaluateSingle</c> method, which
/// does guarantee that an <c>XdmItem</c> (or null) will be returned.
/// </remarks>
/// <returns>
/// An <c>XdmValue</c> representing the results of the expression.
/// </returns>
/// <exception cref="DynamicError">
/// Throws <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
/// with a dynamic error.
/// </exception>
public XdmValue Evaluate()
{
try {
net.sf.saxon.s9api.XdmValue value = selector.evaluate();
return(value == null ? null : XdmValue.Wrap(value.getUnderlyingValue()));
} catch (JSaxonApiException err) {
throw new DynamicError(err);
}
}
/// <summary>
/// Evaluate the query, returning the result as an <c>XdmValue</c> (that is,
/// a sequence of nodes and/or atomic values).
/// </summary>
/// <returns>
/// An <c>XdmValue</c> representing the results of the query
/// </returns>
/// <exception cref="DynamicError">Throws a DynamicError if any run-time failure
/// occurs while evaluating the query.</exception>
public XdmValue Evaluate()
{
try {
ValueRepresentation value = SequenceExtent.makeSequenceExtent(exp.iterator(context));
return(XdmValue.Wrap(value));
} catch (JXPathException err) {
throw new DynamicError(err);
}
}
/// <summary>
/// Evaluate the expression, returning the result as an <c>XdmValue</c> (that is,
/// a sequence of nodes and/or atomic values).
/// </summary>
/// <remarks>
/// Although a singleton result <i>may</i> be represented as an <c>XdmItem</c>, there is
/// no guarantee that this will always be the case. If you know that the expression will return at
/// most one node or atomic value, it is best to use the <c>EvaluateSingle</c> method, which
/// does guarantee that an <c>XdmItem</c> (or null) will be returned.
/// </remarks>
/// <returns>
/// An <c>XdmValue</c> representing the results of the expression.
/// </returns>
/// <exception cref="DynamicError">
/// Throws <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
/// with a dynamic error.
/// </exception>
public XdmValue Evaluate()
{
try {
JSequence value = (JSequence)JSequenceExtent.makeSequenceExtent(
exp.iterate(dynamicContext));
return(XdmValue.Wrap(value));
} catch (net.sf.saxon.trans.XPathException err) {
throw new DynamicError(err);
}
}
/// <summary>
/// Evaluate the query, returning the result as an <c>XdmItem</c> (that is,
/// a single node or atomic value).
/// </summary>
/// <returns>
/// An <c>XdmItem</c> representing the result of the query, or null if the query
/// returns an empty sequence. If the query returns a sequence of more than one item,
/// any items after the first are ignored.
/// </returns>
/// <exception cref="DynamicError">Throws a <c>DynamicError</c> if any run-time failure
/// occurs while evaluating the expression.</exception>
public XdmItem EvaluateSingle()
{
try
{
return((XdmItem)XdmValue.Wrap(evaluator.evaluateSingle().getUnderlyingValue()));
}
catch (JSaxonApiException err)
{
throw new DynamicError(err);
}
}
/// <summary>
/// Evaluate the XPath expression, returning the result as an <c>XdmItem</c> (that is,
/// a single node or atomic value).
/// </summary>
/// <returns>
/// An <c>XdmItem</c> representing the result of the expression, or null if the expression
/// returns an empty sequence. If the expression returns a sequence of more than one item,
/// any items after the first are ignored.
/// </returns>
/// <exception cref="DynamicError">
/// Throws <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
/// with a dynamic error.
/// </exception>
public XdmItem EvaluateSingle()
{
try
{
JXdmItem item = selector.evaluateSingle();
return(item == null ? null : (XdmItem)XdmValue.Wrap(item.getUnderlyingValue().materialize()));
}
catch (JSaxonApiException err)
{
throw new DynamicError(err);
}
}
/// <summary>
/// Evaluate the XPath expression, returning the result as an <c>XdmItem</c> (that is,
/// a single node or atomic value).
/// </summary>
/// <returns>
/// An <c>XdmItem</c> representing the result of the expression, or null if the expression
/// returns an empty sequence. If the expression returns a sequence of more than one item,
/// any items after the first are ignored.
/// </returns>
public XdmItem EvaluateSingle()
{
JXPathContextMajor context = new JXPathContextMajor(contextItem, config);
context.setStackFrame(env.getStackFrameMap(), variableValues);
net.sf.saxon.om.Item i = exp.iterate(context).next();
if (i == null)
{
return(null);
}
return((XdmItem)XdmValue.Wrap(i));
}
/// <summary>
/// Evaluate the query, returning the result as an <c>XdmValue</c> (that is,
/// a sequence of nodes and/or atomic values).
/// </summary>
/// <returns>
/// An <c>XdmValue</c> representing the results of the query
/// </returns>
/// <exception cref="DynamicError">Throws a <c>DynamicError</c> if any run-time failure
/// occurs while evaluating the query.</exception>
public XdmValue Evaluate()
{
try
{
JXdmValue value = evaluator.evaluate();
return(XdmValue.Wrap(value.getUnderlyingValue()));
}
catch (JSaxonApiException err)
{
throw new DynamicError(err);
}
}
/// <summary>
/// Evaluate the XPath expression, returning the result as an <c>XdmItem</c> (that is,
/// a single node or atomic value).
/// </summary>
/// <returns>
/// An <c>XdmItem</c> representing the result of the expression, or null if the expression
/// returns an empty sequence. If the expression returns a sequence of more than one item,
/// any items after the first are ignored.
/// </returns>
/// <exception cref="DynamicError">
/// Throws <c>Saxon.Api.DynamicError</c> if the evaluation of the XPath expression fails
/// with a dynamic error.
/// </exception>
public XdmItem EvaluateSingle()
{
try
{
net.sf.saxon.om.Item i = exp.evaluateSingle(dynamicContext);
if (i == null)
{
return(null);
}
return((XdmItem)XdmValue.Wrap(i));
} catch (net.sf.saxon.trans.XPathException err) {
throw new DynamicError(err);
}
}
/// <summary>
/// Call a global user-defined function in the compiled query.
/// </summary>
/// <remarks>
/// If this is called more than once (to evaluate the same function repeatedly with different arguments,
/// or to evaluate different functions) then the sequence of evaluations uses the same values of global
/// variables including external variables (query parameters); the effect of any changes made to query parameters
/// between calls is undefined.
/// </remarks>
/// <param name="function">
/// The name of the function to be called
/// </param>
/// <param name="arguments">
/// The values of the arguments to be supplied to the function. These
/// must be of the correct type as defined in the function signature (there is no automatic
/// conversion to the required type).
/// </param>
/// <exception cref="ArgumentException">If no function has been defined with the given name and arity
/// or if any of the arguments does not match its required type according to the function
/// signature.</exception>
/// <exception cref="DynamicError">If a dynamic error occurs in evaluating the function.
/// </exception>
public XdmValue CallFunction(QName function, XdmValue[] arguments)
{
try {
JXdmValue[] vr = new JXdmValue[arguments.Length];
for (int i = 0; i < arguments.Length; i++)
{
vr[i] = XdmValue.FromGroundedValueToJXdmValue(arguments[i].value);
}
JSequence result = evaluator.callFunction(function.UnderlyingQName(), vr).getUnderlyingValue();
return(XdmValue.Wrap(result));
} catch (JSaxonApiException e) {
throw new DynamicError(e);
}
}
/// <summary>
/// Load an XML document, delivered using an XmlReader.
/// </summary>
/// <remarks>
/// <para>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 <c>XmlReader</c> as supplied.</para>
/// <para>Use of a plain <c>XmlTextReader</c> 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 <c>XmlValidatingReader</c> (with <c>ValidationType</c>
/// set to <c>None</c>). The constructor for <c>XmlValidatingReader</c> is obsolete in .NET 2.0,
/// but the same effect can be achieved by using the <c>Create</c> method of <c>XmlReader</c> with
/// appropriate <c>XmlReaderSettings</c></para>
/// <para>Conformance with the W3C specifications requires that the <c>Normalization</c> property
/// of an <c>XmlTextReader</c> should be set to <c>true</c>. However, Saxon does not insist
/// on this.</para>
/// <para>If the <c>XmlReader</c> 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 <c>SchemaValidationMode</c> property is set to <c>Strict</c> or <c>Lax</c></para>
/// <para>Note that the Microsoft <c>System.Xml</c> parser does not report whether attributes are
/// defined in the DTD as being of type <c>ID</c> and <c>IDREF</c>. This is true whether or not
/// DTD-based validation is enabled. This means that such attributes are not accessible to the
/// <c>id()</c> and <c>idref()</c> functions.</para>
/// <para>Note that setting the <c>XmlResolver</c> property of the <c>DocumentBuilder</c>
/// has no effect when this method is used; if an <c>XmlResolver</c> is required, it must
/// be set on the <c>XmlReader</c> itself.</para>
/// </remarks>
/// <param name="reader">The XMLReader that supplies the parsed XML source</param>
/// <returns>An <c>XdmNode</c>, the document node at the root of the tree of the resulting
/// in-memory document
/// </returns>
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 = config.buildDocument(source);
return((XdmNode)XdmValue.Wrap(doc));
}
// Build a document from a given stream, with the base URI supplied
// as an extra argument
internal XdmNode Build(Stream input, Uri baseUri)
{
Source source;
if (processor.GetProperty("http://saxon.sf.net/feature/preferJaxpParser") == "true")
{
source = new StreamSource(new DotNetInputStream(input), baseUri.ToString());
}
else
{
XmlReader parser = new XmlTextReader(baseUri.ToString(), input);
((XmlTextReader)parser).Normalization = true;
switch (whitespacePolicy)
{
case WhitespacePolicy.PreserveAll:
((XmlTextReader)parser).WhitespaceHandling = WhitespaceHandling.All;
break;
case WhitespacePolicy.StripAll:
((XmlTextReader)parser).WhitespaceHandling = WhitespaceHandling.None;
break;
case WhitespacePolicy.StripIgnorable:
((XmlTextReader)parser).WhitespaceHandling = WhitespaceHandling.Significant;
break;
}
if (xmlResolver != null)
{
((XmlTextReader)parser).XmlResolver = xmlResolver;
}
// Always need a validating parser, because that's the only way to get entity references expanded
parser = new XmlValidatingReader(parser);
if (dtdValidation)
{
((XmlValidatingReader)parser).ValidationType = ValidationType.DTD;
}
else
{
((XmlValidatingReader)parser).ValidationType = ValidationType.None;
}
source = new PullSource(new DotNetPullProvider(parser));
source.setSystemId(baseUri.ToString());
}
source = augmentSource(source);
DocumentInfo doc = config.buildDocument(source);
return((XdmNode)XdmValue.Wrap(doc));
}
/// <summary>
/// Load an XML document supplied as raw (lexical) XML on a Stream.
/// </summary>
/// <remarks>
/// <para>The document is parsed using the <c>System.Xml</c> parser.</para>
/// <para>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.</para>
/// <para>Note that the Microsoft <c>System.Xml</c> parser does not report whether attributes are
/// defined in the DTD as being of type <c>ID</c> and <c>IDREF</c>. This is true whether or not
/// DTD-based validation is enabled. This means that such attributes are not accessible to the
/// <c>id()</c> and <c>idref()</c> functions.</para>
/// </remarks>
/// <param name="input">The Stream containing the XML source to be parsed</param>
/// <returns>An <c>XdmNode</c>, the document node at the root of the tree of the resulting
/// in-memory document
/// </returns>
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));
}
public net.sf.saxon.s9api.XdmValue call(net.sf.saxon.s9api.XdmValue[] xvarr)
{
XdmValue[] values = new XdmValue[xvarr.Length];
int len = xvarr.Length;
for (int i = 0; i < len; i++)
{
values[i] = XdmValue.Wrap(xvarr[i].getUnderlyingValue());
}
try {
XdmValue result = definition.Call(values);
return(XdmValue.FromGroundedValueToJXdmValue(result.value));
}
catch (Exception ex) {
throw new DynamicError(ex.Message);
}
}
/// <summary>
/// Execute an updating query.
/// </summary>
/// <returns>An array containing the root nodes of documents that have been
/// updated by the query.</returns>
/// <exception cref="DynamicError">Throws a <c>DynamicError</c> if any run-time failure
/// occurs while evaluating the expression, or if the expression is not an
/// updating query.</exception>
public XdmNode[] RunUpdate()
{
try
{
evaluator.run();
java.util.Iterator updatedDocsIter = evaluator.getUpdatedDocuments();
List <XdmNode> resultList = new List <XdmNode>();
for (; updatedDocsIter.hasNext();)
{
resultList.Add((XdmNode)XdmValue.Wrap(((net.sf.saxon.s9api.XdmNode)updatedDocsIter.next()).getUnderlyingNode()));
}
XdmNode[] result = resultList.ToArray();
return(result);
}
catch (JSaxonApiException err)
{
throw new DynamicError(err);
}
}
/// <summary>
/// Load an XML document, delivered using an XmlReader.
/// </summary>
/// <remarks>
/// <para>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 <c>XmlReader</c> as supplied.</para>
/// <para>Use of a plain <c>XmlTextReader</c> 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 <c>XmlValidatingReader</c> (with <c>ValidationType</c>
/// set to <c>None</c>). The constructor for <c>XmlValidatingReader</c> is obsolete in .NET 2.0,
/// but the same effect can be achieved by using the <c>Create</c> method of <c>XmlReader</c> with
/// appropriate <c>XmlReaderSettings</c></para>
/// <para>Conformance with the W3C specifications requires that the <c>Normalization</c> property
/// of an <c>XmlTextReader</c> should be set to <c>true</c>. However, Saxon does not insist
/// on this.</para>
/// <para>If the <c>XmlReader</c> 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 <c>SchemaValidationMode</c> property is set to <c>Strict</c> or <c>Lax</c></para>
/// <para>Note that the Microsoft <c>System.Xml</c> parser does not report whether attributes are
/// defined in the DTD as being of type <c>ID</c> and <c>IDREF</c>. This is true whether or not
/// DTD-based validation is enabled. This means that such attributes are not accessible to the
/// <c>id()</c> and <c>idref()</c> functions.</para>
/// <para>Note that setting the <c>XmlResolver</c> property of the <c>DocumentBuilder</c>
/// has no effect when this method is used; if an <c>XmlResolver</c> is required, it must
/// be set on the <c>XmlReader</c> itself.</para>
/// </remarks>
/// <param name="reader">The XMLReader that supplies the parsed XML source</param>
/// <returns>An <c>XdmNode</c>, the document node at the root of the tree of the resulting
/// in-memory document
/// </returns>
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 = null;
try
{
doc = config.buildDocument(source);
}
catch (net.sf.saxon.trans.XPathException e)
{
throw new StaticError(e);
}
return((XdmNode)XdmValue.Wrap(doc));
}
/// <summary>
/// Execute an updating query.
/// </summary>
/// <returns>An array containing the root nodes of documents that have been
/// updated by the query.</returns>
/// <exception cref="DynamicError">Throws a DynamicError if any run-time failure
/// occurs while evaluating the expression, or if the expression is not an
/// updating query.</exception>
public XdmNode[] RunUpdate()
{
if (!exp.isUpdateQuery())
{
throw new DynamicError("Not an updating query");
}
try
{
java.util.Set updatedDocs = exp.runUpdate(context);
XdmNode[] result = new XdmNode[updatedDocs.size()];
int i = 0;
for (java.util.Iterator iter = updatedDocs.iterator(); iter.hasNext();)
{
result[i++] = (XdmNode)XdmValue.Wrap((NodeInfo)iter.next());
}
return(result);
}
catch (JXPathException err)
{
throw new DynamicError(err);
}
}
///<summary>
/// Call a global user-defined function in the compiled query.
///</summary>
///<remarks>
/// If this is called more than once (to evaluate the same function repeatedly with different arguments,
/// or to evaluate different functions) then the sequence of evaluations uses the same values of global
/// variables including external variables (query parameters); the effect of any changes made to query parameters
/// between calls is undefined.
/// </remarks>
/// <param name="function">
/// The name of the function to be called
/// </param>
/// <param name="arguments">
/// The values of the arguments to be supplied to the function. These
/// must be of the correct type as defined in the function signature (there is no automatic
/// conversion to the required type).
/// </param>
/// <exception cref="ArgumentException">If no function has been defined with the given name and arity
/// or if any of the arguments does not match its required type according to the function
/// signature.</exception>
/// <exception cref="DynamicError">If a dynamic error occurs in evaluating the function.
/// </exception>
public XdmValue CallFunction(QName function, XdmValue[] arguments)
{
JUserFunction fn = exp.getStaticContext().getUserDefinedFunction(
function.Uri, function.LocalName, arguments.Length);
if (fn == null)
{
throw new ArgumentException("No function with name " + function.ClarkName +
" and arity " + arguments.Length + " has been declared in the query");
}
try {
// TODO: use the same controller in other interfaces such as run(), and expose it in a trapdoor API
if (controller == null)
{
controller = exp.newController();
context.initializeController(controller);
controller.defineGlobalParameters();
}
ValueRepresentation[] vr = new ValueRepresentation[arguments.Length];
for (int i = 0; i < arguments.Length; i++)
{
SequenceType type = fn.getParameterDefinitions()[i].getRequiredType();
vr[i] = arguments[i].Unwrap();
if (!type.matches(Value.asValue(vr[i]), controller.getConfiguration()))
{
throw new ArgumentException("Argument " + (i + 1) +
" of function " + function.ClarkName +
" does not match the required type " + type.toString());
}
}
ValueRepresentation result = fn.call(vr, controller);
return(XdmValue.Wrap(result));
} catch (JXPathException e) {
throw new DynamicError(e);
}
}
public override object wrapAsXdmValue(JValue value)
{
return(XdmValue.Wrap(value));
}
/// <summary>
/// Get the value that has set for a schema processor (a parameter defined in the schema using the <c>saxon:param</c>
/// extension)
/// </summary>
/// <param name="name">the parameter whose name is required</param>
/// <returns>the value that has been set for the parameter, or the EmptySequence if no value has been set</returns>
public XdmValue GetParameter(QName name)
{
net.sf.saxon.s9api.XdmValue value = schemaValidator.getParameter(name.UnderlyingQName());
return(value == null ? null : XdmValue.Wrap(value.getUnderlyingValue()));
}
/// <summary>Locate and compile a stylesheet identified by an <?xml-stylesheet?>
/// processing instruction within a source document.
/// </summary>
/// <param name="source">The document node of the source document containing the
/// xml-stylesheet processing instruction.</param>
/// <returns>An <c>XsltExecutable</c> which represents the compiled stylesheet object.</returns>
/// <remarks>There are some limitations in the current implementation. The media type
/// is ignored, as are the other parameters of the xml-stylesheet instruction. The
/// href attribute must either reference an embedded stylesheet within the same
/// document or a non-embedded external stylesheet.</remarks>
public XsltExecutable CompileAssociatedStylesheet(XdmNode source)
{
// TODO: lift the restrictions
if (source == null || source.NodeKind != XmlNodeType.Document)
{
throw new ArgumentException("Source must be a document node");
}
IEnumerator kids = source.EnumerateAxis(XdmAxis.Child);
QName xmlstyle = new QName("", "xml-stylesheet");
while (kids.MoveNext())
{
XdmNode n = (XdmNode)kids.Current;
if (n.NodeKind == XmlNodeType.ProcessingInstruction &&
n.NodeName.Equals(xmlstyle))
{
// TODO: check the media type
String href = JProcInstParser.getPseudoAttribute(n.StringValue, "href");
if (href == null)
{
throw new DynamicError("xml-stylesheet processing instruction has no href attribute");
}
String fragment = null;
int hash = href.LastIndexOf('#');
if (hash == 0)
{
if (href.Length == 1)
{
throw new DynamicError("Relative URI of '#' is invalid");
}
fragment = href.Substring(1);
JNodeInfo target = ((JDocumentInfo)source.value).selectID(fragment);
XdmNode targetWrapper = null;
if (target == null)
{
// There's a problem here because the Microsoft XML parser doesn't
// report id values, so selectID() will never work. We work around that
// by looking for an attribute named "id" appearing on an xsl:stylesheet
// or xsl:transform element
QName qid = new QName("", "id");
IEnumerator en = source.EnumerateAxis(XdmAxis.Descendant);
while (en.MoveNext())
{
XdmNode x = (XdmNode)en.Current;
if (x.NodeKind == XmlNodeType.Element &&
x.NodeName.Uri == "http://www.w3.org/1999/XSL/Transform" &&
(x.NodeName.LocalName == "stylesheet" || x.NodeName.LocalName == "transform" &&
x.GetAttributeValue(qid) == fragment))
{
targetWrapper = x;
}
}
}
else
{
targetWrapper = (XdmNode)XdmValue.Wrap(target);
}
if (targetWrapper == null)
{
throw new DynamicError("No element with id='" + fragment + "' found");
}
return(Compile(targetWrapper));
}
else if (hash > 0)
{
throw new NotImplementedException("href cannot identify an embedded stylesheet in a different document");
}
else
{
Uri uri = new Uri(n.BaseUri, href);
return(Compile(uri));
}
}
}
throw new DynamicError("xml-stylesheet processing instruction not found");
}
/// <summary>
/// Create an atomic value that wraps an external object. Such values can be used
/// in conjunction with extension functions.
/// </summary>
/// <param name="external">The object to be wrapped.</param>
/// <returns>The wrapped object</returns>
public static XdmAtomicValue wrapExternalObject(object external)
{
return((XdmAtomicValue)XdmValue.Wrap(new DotNetObjectValue(external)));
}
