mono/mcs/class/System.ServiceModel/Mono.Xml.XPath/DTMXPathNavigator2.cs

//
// Mono.Xml.XPath.DTMXPathNavigator2
//
// Author:
//	Atsushi Enomoto <[email protected]>
//
// (C) 2004 Novell Inc.
//

//
// 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.
//
using System;
using System.Collections;
using System.Text;
using System.Xml;
using System.Xml.Schema;
using System.Xml.XPath;
using System.ServiceModel.Dispatcher;

namespace Mono.Xml.XPath
{
#if OUTSIDE_SYSTEM_XML
	public
#else
	internal
#endif
		class SeekableDTMXPathNavigator2 : SeekableXPathNavigator, IXmlLineInfo
	{

		public SeekableDTMXPathNavigator2 (DTMXPathDocument2 document)
		{
			this.MoveToRoot ();
			this.document = document;
		}

		// Copy constructor including position informations.
		public SeekableDTMXPathNavigator2 (SeekableDTMXPathNavigator2 org)
		{
			document = org.document;
			currentIsNode = org.currentIsNode;
			currentIsAttr = org.currentIsAttr;

			currentNode = org.currentNode;
			currentAttr = org.currentAttr;
			currentNs = org.currentNs;
		}

		#region SeekableXPathNavigator members

		public override long CurrentPosition {
			get { return currentIsNode ? currentNode : currentIsAttr ? nodes.Length + currentAttr : nodes.Length + attributes.Length + currentNs; }
			set {
				int pos = (int) value;
				if (pos < nodes.Length) {
					currentIsAttr = false;
					currentIsNode = true;
					currentNode = pos;
				} else if (pos < nodes.Length + attributes.Length) {
					currentIsAttr = true;
					currentIsNode = false;
					currentAttr = pos - nodes.Length;
				} else if (pos < nodes.Length + attributes.Length + namespaces.Length) {
					currentIsAttr = false;
					currentIsNode = false;
					currentNs = pos - nodes.Length - attributes.Length;
				} else
					throw new ArgumentOutOfRangeException ();
			}
		}

		public override XPathNodeType GetNodeType (long nodePosition)
		{
			return
				nodePosition < nodes.Length ? nodes [nodePosition].NodeType :
				nodePosition < nodes.Length + attributes.Length ? XPathNodeType.Attribute :
				XPathNodeType.Namespace;
		}

		public override string GetLocalName (long nodePosition)
		{
			switch (GetNodeType (nodePosition)) {
			case XPathNodeType.Namespace:
				return atomicStringPool [namespaces [nodePosition - nodes.Length - attributes.Length].Name];
			case XPathNodeType.Attribute:
				return atomicStringPool [attributes [nodePosition - nodes.Length].LocalName];
			default:
				return atomicStringPool [nodes [nodePosition].LocalName];
			}
		}

		public override string GetName (long nodePosition)
		{
			switch (GetNodeType (nodePosition)) {
			case XPathNodeType.Namespace:
				return atomicStringPool [namespaces [nodePosition - nodes.Length - attributes.Length].Name];
			case XPathNodeType.Attribute:
				return atomicStringPool [attributes [nodePosition - nodes.Length].LocalName];
			default:
				return atomicStringPool [nodes [nodePosition].LocalName];
			}
		}

		public override string GetNamespace (long nodePosition)
		{
			switch (GetNodeType (nodePosition)) {
			case XPathNodeType.Namespace:
				return atomicStringPool [namespaces [nodePosition - nodes.Length - attributes.Length].Namespace];
			case XPathNodeType.Attribute:
				return atomicStringPool [attributes [nodePosition - nodes.Length].NamespaceURI];
			default:
				return atomicStringPool [nodes [nodePosition].NamespaceURI];
			}
		}

		public override string GetValue (long nodePosition)
		{
			switch (GetNodeType (nodePosition)) {
			case XPathNodeType.Namespace:
				return atomicStringPool [namespaces [nodePosition - nodes.Length - attributes.Length].Namespace];
			case XPathNodeType.Attribute:
				return nonAtomicStringPool [attributes [nodePosition - nodes.Length].Value];
			default:
				return nonAtomicStringPool [nodes [nodePosition].Value];
			}
		}

		int GetOwnerPosition (long position)
		{
			int pos = (int) position;
			return pos < nodes.Length ? pos :
				pos < nodes.Length + attributes.Length ?
				attributes [(int) pos].OwnerElement :
				namespaces [(int) pos].DeclaredElement;
		}

		public override XmlNodeOrder ComparePosition (long firstPosition, long secondPosition)
		{
			if (firstPosition == secondPosition)
				return XmlNodeOrder.Same;

			int link1 = GetOwnerPosition (firstPosition);
			int link2 = GetOwnerPosition (secondPosition);
			if (link1 == link2)
				// on the same element. Comparison could be done numerically.
				return firstPosition < secondPosition ? XmlNodeOrder.Before :
					XmlNodeOrder.After;
			else
				// on different linked nodes.
				return link1 < link2 ?
					XmlNodeOrder.Before :
					XmlNodeOrder.After;
		}

		#endregion

		XmlNameTable nameTable {
			get { return document.NameTable; }
		}

		// Created XPathDocument. This is used to identify the origin of the navigator.
		DTMXPathDocument2 document;

		DTMXPathLinkedNode2 [] nodes {
			get { return document.Nodes; }
		}
		DTMXPathAttributeNode2 [] attributes {
			get { return document.Attributes; }
		}
		DTMXPathNamespaceNode2 [] namespaces {
			get { return document.Namespaces; }
		}
		string [] atomicStringPool {
			get { return document.AtomicStringPool; }
		}
		string [] nonAtomicStringPool {
			get { return document.NonAtomicStringPool; }
		}

		// ID table
		Hashtable idTable {
			get { return document.IdTable; }
		}

		bool currentIsNode;
		bool currentIsAttr;

		int currentNode;
		int currentAttr;
		int currentNs;

#region Properties

		public override string BaseURI {
			get { return atomicStringPool [nodes [currentNode].BaseURI]; }
		}

		public override bool HasAttributes {
			get { return currentIsNode ? nodes [currentNode].FirstAttribute != 0 : false; }
		}
		
		public override bool HasChildren {
			get { return currentIsNode ? nodes [currentNode].FirstChild != 0 : false; }
		}

		public override bool IsEmptyElement {
			get { return currentIsNode ? nodes [currentNode].IsEmptyElement : false; }
		}

		int IXmlLineInfo.LineNumber {
			get {
				return currentIsAttr ? attributes [currentAttr].LineNumber :
					nodes [currentNode].LineNumber;
			}
		}

		int IXmlLineInfo.LinePosition {
			get {
				return currentIsAttr ? attributes [currentAttr].LinePosition :
					nodes [currentNode].LinePosition;
			}
		}

		public override string LocalName {
			get {
				if (currentIsNode)
					return atomicStringPool [nodes [currentNode].LocalName];
				else if (currentIsAttr)
					return atomicStringPool [attributes [currentAttr].LocalName];
				else
					return atomicStringPool [namespaces [currentNs].Name];
			}
		}

		// It maybe scarcely used, so I decided to compute it always.
		public override string Name {
			get {
				string prefix;
				string localName;
				if (currentIsNode) {
					prefix = atomicStringPool [nodes [currentNode].Prefix];
					localName = atomicStringPool [nodes [currentNode].LocalName];
				} else if (currentIsAttr) {
					prefix = atomicStringPool [attributes [currentAttr].Prefix];
					localName = atomicStringPool [attributes [currentAttr].LocalName];
				} else
					return atomicStringPool [namespaces [currentNs].Name];

				if (prefix != "")
					return prefix + ':' + localName;
				else
					return localName;
			}
		}

		public override string NamespaceURI {
			get {
				if (currentIsNode)
					return atomicStringPool [nodes [currentNode].NamespaceURI];
				if (currentIsAttr)
					return atomicStringPool [attributes [currentAttr].NamespaceURI];
				return String.Empty;
			}
		}

		public override XmlNameTable NameTable {
			get { return nameTable; }
		}

		public override XPathNodeType NodeType {
			get {
				if (currentIsNode)
					return nodes [currentNode].NodeType;
				else if (currentIsAttr)
					return XPathNodeType.Attribute;
				else
					return XPathNodeType.Namespace;
			}
		}

		public override string Prefix {
			get {
				if (currentIsNode)
					return atomicStringPool [nodes [currentNode].Prefix];
				else if (currentIsAttr)
					return atomicStringPool [attributes [currentAttr].Prefix];
				return String.Empty;
			}
		}

		public override string Value {
			get {
				if (currentIsAttr)
					return nonAtomicStringPool [attributes [currentAttr].Value];
				else if (!currentIsNode)
					return atomicStringPool [namespaces [currentNs].Namespace];
				
				switch (nodes [currentNode].NodeType) {
				case XPathNodeType.Comment:
				case XPathNodeType.ProcessingInstruction:
				case XPathNodeType.Text:
				case XPathNodeType.Whitespace:
				case XPathNodeType.SignificantWhitespace:
					return nonAtomicStringPool [nodes [currentNode].Value];
				}

				// Element - collect all content values
				int iter = nodes [currentNode].FirstChild;
				if (iter == 0)
					return String.Empty;

				StringBuilder builder = null;
				BuildValue (iter, ref builder);
				return builder == null ? String.Empty : builder.ToString ();
			}
		}

		void BuildValue (int iter, ref StringBuilder valueBuilder)
		{
			int end = nodes [currentNode].NextSibling;
			if (end == 0) {
				int tmp = currentNode;
				do {
					tmp = nodes [tmp].Parent;
					end = nodes [tmp].NextSibling;
				} while (end == 0 && tmp != 0);
				if (end == 0)
					end = nodes.Length;
			}

			while (iter < end) {
				switch (nodes [iter].NodeType) {
				case XPathNodeType.Text:
				case XPathNodeType.SignificantWhitespace:
				case XPathNodeType.Whitespace:
					if (valueBuilder == null)
						valueBuilder = new StringBuilder ();
					valueBuilder.Append (nonAtomicStringPool [nodes [iter].Value]);
					break;
				}
				iter++;
			}
		}

		public override string XmlLang {
			get { return atomicStringPool [nodes [currentNode].XmlLang]; }
		}

#endregion

#region Methods

		public override XPathNavigator Clone ()
		{
			return new SeekableDTMXPathNavigator2 (this);
		}

		public override XmlNodeOrder ComparePosition (XPathNavigator nav)
		{
			SeekableDTMXPathNavigator2 another = nav as SeekableDTMXPathNavigator2;

			if (another == null || another.document != this.document)
				return XmlNodeOrder.Unknown;

			if (currentNode > another.currentNode)
				return XmlNodeOrder.After;
			else if (currentNode < another.currentNode)
				return XmlNodeOrder.Before;

			// another may attr or ns, 
			// and this may be also attr or ns.
			if (another.currentIsAttr) {
				if (this.currentIsAttr) {
					if (currentAttr > another.currentAttr)
						return XmlNodeOrder.After;
					else if (currentAttr < another.currentAttr)
						return XmlNodeOrder.Before;
					else
						return XmlNodeOrder.Same;
				} else
					return XmlNodeOrder.Before;
			} else if (!another.currentIsNode) {
				if (!this.currentIsNode) {
					if (currentNs > another.currentNs)
						return XmlNodeOrder.After;
					else if (currentNs < another.currentNs)
						return XmlNodeOrder.Before;
					else
						return XmlNodeOrder.Same;
				} else
					return XmlNodeOrder.Before;
			} else
				return !another.currentIsNode ? XmlNodeOrder.Before : XmlNodeOrder.Same;
		}

		private int findAttribute (string localName, string namespaceURI)
		{
			if (currentIsNode && nodes [currentNode].NodeType == XPathNodeType.Element) {
				int cur = nodes [currentNode].FirstAttribute;
				while (cur != 0) {
					if (atomicStringPool [attributes [cur].LocalName] == localName && atomicStringPool [attributes [cur].NamespaceURI] == namespaceURI)
						return cur;
					cur = attributes [cur].NextAttribute;
				}
			}
			return 0;
		}

		public override string GetAttribute (string localName,
			string namespaceURI)
		{
			int attr = findAttribute (localName, namespaceURI);
			return (attr != 0) ? nonAtomicStringPool [attributes [attr].Value] : String.Empty;
		}

		public override string GetNamespace (string name)
		{
			if (currentIsNode && nodes [currentNode].NodeType == XPathNodeType.Element) {
				int nsNode = nodes [currentNode].FirstNamespace;
				while (nsNode != 0) {
					if (atomicStringPool [namespaces [nsNode].Name] == name)
						return atomicStringPool [namespaces [nsNode].Namespace];
					nsNode = namespaces [nsNode].NextNamespace;
				}
			}
			return String.Empty;
		}

		bool IXmlLineInfo.HasLineInfo ()
		{
			return true;
		}

		public override bool IsDescendant (XPathNavigator nav)
		{
			SeekableDTMXPathNavigator2 another = nav as SeekableDTMXPathNavigator2;

			if (another == null || another.document != this.document)
				return false;

			if (another.currentNode == currentNode)
				return !another.currentIsNode;
			int tmp = nodes [another.currentNode].Parent;

			// ancestors must appear in prior on the node list.
			if (tmp < currentNode)
				return false;

			while (tmp != 0) {
				if (tmp == currentNode)
					return true;
				tmp = nodes [tmp].Parent;
			}
			return false;
		}

		public override bool IsSamePosition (XPathNavigator other)
		{
			SeekableDTMXPathNavigator2 another = other as SeekableDTMXPathNavigator2;

			if (another == null || another.document != this.document)
				return false;

			if (this.currentNode != another.currentNode ||
				this.currentIsAttr != another.currentIsAttr ||
				this.currentIsNode != another.currentIsNode)
				return false;

			if (currentIsAttr)
				return this.currentAttr == another.currentAttr;
			else if (!currentIsNode)
				return this.currentNs == another.currentNs;
			return true;
		}

		public override bool MoveTo (XPathNavigator other)
		{
			SeekableDTMXPathNavigator2 another = other as SeekableDTMXPathNavigator2;

			if (another == null || another.document != this.document)
				return false;

			this.currentNode = another.currentNode;
			this.currentAttr = another.currentAttr;
			this.currentNs = another.currentNs;
			this.currentIsNode = another.currentIsNode;
			this.currentIsAttr = another.currentIsAttr;
			return true;
		}

		public override bool MoveToAttribute (string localName,
			string namespaceURI)
		{
			int attr = findAttribute (localName, namespaceURI);
			if (attr == 0)
				return false;

			currentAttr = attr;
			currentIsAttr = true;
			currentIsNode = false;
			return true;
		}

		public override bool MoveToFirst ()
		{
			if (currentIsAttr)
				return false;

			int cur = nodes [currentNode].PreviousSibling;
			if (cur == 0)
				return false;

			cur = nodes [cur].Parent;
			cur = nodes [cur].FirstChild;
			currentNode = cur;
			currentIsNode = true;
			return true;
		}

		public override bool MoveToFirstAttribute ()
		{
			if (!currentIsNode)
				return false;

			int first = nodes [currentNode].FirstAttribute;
			if (first == 0)
				return false;

			currentAttr = first;
			currentIsAttr = true;
			currentIsNode = false;
			return true;
		}

		public override bool MoveToFirstChild ()
		{
			if (!currentIsNode)
				return false;

			int first = nodes [currentNode].FirstChild;
			if (first == 0)
				return false;

			currentNode = first;
			return true;
		}
		
		private bool moveToSpecifiedNamespace (int cur,
			XPathNamespaceScope namespaceScope)
		{
			if (cur == 0)
				return false;

			if (namespaceScope == XPathNamespaceScope.Local &&
					namespaces [cur].DeclaredElement != currentNode)
				return false;

			if (namespaceScope != XPathNamespaceScope.All
				&& namespaces [cur].Namespace == XmlNamespaces.IndexXML)
				return false;

			if (cur != 0) {
				moveToNamespace (cur);
				return true;
			}
			else
				return false;
		}

		public override bool MoveToFirstNamespace (
			XPathNamespaceScope namespaceScope)
		{
			if (!currentIsNode)
				return false;
			int cur = nodes [currentNode].FirstNamespace;
			return moveToSpecifiedNamespace (cur, namespaceScope);
		}

		// Note that this support is extension to XPathDocument.
		// XPathDocument does not support ID reference.
		public override bool MoveToId (string id)
		{
			if (idTable.ContainsKey (id)) {
				currentNode = (int) idTable [id];
				currentIsNode = true;
				currentIsAttr = false;
				return true;
			}
			else
				return false;
		}

		private void moveToNamespace (int nsNode)
		{
			currentIsNode = currentIsAttr = false;
			currentNs = nsNode;
		}

		public override bool MoveToNamespace (string name)
		{
			int cur = nodes [currentNode].FirstNamespace;
			if (cur == 0)
				return false;

			while (cur != 0) {
				if (atomicStringPool [namespaces [cur].Name] == name) {
					moveToNamespace (cur);
					return true;
				}
				cur = namespaces [cur].NextNamespace;
			}
			return false;
		}

		public override bool MoveToNext ()
		{
			if (currentIsAttr)
				return false;

			int next = nodes [currentNode].NextSibling;
			if (next == 0)
				return false;
			currentNode = next;
			currentIsNode = true;
			return true;
		}

		public override bool MoveToNextAttribute ()
		{
			if (!currentIsAttr)
				return false;

			int next = attributes [currentAttr].NextAttribute;
			if (next == 0)
				return false;
			currentAttr = next;
			return true;
		}

		public override bool MoveToNextNamespace (
			XPathNamespaceScope namespaceScope)
		{
			if (currentIsAttr || currentIsNode)
				return false;

			int cur = namespaces [currentNs].NextNamespace;
			return moveToSpecifiedNamespace (cur, namespaceScope);
		}

		public override bool MoveToParent ()
		{
			if (!currentIsNode) {
				currentIsNode = true;
				currentIsAttr = false;
				return true;
			}

			int parent = nodes [currentNode].Parent;
			if (parent == 0)	// It is root itself.
				return false;

			currentNode = parent;
			return true;
		}

		public override bool MoveToPrevious ()
		{
			if (currentIsAttr)
				return false;

			int previous = nodes [currentNode].PreviousSibling;
			if (previous == 0)
				return false;
			currentNode = previous;
			currentIsNode = true;
			return true;
		}

		public override void MoveToRoot ()
		{
			currentNode = 1;	// root is 1.
			currentIsNode = true;
			currentIsAttr = false;
		}

#endregion
	}

	class XmlNamespaces
	{
		public const string XML = "http://www.w3.org/XML/1998/namespace";
		public const string XMLNS = "http://www.w3.org/2000/xmlns/";
		public const int IndexXML = 2;
		public const int IndexXMLNS = 3;
	}
}