DataDocumentXPathNavigator.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Data / System / NewXml / DataDocumentXPathNavigator.cs / 1305376 / DataDocumentXPathNavigator.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
// [....]
//----------------------------------------------------------------------------- 
#pragma warning disable 618 // ignore obsolete warning about XmlDataDocument 
namespace System.Xml {
    using System; 
    using System.Xml.XPath;

    internal sealed class DataDocumentXPathNavigator: XPathNavigator, IHasXmlNode {
        private XPathNodePointer    _curNode;           //pointer to remember the current node position 
        private XmlDataDocument     _doc;              //pointer to remember the root -- can only be XmlDataDocument for DataDocumentXPathNavigator
        private XPathNodePointer    _temp; 
 
        internal DataDocumentXPathNavigator( XmlDataDocument doc, XmlNode node ) {
            _curNode = new XPathNodePointer( this, doc, node ); 
            _temp = new XPathNodePointer( this, doc, node );
            _doc = doc;
        }
 
        private DataDocumentXPathNavigator( DataDocumentXPathNavigator other ) {
            this._curNode = other._curNode.Clone( this ); 
            this._temp = other._temp.Clone( this ); 
            this._doc = other._doc;
        } 
        public override XPathNavigator Clone(){
            return new DataDocumentXPathNavigator( this );
        }
 
        internal XPathNodePointer CurNode { get { return _curNode; } }
        internal XmlDataDocument Document { get { return _doc; } } 
 
        //Convert will deal with nodeType as Attribute or Namespace nodes
        public override XPathNodeType NodeType { get { return _curNode.NodeType; } } 

        public override string LocalName { get { return _curNode.LocalName; } }

        public override string NamespaceURI { get { return _curNode.NamespaceURI; } } 

        public override string Name { get { return _curNode.Name; } } 
 
        public override string Prefix { get { return _curNode.Prefix; } }
 
        public override string Value {
            get {
                XPathNodeType xnt = _curNode.NodeType;
                if ( xnt == XPathNodeType.Element || xnt == XPathNodeType.Root ) 
                    return _curNode.InnerText;
                return _curNode.Value; 
            } 
        }
 
        public override String BaseURI { get { return _curNode.BaseURI; } }

        public override String XmlLang { get { return _curNode.XmlLang; } }
 
        public override bool IsEmptyElement { get { return _curNode.IsEmptyElement; } }
 
        public override XmlNameTable NameTable { get { return _doc.NameTable; } } 

        // Attributes 
        public override bool HasAttributes { get { return _curNode.AttributeCount > 0; } }

        public override string GetAttribute( string localName, string namespaceURI ) {
            if ( _curNode.NodeType != XPathNodeType.Element ) 
                return string.Empty; //other type of nodes can't have attributes
            _temp.MoveTo( _curNode ); 
            if ( _temp.MoveToAttribute( localName, namespaceURI ) ) 
                return _temp.Value;
            return string.Empty; 
        }

//#if SupportNamespaces
 
        public override string GetNamespace(string name) {
            return _curNode.GetNamespace( name ); 
        } 

        public override bool MoveToNamespace(string name) { 
            if ( _curNode.NodeType != XPathNodeType.Element )
                return false;
            return _curNode.MoveToNamespace( name );
        } 

        public override bool MoveToFirstNamespace(XPathNamespaceScope namespaceScope) { 
            if ( _curNode.NodeType != XPathNodeType.Element ) 
                return false;
            return _curNode.MoveToFirstNamespace(namespaceScope); 
        }

        public override bool MoveToNextNamespace(XPathNamespaceScope namespaceScope) {
            if ( _curNode.NodeType != XPathNodeType.Namespace ) 
                return false;
            return _curNode.MoveToNextNamespace(namespaceScope); 
        } 
//#endif
 
        public override bool MoveToAttribute( string localName, string namespaceURI ) {
            if ( _curNode.NodeType != XPathNodeType.Element )
                return false; //other type of nodes can't have attributes
            return _curNode.MoveToAttribute( localName, namespaceURI ); 
        }
 
        public override bool MoveToFirstAttribute() { 
            if ( _curNode.NodeType != XPathNodeType.Element )
                return false; //other type of nodes can't have attributes 
            return _curNode.MoveToNextAttribute(true);
        }

        public override bool MoveToNextAttribute() { 
            if ( _curNode.NodeType != XPathNodeType.Attribute )
                return false; 
            return _curNode.MoveToNextAttribute(false); 
        }
 

        // Tree
        public override bool MoveToNext() {
            if ( _curNode.NodeType == XPathNodeType.Attribute ) 
                return false;
            return _curNode.MoveToNextSibling(); 
        } 

        public override bool MoveToPrevious() { 
            if ( _curNode.NodeType == XPathNodeType.Attribute )
                return false;
            return _curNode.MoveToPreviousSibling();
        } 

        public override bool MoveToFirst() { 
            if ( _curNode.NodeType == XPathNodeType.Attribute ) 
                return false;
            return _curNode.MoveToFirst(); 
        }

        public override bool HasChildren { get { return _curNode.HasChildren; } }
 
        public override bool MoveToFirstChild() {
            return _curNode.MoveToFirstChild(); 
        } 

        public override bool MoveToParent() { 
            return _curNode.MoveToParent();
        }

        public override void MoveToRoot() { 
            _curNode.MoveToRoot();
        } 
 
        public override bool MoveTo( XPathNavigator other ) {
            if ( other == null ) 
                return false;
            DataDocumentXPathNavigator otherDataDocXPathNav = other as DataDocumentXPathNavigator;
            if ( otherDataDocXPathNav != null ) {
                if ( _curNode.MoveTo( otherDataDocXPathNav.CurNode ) ) { 
                    _doc = _curNode.Document;
                    return true; 
                } 
                else
                    return false; 
            }
            return false;
        }
 
        //doesn't support MoveToId
        public override bool MoveToId( string id ) { 
            return false; 
        }
 
        public override bool IsSamePosition( XPathNavigator other ) {
            if ( other == null )
                return false;
            DataDocumentXPathNavigator otherDataDocXPathNav = other as DataDocumentXPathNavigator; 
            if ( otherDataDocXPathNav != null ) {
                if ( this._doc == otherDataDocXPathNav.Document && this._curNode.IsSamePosition(otherDataDocXPathNav.CurNode) ) 
                    return true; 
            }
            return false; 
        }

        //the function is only called for XPathNodeList enumerate nodes and
        // shouldn't be promoted to frequently use because it will cause foliation 
        XmlNode IHasXmlNode.GetNode() { return _curNode.Node; }
 
        public override XmlNodeOrder ComparePosition( XPathNavigator other ) { 
            if ( other == null )
                return XmlNodeOrder.Unknown; // this is what XPathDocument does. // WebData 103403 

            DataDocumentXPathNavigator otherDataDocXPathNav = other as DataDocumentXPathNavigator;

            if ( otherDataDocXPathNav == null || otherDataDocXPathNav.Document != this._doc ) 
                return XmlNodeOrder.Unknown;
 
            return this._curNode.ComparePosition( otherDataDocXPathNav.CurNode ); 
        }
 
    }

}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK