mvp-xml-cvs

[Oleg T. <he...@us...>]

Update of /cvsroot/mvp-xml/Common/v2/src/XPath
In directory sc8-pr-cvs1.sourceforge.net:/tmp/cvs-serv28965/v2/src/XPath

Added Files:
	DynamicContext.cs IHasXPathNavigator.cs 
	IndexingXPathNavigator.cs SubtreeeXPathNavigator.cs 
	XPathCache.cs XPathIteratorReader.cs XPathNavigatorIterator.cs 
	XPathVariable.cs 
Log Message:


--- NEW FILE: DynamicContext.cs ---
#region using

using System;
using System.Collections.Generic;
using System.Reflection;
using System.Text;
using System.Xml;
using System.Xml.XPath;
using System.Xml.Xsl;

#endregion using

namespace Mvp.Xml.Common.XPath
{
	/// <summary>
	/// Provides the evaluation context for fast execution and custom 
	/// variables resolution.
	/// </summary>
	/// <remarks>
	/// This class is responsible for resolving variables during dynamic expression execution.
	/// <para>Discussed in http://weblogs.asp.net/cazzu/archive/2003/10/07/30888.aspx</para>
	/// <para>Author: Daniel Cazzulino, kz...@gm...</para>
	/// </remarks>
	public class DynamicContext : XsltContext
	{
		#region Private vars

		IDictionary<string, DynamicVariable> _variables = new Dictionary<string, DynamicVariable>();
	
		#endregion Private

		#region Constructors & Initialization

		/// <summary>
		/// Initializes a new instance of the <see cref="DynamicContext"/> class.
		/// </summary>
		public DynamicContext() : base(new NameTable())
		{
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="DynamicContext"/> 
		/// class with the specified <see cref="NameTable"/>.
		/// </summary>
		/// <param name="table">The NameTable to use.</param>
		public DynamicContext(NameTable table) : base(table) 
		{
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="DynamicContext"/> class.
		/// </summary>
		/// <param name="context">A previously filled context with the namespaces to use.</param>
		public DynamicContext(XmlNamespaceManager context) : this(context, new NameTable())
		{			
		}

		/// <summary>
		/// Initializes a new instance of the <see cref="DynamicContext"/> class.
		/// </summary>
		/// <param name="context">A previously filled context with the namespaces to use.</param>
		/// <param name="table">The NameTable to use.</param>
		public DynamicContext(XmlNamespaceManager context, NameTable table) : base(table)
		{
			object xml = table.Add(XmlNamespaces.Xml);
			object xmlns = table.Add(XmlNamespaces.XmlNs);

			if (context != null)
			{
				foreach (string prefix in context)
				{
					string uri = context.LookupNamespace(prefix);
					// Use fast object reference comparison to omit forbidden namespace declarations.
					if (Object.Equals(uri, xml) || Object.Equals(uri, xmlns))
						continue;

					base.AddNamespace(prefix, uri);
				}
			}
		}

		#endregion Constructors & Initialization

		#region Common Overrides

		/// <summary>
    /// Implementation equal to <see cref="XsltContext.CompareDocument(string, string)"/>.
		/// </summary>
		public override int CompareDocument(string baseUri, string nextbaseUri) 
		{
			return String.Compare(baseUri, nextbaseUri, false, System.Globalization.CultureInfo.InvariantCulture);
		}

		/// <summary>
		/// Same as <see cref="XmlNamespaceManager"/>.
		/// </summary>
		public override string LookupNamespace(string prefix)
		{
			string key = NameTable.Get(prefix);
			if (key == null) 
				return null;
			else
				return base.LookupNamespace(key);
		}

		/// <summary>
		/// Same as <see cref="XmlNamespaceManager"/>.
		/// </summary>
		public override string LookupPrefix(string uri)
		{
			string key = NameTable.Get(uri);
			if (key == null) 
				return null;
			else
				return base.LookupPrefix(key);
		}

		/// <summary>
    /// Same as <see cref="XsltContext.PreserveWhitespace(XPathNavigator)"/>.
		/// </summary>
		public override bool PreserveWhitespace(XPathNavigator node)
		{
			return true;
		}

		/// <summary>
    /// Same as <see cref="XsltContext.Whitespace"/>.
		/// </summary>
		public override bool Whitespace 
		{ 
			get { return true; } 
		}

		#endregion Common Overrides

		#region Public Members

		/// <summary>
		/// Shortcut method that compiles an expression using an empty navigator.
		/// </summary>
		/// <param name="xpath">The expression to compile</param>
		/// <returns>A compiled <see cref="XPathExpression"/>.</returns>
		public static XPathExpression Compile(string xpath)
		{
			return new XmlDocument().CreateNavigator().Compile(xpath);
		}

		#endregion Public Members

		#region Variable Handling Code

		/// <summary>
		/// Adds the variable to the dynamic evaluation context.
		/// </summary>
		/// <param name="name">The name of the variable to add to the context.</param>
		/// <param name="value">The value of the variable to add to the context.</param>
		/// <remarks>
		/// Value type conversion for XPath evaluation is as follows:
		/// <list type="table">
		///		<listheader>
		///			<term>CLR Type</term>
		///			<description>XPath type</description>
		///		</listheader>
		///		<item>
		///			<term>System.String</term>
		///			<description>XPathResultType.String</description>
		///		</item>
		///		<item>
		///			<term>System.Double (or types that can be converted to)</term>
		///			<description>XPathResultType.Number</description>
		///		</item>
		///		<item>
		///			<term>System.Boolean</term>
		///			<description>XPathResultType.Boolean</description>
		///		</item>
		///		<item>
		///			<term>System.Xml.XPath.XPathNavigator</term>
		///			<description>XPathResultType.Navigator</description>
		///		</item>
		///		<item>
		///			<term>System.Xml.XPath.XPathNodeIterator</term>
		///			<description>XPathResultType.NodeSet</description>
		///		</item>
		///		<item>
		///			<term>Others</term>
		///			<description>XPathResultType.Any</description>
		///		</item>
		/// </list>
		/// <note type="note">See the topic "Compile, Select, Evaluate, and Matches with 
		/// XPath and XPathExpressions" in MSDN documentation for additional information.</note>
		/// </remarks>
		/// <exception cref="ArgumentNullException">The <paramref name="value"/> is null.</exception>
		public void AddVariable(string name, object value)
		{
			if (value == null) throw new ArgumentNullException("value");
			_variables[name] = new DynamicVariable(name, value);
		}

		/// <summary>
		/// See <see cref="XsltContext"/>. Not used in our implementation.
		/// </summary>
		public override IXsltContextFunction ResolveFunction(string prefix, string name, XPathResultType[] ArgTypes)
		{
			return null;
		}

		/// <summary>
		/// Resolves the dynamic variables added to the context. See <see cref="XsltContext"/>. 
		/// </summary>
		public override IXsltContextVariable ResolveVariable(string prefix, string name)
		{
			return _variables[name] as IXsltContextVariable;
		}

		#endregion Variable Handling Code

		#region Internal DynamicVariable class

		/// <summary>
		/// Represents a variable during dynamic expression execution.
		/// </summary>
		internal class DynamicVariable : IXsltContextVariable
		{
			string _name;
			object _value;

			#region Public Members

			/// <summary>
			/// Initializes a new instance of the class.
			/// </summary>
			/// <param name="name">The name of the variable.</param>
			/// <param name="value">The value of the variable.</param>
			public DynamicVariable(string name, object value)
			{

				_name = name;
				_value = value;

				if (value is String)
					_type = XPathResultType.String;
				else if (value is bool)
					_type = XPathResultType.Boolean;
				else if (value is XPathNavigator)
					_type = XPathResultType.Navigator;
				else if (value is XPathNodeIterator)
					_type = XPathResultType.NodeSet;
				else
				{
					// Try to convert to double (native XPath numeric type)
					if (value is double)
					{
						_type = XPathResultType.Number;
					}
					else
					{
						if (value is IConvertible)
						{
							try
							{
								_value = Convert.ToDouble(value);
								// We suceeded, so it's a number.
								_type = XPathResultType.Number;
							}
							catch (FormatException)
							{
								_type = XPathResultType.Any;
							}
							catch (OverflowException)
							{
								_type = XPathResultType.Any;
							}
						}
						else
						{
							_type = XPathResultType.Any;
						}
					}
				}
			}

			#endregion Public Members

			#region IXsltContextVariable Implementation

			XPathResultType IXsltContextVariable.VariableType
			{
				get { return _type; }
			} XPathResultType _type;

			object IXsltContextVariable.Evaluate(XsltContext context) 
			{
				return _value;
			}

			bool IXsltContextVariable.IsLocal
			{
				get { return false; }
			}

			bool IXsltContextVariable.IsParam
			{
				get  { return false; }
			}

			#endregion IXsltContextVariable Implementation
		}

		#endregion Internal DynamicVariable class
	}
}

--- NEW FILE: XPathIteratorReader.cs ---
#region using

using System;
using System.Collections;
using System.Collections.Specialized;
using System.IO;
using System.Xml;
using System.Xml.Serialization;
using System.Xml.XPath;

#endregion using

namespace Mvp.Xml.Common.XPath
{
	/// <summary>
	/// Provides an <see cref="XmlReader"/> over an 
	/// <see cref="XPathNodeIterator"/>.
	/// </summary>
	/// <remarks>
	/// The reader exposes a new root element enclosing all navigators from the 
	/// iterator. This root node is configured in the constructor, by 
	/// passing the desired name and optional namespace for it.
	/// <para>Author: Daniel Cazzulino, kz...@gm...</para>
	/// See: http://weblogs.asp.net/cazzu/archive/2004/04/26/120684.aspx
	/// </remarks>
	public class XPathIteratorReader : XmlTextReader, IXmlSerializable
	{
		#region Fields

		// Holds the current child being read.
		XmlReader _current;

		// Holds the iterator passed to the ctor. 
		XPathNodeIterator _iterator;

		// The name for the root element.
		XmlQualifiedName _rootname;

		#endregion Fields

		#region Ctor

		/// <summary>
		/// Parameterless constructor for XML serialization.
		/// </summary>
		/// <remarks>Supports the .NET serialization infrastructure. Don't use this 
		/// constructor in your regular application.</remarks>
		[System.ComponentModel.EditorBrowsable(System.ComponentModel.EditorBrowsableState.Never)]
		public XPathIteratorReader()
		{
		}

		/// <summary>
		/// Initializes the reader, using the default &lt;root&gt; element.
		/// </summary>
		/// <param name="iterator">The iterator to expose as a single reader.</param>
		public XPathIteratorReader(XPathNodeIterator iterator) : this(iterator, "root", String.Empty)
		{
		}

		/// <summary>
		/// Initializes the reader.
		/// </summary>
		/// <param name="iterator">The iterator to expose as a single reader.</param>
		/// <param name="rootName">The name to use for the enclosing root element.</param>
		public XPathIteratorReader(XPathNodeIterator iterator, string rootName) : this(iterator, rootName, String.Empty)
		{
		}

		/// <summary>
		/// Initializes the reader.
		/// </summary>
		/// <param name="iterator">The iterator to expose as a single reader.</param>
		/// <param name="rootName">The name to use for the enclosing root element.</param>
		/// <param name="ns">The namespace URI of the root element.</param>
		public XPathIteratorReader(XPathNodeIterator iterator, string rootName, string ns) : base(new StringReader(String.Empty))
		{
			_iterator = iterator.Clone();
			_current = new FakedRootReader(rootName, ns, XmlNodeType.Element);
			_rootname = new XmlQualifiedName(rootName, ns);
		}

		#endregion Ctor

		#region Private Members

		/// <summary>
		/// Returns the XML representation of the current node and all its children.
		/// </summary>
		private string Serialize()
		{
			StringWriter sw = new StringWriter(System.Globalization.CultureInfo.CurrentCulture);
			XmlTextWriter tw = new XmlTextWriter(sw);
			tw.WriteNode(this, false);

			sw.Flush();
			return sw.ToString();
		}

		#endregion Private Members

		#region Properties

		/// <summary>See <see cref="XmlReader.AttributeCount"/></summary>
		public override int AttributeCount 
		{
			get { return _current.AttributeCount; }
		} 
    
		/// <summary>See <see cref="XmlReader.BaseURI"/></summary>
		public override string BaseURI 
		{
			get { return _current.BaseURI; }
		}
    
		/// <summary>See <see cref="XmlReader.Depth"/></summary>
		public override int Depth 
		{
			get { return _current.Depth + 1; }
		} 
    
		/// <summary>See <see cref="XmlReader.EOF"/></summary>
		public override bool EOF 
		{
			get { return _current.ReadState == ReadState.EndOfFile || _current.ReadState == ReadState.Closed; }
		} 
    
		/// <summary>See <see cref="XmlReader.HasValue"/></summary>
		public override bool HasValue 
		{
			get { return _current.HasValue; }
		}
    
		/// <summary>See <see cref="XmlReader.IsDefault"/></summary>
		public override bool IsDefault 
		{
			get { return false; }
		}
    
		/// <summary>See <see cref="XmlReader.IsDefault"/></summary>
		public override bool IsEmptyElement 
		{
			get { return _current.IsEmptyElement; }
		}
    
		/// <summary>See <see cref="XmlReader.this[string, string]"/></summary>
		public override string this[string name, string ns] 
		{
			get { return _current[name, ns]; }
		}
    
		/// <summary>See <see cref="XmlReader.this[string]"/></summary>
		public override string this[string name] 
		{
			get { return _current[name, String.Empty]; }
		}
    
		/// <summary>See <see cref="XmlReader.this[int]"/></summary>
		public override string this[int i] 
		{
			get { return _current[i]; }
		} 
    
		/// <summary>See <see cref="XmlReader.LocalName"/></summary>
		public override string LocalName 
		{
			get { return _current.LocalName; }
		}
    
		/// <summary>See <see cref="XmlReader.Name"/></summary>
		public override string Name 
		{
			get { return _current.Name; }
		}
    
		/// <summary>See <see cref="XmlReader.NamespaceURI"/></summary>
		public override string NamespaceURI 
		{
			get { return _current.NamespaceURI; }
		}
    
		/// <summary>See <see cref="XmlReader.NameTable"/></summary>
		public override XmlNameTable NameTable 
		{
			get { return _current.NameTable; }
		}
    
		/// <summary>See <see cref="XmlReader.NodeType"/></summary>
		public override XmlNodeType NodeType 
		{
			get { return _current.NodeType; }

		}

		/// <summary>See <see cref="XmlReader.Prefix"/></summary>
		public override string Prefix 
		{
			get { return _current.Prefix; }
		}
    
		/// <summary>See <see cref="XmlReader.QuoteChar"/></summary>
		public override char QuoteChar 
		{
			get { return _current.QuoteChar; }
		}
    
		/// <summary>See <see cref="XmlReader.ReadState"/></summary>
		public override ReadState ReadState 
		{
			get { return _current.ReadState; }
		} 
    
		/// <summary>See <see cref="XmlReader.Value"/></summary>
		public override string Value 
		{
			get { return _current.Value; }
		}
    
		/// <summary>See <see cref="XmlReader.XmlLang"/></summary>
		public override string XmlLang 
		{
			get { return _current.XmlLang; }
		}
    
		/// <summary>See <see cref="XmlReader.XmlSpace"/></summary>
		public override XmlSpace XmlSpace 
		{
			get { return XmlSpace.Default; }
		}

		#endregion Properties 

		#region Methods

		/// <summary>See <see cref="XmlReader.Close"/></summary>
		public override void Close() 
		{
			_current.Close();
		}
    
		/// <summary>See <see cref="XmlReader.GetAttribute(string, string)"/></summary>
		public override string GetAttribute(string name, string ns) 
		{
			return _current.GetAttribute(name, ns);
		}
    
		/// <summary>See <see cref="XmlReader.GetAttribute(string)"/></summary>
		public override string GetAttribute(string name) 
		{
			return _current.GetAttribute(name);
		}
    
		/// <summary>See <see cref="XmlReader.GetAttribute(int)"/></summary>
		public override string GetAttribute(int i) 
		{
			return _current.GetAttribute(i);
		}
    
		/// <summary>See <see cref="XmlReader.LookupNamespace"/></summary>
		public override string LookupNamespace(string prefix) 
		{
			return _current.LookupNamespace(prefix);
		}
    
		/// <summary>See <see cref="XmlReader.MoveToAttribute(string, string)"/></summary>
		public override bool MoveToAttribute(string name, string ns) 
		{
			return _current.MoveToAttribute(name, ns);
		}
    
		/// <summary>See <see cref="XmlReader.MoveToAttribute(string)"/></summary>
		public override bool MoveToAttribute(string name) 
		{
			return _current.MoveToAttribute(name);
		}
    
		/// <summary>See <see cref="XmlReader.MoveToAttribute(int)"/></summary>
		public override void MoveToAttribute(int i) 
		{
			_current.MoveToAttribute(i);
		}

		/// <summary>See <see cref="XmlReader.MoveToContent"/></summary>
		public override XmlNodeType MoveToContent()
		{
			return base.MoveToContent();
		}
    
		/// <summary>See <see cref="XmlReader.MoveToElement"/></summary>
		public override bool MoveToElement() 
		{
			return _current.MoveToElement();
		}
    
		/// <summary>See <see cref="XmlReader.MoveToFirstAttribute"/></summary>
		public override bool MoveToFirstAttribute() 
		{
			return _current.MoveToFirstAttribute();
		}
    
		/// <summary>See <see cref="XmlReader.MoveToNextAttribute"/></summary>
		public override bool MoveToNextAttribute() 
		{
			return _current.MoveToNextAttribute();
		}
    
		/// <summary>See <see cref="XmlReader.Read"/></summary>
		public override bool Read() 
		{
			// Return fast if state is no appropriate.
			if (_current.ReadState == ReadState.Closed || _current.ReadState == ReadState.EndOfFile)
				return false;

			bool read = _current.Read();
			if (!read)
			{
				read = _iterator.MoveNext();
				if (read)
				{
					// Just move to the next node and create the reader.
          _current = _iterator.Current.ReadSubtree();
					return _current.Read();
				}
				else
				{
					if (_current is FakedRootReader && _current.NodeType == XmlNodeType.EndElement)
					{
						// We're done!
						return false;
					}
					else
					{
						// We read all nodes in the iterator. Return to faked root end element.
						_current = new FakedRootReader(_rootname.Name, _rootname.Namespace, XmlNodeType.EndElement);
						return true;
					}
				}
			}

			return read;
		}
    
		/// <summary>See <see cref="XmlReader.ReadAttributeValue"/></summary>
		public override bool ReadAttributeValue() 
		{
			return _current.ReadAttributeValue();
		} 

		/// <summary>See <see cref="XmlReader.ReadInnerXml"/></summary>
		public override string ReadInnerXml()
		{
			if (this.Read()) return Serialize();			
			return String.Empty;
		}

		/// <summary>See <see cref="XmlReader.ReadOuterXml"/></summary>
		public override string ReadOuterXml()
		{
			if (_current.ReadState != ReadState.Interactive) return String.Empty;
			return Serialize();
		}
    
		/// <summary>See <see cref="XmlReader.Read"/></summary>
		public override void ResolveEntity() 
		{
			// Not supported.
		}

		#endregion Methods

		#region IXmlSerializable Members

		/// <summary>
		/// See <see cref="IXmlSerializable.WriteXml"/>.
		/// </summary>
		public void WriteXml(XmlWriter writer)
		{
			writer.WriteNode(this, false);
		}

		/// <summary>
		/// See <see cref="IXmlSerializable.GetSchema"/>.
		/// </summary>
		public System.Xml.Schema.XmlSchema GetSchema()
		{
			return null;
		}

		/// <summary>
		/// See <see cref="IXmlSerializable.ReadXml"/>.
		/// </summary>
		public void ReadXml(XmlReader reader)
		{
			XPathDocument doc = new XPathDocument(reader);
			XPathNavigator nav = doc.CreateNavigator();

			// Pull the faked root out.
			nav.MoveToFirstChild();
			_rootname = new XmlQualifiedName(nav.LocalName, nav.NamespaceURI);

			// Get iterator for all child nodes.
			_iterator = nav.SelectChildren(XPathNodeType.All);
		}

		#endregion

		#region Internal Classes

		#region FakedRootReader

		private class FakedRootReader : XmlReader
		{
			public FakedRootReader(string name, string ns, 
				XmlNodeType nodeType)
			{
				_name = name;
				_namespace = ns;
				_nodetype = nodeType;
				_state = nodeType == XmlNodeType.Element ? 
					ReadState.Initial : ReadState.Interactive;
			}

			#region Properties

			/// <summary>See <see cref="XmlReader.AttributeCount"/></summary>
			public override int AttributeCount 
			{
				get { return 0; }
			} 
    
			/// <summary>See <see cref="XmlReader.BaseURI"/></summary>
			public override string BaseURI 
			{
				get { return String.Empty; }
			}
    
			/// <summary>See <see cref="XmlReader.Depth"/></summary>
			public override int Depth 
			{
				// Undo the depth increment of the outer reader.
				get { return -1; }
			} 
    
			/// <summary>See <see cref="XmlReader.EOF"/></summary>
			public override bool EOF 
			{
				get { return _state == ReadState.EndOfFile; }
			} 
    
			/// <summary>See <see cref="XmlReader.HasValue"/></summary>
			public override bool HasValue 
			{
				get { return false; }
			}
    
			/// <summary>See <see cref="XmlReader.IsDefault"/></summary>
			public override bool IsDefault 
			{
				get { return false; }
			}
    
			/// <summary>See <see cref="XmlReader.IsDefault"/></summary>
			public override bool IsEmptyElement 
			{
				get { return false; }
			}

      /// <summary>See <see cref="XmlReader.this[string, string]"/></summary>
			public override string this[string name, string ns] 
			{
				get { return null; }
			}
    
			/// <summary>See <see cref="XmlReader.this[string]"/></summary>
			public override string this[string name] 
			{
				get { return null; }
			}
    
			/// <summary>See <see cref="XmlReader.this[string]"/></summary>
			public override string this[int i] 
			{
				get { return null; }
			} 
    
			/// <summary>See <see cref="XmlReader.LocalName"/></summary>
			public override string LocalName 
			{
				get { return _name; }
			} string _name;
    
			/// <summary>See <see cref="XmlReader.Name"/></summary>
			public override string Name 
			{
				get { return _name; }
			}
    
			/// <summary>See <see cref="XmlReader.NamespaceURI"/></summary>
			public override string NamespaceURI 
			{
				get { return _namespace; }
			} string _namespace;
    
			/// <summary>See <see cref="XmlReader.NameTable"/></summary>
			public override XmlNameTable NameTable 
			{
				get { return null; }
			} 
    
			/// <summary>See <see cref="XmlReader.NodeType"/></summary>
			public override XmlNodeType NodeType 
			{
				get { return _state == ReadState.Initial ? XmlNodeType.None : _nodetype; }
			} XmlNodeType _nodetype;

			/// <summary>See <see cref="XmlReader.Prefix"/></summary>
			public override string Prefix 
			{
				get { return String.Empty; }
			}
    
			/// <summary>See <see cref="XmlReader.QuoteChar"/></summary>
			public override char QuoteChar 
			{
				get { return '"'; }
			}
    
			/// <summary>See <see cref="XmlReader.ReadState"/></summary>
			public override ReadState ReadState 
			{
				get { return _state; }
			} ReadState _state;
    
			/// <summary>See <see cref="XmlReader.Value"/></summary>
			public override string Value 
			{
				get { return String.Empty; }
			}
    
			/// <summary>See <see cref="XmlReader.XmlLang"/></summary>
			public override string XmlLang 
			{
				get { return String.Empty; }
			}
    
			/// <summary>See <see cref="XmlReader.XmlSpace"/></summary>
			public override XmlSpace XmlSpace 
			{
				get { return XmlSpace.Default; }
			}

			#endregion Properties 

			#region Methods

			/// <summary>See <see cref="XmlReader.Close"/></summary>
			public override void Close() 
			{
				_state = ReadState.Closed;
			}
    
			/// <summary>See <see cref="XmlReader.GetAttribute(string, string)"/></summary>
			public override string GetAttribute(string name, string ns) 
			{
				return null;
			}
    
			/// <summary>See <see cref="XmlReader.GetAttribute(string)"/></summary>
			public override string GetAttribute(string name) 
			{
				return null;
			}
    
			/// <summary>See <see cref="XmlReader.GetAttribute(int)"/></summary>
			public override string GetAttribute(int i) 
			{
				return null;
			}
    
			/// <summary>See <see cref="XmlReader.LookupNamespace"/></summary>
			public override string LookupNamespace(string prefix) 
			{
				return null;
			}
    
			/// <summary>See <see cref="XmlReader.MoveToAttribute(string, string)"/></summary>
			public override bool MoveToAttribute(string name, string ns) 
			{
				return false;
			}
    
			/// <summary>See <see cref="XmlReader.MoveToAttribute(string)"/></summary>
			public override bool MoveToAttribute(string name) 
			{
				return false;
			}
    
			/// <summary>See <see cref="XmlReader.MoveToAttribute(int)"/></summary>
			public override void MoveToAttribute(int i) 
			{
			}

			public override XmlNodeType MoveToContent()
			{
				if (_state == ReadState.Initial)
					_state = ReadState.Interactive;
				return _nodetype;
			}

    
			/// <summary>See <see cref="XmlReader.MoveToElement"/></summary>
			public override bool MoveToElement() 
			{
				return false;
			}
    
			/// <summary>See <see cref="XmlReader.MoveToFirstAttribute"/></summary>
			public override bool MoveToFirstAttribute() 
			{
				return false;
			}
    
			/// <summary>See <see cref="XmlReader.MoveToNextAttribute"/></summary>
			public override bool MoveToNextAttribute() 
			{
				return false;
			}
    
			/// <summary>See <see cref="XmlReader.Read"/></summary>
			public override bool Read() 
			{
				if (_state == ReadState.Initial)
				{
					_state = ReadState.Interactive;
					return true;
				}
				if (_state == ReadState.Interactive && _nodetype == XmlNodeType.EndElement)
				{
					_state = ReadState.EndOfFile;
					return false;
				}

				return false;
			}
    
			/// <summary>See <see cref="XmlReader.ReadAttributeValue"/></summary>
			public override bool ReadAttributeValue() 
			{
				return false;
			} 

			/// <summary>See <see cref="XmlReader.ReadInnerXml"/></summary>
			public override string ReadInnerXml()
			{
				return String.Empty;
			}

			/// <summary>See <see cref="XmlReader.ReadOuterXml"/></summary>
			public override string ReadOuterXml()
			{
				return String.Empty;
			}
    
			/// <summary>See <see cref="XmlReader.Read"/></summary>
			public override void ResolveEntity() 
			{
				// Not supported.
			}

			#endregion Methods
		}

		#endregion FakedRootReader 

		#endregion Internal Classes
	}
}

--- NEW FILE: IndexingXPathNavigator.cs ---
#region using

using System;
using System.Collections.Generic;
using System.Xml;
using System.Xml.XPath;
using System.Xml.Xsl;
using System.Reflection;

#endregion using

namespace Mvp.Xml.Common.XPath
{
	/// <summary>	
	/// IndexingXPathNavigator enables lazy or eager indexing of any XML store
	/// (XmlDocument, XPathDocument or any other IXPathNavigable store) thus
	/// providing alternative way to select nodes directly from built index table 
	/// and not searhing the tree. This allows drastically decrease selection time
	/// on preindexed selections.
	/// </summary>
	/// <remarks>Author: Oleg Tkachenko, ol...@tk...
	/// Contributors: Daniel Cazzulino, kz...@gm...
	/// <para>See http://www.tkachenko.com/blog/archives/000194.html</para>
	/// </remarks>
	public class IndexingXPathNavigator : XPathNavigator
	{
		#region Fields & Ctor

		private XPathNavigator nav;
		private XPathNavigatorIndexManager manager;    

		/// <summary>
		/// Creates IndexingXPathNavigator over specified XPathNavigator.
		/// </summary>
		/// <param name="navigator">Core XPathNavigator</param>
		public IndexingXPathNavigator(XPathNavigator navigator)
		{
			this.nav = navigator;      
			manager = new XPathNavigatorIndexManager();
		} 

		#endregion Fields & Ctor

		#region Public Methods

		/// <summary>
		/// Builds indexes according to defined keys.
		/// </summary>
		public void BuildIndexes() 
		{
			manager.BuildIndexes();
		}

		/// <summary>
		/// Adds named key for use with key() function.
		/// </summary>
		/// <param name="keyName">The name of the key</param>
		/// <param name="match">XPath pattern, defining the nodes to which 
		/// this key is applicable</param>
		/// <param name="use">XPath expression used to determine 
		/// the value of the key for each matching node</param>
		public virtual void AddKey(string keyName, string match, string use) 
		{      
			KeyDef key = new KeyDef(nav, match, use);      
			manager.AddKey(nav, keyName, key);
		}

		#endregion Public Methods

		#region Important Overrides
    
		/// <summary>
		/// Compiles XPath expressions using base XPathNavigator.Compile()
		/// method and set IndexingXsltContext instance to the result of 
		/// the compilation so compiled expressions support key() extension
		/// function.
		/// </summary>
		/// <param name="xpath">XPath expression to complile</param>
		/// <returns>Compiled XPath expression with augmented context 
		/// to support key() extension function</returns>
		public override XPathExpression Compile(string xpath) 
		{
			XPathExpression expr = base.Compile(xpath);       
			expr.SetContext(new IndexingXsltContext(manager, nav.NameTable));
			return expr;
		}

		/// <summary>
		/// Selects a node set using the specified XPath expression.
		/// </summary>
		/// <param name="xpath">A string representing an XPath expression</param>
		/// <returns>An XPathNodeIterator pointing to the selected node set</returns>
		public override XPathNodeIterator Select(string xpath)
		{
			XPathExpression expr = Compile(xpath);
			return base.Select(expr);
		}

		/// <summary>
		/// Creates new cloned version of the IndexingXPathNavigator.
		/// </summary>
		/// <returns>Cloned copy of the IndexingXPathNavigator</returns>
		public override XPathNavigator Clone() 
		{
			return new IndexingXPathNavigator(nav.Clone());
		}

		#endregion Important Overrides

		#region XPathNavigator dummy overrides
		
		/// <summary>
		/// See <see cref="XPathNavigator.NodeType"/>.
		/// </summary>
		public override XPathNodeType NodeType 
		{ 
			get { return nav.NodeType; }
		}

		/// <summary>
		/// See <see cref="XPathNavigator.LocalName"/>.
		/// </summary>
		public override string LocalName 
		{         
			get { return nav.LocalName; }
		}

		/// <summary>
		/// See <see cref="XPathNavigator.Name"/>.
		/// </summary>
		public override string Name 
		{ 
			get { return nav.Name; }
		}
		
		/// <summary>
		/// See <see cref="XPathNavigator.NamespaceURI"/>.
		/// </summary>
		public...
 
[truncated message content]