mono/mcs/class/System.XML/System.Xml.Query/XPathSequence.cs

//
// XPathSequence.cs - represents XPath sequence iterator
//
// Author:
//	Atsushi Enomoto <[email protected]>
//
//
// Copyright (C) 2004 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//

#if NET_2_0
using System;
using System.Collections;
using System.Xml;
using System.Xml.Schema;
using System.Xml.Query;
using System.Xml.XPath;

namespace Mono.Xml.XPath2
{
	public abstract class XPathSequence : IEnumerable, ICloneable
	{
		XQueryContext ctx;
		int countCache = -1;
		int position = 0;

		internal XPathSequence (XQueryContext ctx)
		{
			this.ctx = ctx;
		}

		internal XPathSequence (XPathSequence original)
		{
			ctx = original.ctx;
			position = original.position;
		}

		internal XQueryContext Context {
//			get { return ctx; }
			get { return ctx.ContextManager.CurrentContext; }
		}

		public virtual int Count {
			get {
				if (countCache >= 0)
					return countCache;
				XPathSequence clone = Clone ();
				while (clone.MoveNext ())
					;
				countCache = clone.Position;
				return countCache;
			}
		}

		public XPathItem Current {
			get {
				if (Position == 0)
					throw new InvalidOperationException ("XQuery internal error (should not happen)");
				return CurrentCore;
			}
		}

		public abstract XPathItem CurrentCore { get; }

		// Returns 0 if not started, otherwise returns XPath positional integer.
		public virtual int Position {
			get { return position; }
		}

		public virtual bool MoveNext ()
		{
			if (!MoveNextCore ())
				return false;
			position++;
			return true;
		}

		protected abstract bool MoveNextCore ();

		public abstract XPathSequence Clone ();

		object ICloneable.Clone ()
		{
			return this.Clone ();
		}

		public virtual IEnumerator GetEnumerator ()
		{
			while (MoveNext ())
				yield return CurrentCore;
		}

	}

	// empty iterator (still required since it contains XQueryContext)
	class XPathEmptySequence : XPathSequence
	{
		internal XPathEmptySequence (XQueryContext ctx)
			: base (ctx)
		{
		}

		public override int Count {
			get { return 0; }
		}

		protected override bool MoveNextCore ()
		{
			return false;
		}

		public override XPathItem CurrentCore {
			get { throw new InvalidOperationException ("Should not happen. In XPathEmptySequence.Current."); }
		}

		// Don't return clone. It's waste of resource.
		public override XPathSequence Clone ()
		{
			return this;
		}
	}

	// single item iterator

	internal class SingleItemIterator : XPathSequence
	{
		XPathItem item;
		XPathItem current;

		// for XQuery execution start point
		internal SingleItemIterator (XPathItem item, XQueryContext ctx)
			: base (ctx)
		{
			this.item = item;
		}

		private SingleItemIterator (SingleItemIterator other)
			: base (other)
		{
			this.item = other.item;
			this.current = other.current;
		}

		public override XPathSequence Clone ()
		{
			return new SingleItemIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			if (current == null) {
				current = item;
				return true;
			}
			return false;
		}

		public override XPathItem CurrentCore {
			get {
				return current;
			}
		}
	}

	// RangeExpr iterator

	internal class IntegerRangeIterator : XPathSequence
	{
		static XmlSchemaSimpleType intType = XmlSchemaType.GetBuiltInSimpleType (new XmlQualifiedName ("int", XmlSchema.Namespace));

		int start;
		int end;
		int next;
		XPathItem current;

		public IntegerRangeIterator (XQueryContext ctx, int start, int end)
			: base (ctx)
		{
			this.start = start;
			this.end = end;
		}

		private IntegerRangeIterator (IntegerRangeIterator other)
			: base (other)
		{
			this.start = other.start;
			this.end = other.end;
			this.next = other.next;
			this.current = other.current;
		}

		public override XPathSequence Clone ()
		{
			return new IntegerRangeIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			if (current == null)
				next = start;
			if (next > end)
				return false;
			current = new XPathAtomicValue (next++, intType);
			return true;
		}

		public override XPathItem CurrentCore {
			get {
				return current;
			}
		}
	}

	// Slash iterator
	// <copy original='System.Xml.XPath/Iterator.cs,
	//	System.Xml.XPath/XPathComparer.cs'>
	internal class PathStepIterator : XPathSequence
	{
		XPathSequence left;
		XPathSequence right;
		PathStepExpr step;
		ArrayList nodeStore;
		SortedList storedIterators;
		bool finished;
		XPathSequence nextRight;

		public PathStepIterator (XPathSequence iter, PathStepExpr source)
			: base (iter.Context)
		{
			left = iter;
			step = source;
		}

		private PathStepIterator (PathStepIterator other)
			: base (other)
		{
			left = other.left.Clone ();
			step = other.step;
			if (other.right != null)
				right = other.right.Clone ();
			if (other.nodeStore != null)
				nodeStore = (ArrayList) other.nodeStore.Clone ();
			if (other.storedIterators != null)
				storedIterators = (SortedList) other.storedIterators.Clone ();
			if (other.nextRight != null)
				nextRight = other.nextRight.Clone ();
		}

		public override XPathSequence Clone ()
		{
			return new PathStepIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			if (finished)
				return false;
			if (step.RequireSorting) {
				// Mainly '//' ('/descendant-or-self::node()/')
				if (nodeStore == null) {
					CollectResults ();
					if (nodeStore.Count == 0) {
						finished = true;
						return false;
					} else
						// Initially it must not go to
						// the while loop below
						// (.Position -1 is -1).
						return true;
				}
				if (nodeStore.Count == Position) {
					finished = true;
					return false;
				}
				while (nodeStore.Count > Position) {
					if (((XPathNavigator) nodeStore [Position]).ComparePosition (
						(XPathNavigator) nodeStore [Position - 1]) == XmlNodeOrder.Same)
						nodeStore.RemoveAt (Position);
					else
						break;
				}

				return true;
			} else { // Sorting not required
				if (right == null) { // First time
					if (!left.MoveNext ())
						return false;
					right = step.Next.Evaluate (left);
					storedIterators = new SortedList (XPathSequenceComparer.Instance);
				}

				while (true) {
					while (!right.MoveNext ()) {
						if (storedIterators.Count > 0) {
							int last = storedIterators.Count - 1;
							XPathSequence tmpIter = (XPathSequence) storedIterators.GetByIndex (last);
							storedIterators.RemoveAt (last);
							switch (((XPathNavigator) tmpIter.Current).ComparePosition ((XPathNavigator) right.Current)) {
							case XmlNodeOrder.Same:
							case XmlNodeOrder.Before:
								right = tmpIter;
								continue;
							default:
								right = tmpIter;
								break;
							}
							break;
						} else if (nextRight != null) {
							right = nextRight;
							nextRight = null;
							break;
						} else if (!left.MoveNext ()) {
							finished = true;
							return false;
						}
						else
							right = step.Next.Evaluate (left);
					}
					bool loop = true;
					while (loop) {
						loop = false;
						if (nextRight == null) {
							bool noMoreNext = false;
							while (nextRight == null || !nextRight.MoveNext ()) {
								if(left.MoveNext ())
									nextRight = step.Next.Evaluate (left);
								else {
									noMoreNext = true;
									break;
								}
							}
							if (noMoreNext)
								nextRight = null; // FIXME: More efficient code. Maybe making noMoreNext class scope would be better.
						}
						if (nextRight != null) {
							switch (((XPathNavigator) right.Current).ComparePosition ((XPathNavigator) nextRight.Current)) {
							case XmlNodeOrder.After:
								storedIterators.Add (storedIterators.Count, right);
								right = nextRight;
								nextRight = null;
								loop = true;
								break;
							case XmlNodeOrder.Same:
								if (!nextRight.MoveNext ())
									nextRight = null;

								else {
									int last = storedIterators.Count;
									if (last > 0) {
										storedIterators.Add (last, nextRight);
										nextRight = (XPathSequence) storedIterators.GetByIndex (last);
										storedIterators.RemoveAt (last);
									}
								}

								loop = true;
								break;
							}
						}
					}
					return true;
				}
			}
		}

		private void CollectResults ()
		{
			if (nodeStore != null)
				return;
			nodeStore = new ArrayList ();
			while (true) {
				while (right == null || !right.MoveNext ()) {
					if (!left.MoveNext ()) {
						nodeStore.Sort (XPathNavigatorComparer2.Instance);
						return;
					}
					right = step.Next.Evaluate (left);
				}
				XPathNavigator nav = (XPathNavigator) right.Current;
				nodeStore.Add (nav);
			}
		}

		public override XPathItem CurrentCore { 
			get {
				if (Position <= 0) return null;
				if (step.RequireSorting) {
					return (XPathNavigator) nodeStore [Position - 1];
				} else {
					return right.Current;
				}
			}
		}

		public override int Count {
			get {
				if (nodeStore == null)
					return base.Count;
				else
					return nodeStore.Count;
			}
		}


		internal class XPathSequenceComparer : IComparer
		{
			public static XPathSequenceComparer Instance = new XPathSequenceComparer ();
			private XPathSequenceComparer ()
			{
			}

			public int Compare (object o1, object o2)
			{
				XPathSequence nav1 = o1 as XPathSequence;
				XPathSequence nav2 = o2 as XPathSequence;
				if (nav1 == null)
					return -1;
				if (nav2 == null)
					return 1;
				switch (((XPathNavigator) nav1.Current).ComparePosition ((XPathNavigator) nav2.Current)) {
				case XmlNodeOrder.Same:
					return 0;
				case XmlNodeOrder.After:
					return -1;
				default:
					return 1;
				}
			}
		}

		internal class XPathNavigatorComparer2 : IComparer
		{
			public static XPathNavigatorComparer2 Instance = new XPathNavigatorComparer2 ();
			private XPathNavigatorComparer2 ()
			{
			}

			public int Compare (object o1, object o2)
			{
				XPathNavigator nav1 = o1 as XPathNavigator;
				XPathNavigator nav2 = o2 as XPathNavigator;
				if (nav1 == null)
					return -1;
				if (nav2 == null)
					return 1;
				switch (nav1.ComparePosition (nav2)) {
				case XmlNodeOrder.Same:
					return 0;
				case XmlNodeOrder.After:
					return 1;
				default:
					return -1;
				}
			}
		}
	}
	// </copy>

	// Filter step iterator
	internal class FilteredIterator : XPathSequence
	{
		XPathSequence left;
		ExprSequence filter;

		public FilteredIterator (XPathSequence iter, FilterStepExpr source)
			: base (iter.Context)
		{
			left = source.Expr.Evaluate (iter);
			filter = source.Predicate;
		}

		private FilteredIterator (FilteredIterator other)
			: base (other)
		{
			left = other.left.Clone ();
			filter = other.filter;
		}

		public override XPathSequence Clone ()
		{
			return new FilteredIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			// FIXME: as for numeric predicates, it is MUCH faster
			// when it skips apparent non-candidates, with possible
			// method implementation "XPathSequence.SkipTo (int)".
			// When it comes true, iteration won't be done first.
			while (left.MoveNext ()) {
				bool doesntPass = true;
				// Treat as OK if any of filter expr passed.
				// FIXME: handle numeric predicate.
				foreach (ExprSingle single in filter) {
					XPathAtomicValue av = single.EvaluateAsAtomic (left);
					if (av == null)
						continue;
					if (SequenceType.IsNumeric (av.XmlType.TypeCode)) {
						// numeric filter
						if (av.ValueAsInt32 == left.Position) {
							doesntPass = false;
							break;
						}
					}
					else if (single.EvaluateAsBoolean (left)) {
						doesntPass = false;
						break;
					}
				}
				if (doesntPass)
					continue;
				return true;
			}
			return false;
		}

		public override XPathItem CurrentCore {
			get { return left.Current; }
		}
	}

	// AxisIterator
	internal class AxisIterator : XPathSequence
	{
		NodeIterator iter;
		AxisStepExpr source;

		public AxisIterator (NodeIterator iter, AxisStepExpr source)
			: base (iter.Context)
		{
			this.iter = iter;
			this.source = source;
		}

		private AxisIterator (AxisIterator other)
			: base (other)
		{
			iter = (NodeIterator) other.iter.Clone ();
			source = other.source;
		}

		public override XPathSequence Clone ()
		{
			return new AxisIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			while (iter.MoveNext ()) {
				if (source.Matches (iter.Current as XPathNavigator))
					return true;
			}
			return false;
		}

		public override XPathItem CurrentCore {
			get { return iter.Current; }
		}
	}

	internal abstract class NodeIterator : XPathSequence
	{
		XPathNavigator node;
		XPathNavigator current;
		bool emptyInput;

		public NodeIterator (XPathNavigator nav, XQueryContext ctx)
			: base (ctx)
		{
			this.node = nav.Clone ();
		}

		/*
		public NodeIterator (XPathSequence iter)
			: base (iter.Context)
		{
			if (iter.Position == 0) {
				if (!iter.MoveNext ()) {
					emptyInput = true;
					return;
				}
			}
			XPathItem item = iter.Current;
			node = item as XPathNavigator;
			if (node == null)
				throw new XmlQueryException (String.Format ("Current item is expected to be a node, but it is {0} ({1}).", item.XmlType.QualifiedName, item.XmlType.TypeCode));
			node = node.Clone ();
		}
		*/

		internal NodeIterator (NodeIterator other, bool cloneFlag)
			: base (other)
		{
			if (other.emptyInput)
				emptyInput = true;
			else
				node = other.node.Clone ();
		}

		internal XPathNavigator Node {
			get { return node; }
		}

		public override bool MoveNext ()
		{
			if (emptyInput)
				return false;
			if (!base.MoveNext ())
				return false;
			current = null;
			return true;
		}

		public override XPathItem CurrentCore {
			get {
				if (current == null)
					current = node.Clone ();
				return current;
			}
		}

		public virtual bool ReverseAxis {
			get { return false; }
		}
	}

	// <copy original='System.Xml.XPath/Iterator.cs'>

	internal class SelfIterator : NodeIterator
	{
		public SelfIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		private SelfIterator (SelfIterator other, bool cloneFlag) 
			: base (other, true)
		{
		}

		public override XPathSequence Clone ()
		{
			return new SelfIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (Position == 0)
				return true;
			return false;
		}
	}

	internal class ParentIterator : NodeIterator
	{
		public ParentIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		private ParentIterator (ParentIterator other, bool cloneFlag) 
			: base (other, true)
		{
		}

		public override XPathSequence Clone ()
		{
			return new ParentIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (Position == 0 && Node.MoveToParent ())
				return true;
			return false;
		}

		public override bool ReverseAxis {
			get { return true; }
		}
	}

	internal class ChildIterator : NodeIterator
	{
		public ChildIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		private ChildIterator (ChildIterator other, bool cloneFlag) 
			: base (other, true)
		{
		}

		public override XPathSequence Clone ()
		{
			return new ChildIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (Position == 0)
				return Node.MoveToFirstChild ();
			else
				return Node.MoveToNext ();
		}
	}

	internal class FollowingSiblingIterator : NodeIterator
	{
		public FollowingSiblingIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		private FollowingSiblingIterator (FollowingSiblingIterator other, bool cloneFlag) 
			: base (other, true)
		{
		}

		public override XPathSequence Clone ()
		{
			return new FollowingSiblingIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			return Node.MoveToNext ();
		}
	}

	internal class PrecedingSiblingIterator : NodeIterator
	{
		bool finished;
		bool started;
		XPathNavigator startPosition;

		public PrecedingSiblingIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
			startPosition = Node.Clone ();
		}

		private PrecedingSiblingIterator (PrecedingSiblingIterator other, bool cloneFlag) 
			: base (other, true)
		{
			startPosition = other.startPosition;
			started = other.started;
			finished = other.finished;
		}

		public override XPathSequence Clone ()
		{
			return new PrecedingSiblingIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (finished)
				return false;
			if (!started) {
				started = true;
				Node.MoveToFirst ();
			} else {
				Node.MoveToNext ();
			}
			if (Node.ComparePosition (startPosition) == XmlNodeOrder.Same) {
				finished = true;
				return false;
			}
			else
				return true;
		}

		public override bool ReverseAxis {
			get { return true; }
		}
	}

	internal class AncestorIterator : NodeIterator
	{
		bool finished;
		ArrayList nodes = new ArrayList ();

		public AncestorIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		private AncestorIterator (AncestorIterator other, bool cloneFlag) 
			: base (other, true)
		{
			finished = other.finished;
			nodes = other.nodes;
		}

		public override XPathSequence Clone ()
		{
			return new AncestorIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (finished)
				return false;
			if (nodes != null) {
				nodes = new ArrayList ();
				while (Node.MoveToParent () && Node.NodeType != XPathNodeType.Root)
					nodes.Add (Node.Clone ());
				nodes.Reverse ();
			}
			if (nodes.Count >= Position)
				return false;
			Node.MoveTo (nodes [Position] as XPathNavigator);
			return true;
		}

		public override bool ReverseAxis {
			get { return true; }
		}

		public override int Count {
			get {
				if (Position == 0)
					return base.Count;
				return nodes.Count;
			}
		}
	}

	internal class AncestorOrSelfIterator : NodeIterator
	{
		bool finished;
		ArrayList nodes = new ArrayList ();

		public AncestorOrSelfIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		private AncestorOrSelfIterator (AncestorOrSelfIterator other, bool cloneFlag) 
			: base (other, true)
		{
			finished = other.finished;
			nodes = other.nodes;
		}

		public override XPathSequence Clone ()
		{
			return new AncestorOrSelfIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (finished)
				return false;
			if (nodes != null) {
				nodes = new ArrayList ();
				do {
					nodes.Add (Node.Clone ());
				} while (Node.MoveToParent () && Node.NodeType != XPathNodeType.Root);
				nodes.Reverse ();
			}
			if (nodes.Count >= Position)
				return false;
			Node.MoveTo (nodes [Position] as XPathNavigator);
			return true;
		}

		public override bool ReverseAxis {
			get { return true; }
		}

		public override int Count {
			get {
				if (Position == 0)
					return base.Count;
				return nodes.Count;
			}
		}
	}

	internal class DescendantIterator : NodeIterator
	{
		private int depth;
		private bool finished;

		public DescendantIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		private DescendantIterator (DescendantIterator other, bool cloneFlag) 
			: base (other, true)
		{
			finished = other.finished;
			depth = other.depth;
		}

		public override XPathSequence Clone ()
		{
			return new DescendantIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (finished)
				return false;

			if (Node.MoveToFirstChild ()) {
				depth ++;
				return true;
			}
			while (depth != 0) {
				if (Node.MoveToNext ())
					return true;

				if (!Node.MoveToParent ())	// should NEVER fail!
					throw new XmlQueryException ("There seems some bugs on the XPathNavigator implementation class.");
				depth --;
			}
			finished = true;
			return false;
		}
	}

	internal class DescendantOrSelfIterator : NodeIterator
	{
		protected int depth;
		private bool finished;

		public DescendantOrSelfIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		protected DescendantOrSelfIterator (DescendantOrSelfIterator other, bool cloneFlag) 
			: base (other, true)
		{
			depth = other.depth;
			finished = other.finished;
		}

		public override XPathSequence Clone ()
		{
			return new DescendantOrSelfIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (finished)
				return false;

			if (Position == 0)
				return true; // Self


			if (Node.MoveToFirstChild ()) {
				depth ++;
				return true;
			}
			while (depth != 0) {
				if (Node.MoveToNext ())
					return true;

				if (!Node.MoveToParent ())	// should NEVER fail!
					throw new XmlQueryException ("There seems some bugs on the XPathNavigator implementation class.");
				depth --;
			}
			finished = true;
			return false;
		}
	}

	internal class FollowingIterator : NodeIterator
	{
		private bool finished;

		public FollowingIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		protected FollowingIterator (FollowingIterator other, bool cloneFlag) 
			: base (other, true)
		{
			finished = other.finished;
		}

		public override XPathSequence Clone ()
		{
			return new FollowingIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (finished)
				return false;
			if (Position == 0) {
				// At first, it should not iterate children.
				if (Node.MoveToNext ())
					return true;
				else {
					while (Node.MoveToParent ())
						if (Node.MoveToNext ())
							return true;
				}
			} else {
				if (Node.MoveToFirstChild ())
					return true;
				do {
					if (Node.MoveToNext ())
						return true;
				} while (Node.MoveToParent ());
			}
			finished = true;
			return false;
		}
	}

	internal class PrecedingIterator : NodeIterator
	{
		bool finished;
		bool started;
		XPathNavigator startPosition;

		public PrecedingIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
			startPosition = Node.Clone ();
		}

		private PrecedingIterator (PrecedingIterator other, bool cloneFlag) 
			: base (other, true)
		{
			startPosition = other.startPosition;
			started = other.started;
			finished = other.finished;
		}

		public override XPathSequence Clone ()
		{
			return new PrecedingIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (finished)
				return false;
			if (!started) {
				started = true;
				Node.MoveToRoot ();
			}
			bool loop = true;
			while (loop) {
				while (!Node.MoveToFirstChild ()) {
					while (!Node.MoveToNext ()) {
						if (!Node.MoveToParent ()) { // Should not finish, at least before startPosition.
							finished = true;
							return false;
						}
					}
					break;
				}
				if (Node.IsDescendant (startPosition))
					continue;
				loop = false;
				break;
			}
			if (Node.ComparePosition (startPosition) != XmlNodeOrder.Before) {
				// Note that if _nav contains only 1 node, it won't be Same.
				finished = true;
				return false;
			}
			else
				return true;
		}

		public override bool ReverseAxis {
			get { return true; }
		}
	}

	internal class NamespaceIterator : NodeIterator
	{
		public NamespaceIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		private NamespaceIterator (NamespaceIterator other, bool cloneFlag) 
			: base (other, true)
		{
		}

		public override XPathSequence Clone ()
		{
			return new NamespaceIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (Position == 0) {
				if (Node.MoveToFirstNamespace ())
					return true;
			}
			else if (Node.MoveToNextNamespace ())
				return true;
			return false;
		}

		public override bool ReverseAxis { get { return true; } }
	}

	internal class AttributeIterator : NodeIterator
	{
		public AttributeIterator (XPathNavigator nav, XQueryContext ctx)
			: base (nav, ctx)
		{
		}

		private AttributeIterator (AttributeIterator other, bool cloneFlag) 
			: base (other, true)
		{
		}

		public override XPathSequence Clone ()
		{
			return new AttributeIterator (this, true);
		}

		protected override bool MoveNextCore ()
		{
			if (Position == 0) {
				if (Node.MoveToFirstAttribute ())
					return true;
			}
			else if (Node.MoveToNextAttribute ())
				return true;
			return false;
		}
	}

	// </copy>

	internal class ExprSequenceIterator : XPathSequence
	{
		XPathSequence contextSequence;
		XPathSequence iter;
		ExprSequence expr;
		int currentExprIndex;

		public ExprSequenceIterator (XPathSequence iter, ExprSequence expr)
			: base (iter.Context)
		{
			contextSequence = iter;
			this.expr = expr;
		}

		private ExprSequenceIterator (ExprSequenceIterator other)
			: base (other)
		{
			if (other.iter != null)
				iter = other.iter.Clone ();
			expr = other.expr;
			contextSequence = other.contextSequence;
			currentExprIndex = other.currentExprIndex;
		}

		public override XPathSequence Clone ()
		{
			return new ExprSequenceIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			if (iter != null && iter.MoveNext ())
				return true;
			while (currentExprIndex < expr.Count) {
				iter = expr [currentExprIndex++].Evaluate (contextSequence);
				if (iter.MoveNext ())
					return true;
			}
			return false;
		}

		public override XPathItem CurrentCore {
			get { return iter.Current; }
		}
	}

	// FLWOR - Order By
	internal class FLWORIterator : XPathSequence
	{
		XPathSequence contextSequence;
		FLWORExpr expr;
		ArrayList forStack = new ArrayList ();
		IEnumerator en;
		bool finished;

		public FLWORIterator (XPathSequence iter, FLWORExpr expr)
			: base (iter.Context)
		{
			this.contextSequence = iter;
			this.expr = expr;
		}

		private FLWORIterator (FLWORIterator other)
			: base (other)
		{
			contextSequence = other.contextSequence;
			expr = other.expr;
			forStack = other.forStack.Clone () as ArrayList;
			if (en != null)
				en = ((ICloneable) other.en).Clone () as IEnumerator;
			finished = other.finished;
		}

		public override XPathSequence Clone ()
		{
			return new FLWORIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			if (en == null)
				en = GetEnumerator ();
			return en.MoveNext ();
		}

		public override IEnumerator GetEnumerator ()
		{
			return EvaluateRemainingForLet (0);
		}
		
		private IEnumerator EvaluateRemainingForLet (int flcPosition)
		{
			// Prepare iteration stack
			if (flcPosition < expr.ForLetClauses.Count) {
				IEnumerator items = EvaluateRemainingSingleItem (flcPosition, 0);
				while (items.MoveNext ())
					yield return items.Current;
			} else {
				bool passedFilter = expr.WhereClause == null;
				if (!passedFilter)
					passedFilter = expr.WhereClause.EvaluateAsBoolean (contextSequence);
				if (passedFilter) {
					IEnumerator ie = expr.ReturnExpr.Evaluate (contextSequence).GetEnumerator ();
					while (ie.MoveNext ())
						yield return (XPathItem) ie.Current;
				}
			}
		}

		private IEnumerator EvaluateRemainingSingleItem (int flcPosition, int singlePosition)
		{
			if (singlePosition < expr.ForLetClauses [flcPosition].Count) {
				ForLetSingleBody sb = expr.ForLetClauses [flcPosition] [singlePosition];
				ForSingleBody fsb = sb as ForSingleBody;
				if (fsb != null) {
					XPathSequence backup = contextSequence;
					contextSequence = fsb.Expression.Evaluate (Context.CurrentSequence);
					Context.ContextManager.PushCurrentSequence (contextSequence);
					while (contextSequence.MoveNext ()) {
						XPathItem forItem = (XPathItem) contextSequence.Current;
						Context.PushVariable (fsb.PositionalVar, contextSequence.Position);
						Context.PushVariable (sb.VarName, forItem);
						// recurse here (including following bindings)
						IEnumerator items = EvaluateRemainingSingleItem (flcPosition, singlePosition + 1);
						while (items.MoveNext ())
							yield return (XPathItem) items.Current;
						Context.PopVariable ();
						Context.PopVariable ();
					}
					Context.ContextManager.PopCurrentSequence ();
					contextSequence = backup;
				} else {
					Context.PushVariable (sb.VarName, sb.Expression.Evaluate (contextSequence));
					// recurse here (including following bindings)
					IEnumerator items = EvaluateRemainingSingleItem (flcPosition, singlePosition + 1);
					while (items.MoveNext ())
						yield return (XPathItem) items.Current;
					Context.PopVariable ();
				}
			} else {
				// evaluate next binding
				IEnumerator items = EvaluateRemainingForLet (flcPosition + 1);
				while (items.MoveNext ())
					yield return (XPathItem) items.Current;
			}
		}

		public override XPathItem CurrentCore {
			get { return (XPathItem) en.Current; }
		}
	}

	internal class GroupIterator : XPathSequence
	{
		GroupExpr expr;
		XPathSequence lseq;
		XPathSequence rseq;
		bool started;
		bool left;
		bool leftFinished;
		bool rightFinished;

		public GroupIterator (XPathSequence iter, GroupExpr expr)
			: base (iter.Context)
		{
			this.expr = expr;
			left = true;
			lseq = expr.Left.EvaluateOrdered (iter);
			rseq = expr.Right.EvaluateOrdered (iter);
		}

		private GroupIterator (GroupIterator other)
			: base (other)
		{
			this.expr = other.expr;
			this.started = other.started;
			this.left = other.left;
			this.leftFinished = other.leftFinished;
			this.rightFinished = other.rightFinished;
			this.lseq = other.lseq.Clone ();
			this.rseq = other.rseq.Clone ();
		}

		public override XPathSequence Clone ()
		{
			return new GroupIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			if (leftFinished && rightFinished)
				return false;
			bool proceeded = false;
			if (started) {
				if (left) {
					if (!leftFinished && lseq.MoveNext ())
						proceeded = true;
					else
						leftFinished = true;
				} else {
					if (rightFinished && rseq.MoveNext ())
						proceeded = true;
					else
						rightFinished = true;
				}
			} else {
				started = true;
				if (!lseq.MoveNext ()) {
					leftFinished = true;
					if (!rseq.MoveNext ()) {
						rightFinished = true;
						return false;
					}
					left = false;
					return true;
				}
				proceeded = true;
				if (!rseq.MoveNext ()) {
					rightFinished = true;
					return true;
				}
			}
			if (!proceeded) {
				if (expr.AggregationType == AggregationType.Intersect)
					return false;
				left = !leftFinished;
				return !leftFinished || !rightFinished;
			}

			XPathNavigator lnav = lseq.Current as XPathNavigator;
			XPathNavigator rnav = rseq.Current as XPathNavigator;
			if (lnav == null || rnav == null)
				throw new XmlQueryException ("XP0006: Evaluation against union, intersect, except expressions must result in nodes.");
			XmlNodeOrder order = lnav.ComparePosition (rnav);
			switch (order) {
			case XmlNodeOrder.Same:
				switch (expr.AggregationType) {
				case AggregationType.Union:
					left = false;
					if (!lseq.MoveNext ())
						leftFinished = true;
					return true;
				case AggregationType.Intersect:
					return true;
				case AggregationType.Except:
				default:
					return MoveNext ();
				}
			case XmlNodeOrder.Before:
				left = true;
				if (expr.AggregationType == AggregationType.Intersect)
					return MoveNext ();
				return true;
			default: // After, Unknown
				left = false;
				if (expr.AggregationType == AggregationType.Intersect)
					return MoveNext ();
				return true;
			}
		}

		public override XPathItem CurrentCore {
			get { return left ? lseq.Current : rseq.Current; }
		}
	}

	internal class AtomizingIterator : XPathSequence
	{
		XPathSequence iter;

		public AtomizingIterator (XPathSequence iter)
			: base (iter.Context)
		{
			this.iter = iter;
		}

		private AtomizingIterator (AtomizingIterator other)
			: base (other)
		{
			iter = other.iter.Clone ();
		}

		public override XPathSequence Clone ()
		{
			return new AtomizingIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			return iter.MoveNext ();
		}

		public override XPathItem CurrentCore {
			get {
				XPathNavigator nav = iter.Current as XPathNavigator;
				if (nav == null)
					return (XPathAtomicValue) iter.Current;
				if (nav.SchemaInfo != null)
					return new XPathAtomicValue (
						nav.TypedValue,
						nav.SchemaInfo.SchemaType);
				else
					return new XPathAtomicValue (nav.Value, null);
			}
		}
	}

	internal class ConvertingIterator : XPathSequence
	{
		XPathSequence iter;
		SequenceType type;

		public ConvertingIterator (XPathSequence iter, SequenceType type)
			: base (iter.Context)
		{
			this.iter = iter;
			this.type = type;
		}

		private ConvertingIterator (ConvertingIterator other)
			: base (other)
		{
			iter = other.iter.Clone ();
			type = other.type;
		}

		public override XPathSequence Clone ()
		{
			return new ConvertingIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			return iter.MoveNext ();
		}

		public override XPathItem CurrentCore {
			get { return type.Convert (iter.Current); }
		}
	}

	internal class TracingIterator : XPathSequence
	{
		XPathSequence iter;
		string format;

		public TracingIterator (XPathSequence iter, string format)
			: base (iter.Context)
		{
			this.iter = iter;
			this.format = format;
		}

		private TracingIterator (TracingIterator other)
			: base (other)
		{
			iter = other.iter.Clone ();
			format = other.format;
		}

		public override XPathSequence Clone ()
		{
			return new TracingIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			if (!iter.MoveNext ())
				return false;
			// FIXME: use OnMessageEvent
			string output = String.Format (format, iter.Current.TypedValue);
			Context.StaticContext.OnMessageEvent (iter.Current, new TraceEventArgs (output));
			return true;
		}

		public override XPathItem CurrentCore {
			get { return iter.Current; }
		}

		internal class TraceEventArgs : QueryEventArgs
		{
			string message;

			internal TraceEventArgs (string message)
			{
				this.message = message;
			}

			public override string Message {
				get { return message; }
			}
		}

	}

	internal class ListIterator : XPathSequence
	{
		IList list;

		public ListIterator (XPathSequence iter, IList list)
			: base (iter.Context)
		{
			if (list is ICloneable)
				this.list = list;
			else
				throw new InvalidOperationException (String.Format ("XQuery internal error: target list is not cloneable. List is {0}.", list != null ? list.GetType ().ToString () : "null argument"));
		}

		private ListIterator (ListIterator other)
			: base (other)
		{
			this.list = (IList) ((ICloneable) other.list).Clone ();
		}

		public override XPathSequence Clone ()
		{
			return new ListIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			return (Position < list.Count);
		}

		public override XPathItem CurrentCore {
			get { return (XPathItem) list [Position - 1]; }
		}
	}

	internal class EnumeratorIterator : XPathSequence
	{
		IEnumerator list;

		public EnumeratorIterator (XQueryContext ctx, IEnumerable en)
			: base (ctx)
		{
			list = en.GetEnumerator ();
			if (list is ICloneable)
				this.list = list;
			else
				throw new InvalidOperationException (String.Format ("XQuery internal error: target list's enumerator is not cloneable. List is {0}.", en != null ? en.GetType ().ToString () : "null argument"));
		}

		private EnumeratorIterator (EnumeratorIterator other)
			: base (other)
		{
			this.list = (IEnumerator) ((ICloneable) other.list).Clone ();
		}

		public override XPathSequence Clone ()
		{
			return new EnumeratorIterator (this);
		}

		protected override bool MoveNextCore ()
		{
			return list.MoveNext ();
		}

		public override XPathItem CurrentCore {
			get { return (XPathItem) list.Current; }
		}
	}
}

#endif