XPathDocumentIterator.cs source code in C# .NET

                        Code:
                         / 4.0 / 4.0 / untmp / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / Xml / System / Xml / Cache / XPathDocumentIterator.cs / 1305376 / XPathDocumentIterator.cs
                        
                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
// [....] 
//-----------------------------------------------------------------------------
using System; 
using System.Xml; 
using System.Xml.XPath;
using System.Diagnostics; 

namespace MS.Internal.Xml.Cache {

    ///  
    /// Base internal class of all XPathDocument XPathNodeIterator implementations.
    ///  
    internal abstract class XPathDocumentBaseIterator : XPathNodeIterator { 
        protected XPathDocumentNavigator ctxt;
        protected int pos; 

        /// 
        /// Create a new iterator that is initially positioned on the "ctxt" node.
        ///  
        protected XPathDocumentBaseIterator(XPathDocumentNavigator ctxt) {
            this.ctxt = new XPathDocumentNavigator(ctxt); 
        } 

        ///  
        /// Create a new iterator that is a copy of "iter".
        /// 
        protected XPathDocumentBaseIterator(XPathDocumentBaseIterator iter) {
            this.ctxt = new XPathDocumentNavigator(iter.ctxt); 
            this.pos = iter.pos;
        } 
 
        /// 
        /// Return the current navigator. 
        /// 
        public override XPathNavigator Current {
            get { return this.ctxt; }
        } 

        ///  
        /// Return the iterator's current position. 
        /// 
        public override int CurrentPosition { 
            get { return this.pos; }
        }
    }
 

    ///  
    /// Iterate over all element children with a particular QName. 
    /// 
    internal class XPathDocumentElementChildIterator : XPathDocumentBaseIterator { 
        private string localName, namespaceUri;

        /// 
        /// Create an iterator that ranges over all element children of "parent" having the specified QName. 
        /// 
        public XPathDocumentElementChildIterator(XPathDocumentNavigator parent, string name, string namespaceURI) : base(parent) { 
            if (namespaceURI == null) throw new ArgumentNullException("namespaceURI"); 

            this.localName = parent.NameTable.Get(name); 
            this.namespaceUri = namespaceURI;
        }

        ///  
        /// Create a new iterator that is a copy of "iter".
        ///  
        public XPathDocumentElementChildIterator(XPathDocumentElementChildIterator iter) : base(iter) { 
            this.localName = iter.localName;
            this.namespaceUri = iter.namespaceUri; 
        }

        /// 
        /// Create a copy of this iterator. 
        /// 
        public override XPathNodeIterator Clone() { 
            return new XPathDocumentElementChildIterator(this); 
        }
 
        /// 
        /// Position the iterator to the next matching child.
        /// 
        public override bool MoveNext() { 
            if (this.pos == 0) {
                if (!this.ctxt.MoveToChild(this.localName, this.namespaceUri)) 
                    return false; 
            }
            else { 
                if (!this.ctxt.MoveToNext(this.localName, this.namespaceUri))
                    return false;
            }
 
            this.pos++;
            return true; 
        } 
    }
 

    /// 
    /// Iterate over all content children with a particular XPathNodeType.
    ///  
    internal class XPathDocumentKindChildIterator : XPathDocumentBaseIterator {
        private XPathNodeType typ; 
 
        /// 
        /// Create an iterator that ranges over all content children of "parent" having the specified XPathNodeType. 
        /// 
        public XPathDocumentKindChildIterator(XPathDocumentNavigator parent, XPathNodeType typ) : base(parent) {
            this.typ = typ;
        } 

        ///  
        /// Create a new iterator that is a copy of "iter". 
        /// 
        public XPathDocumentKindChildIterator(XPathDocumentKindChildIterator iter) : base(iter) { 
            this.typ = iter.typ;
        }

        ///  
        /// Create a copy of this iterator.
        ///  
        public override XPathNodeIterator Clone() { 
            return new XPathDocumentKindChildIterator(this);
        } 

        /// 
        /// Position the iterator to the next descendant.
        ///  
        public override bool MoveNext() {
            if (this.pos == 0) { 
                if (!this.ctxt.MoveToChild(this.typ)) 
                    return false;
            } 
            else {
                if (!this.ctxt.MoveToNext(this.typ))
                    return false;
            } 

            this.pos++; 
            return true; 
        }
    } 


    /// 
    /// Iterate over all element descendants with a particular QName. 
    /// 
    internal class XPathDocumentElementDescendantIterator : XPathDocumentBaseIterator { 
        private XPathDocumentNavigator end; 
        private string localName, namespaceUri;
        private bool matchSelf; 

        /// 
        /// Create an iterator that ranges over all element descendants of "root" having the specified QName.
        ///  
        public XPathDocumentElementDescendantIterator(XPathDocumentNavigator root, string name, string namespaceURI, bool matchSelf) : base(root) {
            if (namespaceURI == null) throw new ArgumentNullException("namespaceURI"); 
 
            this.localName = root.NameTable.Get(name);
            this.namespaceUri = namespaceURI; 
            this.matchSelf = matchSelf;

            // Find the next non-descendant node that follows "root" in document order
            if (root.NodeType != XPathNodeType.Root) { 
                this.end = new XPathDocumentNavigator(root);
                this.end.MoveToNonDescendant(); 
            } 
        }
 
        /// 
        /// Create a new iterator that is a copy of "iter".
        /// 
        public XPathDocumentElementDescendantIterator(XPathDocumentElementDescendantIterator iter) : base(iter) { 
            this.end = iter.end;
            this.localName = iter.localName; 
            this.namespaceUri = iter.namespaceUri; 
            this.matchSelf = iter.matchSelf;
        } 

        /// 
        /// Create a copy of this iterator.
        ///  
        public override XPathNodeIterator Clone() {
            return new XPathDocumentElementDescendantIterator(this); 
        } 

        ///  
        /// Position the iterator to the next descendant.
        /// 
        public override bool MoveNext() {
            if (this.matchSelf) { 
                this.matchSelf = false;
 
                if (this.ctxt.IsElementMatch(this.localName, this.namespaceUri)) { 
                    this.pos++;
                    return true; 
                }
            }

            if (!this.ctxt.MoveToFollowing(this.localName, this.namespaceUri, this.end)) 
                return false;
 
            this.pos++; 
            return true;
        } 
    }


    ///  
    /// Iterate over all content descendants with a particular XPathNodeType.
    ///  
    internal class XPathDocumentKindDescendantIterator : XPathDocumentBaseIterator { 
        private XPathDocumentNavigator end;
        private XPathNodeType typ; 
        private bool matchSelf;

        /// 
        /// Create an iterator that ranges over all content descendants of "root" having the specified XPathNodeType. 
        /// 
        public XPathDocumentKindDescendantIterator(XPathDocumentNavigator root, XPathNodeType typ, bool matchSelf) : base(root) { 
            this.typ = typ; 
            this.matchSelf = matchSelf;
 
            // Find the next non-descendant node that follows "root" in document order
            if (root.NodeType != XPathNodeType.Root) {
                this.end = new XPathDocumentNavigator(root);
                this.end.MoveToNonDescendant(); 
            }
        } 
 
        /// 
        /// Create a new iterator that is a copy of "iter". 
        /// 
        public XPathDocumentKindDescendantIterator(XPathDocumentKindDescendantIterator iter) : base(iter) {
            this.end = iter.end;
            this.typ = iter.typ; 
            this.matchSelf = iter.matchSelf;
        } 
 
        /// 
        /// Create a copy of this iterator. 
        /// 
        public override XPathNodeIterator Clone() {
            return new XPathDocumentKindDescendantIterator(this);
        } 

        ///  
        /// Position the iterator to the next descendant. 
        /// 
        public override bool MoveNext() { 
            if (this.matchSelf) {
                this.matchSelf = false;

                if (this.ctxt.IsKindMatch(this.typ)) { 
                    this.pos++;
                    return true; 
                } 
            }
 
            if (!this.ctxt.MoveToFollowing(this.typ, this.end))
                return false;

            this.pos++; 
            return true;
        } 
    } 
}
 

// 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
XPathDocumentIterator.cs source code in C# .NET

Source code for the .NET framework in C#

Code:

Link Menu
