XPathNavigator.cs

using MS.Internal.Xml.XPath;
using System.Collections;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.IO;
using System.Text;
using System.Xml.Schema;

namespace System.Xml.XPath
{
    [DebuggerDisplay("{debuggerDisplayProxy}")]
    public abstract class XPathNavigator : XPathItem, ICloneable, IXPathNavigable, IXmlNamespaceResolver
    {
        private class CheckValidityHelper
        {
            private bool isValid;

            private ValidationEventHandler nextEventHandler;

            private XPathNavigatorReader reader;

            internal bool IsValid => isValid;

            internal CheckValidityHelper(ValidationEventHandler nextEventHandler, XPathNavigatorReader reader)
            {
                isValid = true;
                this.nextEventHandler = nextEventHandler;
                this.reader = reader;
            }

            internal void ValidationCallback(object sender, ValidationEventArgs args)
            {
                if (args.Severity == XmlSeverityType.Error)
                {
                    isValid = false;
                }
                XmlSchemaValidationException ex = args.Exception as XmlSchemaValidationException;
                if (ex != null && reader != null)
                {
                    ex.SetSourceObject(reader.UnderlyingObject);
                }
                if (nextEventHandler != null)
                {
                    nextEventHandler(sender, args);
                }
                else if (ex != null && args.Severity == XmlSeverityType.Error)
                {
                    throw ex;
                }
            }
        }

        [DebuggerDisplay("{ToString()}")]
        internal struct DebuggerDisplayProxy
        {
            private XPathNavigator nav;

            public DebuggerDisplayProxy(XPathNavigator nav)
            {
                this.nav = nav;
            }

            public override string ToString()
            {
                string text = nav.NodeType.ToString();
                switch (nav.NodeType)
                {
                case XPathNodeType.Element:
                    text = text + ", Name=\"" + nav.Name + "\"";
                    break;
                case XPathNodeType.Attribute:
                case XPathNodeType.Namespace:
                case XPathNodeType.ProcessingInstruction:
                    text = text + ", Name=\"" + nav.Name + "\"";
                    text = text + ", Value=\"" + XmlConvert.EscapeValueForDebuggerDisplay(nav.Value) + "\"";
                    break;
                case XPathNodeType.Text:
                case XPathNodeType.SignificantWhitespace:
                case XPathNodeType.Whitespace:
                case XPathNodeType.Comment:
                    text = text + ", Value=\"" + XmlConvert.EscapeValueForDebuggerDisplay(nav.Value) + "\"";
                    break;
                }
                return text;
            }
        }

        internal static readonly XPathNavigatorKeyComparer comparer = new XPathNavigatorKeyComparer();

        internal static readonly char[] NodeTypeLetter = new char[10]
        {
            'R',
            'E',
            'A',
            'N',
            'T',
            'S',
            'W',
            'P',
            'C',
            'X'
        };

        internal static readonly char[] UniqueIdTbl = new char[32]
        {
            'A',
            'B',
            'C',
            'D',
            'E',
            'F',
            'G',
            'H',
            'I',
            'J',
            'K',
            'L',
            'M',
            'N',
            'O',
            'P',
            'Q',
            'R',
            'S',
            'T',
            'U',
            'V',
            'W',
            'X',
            'Y',
            'Z',
            '1',
            '2',
            '3',
            '4',
            '5',
            '6'
        };

        internal const int AllMask = int.MaxValue;

        internal const int NoAttrNmspMask = 2147483635;

        internal const int TextMask = 112;

        internal static readonly int[] ContentKindMasks = new int[10]
        {
            1,
            2,
            0,
            0,
            112,
            32,
            64,
            128,
            256,
            2147483635
        };

        public sealed override bool IsNode => true;

        public override XmlSchemaType XmlType
        {
            get
            {
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null && schemaInfo.Validity == XmlSchemaValidity.Valid)
                {
                    XmlSchemaType memberType = schemaInfo.MemberType;
                    if (memberType != null)
                    {
                        return memberType;
                    }
                    return schemaInfo.SchemaType;
                }
                return null;
            }
        }

        public override object TypedValue
        {
            get
            {
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null)
                {
                    if (schemaInfo.Validity == XmlSchemaValidity.Valid)
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.MemberType;
                        if (xmlSchemaType == null)
                        {
                            xmlSchemaType = schemaInfo.SchemaType;
                        }
                        if (xmlSchemaType != null)
                        {
                            XmlSchemaDatatype datatype = xmlSchemaType.Datatype;
                            if (datatype != null)
                            {
                                return xmlSchemaType.ValueConverter.ChangeType(Value, datatype.ValueType, this);
                            }
                        }
                    }
                    else
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.SchemaType;
                        if (xmlSchemaType != null)
                        {
                            XmlSchemaDatatype datatype = xmlSchemaType.Datatype;
                            if (datatype != null)
                            {
                                return xmlSchemaType.ValueConverter.ChangeType(datatype.ParseValue(Value, NameTable, this), datatype.ValueType, this);
                            }
                        }
                    }
                }
                return Value;
            }
        }

        public override Type ValueType
        {
            get
            {
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null)
                {
                    if (schemaInfo.Validity == XmlSchemaValidity.Valid)
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.MemberType;
                        if (xmlSchemaType == null)
                        {
                            xmlSchemaType = schemaInfo.SchemaType;
                        }
                        if (xmlSchemaType != null)
                        {
                            XmlSchemaDatatype datatype = xmlSchemaType.Datatype;
                            if (datatype != null)
                            {
                                return datatype.ValueType;
                            }
                        }
                    }
                    else
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.SchemaType;
                        if (xmlSchemaType != null)
                        {
                            XmlSchemaDatatype datatype = xmlSchemaType.Datatype;
                            if (datatype != null)
                            {
                                return datatype.ValueType;
                            }
                        }
                    }
                }
                return typeof(string);
            }
        }

        public override bool ValueAsBoolean
        {
            get
            {
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null)
                {
                    if (schemaInfo.Validity == XmlSchemaValidity.Valid)
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.MemberType;
                        if (xmlSchemaType == null)
                        {
                            xmlSchemaType = schemaInfo.SchemaType;
                        }
                        if (xmlSchemaType != null)
                        {
                            return xmlSchemaType.ValueConverter.ToBoolean(Value);
                        }
                    }
                    else
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.SchemaType;
                        if (xmlSchemaType != null)
                        {
                            XmlSchemaDatatype datatype = xmlSchemaType.Datatype;
                            if (datatype != null)
                            {
                                return xmlSchemaType.ValueConverter.ToBoolean(datatype.ParseValue(Value, NameTable, this));
                            }
                        }
                    }
                }
                return XmlUntypedConverter.Untyped.ToBoolean(Value);
            }
        }

        public override DateTime ValueAsDateTime
        {
            get
            {
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null)
                {
                    if (schemaInfo.Validity == XmlSchemaValidity.Valid)
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.MemberType;
                        if (xmlSchemaType == null)
                        {
                            xmlSchemaType = schemaInfo.SchemaType;
                        }
                        if (xmlSchemaType != null)
                        {
                            return xmlSchemaType.ValueConverter.ToDateTime(Value);
                        }
                    }
                    else
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.SchemaType;
                        if (xmlSchemaType != null)
                        {
                            XmlSchemaDatatype datatype = xmlSchemaType.Datatype;
                            if (datatype != null)
                            {
                                return xmlSchemaType.ValueConverter.ToDateTime(datatype.ParseValue(Value, NameTable, this));
                            }
                        }
                    }
                }
                return XmlUntypedConverter.Untyped.ToDateTime(Value);
            }
        }

        public override double ValueAsDouble
        {
            get
            {
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null)
                {
                    if (schemaInfo.Validity == XmlSchemaValidity.Valid)
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.MemberType;
                        if (xmlSchemaType == null)
                        {
                            xmlSchemaType = schemaInfo.SchemaType;
                        }
                        if (xmlSchemaType != null)
                        {
                            return xmlSchemaType.ValueConverter.ToDouble(Value);
                        }
                    }
                    else
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.SchemaType;
                        if (xmlSchemaType != null)
                        {
                            XmlSchemaDatatype datatype = xmlSchemaType.Datatype;
                            if (datatype != null)
                            {
                                return xmlSchemaType.ValueConverter.ToDouble(datatype.ParseValue(Value, NameTable, this));
                            }
                        }
                    }
                }
                return XmlUntypedConverter.Untyped.ToDouble(Value);
            }
        }

        public override int ValueAsInt
        {
            get
            {
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null)
                {
                    if (schemaInfo.Validity == XmlSchemaValidity.Valid)
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.MemberType;
                        if (xmlSchemaType == null)
                        {
                            xmlSchemaType = schemaInfo.SchemaType;
                        }
                        if (xmlSchemaType != null)
                        {
                            return xmlSchemaType.ValueConverter.ToInt32(Value);
                        }
                    }
                    else
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.SchemaType;
                        if (xmlSchemaType != null)
                        {
                            XmlSchemaDatatype datatype = xmlSchemaType.Datatype;
                            if (datatype != null)
                            {
                                return xmlSchemaType.ValueConverter.ToInt32(datatype.ParseValue(Value, NameTable, this));
                            }
                        }
                    }
                }
                return XmlUntypedConverter.Untyped.ToInt32(Value);
            }
        }

        public override long ValueAsLong
        {
            get
            {
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null)
                {
                    if (schemaInfo.Validity == XmlSchemaValidity.Valid)
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.MemberType;
                        if (xmlSchemaType == null)
                        {
                            xmlSchemaType = schemaInfo.SchemaType;
                        }
                        if (xmlSchemaType != null)
                        {
                            return xmlSchemaType.ValueConverter.ToInt64(Value);
                        }
                    }
                    else
                    {
                        XmlSchemaType xmlSchemaType = schemaInfo.SchemaType;
                        if (xmlSchemaType != null)
                        {
                            XmlSchemaDatatype datatype = xmlSchemaType.Datatype;
                            if (datatype != null)
                            {
                                return xmlSchemaType.ValueConverter.ToInt64(datatype.ParseValue(Value, NameTable, this));
                            }
                        }
                    }
                }
                return XmlUntypedConverter.Untyped.ToInt64(Value);
            }
        }

        public abstract XmlNameTable NameTable
        {
            get;
        }

        public static IEqualityComparer NavigatorComparer => comparer;

        public abstract XPathNodeType NodeType
        {
            get;
        }

        public abstract string LocalName
        {
            get;
        }

        public abstract string Name
        {
            get;
        }

        public abstract string NamespaceURI
        {
            get;
        }

        public abstract string Prefix
        {
            get;
        }

        public abstract string BaseURI
        {
            get;
        }

        public abstract bool IsEmptyElement
        {
            get;
        }

        public virtual string XmlLang
        {
            get
            {
                XPathNavigator xPathNavigator = Clone();
                do
                {
                    if (xPathNavigator.MoveToAttribute("lang", "http://www.w3.org/XML/1998/namespace"))
                    {
                        return xPathNavigator.Value;
                    }
                }
                while (xPathNavigator.MoveToParent());
                return string.Empty;
            }
        }

        public virtual object UnderlyingObject => null;

        public virtual bool HasAttributes
        {
            get
            {
                if (!MoveToFirstAttribute())
                {
                    return false;
                }
                MoveToParent();
                return true;
            }
        }

        public virtual bool HasChildren
        {
            get
            {
                if (MoveToFirstChild())
                {
                    MoveToParent();
                    return true;
                }
                return false;
            }
        }

        public virtual IXmlSchemaInfo SchemaInfo => this as IXmlSchemaInfo;

        public virtual bool CanEdit => false;

        public virtual string OuterXml
        {
            get
            {
                if (NodeType == XPathNodeType.Attribute)
                {
                    return Name + "=\"" + Value + "\"";
                }
                if (NodeType == XPathNodeType.Namespace)
                {
                    if (LocalName.Length == 0)
                    {
                        return "xmlns=\"" + Value + "\"";
                    }
                    return "xmlns:" + LocalName + "=\"" + Value + "\"";
                }
                StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
                XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
                xmlWriterSettings.Indent = true;
                xmlWriterSettings.OmitXmlDeclaration = true;
                xmlWriterSettings.ConformanceLevel = ConformanceLevel.Auto;
                XmlWriter xmlWriter = XmlWriter.Create(stringWriter, xmlWriterSettings);
                try
                {
                    xmlWriter.WriteNode(this, defattr: true);
                }
                finally
                {
                    xmlWriter.Close();
                }
                return stringWriter.ToString();
            }
            set
            {
                ReplaceSelf(value);
            }
        }

        public virtual string InnerXml
        {
            get
            {
                switch (NodeType)
                {
                case XPathNodeType.Root:
                case XPathNodeType.Element:
                {
                    StringWriter stringWriter = new StringWriter(CultureInfo.InvariantCulture);
                    XmlWriterSettings xmlWriterSettings = new XmlWriterSettings();
                    xmlWriterSettings.Indent = true;
                    xmlWriterSettings.OmitXmlDeclaration = true;
                    xmlWriterSettings.ConformanceLevel = ConformanceLevel.Auto;
                    XmlWriter xmlWriter = XmlWriter.Create(stringWriter, xmlWriterSettings);
                    try
                    {
                        if (MoveToFirstChild())
                        {
                            do
                            {
                                xmlWriter.WriteNode(this, defattr: true);
                            }
                            while (MoveToNext());
                            MoveToParent();
                        }
                    }
                    finally
                    {
                        xmlWriter.Close();
                    }
                    return stringWriter.ToString();
                }
                case XPathNodeType.Attribute:
                case XPathNodeType.Namespace:
                    return Value;
                default:
                    return string.Empty;
                }
            }
            set
            {
                if (value == null)
                {
                    throw new ArgumentNullException("value");
                }
                switch (NodeType)
                {
                case XPathNodeType.Root:
                case XPathNodeType.Element:
                {
                    XPathNavigator xPathNavigator = CreateNavigator();
                    while (xPathNavigator.MoveToFirstChild())
                    {
                        xPathNavigator.DeleteSelf();
                    }
                    if (value.Length != 0)
                    {
                        xPathNavigator.AppendChild(value);
                    }
                    break;
                }
                case XPathNodeType.Attribute:
                    SetValue(value);
                    break;
                default:
                    throw new InvalidOperationException(Res.GetString("Xpn_BadPosition"));
                }
            }
        }

        internal uint IndexInParent
        {
            get
            {
                XPathNavigator xPathNavigator = Clone();
                uint num = 0u;
                XPathNodeType nodeType = NodeType;
                if (nodeType != XPathNodeType.Attribute)
                {
                    if (nodeType == XPathNodeType.Namespace)
                    {
                        while (xPathNavigator.MoveToNextNamespace())
                        {
                            num++;
                        }
                    }
                    else
                    {
                        while (xPathNavigator.MoveToNext())
                        {
                            num++;
                        }
                    }
                }
                else
                {
                    while (xPathNavigator.MoveToNextAttribute())
                    {
                        num++;
                    }
                }
                return num;
            }
        }

        internal virtual string UniqueId
        {
            get
            {
                XPathNavigator xPathNavigator = Clone();
                StringBuilder stringBuilder = new StringBuilder();
                stringBuilder.Append(NodeTypeLetter[(int)NodeType]);
                while (true)
                {
                    uint num = xPathNavigator.IndexInParent;
                    if (!xPathNavigator.MoveToParent())
                    {
                        break;
                    }
                    if (num <= 31)
                    {
                        stringBuilder.Append(UniqueIdTbl[num]);
                        continue;
                    }
                    stringBuilder.Append('0');
                    do
                    {
                        stringBuilder.Append(UniqueIdTbl[num & 0x1F]);
                        num >>= 5;
                    }
                    while (num != 0);
                    stringBuilder.Append('0');
                }
                return stringBuilder.ToString();
            }
        }

        private object debuggerDisplayProxy => new DebuggerDisplayProxy(this);

        public override string ToString()
        {
            return Value;
        }

        public virtual void SetValue(string value)
        {
            throw new NotSupportedException();
        }

        public virtual void SetTypedValue(object typedValue)
        {
            if (typedValue == null)
            {
                throw new ArgumentNullException("typedValue");
            }
            XPathNodeType nodeType = NodeType;
            if (nodeType != XPathNodeType.Element && nodeType != XPathNodeType.Attribute)
            {
                throw new InvalidOperationException(Res.GetString("Xpn_BadPosition"));
            }
            string text = null;
            IXmlSchemaInfo schemaInfo = SchemaInfo;
            if (schemaInfo != null)
            {
                XmlSchemaType schemaType = schemaInfo.SchemaType;
                if (schemaType != null)
                {
                    text = schemaType.ValueConverter.ToString(typedValue, this);
                    schemaType.Datatype?.ParseValue(text, NameTable, this);
                }
            }
            if (text == null)
            {
                text = XmlUntypedConverter.Untyped.ToString(typedValue, this);
            }
            SetValue(text);
        }

        public override object ValueAs(Type returnType, IXmlNamespaceResolver nsResolver)
        {
            if (nsResolver == null)
            {
                nsResolver = this;
            }
            IXmlSchemaInfo schemaInfo = SchemaInfo;
            if (schemaInfo != null)
            {
                if (schemaInfo.Validity == XmlSchemaValidity.Valid)
                {
                    XmlSchemaType xmlSchemaType = schemaInfo.MemberType;
                    if (xmlSchemaType == null)
                    {
                        xmlSchemaType = schemaInfo.SchemaType;
                    }
                    if (xmlSchemaType != null)
                    {
                        return xmlSchemaType.ValueConverter.ChangeType(Value, returnType, nsResolver);
                    }
                }
                else
                {
                    XmlSchemaType xmlSchemaType = schemaInfo.SchemaType;
                    if (xmlSchemaType != null)
                    {
                        XmlSchemaDatatype datatype = xmlSchemaType.Datatype;
                        if (datatype != null)
                        {
                            return xmlSchemaType.ValueConverter.ChangeType(datatype.ParseValue(Value, NameTable, nsResolver), returnType, nsResolver);
                        }
                    }
                }
            }
            return XmlUntypedConverter.Untyped.ChangeType(Value, returnType, nsResolver);
        }

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

        public virtual XPathNavigator CreateNavigator()
        {
            return Clone();
        }

        public virtual string LookupNamespace(string prefix)
        {
            if (prefix == null)
            {
                return null;
            }
            if (NodeType != XPathNodeType.Element)
            {
                XPathNavigator xPathNavigator = Clone();
                if (xPathNavigator.MoveToParent())
                {
                    return xPathNavigator.LookupNamespace(prefix);
                }
            }
            else if (MoveToNamespace(prefix))
            {
                string value = Value;
                MoveToParent();
                return value;
            }
            if (prefix.Length == 0)
            {
                return string.Empty;
            }
            if (prefix == "xml")
            {
                return "http://www.w3.org/XML/1998/namespace";
            }
            if (prefix == "xmlns")
            {
                return "http://www.w3.org/2000/xmlns/";
            }
            return null;
        }

        public virtual string LookupPrefix(string namespaceURI)
        {
            if (namespaceURI == null)
            {
                return null;
            }
            XPathNavigator xPathNavigator = Clone();
            if (NodeType != XPathNodeType.Element)
            {
                if (xPathNavigator.MoveToParent())
                {
                    return xPathNavigator.LookupPrefix(namespaceURI);
                }
            }
            else if (xPathNavigator.MoveToFirstNamespace(XPathNamespaceScope.All))
            {
                do
                {
                    if (namespaceURI == xPathNavigator.Value)
                    {
                        return xPathNavigator.LocalName;
                    }
                }
                while (xPathNavigator.MoveToNextNamespace(XPathNamespaceScope.All));
            }
            if (namespaceURI == LookupNamespace(string.Empty))
            {
                return string.Empty;
            }
            if (namespaceURI == "http://www.w3.org/XML/1998/namespace")
            {
                return "xml";
            }
            if (namespaceURI == "http://www.w3.org/2000/xmlns/")
            {
                return "xmlns";
            }
            return null;
        }

        public virtual IDictionary<string, string> GetNamespacesInScope(XmlNamespaceScope scope)
        {
            XPathNodeType nodeType = NodeType;
            if ((nodeType != XPathNodeType.Element && scope != XmlNamespaceScope.Local) || nodeType == XPathNodeType.Attribute || nodeType == XPathNodeType.Namespace)
            {
                XPathNavigator xPathNavigator = Clone();
                if (xPathNavigator.MoveToParent())
                {
                    return xPathNavigator.GetNamespacesInScope(scope);
                }
            }
            Dictionary<string, string> dictionary = new Dictionary<string, string>();
            if (scope == XmlNamespaceScope.All)
            {
                dictionary["xml"] = "http://www.w3.org/XML/1998/namespace";
            }
            if (MoveToFirstNamespace((XPathNamespaceScope)scope))
            {
                do
                {
                    string localName = LocalName;
                    string value = Value;
                    if (localName.Length != 0 || value.Length != 0 || scope == XmlNamespaceScope.Local)
                    {
                        dictionary[localName] = value;
                    }
                }
                while (MoveToNextNamespace((XPathNamespaceScope)scope));
                MoveToParent();
            }
            return dictionary;
        }

        public abstract XPathNavigator Clone();

        public virtual XmlReader ReadSubtree()
        {
            XPathNodeType nodeType = NodeType;
            if (nodeType != 0 && nodeType != XPathNodeType.Element)
            {
                throw new InvalidOperationException(Res.GetString("Xpn_BadPosition"));
            }
            return CreateReader();
        }

        public virtual void WriteSubtree(XmlWriter writer)
        {
            if (writer == null)
            {
                throw new ArgumentNullException("writer");
            }
            writer.WriteNode(this, defattr: true);
        }

        public virtual string GetAttribute(string localName, string namespaceURI)
        {
            if (!MoveToAttribute(localName, namespaceURI))
            {
                return "";
            }
            string value = Value;
            MoveToParent();
            return value;
        }

        public virtual bool MoveToAttribute(string localName, string namespaceURI)
        {
            if (MoveToFirstAttribute())
            {
                do
                {
                    if (localName == LocalName && namespaceURI == NamespaceURI)
                    {
                        return true;
                    }
                }
                while (MoveToNextAttribute());
                MoveToParent();
            }
            return false;
        }

        public abstract bool MoveToFirstAttribute();

        public abstract bool MoveToNextAttribute();

        public virtual string GetNamespace(string name)
        {
            if (!MoveToNamespace(name))
            {
                if (name == "xml")
                {
                    return "http://www.w3.org/XML/1998/namespace";
                }
                if (name == "xmlns")
                {
                    return "http://www.w3.org/2000/xmlns/";
                }
                return string.Empty;
            }
            string value = Value;
            MoveToParent();
            return value;
        }

        public virtual bool MoveToNamespace(string name)
        {
            if (MoveToFirstNamespace(XPathNamespaceScope.All))
            {
                do
                {
                    if (name == LocalName)
                    {
                        return true;
                    }
                }
                while (MoveToNextNamespace(XPathNamespaceScope.All));
                MoveToParent();
            }
            return false;
        }

        public abstract bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope);

        public abstract bool MoveToNextNamespace(XPathNamespaceScope namespaceScope);

        public bool MoveToFirstNamespace()
        {
            return MoveToFirstNamespace(XPathNamespaceScope.All);
        }

        public bool MoveToNextNamespace()
        {
            return MoveToNextNamespace(XPathNamespaceScope.All);
        }

        public abstract bool MoveToNext();

        public abstract bool MoveToPrevious();

        public virtual bool MoveToFirst()
        {
            XPathNodeType nodeType = NodeType;
            if (nodeType == XPathNodeType.Attribute || nodeType == XPathNodeType.Namespace)
            {
                return false;
            }
            if (!MoveToParent())
            {
                return false;
            }
            return MoveToFirstChild();
        }

        public abstract bool MoveToFirstChild();

        public abstract bool MoveToParent();

        public virtual void MoveToRoot()
        {
            while (MoveToParent())
            {
            }
        }

        public abstract bool MoveTo(XPathNavigator other);

        public abstract bool MoveToId(string id);

        public virtual bool MoveToChild(string localName, string namespaceURI)
        {
            if (MoveToFirstChild())
            {
                do
                {
                    if (NodeType == XPathNodeType.Element && localName == LocalName && namespaceURI == NamespaceURI)
                    {
                        return true;
                    }
                }
                while (MoveToNext());
                MoveToParent();
            }
            return false;
        }

        public virtual bool MoveToChild(XPathNodeType type)
        {
            if (MoveToFirstChild())
            {
                int contentKindMask = GetContentKindMask(type);
                do
                {
                    if (((1 << (int)NodeType) & contentKindMask) != 0)
                    {
                        return true;
                    }
                }
                while (MoveToNext());
                MoveToParent();
            }
            return false;
        }

        public virtual bool MoveToFollowing(string localName, string namespaceURI)
        {
            return MoveToFollowing(localName, namespaceURI, null);
        }

        public virtual bool MoveToFollowing(string localName, string namespaceURI, XPathNavigator end)
        {
            XPathNavigator other = Clone();
            XPathNodeType nodeType;
            if (end != null)
            {
                nodeType = end.NodeType;
                if (nodeType == XPathNodeType.Attribute || nodeType == XPathNodeType.Namespace)
                {
                    end = end.Clone();
                    end.MoveToNonDescendant();
                }
            }
            nodeType = NodeType;
            if ((nodeType == XPathNodeType.Attribute || nodeType == XPathNodeType.Namespace) && !MoveToParent())
            {
                return false;
            }
            do
            {
                if (!MoveToFirstChild())
                {
                    while (!MoveToNext())
                    {
                        if (!MoveToParent())
                        {
                            MoveTo(other);
                            return false;
                        }
                    }
                }
                if (end != null && IsSamePosition(end))
                {
                    MoveTo(other);
                    return false;
                }
            }
            while (NodeType != XPathNodeType.Element || localName != LocalName || namespaceURI != NamespaceURI);
            return true;
        }

        public virtual bool MoveToFollowing(XPathNodeType type)
        {
            return MoveToFollowing(type, null);
        }

        public virtual bool MoveToFollowing(XPathNodeType type, XPathNavigator end)
        {
            XPathNavigator other = Clone();
            int contentKindMask = GetContentKindMask(type);
            XPathNodeType nodeType;
            if (end != null)
            {
                nodeType = end.NodeType;
                if (nodeType == XPathNodeType.Attribute || nodeType == XPathNodeType.Namespace)
                {
                    end = end.Clone();
                    end.MoveToNonDescendant();
                }
            }
            nodeType = NodeType;
            if ((nodeType == XPathNodeType.Attribute || nodeType == XPathNodeType.Namespace) && !MoveToParent())
            {
                return false;
            }
            do
            {
                if (!MoveToFirstChild())
                {
                    while (!MoveToNext())
                    {
                        if (!MoveToParent())
                        {
                            MoveTo(other);
                            return false;
                        }
                    }
                }
                if (end != null && IsSamePosition(end))
                {
                    MoveTo(other);
                    return false;
                }
            }
            while (((1 << (int)NodeType) & contentKindMask) == 0);
            return true;
        }

        public virtual bool MoveToNext(string localName, string namespaceURI)
        {
            XPathNavigator other = Clone();
            while (MoveToNext())
            {
                if (NodeType == XPathNodeType.Element && localName == LocalName && namespaceURI == NamespaceURI)
                {
                    return true;
                }
            }
            MoveTo(other);
            return false;
        }

        public virtual bool MoveToNext(XPathNodeType type)
        {
            XPathNavigator other = Clone();
            int contentKindMask = GetContentKindMask(type);
            while (MoveToNext())
            {
                if (((1 << (int)NodeType) & contentKindMask) != 0)
                {
                    return true;
                }
            }
            MoveTo(other);
            return false;
        }

        public abstract bool IsSamePosition(XPathNavigator other);

        public virtual bool IsDescendant(XPathNavigator nav)
        {
            if (nav != null)
            {
                nav = nav.Clone();
                while (nav.MoveToParent())
                {
                    if (nav.IsSamePosition(this))
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        public virtual XmlNodeOrder ComparePosition(XPathNavigator nav)
        {
            if (nav == null)
            {
                return XmlNodeOrder.Unknown;
            }
            if (IsSamePosition(nav))
            {
                return XmlNodeOrder.Same;
            }
            XPathNavigator xPathNavigator = Clone();
            XPathNavigator xPathNavigator2 = nav.Clone();
            int num = GetDepth(xPathNavigator.Clone());
            int num2 = GetDepth(xPathNavigator2.Clone());
            if (num > num2)
            {
                while (num > num2)
                {
                    xPathNavigator.MoveToParent();
                    num--;
                }
                if (xPathNavigator.IsSamePosition(xPathNavigator2))
                {
                    return XmlNodeOrder.After;
                }
            }
            if (num2 > num)
            {
                while (num2 > num)
                {
                    xPathNavigator2.MoveToParent();
                    num2--;
                }
                if (xPathNavigator.IsSamePosition(xPathNavigator2))
                {
                    return XmlNodeOrder.Before;
                }
            }
            XPathNavigator xPathNavigator3 = xPathNavigator.Clone();
            XPathNavigator xPathNavigator4 = xPathNavigator2.Clone();
            while (true)
            {
                if (!xPathNavigator3.MoveToParent() || !xPathNavigator4.MoveToParent())
                {
                    return XmlNodeOrder.Unknown;
                }
                if (xPathNavigator3.IsSamePosition(xPathNavigator4))
                {
                    break;
                }
                xPathNavigator.MoveToParent();
                xPathNavigator2.MoveToParent();
            }
            bool flag = xPathNavigator.GetType().ToString() != "Microsoft.VisualStudio.Modeling.StoreNavigator";
            return CompareSiblings(xPathNavigator, xPathNavigator2);
        }

        public virtual bool CheckValidity(XmlSchemaSet schemas, ValidationEventHandler validationEventHandler)
        {
            XmlSchemaType xmlSchemaType = null;
            XmlSchemaElement xmlSchemaElement = null;
            XmlSchemaAttribute xmlSchemaAttribute = null;
            switch (NodeType)
            {
            case XPathNodeType.Root:
                if (schemas == null)
                {
                    throw new InvalidOperationException(Res.GetString("XPathDocument_MissingSchemas"));
                }
                xmlSchemaType = null;
                break;
            case XPathNodeType.Element:
            {
                if (schemas == null)
                {
                    throw new InvalidOperationException(Res.GetString("XPathDocument_MissingSchemas"));
                }
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null)
                {
                    xmlSchemaType = schemaInfo.SchemaType;
                    xmlSchemaElement = schemaInfo.SchemaElement;
                }
                if (xmlSchemaType == null && xmlSchemaElement == null)
                {
                    throw new InvalidOperationException(Res.GetString("XPathDocument_NotEnoughSchemaInfo", null));
                }
                break;
            }
            case XPathNodeType.Attribute:
            {
                if (schemas == null)
                {
                    throw new InvalidOperationException(Res.GetString("XPathDocument_MissingSchemas"));
                }
                IXmlSchemaInfo schemaInfo = SchemaInfo;
                if (schemaInfo != null)
                {
                    xmlSchemaType = schemaInfo.SchemaType;
                    xmlSchemaAttribute = schemaInfo.SchemaAttribute;
                }
                if (xmlSchemaType == null && xmlSchemaAttribute == null)
                {
                    throw new InvalidOperationException(Res.GetString("XPathDocument_NotEnoughSchemaInfo", null));
                }
                break;
            }
            default:
                throw new InvalidOperationException(Res.GetString("XPathDocument_ValidateInvalidNodeType", null));
            }
            XmlReader xmlReader = CreateReader();
            CheckValidityHelper checkValidityHelper = new CheckValidityHelper(validationEventHandler, xmlReader as XPathNavigatorReader);
            validationEventHandler = checkValidityHelper.ValidationCallback;
            XmlReader validatingReader = GetValidatingReader(xmlReader, schemas, validationEventHandler, xmlSchemaType, xmlSchemaElement, xmlSchemaAttribute);
            while (validatingReader.Read())
            {
            }
            return checkValidityHelper.IsValid;
        }

        private XmlReader GetValidatingReader(XmlReader reader, XmlSchemaSet schemas, ValidationEventHandler validationEvent, XmlSchemaType schemaType, XmlSchemaElement schemaElement, XmlSchemaAttribute schemaAttribute)
        {
            if (schemaAttribute != null)
            {
                return schemaAttribute.Validate(reader, null, schemas, validationEvent);
            }
            if (schemaElement != null)
            {
                return schemaElement.Validate(reader, null, schemas, validationEvent);
            }
            if (schemaType != null)
            {
                return schemaType.Validate(reader, null, schemas, validationEvent);
            }
            XmlReaderSettings xmlReaderSettings = new XmlReaderSettings();
            xmlReaderSettings.ConformanceLevel = ConformanceLevel.Auto;
            xmlReaderSettings.ValidationType = ValidationType.Schema;
            xmlReaderSettings.Schemas = schemas;
            xmlReaderSettings.ValidationEventHandler += validationEvent;
            return XmlReader.Create(reader, xmlReaderSettings);
        }

        public virtual XPathExpression Compile(string xpath)
        {
            return XPathExpression.Compile(xpath);
        }

        public virtual XPathNavigator SelectSingleNode(string xpath)
        {
            return SelectSingleNode(XPathExpression.Compile(xpath));
        }

        public virtual XPathNavigator SelectSingleNode(string xpath, IXmlNamespaceResolver resolver)
        {
            return SelectSingleNode(XPathExpression.Compile(xpath, resolver));
        }

        public virtual XPathNavigator SelectSingleNode(XPathExpression expression)
        {
            XPathNodeIterator xPathNodeIterator = Select(expression);
            if (xPathNodeIterator.MoveNext())
            {
                return xPathNodeIterator.Current;
            }
            return null;
        }

        public virtual XPathNodeIterator Select(string xpath)
        {
            return Select(XPathExpression.Compile(xpath));
        }

        public virtual XPathNodeIterator Select(string xpath, IXmlNamespaceResolver resolver)
        {
            return Select(XPathExpression.Compile(xpath, resolver));
        }

        public virtual XPathNodeIterator Select(XPathExpression expr)
        {
            XPathNodeIterator xPathNodeIterator = Evaluate(expr) as XPathNodeIterator;
            if (xPathNodeIterator == null)
            {
                throw XPathException.Create("Xp_NodeSetExpected");
            }
            return xPathNodeIterator;
        }

        public virtual object Evaluate(string xpath)
        {
            return Evaluate(XPathExpression.Compile(xpath), null);
        }

        public virtual object Evaluate(string xpath, IXmlNamespaceResolver resolver)
        {
            return Evaluate(XPathExpression.Compile(xpath, resolver));
        }

        public virtual object Evaluate(XPathExpression expr)
        {
            return Evaluate(expr, null);
        }

        public virtual object Evaluate(XPathExpression expr, XPathNodeIterator context)
        {
            CompiledXpathExpr compiledXpathExpr = expr as CompiledXpathExpr;
            if (compiledXpathExpr == null)
            {
                throw XPathException.Create("Xp_BadQueryObject");
            }
            Query query = Query.Clone(compiledXpathExpr.QueryTree);
            query.Reset();
            if (context == null)
            {
                context = new XPathSingletonIterator(Clone(), moved: true);
            }
            object obj = query.Evaluate(context);
            if (obj is XPathNodeIterator)
            {
                return new XPathSelectionIterator(context.Current, query);
            }
            return obj;
        }

        public virtual bool Matches(XPathExpression expr)
        {
            CompiledXpathExpr compiledXpathExpr = expr as CompiledXpathExpr;
            if (compiledXpathExpr == null)
            {
                throw XPathException.Create("Xp_BadQueryObject");
            }
            Query query = Query.Clone(compiledXpathExpr.QueryTree);
            try
            {
                return query.MatchNode(this) != null;
            }
            catch (XPathException)
            {
                throw XPathException.Create("Xp_InvalidPattern", compiledXpathExpr.Expression);
            }
        }

        public virtual bool Matches(string xpath)
        {
            return Matches(CompileMatchPattern(xpath));
        }

        public virtual XPathNodeIterator SelectChildren(XPathNodeType type)
        {
            return new XPathChildIterator(Clone(), type);
        }

        public virtual XPathNodeIterator SelectChildren(string name, string namespaceURI)
        {
            return new XPathChildIterator(Clone(), name, namespaceURI);
        }

        public virtual XPathNodeIterator SelectAncestors(XPathNodeType type, bool matchSelf)
        {
            return new XPathAncestorIterator(Clone(), type, matchSelf);
        }

        public virtual XPathNodeIterator SelectAncestors(string name, string namespaceURI, bool matchSelf)
        {
            return new XPathAncestorIterator(Clone(), name, namespaceURI, matchSelf);
        }

        public virtual XPathNodeIterator SelectDescendants(XPathNodeType type, bool matchSelf)
        {
            return new XPathDescendantIterator(Clone(), type, matchSelf);
        }

        public virtual XPathNodeIterator SelectDescendants(string name, string namespaceURI, bool matchSelf)
        {
            return new XPathDescendantIterator(Clone(), name, namespaceURI, matchSelf);
        }

        public virtual XmlWriter PrependChild()
        {
            throw new NotSupportedException();
        }

        public virtual XmlWriter AppendChild()
        {
            throw new NotSupportedException();
        }

        public virtual XmlWriter InsertAfter()
        {
            throw new NotSupportedException();
        }

        public virtual XmlWriter InsertBefore()
        {
            throw new NotSupportedException();
        }

        public virtual XmlWriter CreateAttributes()
        {
            throw new NotSupportedException();
        }

        public virtual XmlWriter ReplaceRange(XPathNavigator lastSiblingToReplace)
        {
            throw new NotSupportedException();
        }

        public virtual void ReplaceSelf(string newNode)
        {
            XmlReader newNode2 = CreateContextReader(newNode, fromCurrentNode: false);
            ReplaceSelf(newNode2);
        }

        public virtual void ReplaceSelf(XmlReader newNode)
        {
            if (newNode == null)
            {
                throw new ArgumentNullException("newNode");
            }
            XPathNodeType nodeType = NodeType;
            if (nodeType == XPathNodeType.Root || nodeType == XPathNodeType.Attribute || nodeType == XPathNodeType.Namespace)
            {
                throw new InvalidOperationException(Res.GetString("Xpn_BadPosition"));
            }
            XmlWriter xmlWriter = ReplaceRange(this);
            BuildSubtree(newNode, xmlWriter);
            xmlWriter.Close();
        }

        public virtual void ReplaceSelf(XPathNavigator newNode)
        {
            if (newNode == null)
            {
                throw new ArgumentNullException("newNode");
            }
            XmlReader newNode2 = newNode.CreateReader();
            ReplaceSelf(newNode2);
        }

        public virtual void AppendChild(string newChild)
        {
            XmlReader newChild2 = CreateContextReader(newChild, fromCurrentNode: true);
            AppendChild(newChild2);
        }

        public virtual void AppendChild(XmlReader newChild)
        {
            if (newChild == null)
            {
                throw new ArgumentNullException("newChild");
            }
            XmlWriter xmlWriter = AppendChild();
            BuildSubtree(newChild, xmlWriter);
            xmlWriter.Close();
        }

        public virtual void AppendChild(XPathNavigator newChild)
        {
            if (newChild == null)
            {
                throw new ArgumentNullException("newChild");
            }
            if (!IsValidChildType(newChild.NodeType))
            {
                throw new InvalidOperationException(Res.GetString("Xpn_BadPosition"));
            }
            XmlReader newChild2 = newChild.CreateReader();
            AppendChild(newChild2);
        }

        public virtual void PrependChild(string newChild)
        {
            XmlReader newChild2 = CreateContextReader(newChild, fromCurrentNode: true);
            PrependChild(newChild2);
        }

        public virtual void PrependChild(XmlReader newChild)
        {
            if (newChild == null)
            {
                throw new ArgumentNullException("newChild");
            }
            XmlWriter xmlWriter = PrependChild();
            BuildSubtree(newChild, xmlWriter);
            xmlWriter.Close();
        }

        public virtual void PrependChild(XPathNavigator newChild)
        {
            if (newChild == null)
            {
                throw new ArgumentNullException("newChild");
            }
            if (!IsValidChildType(newChild.NodeType))
            {
                throw new InvalidOperationException(Res.GetString("Xpn_BadPosition"));
            }
            XmlReader newChild2 = newChild.CreateReader();
            PrependChild(newChild2);
        }

        public virtual void InsertBefore(string newSibling)
        {
            XmlReader newSibling2 = CreateContextReader(newSibling, fromCurrentNode: false);
            InsertBefore(newSibling2);
        }

        public virtual void InsertBefore(XmlReader newSibling)
        {
            if (newSibling == null)
            {
                throw new ArgumentNullException("newSibling");
            }
            XmlWriter xmlWriter = InsertBefore();
            BuildSubtree(newSibling, xmlWriter);
            xmlWriter.Close();
        }

        public virtual void InsertBefore(XPathNavigator newSibling)
        {
            if (newSibling == null)
            {
                throw new ArgumentNullException("newSibling");
            }
            if (!IsValidSiblingType(newSibling.NodeType))
            {
                throw new InvalidOperationException(Res.GetString("Xpn_BadPosition"));
            }
            XmlReader newSibling2 = newSibling.CreateReader();
            InsertBefore(newSibling2);
        }

        public virtual void InsertAfter(string newSibling)
        {
            XmlReader newSibling2 = CreateContextReader(newSibling, fromCurrentNode: false);
            InsertAfter(newSibling2);
        }

        public virtual void InsertAfter(XmlReader newSibling)
        {
            if (newSibling == null)
            {
                throw new ArgumentNullException("newSibling");
            }
            XmlWriter xmlWriter = InsertAfter();
            BuildSubtree(newSibling, xmlWriter);
            xmlWriter.Close();
        }

        public virtual void InsertAfter(XPathNavigator newSibling)
        {
            if (newSibling == null)
            {
                throw new ArgumentNullException("newSibling");
            }
            if (!IsValidSiblingType(newSibling.NodeType))
            {
                throw new InvalidOperationException(Res.GetString("Xpn_BadPosition"));
            }
            XmlReader newSibling2 = newSibling.CreateReader();
            InsertAfter(newSibling2);
        }

        public virtual void DeleteRange(XPathNavigator lastSiblingToDelete)
        {
            throw new NotSupportedException();
        }

        public virtual void DeleteSelf()
        {
            DeleteRange(this);
        }

        public virtual void PrependChildElement(string prefix, string localName, string namespaceURI, string value)
        {
            XmlWriter xmlWriter = PrependChild();
            xmlWriter.WriteStartElement(prefix, localName, namespaceURI);
            if (value != null)
            {
                xmlWriter.WriteString(value);
            }
            xmlWriter.WriteEndElement();
            xmlWriter.Close();
        }

        public virtual void AppendChildElement(string prefix, string localName, string namespaceURI, string value)
        {
            XmlWriter xmlWriter = AppendChild();
            xmlWriter.WriteStartElement(prefix, localName, namespaceURI);
            if (value != null)
            {
                xmlWriter.WriteString(value);
            }
            xmlWriter.WriteEndElement();
            xmlWriter.Close();
        }

        public virtual void InsertElementBefore(string prefix, string localName, string namespaceURI, string value)
        {
            XmlWriter xmlWriter = InsertBefore();
            xmlWriter.WriteStartElement(prefix, localName, namespaceURI);
            if (value != null)
            {
                xmlWriter.WriteString(value);
            }
            xmlWriter.WriteEndElement();
            xmlWriter.Close();
        }

        public virtual void InsertElementAfter(string prefix, string localName, string namespaceURI, string value)
        {
            XmlWriter xmlWriter = InsertAfter();
            xmlWriter.WriteStartElement(prefix, localName, namespaceURI);
            if (value != null)
            {
                xmlWriter.WriteString(value);
            }
            xmlWriter.WriteEndElement();
            xmlWriter.Close();
        }

        public virtual void CreateAttribute(string prefix, string localName, string namespaceURI, string value)
        {
            XmlWriter xmlWriter = CreateAttributes();
            xmlWriter.WriteStartAttribute(prefix, localName, namespaceURI);
            if (value != null)
            {
                xmlWriter.WriteString(value);
            }
            xmlWriter.WriteEndAttribute();
            xmlWriter.Close();
        }

        internal bool MoveToPrevious(string localName, string namespaceURI)
        {
            XPathNavigator other = Clone();
            localName = ((localName != null) ? NameTable.Get(localName) : null);
            while (MoveToPrevious())
            {
                if (NodeType == XPathNodeType.Element && (object)localName == LocalName && namespaceURI == NamespaceURI)
                {
                    return true;
                }
            }
            MoveTo(other);
            return false;
        }

        internal bool MoveToPrevious(XPathNodeType type)
        {
            XPathNavigator other = Clone();
            int contentKindMask = GetContentKindMask(type);
            while (MoveToPrevious())
            {
                if (((1 << (int)NodeType) & contentKindMask) != 0)
                {
                    return true;
                }
            }
            MoveTo(other);
            return false;
        }

        internal bool MoveToNonDescendant()
        {
            if (NodeType == XPathNodeType.Root)
            {
                return false;
            }
            if (MoveToNext())
            {
                return true;
            }
            XPathNavigator xPathNavigator = Clone();
            if (!MoveToParent())
            {
                return false;
            }
            XPathNodeType nodeType = xPathNavigator.NodeType;
            if ((nodeType == XPathNodeType.Attribute || nodeType == XPathNodeType.Namespace) && MoveToFirstChild())
            {
                return true;
            }
            while (!MoveToNext())
            {
                if (!MoveToParent())
                {
                    MoveTo(xPathNavigator);
                    return false;
                }
            }
            return true;
        }

        private static XPathExpression CompileMatchPattern(string xpath)
        {
            bool needContext;
            Query query = new QueryBuilder().BuildPatternQuery(xpath, out needContext);
            return new CompiledXpathExpr(query, xpath, needContext);
        }

        private static int GetDepth(XPathNavigator nav)
        {
            int num = 0;
            while (nav.MoveToParent())
            {
                num++;
            }
            return num;
        }

        private XmlNodeOrder CompareSiblings(XPathNavigator n1, XPathNavigator n2)
        {
            int num = 0;
            switch (n1.NodeType)
            {
            case XPathNodeType.Attribute:
                num++;
                break;
            default:
                num += 2;
                break;
            case XPathNodeType.Namespace:
                break;
            }
            switch (n2.NodeType)
            {
            case XPathNodeType.Namespace:
                if (num != 0)
                {
                    break;
                }
                while (n1.MoveToNextNamespace())
                {
                    if (n1.IsSamePosition(n2))
                    {
                        return XmlNodeOrder.Before;
                    }
                }
                break;
            case XPathNodeType.Attribute:
                num--;
                if (num != 0)
                {
                    break;
                }
                while (n1.MoveToNextAttribute())
                {
                    if (n1.IsSamePosition(n2))
                    {
                        return XmlNodeOrder.Before;
                    }
                }
                break;
            default:
                num -= 2;
                if (num != 0)
                {
                    break;
                }
                while (n1.MoveToNext())
                {
                    if (n1.IsSamePosition(n2))
                    {
                        return XmlNodeOrder.Before;
                    }
                }
                break;
            }
            if (num >= 0)
            {
                return XmlNodeOrder.After;
            }
            return XmlNodeOrder.Before;
        }

        internal static XmlNamespaceManager GetNamespaces(IXmlNamespaceResolver resolver)
        {
            XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(new NameTable());
            IDictionary<string, string> namespacesInScope = resolver.GetNamespacesInScope(XmlNamespaceScope.All);
            foreach (KeyValuePair<string, string> item in namespacesInScope)
            {
                if (item.Key != "xmlns")
                {
                    xmlNamespaceManager.AddNamespace(item.Key, item.Value);
                }
            }
            return xmlNamespaceManager;
        }

        internal static int GetContentKindMask(XPathNodeType type)
        {
            return ContentKindMasks[(int)type];
        }

        internal static int GetKindMask(XPathNodeType type)
        {
            switch (type)
            {
            case XPathNodeType.All:
                return int.MaxValue;
            case XPathNodeType.Text:
                return 112;
            default:
                return 1 << (int)type;
            }
        }

        internal static bool IsText(XPathNodeType type)
        {
            return (uint)(type - 4) <= 2u;
        }

        private bool IsValidChildType(XPathNodeType type)
        {
            switch (NodeType)
            {
            case XPathNodeType.Root:
                switch (type)
                {
                case XPathNodeType.Element:
                case XPathNodeType.SignificantWhitespace:
                case XPathNodeType.Whitespace:
                case XPathNodeType.ProcessingInstruction:
                case XPathNodeType.Comment:
                    return true;
                }
                break;
            case XPathNodeType.Element:
                switch (type)
                {
                case XPathNodeType.Element:
                case XPathNodeType.Text:
                case XPathNodeType.SignificantWhitespace:
                case XPathNodeType.Whitespace:
                case XPathNodeType.ProcessingInstruction:
                case XPathNodeType.Comment:
                    return true;
                }
                break;
            }
            return false;
        }

        private bool IsValidSiblingType(XPathNodeType type)
        {
            switch (NodeType)
            {
            case XPathNodeType.Element:
            case XPathNodeType.Text:
            case XPathNodeType.SignificantWhitespace:
            case XPathNodeType.Whitespace:
            case XPathNodeType.ProcessingInstruction:
            case XPathNodeType.Comment:
                switch (type)
                {
                case XPathNodeType.Element:
                case XPathNodeType.Text:
                case XPathNodeType.SignificantWhitespace:
                case XPathNodeType.Whitespace:
                case XPathNodeType.ProcessingInstruction:
                case XPathNodeType.Comment:
                    return true;
                }
                break;
            }
            return false;
        }

        private XmlReader CreateReader()
        {
            return XPathNavigatorReader.Create(this);
        }

        private XmlReader CreateContextReader(string xml, bool fromCurrentNode)
        {
            if (xml == null)
            {
                throw new ArgumentNullException("xml");
            }
            XPathNavigator xPathNavigator = CreateNavigator();
            XmlNamespaceManager xmlNamespaceManager = new XmlNamespaceManager(NameTable);
            if (!fromCurrentNode)
            {
                xPathNavigator.MoveToParent();
            }
            if (xPathNavigator.MoveToFirstNamespace(XPathNamespaceScope.All))
            {
                do
                {
                    xmlNamespaceManager.AddNamespace(xPathNavigator.LocalName, xPathNavigator.Value);
                }
                while (xPathNavigator.MoveToNextNamespace(XPathNamespaceScope.All));
            }
            XmlParserContext context = new XmlParserContext(NameTable, xmlNamespaceManager, null, XmlSpace.Default);
            XmlTextReader xmlTextReader = new XmlTextReader(xml, XmlNodeType.Element, context);
            xmlTextReader.WhitespaceHandling = WhitespaceHandling.Significant;
            return xmlTextReader;
        }

        internal void BuildSubtree(XmlReader reader, XmlWriter writer)
        {
            string text = "http://www.w3.org/2000/xmlns/";
            ReadState readState = reader.ReadState;
            if (readState != 0 && readState != ReadState.Interactive)
            {
                throw new ArgumentException(Res.GetString("Xml_InvalidOperation"), "reader");
            }
            int num = 0;
            if (readState == ReadState.Initial)
            {
                if (!reader.Read())
                {
                    return;
                }
                num++;
            }
            do
            {
                switch (reader.NodeType)
                {
                case XmlNodeType.Element:
                {
                    writer.WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI);
                    bool isEmptyElement = reader.IsEmptyElement;
                    while (reader.MoveToNextAttribute())
                    {
                        if ((object)reader.NamespaceURI == text)
                        {
                            if (reader.Prefix.Length == 0)
                            {
                                writer.WriteAttributeString("", "xmlns", text, reader.Value);
                            }
                            else
                            {
                                writer.WriteAttributeString("xmlns", reader.LocalName, text, reader.Value);
                            }
                        }
                        else
                        {
                            writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
                            writer.WriteString(reader.Value);
                            writer.WriteEndAttribute();
                        }
                    }
                    reader.MoveToElement();
                    if (isEmptyElement)
                    {
                        writer.WriteEndElement();
                    }
                    else
                    {
                        num++;
                    }
                    break;
                }
                case XmlNodeType.EndElement:
                    writer.WriteFullEndElement();
                    num--;
                    break;
                case XmlNodeType.Text:
                case XmlNodeType.CDATA:
                    writer.WriteString(reader.Value);
                    break;
                case XmlNodeType.Whitespace:
                case XmlNodeType.SignificantWhitespace:
                    writer.WriteString(reader.Value);
                    break;
                case XmlNodeType.Comment:
                    writer.WriteComment(reader.Value);
                    break;
                case XmlNodeType.ProcessingInstruction:
                    writer.WriteProcessingInstruction(reader.LocalName, reader.Value);
                    break;
                case XmlNodeType.EntityReference:
                    reader.ResolveEntity();
                    break;
                case XmlNodeType.Attribute:
                    if ((object)reader.NamespaceURI == text)
                    {
                        if (reader.Prefix.Length == 0)
                        {
                            writer.WriteAttributeString("", "xmlns", text, reader.Value);
                        }
                        else
                        {
                            writer.WriteAttributeString("xmlns", reader.LocalName, text, reader.Value);
                        }
                    }
                    else
                    {
                        writer.WriteStartAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI);
                        writer.WriteString(reader.Value);
                        writer.WriteEndAttribute();
                    }
                    break;
                }
            }
            while (reader.Read() && num > 0);
        }
    }
}