/** * Execute the compiled Query, returning the first item in the result. This is useful where it is * known that the expression will only return a singleton value (for example, a single node, or a * boolean). * * @param env Provides the dynamic query evaluation context * @return The first item in the sequence returned by the expression. If the expression returns an * empty sequence, this method returns null. Otherwise, it returns the first item in the * result sequence, represented as a Java object using the same mapping as for the {@link * XQueryExpression#evaluate evaluate} method */ public Object evaluateSingle(DynamicQueryContext env) throws XPathException { if (isUpdating) { throw new XPathException("Cannot call evaluateSingle() on an updating query"); } SequenceIterator iterator = iterator(env); Item item = iterator.next(); if (item == null) { return null; } return Value.convertToJava(item); }
/** * Execute a the compiled Query, returning the results as a List. * * @param env Provides the dynamic query evaluation context * @return The results of the expression, as a List. The List represents the sequence of items * returned by the expression. Each item in the list will either be an object representing a * node, or an object representing an atomic value. For the types of Java object that may be * returned, see the description of the {@link org.orbeon.saxon.xpath.XPathEvaluator#evaluate * evaluate} method of class XPathProcessor */ public List evaluate(DynamicQueryContext env) throws XPathException { if (isUpdating) { throw new XPathException("Cannot call evaluate() on an updating query"); } SequenceIterator iterator = iterator(env); ArrayList list = new ArrayList(100); while (true) { Item item = iterator.next(); if (item == null) { return list; } list.add(Value.convertToJava(item)); } }
public Item next() throws XPathException { try { return base.next(); } catch (XPathException e1) { e1.maybeSetLocation(expression); try { listener.fatalError(e1); } catch (TransformerException e2) { // } e1.setHasBeenReported(); throw e1; } }
/** Evaluate as an expression. */ public Item evaluateItem(XPathContext context) throws XPathException { if (isLazyConstruction() && (context.getConfiguration().areAllNodesUntyped() || (validation == Validation.PRESERVE && getSchemaType() == null))) { return new UnconstructedDocument(this, context); } else { Controller controller = context.getController(); DocumentInfo root; if (textOnly) { CharSequence textValue; if (constantText != null) { textValue = constantText; } else { FastStringBuffer sb = new FastStringBuffer(100); SequenceIterator iter = content.iterate(context); while (true) { Item item = iter.next(); if (item == null) break; sb.append(item.getStringValueCS()); } textValue = sb.condense(); } root = new TextFragmentValue(textValue, getBaseURI()); ((TextFragmentValue) root).setConfiguration(controller.getConfiguration()); } else { try { XPathContext c2 = context.newMinorContext(); c2.setOrigin(this); Builder builder = controller.makeBuilder(); // builder.setSizeParameters(treeSizeParameters); builder.setLineNumbering(controller.getConfiguration().isLineNumbering()); // receiver.setSystemId(getBaseURI()); builder.setBaseURI(getBaseURI()); builder.setTiming(false); PipelineConfiguration pipe = controller.makePipelineConfiguration(); pipe.setHostLanguage(getHostLanguage()); // pipe.setBaseURI(baseURI); builder.setPipelineConfiguration(pipe); c2.changeOutputDestination( null, builder, false, getHostLanguage(), validation, getSchemaType()); Receiver out = c2.getReceiver(); out.open(); out.startDocument(0); content.process(c2); out.endDocument(); out.close(); root = (DocumentInfo) builder.getCurrentRoot(); } catch (XPathException e) { e.maybeSetLocation(this); e.maybeSetContext(context); throw e; } } return root; } }
public SequenceIterator getAnother() throws XPathException { return new ErrorReportingIterator(base.getAnother(), listener); }
public void close() { base.close(); }
public int position() { return base.position(); }
public Item current() { return base.current(); }