Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.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.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package org.apache.commons.jxpath.ri; import java.util.ArrayList; import java.util.Collections; import java.util.HashSet; import java.util.Iterator; import java.util.List; import java.util.NoSuchElementException; import org.apache.commons.jxpath.BasicNodeSet; import org.apache.commons.jxpath.ExpressionContext; import org.apache.commons.jxpath.JXPathContext; import org.apache.commons.jxpath.JXPathException; import org.apache.commons.jxpath.NodeSet; import org.apache.commons.jxpath.Pointer; import org.apache.commons.jxpath.ri.axes.RootContext; import org.apache.commons.jxpath.ri.model.NodePointer; import org.apache.commons.jxpath.util.ReverseComparator; /** * An XPath evaluation context. * * When evaluating a path, a chain of EvalContexts is created, each context in * the chain representing a step of the path. Subclasses of EvalContext * implement behavior of various XPath axes: "child::", "parent::" etc. * * @author Dmitri Plotnikov * @version $Revision: 652845 $ $Date: 2008-05-02 12:46:46 -0500 (Fri, 02 May 2008) $ */ public abstract class EvalContext implements ExpressionContext, Iterator { /** parent context */ protected EvalContext parentContext; /** root context */ protected RootContext rootContext; /** position */ protected int position = 0; private boolean startedSetIteration = false; private boolean done = false; private boolean hasPerformedIteratorStep = false; private Iterator pointerIterator; /** * Create a new EvalContext. * @param parentContext parent context */ public EvalContext(EvalContext parentContext) { this.parentContext = parentContext; } public Pointer getContextNodePointer() { return getCurrentNodePointer(); } public JXPathContext getJXPathContext() { return getRootContext().getJXPathContext(); } public int getPosition() { return position; } /** * Determines the document order for this context. * * @return 1 ascending order, -1 descending order, * 0 - does not require ordering */ public int getDocumentOrder() { return parentContext != null && parentContext.isChildOrderingRequired() ? 1 : 0; } /** * Even if this context has the natural ordering and therefore does * not require collecting and sorting all nodes prior to returning them, * such operation may be required for any child context. * @return boolean */ public boolean isChildOrderingRequired() { // Default behavior: if this context needs to be ordered, // the children need to be ordered too return getDocumentOrder() != 0; } /** * Returns true if there are mode nodes matching the context's constraints. * @return boolean */ public boolean hasNext() { if (pointerIterator != null) { return pointerIterator.hasNext(); } if (getDocumentOrder() != 0) { return constructIterator(); } if (!done && !hasPerformedIteratorStep) { performIteratorStep(); } return !done; } /** * Returns the next node pointer in the context * @return Object */ public Object next() { if (pointerIterator != null) { return pointerIterator.next(); } if (getDocumentOrder() != 0) { if (!constructIterator()) { throw new NoSuchElementException(); } return pointerIterator.next(); } if (!done && !hasPerformedIteratorStep) { performIteratorStep(); } if (done) { throw new NoSuchElementException(); } hasPerformedIteratorStep = false; return getCurrentNodePointer(); } /** * Moves the iterator forward by one position */ private void performIteratorStep() { done = true; if (position != 0 && nextNode()) { done = false; } else { while (nextSet()) { if (nextNode()) { done = false; break; } } } hasPerformedIteratorStep = true; } /** * Operation is not supported * @throws UnsupportedOperationException */ public void remove() { throw new UnsupportedOperationException("JXPath iterators cannot remove nodes"); } /** * Construct an iterator. * @return whether the Iterator was constructed */ private boolean constructIterator() { HashSet set = new HashSet(); ArrayList list = new ArrayList(); while (nextSet()) { while (nextNode()) { NodePointer pointer = getCurrentNodePointer(); if (!set.contains(pointer)) { set.add(pointer); list.add(pointer); } } } if (list.isEmpty()) { return false; } sortPointers(list); pointerIterator = list.iterator(); return true; } /** * Sort a list of pointers based on document order. * @param l the list to sort. */ protected void sortPointers(List l) { switch (getDocumentOrder()) { case 1: Collections.sort(l); break; case -1: Collections.sort(l, ReverseComparator.INSTANCE); break; default: } } /** * Returns the list of all Pointers in this context for the current * position of the parent context. * @return List */ public List getContextNodeList() { int pos = position; if (pos != 0) { reset(); } List list = new ArrayList(); while (nextNode()) { list.add(getCurrentNodePointer()); } if (pos != 0) { setPosition(pos); } else { reset(); } return list; } /** * Returns the list of all Pointers in this context for all positions * of the parent contexts. If there was an ongoing iteration over * this context, the method should not be called. * @return NodeSet */ public NodeSet getNodeSet() { if (position != 0) { throw new JXPathException("Simultaneous operations: " + "should not request pointer list while " + "iterating over an EvalContext"); } BasicNodeSet set = new BasicNodeSet(); while (nextSet()) { while (nextNode()) { set.add((Pointer) getCurrentNodePointer().clone()); } } return set; } /** * Typically returns the NodeSet by calling getNodeSet(), * but will be overridden for contexts that more naturally produce * individual values, e.g. VariableContext * @return Object */ public Object getValue() { return getNodeSet(); } public String toString() { Pointer ptr = getContextNodePointer(); return ptr == null ? "Empty expression context" : "Expression context [" + getPosition() + "] " + ptr.asPath(); } /** * Returns the root context of the path, which provides easy * access to variables and functions. * @return RootContext */ public RootContext getRootContext() { if (rootContext == null) { rootContext = parentContext.getRootContext(); } return rootContext; } /** * Sets current position = 0, which is the pre-iteration state. */ public void reset() { position = 0; } /** * Get the current position. * @return int position. */ public int getCurrentPosition() { return position; } /** * Returns the first encountered Pointer that matches the current * context's criteria. * @return Pointer */ public Pointer getSingleNodePointer() { reset(); while (nextSet()) { if (nextNode()) { return getCurrentNodePointer(); } } return null; } /** * Returns the current context node. Undefined before the beginning * of the iteration. * @return NodePoiner */ public abstract NodePointer getCurrentNodePointer(); /** * Returns true if there is another sets of objects to interate over. * Resets the current position and node. * @return boolean */ public boolean nextSet() { reset(); // Restart iteration within the set // Most of the time you have one set per parent node // First time this method is called, we should look for // the first parent set that contains at least one node. if (!startedSetIteration) { startedSetIteration = true; while (parentContext.nextSet()) { if (parentContext.nextNode()) { return true; } } return false; } // In subsequent calls, we see if the parent context // has any nodes left in the current set if (parentContext.nextNode()) { return true; } // If not, we look for the next set that contains // at least one node while (parentContext.nextSet()) { if (parentContext.nextNode()) { return true; } } return false; } /** * Returns true if there is another object in the current set. * Switches the current position and node to the next object. * @return boolean */ public abstract boolean nextNode(); /** * Moves the current position to the specified index. Used with integer * predicates to quickly get to the n'th element of the node set. * Returns false if the position is out of the node set range. * You can call it with 0 as the position argument to restart the iteration. * @param position to set * @return boolean */ public boolean setPosition(int position) { this.position = position; return true; } }