/// <summary> /// Set the value of a variable /// </summary> /// <param name="name">The name of the variable. This must match the name of a variable /// that was declared to the <c>XPathCompiler</c>. No error occurs if the expression does not /// actually reference a variable with this name.</param> /// <param name="value">The value to be given to the variable.</param> public void SetVariable(QName name, XdmValue value) { try { selector.setVariable(name.UnderlyingQName(), value == null ? null : XdmValue.FromGroundedValueToJXdmValue(value.value)); } catch (JXPathException err) { throw new StaticError(err); } }
public override JSequence call(JXPathContext context, JSequence [] argument) { SequenceEnumerator <XdmItem>[] na = new SequenceEnumerator <XdmItem> [argument.Length]; for (int i = 0; i < na.Length; i++) { na[i] = new SequenceEnumerator <XdmItem>((JXdmSequenceIterator)XdmValue.FromGroundedValueToJXdmValue(argument[i].materialize()).iterator()); } DynamicContext dc = new DynamicContext(context); IEnumerator <XdmItem> result = functionCall.Call(na, dc); return(new net.sf.saxon.om.LazySequence(new net.sf.saxon.om.IteratorWrapper(new net.sf.saxon.dotnet.DotNetIterator(result, new Mapper())))); }
/// <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); } }
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> /// Serialize an <c>XdmNode</c> to the selected output destination using this serializer. /// </summary> /// <param name="node">The node to be serialized</param> /// <remarks>since 9.8</remarks> public void SerializeXdmNode(XdmNode node) { serializer.serializeNode((net.sf.saxon.s9api.XdmNode)XdmValue.FromGroundedValueToJXdmValue(node.value)); }
/// <summary> /// Determine whether this item type matches a given item. /// </summary> /// <param name="item">the item to be tested against this item type</param> /// <returns>true if the item matches this item type, false if it does not match.</returns> virtual public bool Matches(XdmItem item) { return(type.matches((net.sf.saxon.s9api.XdmItem)XdmValue.FromGroundedValueToJXdmValue(item.value))); }
/// <summary> /// Set the value of a schema parameter (a parameter defined in the schema using the <c>saxon:param</c> extension) /// </summary> /// <param name="name">the name of the schema parameter, as a QName</param> /// <param name="value">the value of the schema parameter, or null to clear a previously set value</param> public void SetParameter(QName name, XdmValue value) { try { schemaValidator.setParameter(name.UnderlyingQName(), value == null ? null : XdmValue.FromGroundedValueToJXdmValue(value.value)); } catch (net.sf.saxon.s9api.SaxonApiUncheckedException ex) { throw new StaticError(ex); } }
/// <summary> /// Set the value of an external variable declared in the query. /// </summary> /// <param name="name">The name of the external variable, expressed /// as a <c>QName</c>. If an external variable of this name has been declared in the /// query prolog, the given value will be assigned to the variable. If the /// variable has not been declared, calling this method has no effect (it is /// not an error).</param> /// <param name="value">The value to be given to the external variable. /// If the variable declaration defines a required type for the variable, then /// this value must match the required type: no conversions are applied.</param> public void SetExternalVariable(QName name, XdmValue value) { evaluator.setExternalVariable(new JXQName(name.ToStructuredQName()), value == null ? null : XdmValue.FromGroundedValueToJXdmValue(value.value)); }