MoveToRoot() 공개 메소드

public MoveToRoot ( ) : void
리턴 void
예제 #1
0
 internal override void setContext(XPathNavigator e)
 {
     Debug.Assert(e != null);
     e = e.Clone();
     e.MoveToRoot();
     base.setContext(e);
 }
예제 #2
0
		protected virtual void OnMovingToRootItem(XPathNavigator navigator)
		{
			navigator.MoveToRoot();
			if (!navigator.MoveToFirstChild())
				throw new InvalidXmlException("Expected node n2 not found");
			if (!navigator.MoveToFirstChild())
				throw new InvalidXmlException("Expected node item not found");
		}
예제 #3
0
 internal override XPathNavigator advance()
 {
     if (proceed)
     {
         if (temp == null)
         {
             XPathNavigator _eLast = m_qyInput.advance();
             while (_eLast != null)
             {
                 temp   = _eLast.Clone();
                 _eLast = m_qyInput.advance();
             }
             if (temp == null || temp.NodeType == XPathNodeType.Root)
             {
                 return(null);
             }
             if (temp.NodeType == XPathNodeType.Attribute || temp.NodeType == XPathNodeType.Namespace)
             {
                 temp.MoveToParent();
             }
             NotVisited(temp.Clone());
             _AncestorStk.Add(temp.Clone());
             temp.MoveToRoot();
             _qy = temp.SelectDescendants(XPathNodeType.All, false);
         }
         int flag;
         while (_qy.MoveNext())
         {
             m_eNext = _qy.Current;
             if (matches(m_eNext))
             {
                 flag = InStk(m_eNext);
                 if (flag == 1)
                 {
                     _position++;
                     return(m_eNext);
                 }
                 if (flag == 2)
                 {
                     proceed = false;
                     m_eNext = null;
                     return(null);
                 }
             }
             else
             {
                 if (m_eNext.IsSamePosition((XPathNavigator)_AncestorStk[_AncestorStk.Count - 1]))
                 {
                     proceed = false;
                     m_eNext = null;
                     return(null);
                 }
             }
         }
         return(null);
     }
     return(null);
 }
예제 #4
0
        public override object Evaluate(BaseIterator iter)
        {
            if (iter.CurrentPosition == 0)
            {
                iter = (BaseIterator)iter.Clone();
                iter.MoveNext();
            }
            XPathNavigator xpathNavigator = iter.Current.Clone();

            xpathNavigator.MoveToRoot();
            return(new SelfIterator(xpathNavigator, iter.NamespaceManager));
        }
 internal static string ExtractFromNavigator(XPathNavigator nav)
 {
     nav.MoveToRoot();
     if (nav.MoveToFirstChild())
     {
         string namespaceURI = nav.NamespaceURI;
         if (!(nav.LocalName != "Envelope") && (!(namespaceURI != "http://schemas.xmlsoap.org/soap/envelope/") || !(namespaceURI != "http://www.w3.org/2003/05/soap-envelope")))
         {
             return namespaceURI;
         }
     }
     return string.Empty;
 }
 internal static string ExtractFromNavigator(XPathNavigator nav)
 {
     string attribute = nav.GetAttribute(XPathMessageContext.Actor11A, "http://schemas.xmlsoap.org/soap/envelope/");
     string str2 = nav.GetAttribute(XPathMessageContext.Actor12A, "http://www.w3.org/2003/05/soap-envelope");
     nav.MoveToRoot();
     nav.MoveToFirstChild();
     if ((nav.LocalName == "Envelope") && (nav.NamespaceURI == "http://schemas.xmlsoap.org/soap/envelope/"))
     {
         return attribute;
     }
     if ((nav.LocalName == "Envelope") && (nav.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope"))
     {
         return str2;
     }
     return string.Empty;
 }
 internal static bool ExtractFromNavigator(XPathNavigator nav)
 {
     string str = XPathMessageFunctionActor.ExtractFromNavigator(nav);
     nav.MoveToRoot();
     if (nav.MoveToFirstChild() && (nav.LocalName == "Envelope"))
     {
         if (nav.NamespaceURI == "http://schemas.xmlsoap.org/soap/envelope/")
         {
             return (str == S11UltRec);
         }
         if (nav.NamespaceURI == "http://www.w3.org/2003/05/soap-envelope")
         {
             return (str == S12UltRec);
         }
     }
     return false;
 }
예제 #8
0
		public void ReadSubtree1 ()
		{
			string xml = "<root/>";

			nav = GetXmlDocumentNavigator (xml);
			ReadSubtree1 (nav, "#1.");

			nav.MoveToRoot ();
			nav.MoveToFirstChild ();
			ReadSubtree1 (nav, "#2.");

			nav = GetXPathDocumentNavigator (document);
			ReadSubtree1 (nav, "#3.");

			nav.MoveToRoot ();
			nav.MoveToFirstChild ();
			ReadSubtree1 (nav, "#4.");
		}
 internal static bool MoveToBody(XPathNavigator nav)
 {
     nav.MoveToRoot();
     if (nav.MoveToFirstChild())
     {
         string namespaceURI = nav.NamespaceURI;
         if ((nav.LocalName != "Envelope") || ((namespaceURI != "http://schemas.xmlsoap.org/soap/envelope/") && (namespaceURI != "http://www.w3.org/2003/05/soap-envelope")))
         {
             return false;
         }
         if (nav.MoveToFirstChild())
         {
             do
             {
                 if ((nav.LocalName == "Body") && (nav.NamespaceURI == namespaceURI))
                 {
                     return true;
                 }
             }
             while (nav.MoveToNext());
         }
     }
     return false;
 }
        internal static bool ExtractFromNavigator(XPathNavigator nav)
        {
            string mand11 = nav.GetAttribute(XPathMessageContext.MandatoryA, XPathMessageContext.S11NS);
            string mand12 = nav.GetAttribute(XPathMessageContext.MandatoryA, XPathMessageContext.S12NS);

            nav.MoveToRoot();
            nav.MoveToFirstChild();
            if (nav.LocalName == XPathMessageContext.EnvelopeE && nav.NamespaceURI == XPathMessageContext.S11NS)
            {
                return mand11 == "1";
            }
            else if (nav.LocalName == XPathMessageContext.EnvelopeE && nav.NamespaceURI == XPathMessageContext.S12NS)
            {
                return mand12 == "true";
            }

            return false;
        }
예제 #11
0
 internal override void setContext( XPathNavigator e) {
     Debug.Assert(e != null);
     e = e.Clone();
     e.MoveToRoot();
     base.setContext( e);
 }
예제 #12
0
        /// <summary>
        /// Parses an XML document for its namespaces.
        /// </summary>
        /// <param name="navigator">The navigator.</param>
        public void ParseNamespaces(XPathNavigator navigator)
        {
            if (navigator == null)
                throw new ArgumentNullException("navigator");

            if (Namespaces == null)
                Namespaces = new Dictionary<string, string>();

            if (String.IsNullOrEmpty(DefaultPrefix))
                DefaultPrefix = "d";

            DefaultNamespaces.Clear();

            navigator.MoveToRoot();
            RrecursiveParse(navigator);

            //add default namespaces
            int defaultIndex = 0;
            foreach (string name in DefaultNamespaces)
            {
                string key = GetDefaultKey(defaultIndex++);
                Namespaces.Add(key, name);
            }
        }
예제 #13
0
		private void XmlNamespaceNode (XPathNavigator nav)
		{
			string xhtml = "http://www.w3.org/1999/xhtml";
			string xmlNS = "http://www.w3.org/XML/1998/namespace";
			nav.MoveToFirstChild ();
			AssertNavigator ("#1", nav, XPathNodeType.Element,
				"", "html", xhtml, "html", "test.", false, true, false);
			Assert.IsTrue (nav.MoveToFirstNamespace (XPathNamespaceScope.Local));
			AssertNavigator ("#2", nav, XPathNodeType.Namespace,
				"", "", "", "", xhtml, false, false, false);

			// Test difference between Local, ExcludeXml and All.
			Assert.IsTrue (!nav.MoveToNextNamespace (XPathNamespaceScope.Local));
			Assert.IsTrue (!nav.MoveToNextNamespace (XPathNamespaceScope.ExcludeXml));
			// LAMESPEC: MS.NET 1.0 XmlDocument seems to have some bugs around here.
			// see http://support.microsoft.com/default.aspx?scid=kb;EN-US;Q316808
#if true
			Assert.IsTrue (nav.MoveToNextNamespace (XPathNamespaceScope.All));
			AssertNavigator ("#3", nav, XPathNodeType.Namespace,
				"", "xml", "", "xml", xmlNS, false, false, false);
			Assert.IsTrue (!nav.MoveToNextNamespace (XPathNamespaceScope.All));
#endif
			// Test to check if MoveToRoot() resets Namespace node status.
			nav.MoveToRoot ();
			AssertNavigator ("#4", nav, XPathNodeType.Root, "", "", "", "", "test.", false, true, false);
			nav.MoveToFirstChild ();

			// Test without XPathNamespaceScope argument.
			Assert.IsTrue (nav.MoveToFirstNamespace ());
			Assert.IsTrue (nav.MoveToNextNamespace ());
			AssertNavigator ("#5", nav, XPathNodeType.Namespace,
				"", "xml", "", "xml", xmlNS, false, false, false);

			// Test MoveToParent()
			Assert.IsTrue (nav.MoveToParent ());
			AssertNavigator ("#6", nav, XPathNodeType.Element,
				"", "html", xhtml, "html", "test.", false, true, false);

			nav.MoveToFirstChild ();	// body
			// Test difference between Local and ExcludeXml
			Assert.IsTrue (!nav.MoveToFirstNamespace (XPathNamespaceScope.Local), "Local should fail");
			Assert.IsTrue (nav.MoveToFirstNamespace (XPathNamespaceScope.ExcludeXml), "ExcludeXml should succeed");
			AssertNavigator ("#7", nav, XPathNodeType.Namespace,
				"", "", "", "", xhtml, false, false, false);

			Assert.IsTrue (nav.MoveToNextNamespace (XPathNamespaceScope.All));
			AssertNavigator ("#8", nav, XPathNodeType.Namespace,
				"", "xml", "", "xml", xmlNS, false, false, false);
			Assert.IsTrue (nav.MoveToParent ());
			AssertNavigator ("#9", nav, XPathNodeType.Element,
				"", "body", xhtml, "body", "test.", false, true, false);

			nav.MoveToRoot ();
			AssertNavigator ("#10", nav, XPathNodeType.Root, "", "", "", "", "test.", false, true, false);
		}
예제 #14
0
		private void XmlTwoElementsContent (XPathNavigator nav)
		{
			AssertNavigator ("#1", nav, XPathNodeType.Root, "", "", "", "", "", false, true, false);

			Assert.IsTrue (nav.MoveToFirstChild ());
			AssertNavigator ("#2", nav, XPathNodeType.Element, "", "foo", "", "foo", "", false, true, false);
			Assert.IsTrue (!nav.MoveToNext ());
			Assert.IsTrue (!nav.MoveToPrevious ());

			Assert.IsTrue (nav.MoveToFirstChild ());
			AssertNavigator ("#3", nav, XPathNodeType.Element, "", "bar", "", "bar", "", false, false, true);
			Assert.IsTrue (!nav.MoveToFirstChild ());

			Assert.IsTrue (nav.MoveToNext ());
			AssertNavigator ("#4", nav, XPathNodeType.Element, "", "baz", "", "baz", "", false, false, true);
			Assert.IsTrue (!nav.MoveToFirstChild ());

			Assert.IsTrue (nav.MoveToPrevious ());
			AssertNavigator ("#5", nav, XPathNodeType.Element, "", "bar", "", "bar", "", false, false, true);

			nav.MoveToRoot ();
			AssertNavigator ("#6", nav, XPathNodeType.Root, "", "", "", "", "", false, true, false);
			Assert.IsTrue (!nav.MoveToNext ());
		}
예제 #15
0
		public void ElementAndRootValues()
		{
			document.LoadXml ("<foo><bar>baz</bar><quux>quuux</quux></foo>");
			navigator = document.DocumentElement.CreateNavigator ();

			Assert.AreEqual (XPathNodeType.Element, navigator.NodeType, "#1");
			Assert.AreEqual ("foo", navigator.Name, "#2");
			//Assert.AreEqual ("bazquuux", navigator.Value, "#3");

			navigator.MoveToRoot ();
			//Assert.AreEqual ("bazquuux", navigator.Value, "#4");
		}
예제 #16
0
		public void DocElem_OpenClose_Attribute ()
		{
			string xml = "<root attr='value'></root>";

			nav = GetXmlDocumentNavigator (xml);
			DocElem_OpenClose_Attribute (nav, "#1.");

			nav.MoveToRoot ();
			nav.MoveToFirstChild ();
			DocElem_OpenClose_Attribute (nav, "#2.");

			nav = GetXPathDocumentNavigator (document);
			DocElem_OpenClose_Attribute (nav, "#3.");

			nav.MoveToRoot ();
			nav.MoveToFirstChild ();
			DocElem_OpenClose_Attribute (nav, "#4.");
		}
예제 #17
0
		[Category ("NotDotNet")] // MS bug
		public void AttributesAndNamespaces ()
		{
			string xml = "<root attr='value' x:a2='v2' xmlns:x='urn:foo' xmlns='urn:default'></root>";

			nav = GetXmlDocumentNavigator (xml);
			AttributesAndNamespaces (nav, "#1.");

			nav.MoveToRoot ();
			nav.MoveToFirstChild ();
			AttributesAndNamespaces (nav, "#2.");

			nav = GetXPathDocumentNavigator (document);
			AttributesAndNamespaces (nav, "#3.");

			nav.MoveToRoot ();
			nav.MoveToFirstChild ();
			AttributesAndNamespaces (nav, "#4.");
		}
예제 #18
0
        internal override XPathNavigator advance()
        {
            XPathNavigator res1, res2;
            XmlNodeOrder   order = 0;

            if (advance1)
            {
                res1 = qy1.advance();
            }
            else
            {
                res1 = _last;
            }
            if (advance2)
            {
                res2 = qy2.advance();
            }
            else
            {
                res2 = _last;
            }

            if (res1 != null && res2 != null)
            {
                order = res1.ComparePosition(res2);
            }

            else if (res2 == null)
            {
                advance1 = true;
                advance2 = false;
                m_eNext  = res1;
                _last    = null;
                return(res1);
            }
            else
            {
                advance1 = false;
                advance2 = true;
                m_eNext  = res2;
                _last    = null;
                return(res2);
            }

            if (order == XmlNodeOrder.Same)
            {
                return(ProcessSamePosition(res1));
            }
            if (order == XmlNodeOrder.Before)
            {
                return(ProcessBeforePosition(res1, res2));
            }
            if (order == XmlNodeOrder.After)
            {
                return(ProcessAfterPosition(res1, res2));
            }
            //Now order is XmlNodeOrder.Unknown
            XPathNavigator dummyres1 = res1.Clone();

            dummyres1.MoveToRoot();

            XPathNavigator dummyres2 = res2.Clone();

            dummyres2.MoveToRoot();
            int uriOrder = context.CompareDocument(dummyres1.BaseURI, dummyres2.BaseURI);

            if (uriOrder == 0)
            {
                return(ProcessSamePosition(res1));
            }
            if (uriOrder < 0)
            {
                return(ProcessBeforePosition(res1, res2));
            }
            if (uriOrder > 0)
            {
                return(ProcessAfterPosition(res1, res2));
            }
            Debug.Assert(false, "should not be herein OrQuery.advance()");
            return(null);
        }
        internal static bool ExtractFromNavigator(XPathNavigator nav)
        {
            string actor = XPathMessageFunctionActor.ExtractFromNavigator(nav);

            nav.MoveToRoot();
            if (!nav.MoveToFirstChild())
            {
                return false;
            }

            if (nav.LocalName == XPathMessageContext.EnvelopeE)
            {
                if (nav.NamespaceURI == XPathMessageContext.S11NS)
                {
                    return actor == S11UltRec;
                }
                else if (nav.NamespaceURI == XPathMessageContext.S12NS)
                {
                    return actor == S12UltRec;
                }
            }

            return false;
        }
        internal static bool MoveToBody(XPathNavigator nav)
        {
            nav.MoveToRoot();
            if (!nav.MoveToFirstChild())
            {
                return false;
            }

            string ns = nav.NamespaceURI;
            if (nav.LocalName != XPathMessageContext.EnvelopeE || (ns != XPathMessageContext.S11NS && ns != XPathMessageContext.S12NS))
            {
                return false;
            }

            if (!nav.MoveToFirstChild())
            {
                return false;
            }

            do
            {
                if (nav.LocalName == XPathMessageContext.BodyE && nav.NamespaceURI == ns)
                {
                    return true;
                }
            } while (nav.MoveToNext());

            return false;
        }
예제 #21
0
        internal override XPathNavigator advance()
        {
            if (proceed) {
                if (temp == null )
                {
                        XPathNavigator _eLast = m_qyInput.advance();    
                        while (_eLast != null){
                            temp = _eLast.Clone();
                            _eLast = m_qyInput.advance();
                        }
                        if (temp == null || temp.NodeType == XPathNodeType.Root) 
                            return null;
                        if (temp.NodeType == XPathNodeType.Attribute || temp.NodeType == XPathNodeType.Namespace){
                            temp.MoveToParent();
                        }
                        NotVisited(temp.Clone());
                        _AncestorStk.Add(temp.Clone());
                        temp.MoveToRoot();
                        _qy = temp.SelectDescendants(XPathNodeType.All, false);
                } 
                int flag;
                while ( _qy.MoveNext())
                {
                    m_eNext = _qy.Current;
                    if (matches(m_eNext)){
                        flag = InStk(m_eNext);
                        if (flag == 1){
                            _position++;
                            return m_eNext;
                        }
                        if (flag == 2) {
                            proceed = false;
                            m_eNext = null;
                            return null;
                        }
                    }
                    else{
                        if (m_eNext.IsSamePosition((XPathNavigator)_AncestorStk[_AncestorStk.Count -1])) {
                            proceed = false;
                            m_eNext = null;
                            return null;
                        }
                    }
                }
                return null;

            }
            return null;

        }
예제 #22
0
		private void XmlSimpleTextContent (XPathNavigator nav)
		{
			AssertNavigator ("#1", nav, XPathNodeType.Root, "", "", "", "", "Test.", false, true, false);
			Assert.IsTrue (nav.MoveToFirstChild (), "#x1");
			AssertNavigator ("#2", nav, XPathNodeType.Element, "", "foo", "", "foo", "Test.", false, true, false);
			Assert.IsTrue (!nav.MoveToNext (), "#x2");
			Assert.IsTrue (!nav.MoveToPrevious (), "#x3");
			Assert.IsTrue (nav.MoveToFirstChild (), "#x4");
			AssertNavigator ("#3", nav, XPathNodeType.Text, "", "", "", "", "Test.", false, false, false);

			Assert.IsTrue (nav.MoveToParent (), "#x5");
			AssertNavigator ("#4", nav, XPathNodeType.Element, "", "foo", "", "foo", "Test.", false, true, false);

			Assert.IsTrue (nav.MoveToParent (), "#x6");
			AssertNavigator ("#5", nav, XPathNodeType.Root, "", "", "", "", "Test.", false, true, false);

			nav.MoveToFirstChild ();
			nav.MoveToFirstChild ();
			nav.MoveToRoot ();
			AssertNavigator ("#6", nav, XPathNodeType.Root, "", "", "", "", "Test.", false, true, false);
			Assert.IsTrue (!nav.MoveToNext (), "#x7");
		}
        internal static string ExtractFromNavigator(XPathNavigator nav)
        {
            string actor11 = nav.GetAttribute(XPathMessageContext.Actor11A, XPathMessageContext.S11NS);
            string actor12 = nav.GetAttribute(XPathMessageContext.Actor12A, XPathMessageContext.S12NS);

            nav.MoveToRoot();
            nav.MoveToFirstChild();
            if (nav.LocalName == XPathMessageContext.EnvelopeE && nav.NamespaceURI == XPathMessageContext.S11NS)
            {
                return actor11;
            }
            else if (nav.LocalName == XPathMessageContext.EnvelopeE && nav.NamespaceURI == XPathMessageContext.S12NS)
            {
                return actor12;
            }

            return string.Empty;
        }
예제 #24
0
        /// <summary>
        /// Initialize the PrecedingIterator (no possibility of duplicates).
        /// </summary>
        public void Create(XPathNavigator context, XmlNavigatorFilter filter)
        {
            // Start at root, which is always first node in the document
            _navCurrent = XmlQueryRuntime.SyncToNavigator(_navCurrent, context);
            _navCurrent.MoveToRoot();
            _stack.Reset();

            // If root node is not the ending node,
            if (!_navCurrent.IsSamePosition(context))
            {
                // Push root onto the stack if it is not filtered
                if (!filter.IsFiltered(_navCurrent))
                    _stack.Push(_navCurrent.Clone());

                // Push all matching nodes onto stack
                while (filter.MoveToFollowing(_navCurrent, context))
                    _stack.Push(_navCurrent.Clone());
            }
        }
예제 #25
0
		public void Navigation ()
		{
			document.LoadXml ("<foo><bar /><baz /></foo>");
			navigator = document.DocumentElement.CreateNavigator ();
			
			Assert.AreEqual ("foo", navigator.Name, "#1");
			Assert.IsTrue (navigator.MoveToFirstChild (), "#2");
			Assert.AreEqual ("bar", navigator.Name, "#3");
			Assert.IsTrue (navigator.MoveToNext (), "#4");
			Assert.AreEqual ("baz", navigator.Name, "#5");
			Assert.IsTrue (!navigator.MoveToNext (), "#6");
			Assert.AreEqual ("baz", navigator.Name, "#7");
			Assert.IsTrue (navigator.MoveToPrevious (), "#8");
			Assert.AreEqual ("bar", navigator.Name, "#9");
			Assert.IsTrue (!navigator.MoveToPrevious (), "#10");
			Assert.IsTrue (navigator.MoveToParent (), "#11");
			Assert.AreEqual ("foo", navigator.Name, "#12");
			navigator.MoveToRoot ();
			Assert.AreEqual (XPathNodeType.Root, navigator.NodeType, "#13");
			Assert.IsTrue (!navigator.MoveToParent (), "#14");
			Assert.AreEqual (XPathNodeType.Root, navigator.NodeType, "#15");
			Assert.IsTrue (navigator.MoveToFirstChild (), "#16");
			Assert.AreEqual ("foo", navigator.Name, "#17");
			Assert.IsTrue (navigator.MoveToFirst (), "#18");
			Assert.AreEqual ("foo", navigator.Name, "#19");
			Assert.IsTrue (navigator.MoveToFirstChild (), "#20");
			Assert.AreEqual ("bar", navigator.Name, "#21");
			Assert.IsTrue (navigator.MoveToNext (), "#22");
			Assert.AreEqual ("baz", navigator.Name, "#23");
			Assert.IsTrue (navigator.MoveToFirst (), "#24");
			Assert.AreEqual ("bar", navigator.Name, "#25");
		}
예제 #26
0
        public virtual XmlNodeOrder ComparePosition(XPathNavigator nav)
        {
            if (IsSamePosition(nav))
            {
                return(XmlNodeOrder.Same);
            }

            if (IsDescendant(nav))
            {
                return(XmlNodeOrder.Before);
            }
            else if (nav.IsDescendant(this))
            {
                return(XmlNodeOrder.After);
            }

            XPathNavigator copy  = this.Clone();
            XPathNavigator other = nav.Clone();

            /* now, it gets expensive - we find the
             * closest common ancestor. But these two
             * might be from totally different places.
             *
             * Someone should re-implement this somewhere,
             * so that it is faster for XmlDocument.
             */
            int common     = 0;
            int otherDepth = 0;
            int copyDepth  = 0;

            copy.MoveToRoot();
            other.MoveToRoot();

            if (!copy.IsSamePosition(other))
            {
                return(XmlNodeOrder.Unknown);
            }

            /* what do you think ? I'm made of GC space ? */
            copy.MoveTo(this);
            other.MoveTo(nav);

            while (other.MoveToParent())
            {
                otherDepth++;
            }

            while (copy.MoveToParent())
            {
                copyDepth++;
            }

            common = (otherDepth > copyDepth) ? copyDepth : otherDepth;

            other.MoveTo(nav);
            copy.MoveTo(this);

            // traverse both till you get to depth == common
            for (; otherDepth > common; otherDepth--)
            {
                other.MoveToParent();
            }
            for (; copyDepth > common; copyDepth--)
            {
                copy.MoveToParent();
            }

            other.MoveTo(nav);
            copy.MoveTo(this);

            XPathNavigator copy1  = copy.Clone();
            XPathNavigator other1 = other.Clone();

            while (copy.IsSamePosition(other))
            {
                copy1.MoveTo(copy);
                other1.MoveTo(other);

                copy.MoveToParent();
                other.MoveToParent();
            }

            copy.MoveTo(copy1);
            other.MoveTo(other1);

            // Now copy & other are siblings and can be compared
            while (copy.MoveToNext())
            {
                if (copy.IsSamePosition(other))
                {
                    return(XmlNodeOrder.Before);
                }
            }

            return(XmlNodeOrder.After);
        }
예제 #27
0
		public void DocumentWithXmlDeclaration ()
		{
			document.LoadXml ("<?xml version=\"1.0\" standalone=\"yes\"?><Root><foo>bar</foo></Root>");
			navigator = document.CreateNavigator ();

			navigator.MoveToRoot ();
			navigator.MoveToFirstChild ();
			Assert.AreEqual (XPathNodeType.Element, navigator.NodeType, "#1");
			Assert.AreEqual ("Root", navigator.Name, "#2");
		}
예제 #28
0
		public void MoveToFirstAttributeFromAttribute ()
		{
			string xml = @"<one xmlns:foo='urn:foo' a='v' />";

			nav = GetXmlDocumentNavigator (xml);
			MoveToFirstAttributeFromAttribute (nav, "#1.");

			nav.MoveToRoot ();
			nav.MoveToFirstChild ();
			MoveToFirstAttributeFromAttribute (nav, "#2.");

			nav = GetXPathDocumentNavigator (document);
			MoveToFirstAttributeFromAttribute (nav, "#3.");

			nav.MoveToRoot ();
			nav.MoveToFirstChild ();
			MoveToFirstAttributeFromAttribute (nav, "#4.");
		}
예제 #29
0
		private void XmlRootElementOnly (XPathNavigator nav)
		{
			AssertNavigator ("#1", nav, XPathNodeType.Root, "", "", "", "", "", false, true, false);
			Assert.IsTrue (nav.MoveToFirstChild ());
			AssertNavigator ("#2", nav, XPathNodeType.Element, "", "foo", "", "foo", "", false, false, true);
			Assert.IsTrue (!nav.MoveToFirstChild ());
			Assert.IsTrue (!nav.MoveToNext ());
			Assert.IsTrue (!nav.MoveToPrevious ());
			nav.MoveToRoot ();
			AssertNavigator ("#3", nav, XPathNodeType.Root, "", "", "", "", "", false, true, false);
			Assert.IsTrue (!nav.MoveToNext ());
		}
예제 #30
0
        IEnumerable<FootballEvent> NavigateSprts(XPathNavigator nav)
        {
            // move to the root and the first element - <books>
            nav.MoveToRoot();

            var sports = nav.Select("//rsp/fd/sports/sport");
            while (sports.MoveNext())
            {
                var sport = sports.Current;
                var sportName = _sportKindResonlver(GetIdFromNode(sport));
                var leagues = sport.Select("leagues/league");

                while (leagues.MoveNext())
                {
                    var leagueName = _leagueNameResolver(GetIdFromNode(leagues.Current));
                    var events = leagues.Current.Select("events/event");
                    while (events.MoveNext())
                    {
                        var @event = events.Current;
                        var eventid = GetIdFromNode(@event);

                        var when = DateTimeOffset.Parse(GetChildNodeValue(@event, "startDateTime").First());
                        var homeTeam = GetChildNodeValue(@event, "homeTeam/name").First();
                        var awayTeam = GetChildNodeValue(@event, "awayTeam/name").First();

                        var periods = @event.Select("periods/period");
                        var pperiods = ParsePeriods(periods).ToArray();

                        yield return new FootballEvent { AwayTeam = awayTeam, HomeTeam = homeTeam, League = leagueName, Sport = sportName, Periods = pperiods, When = when };
                    }
                }
            }
        }
예제 #31
0
		private void XmlElementWithAttributes (XPathNavigator nav)
		{
			nav.MoveToFirstChild ();
			AssertNavigator ("#1", nav, XPathNodeType.Element, "", "img", "", "img", "", true, false, true);
			Assert.IsTrue (!nav.MoveToNext ());
			Assert.IsTrue (!nav.MoveToPrevious ());

			Assert.IsTrue (nav.MoveToFirstAttribute ());
			AssertNavigator ("#2", nav, XPathNodeType.Attribute, "", "src", "", "src", "foo.png", false, false, false);
			Assert.IsTrue (!nav.MoveToFirstAttribute ());	// On attributes, it fails.

			Assert.IsTrue (nav.MoveToNextAttribute ());
			AssertNavigator ("#3", nav, XPathNodeType.Attribute, "", "alt", "", "alt", "image Fooooooo!", false, false, false);
			Assert.IsTrue (!nav.MoveToNextAttribute ());

			Assert.IsTrue (nav.MoveToParent ());
			AssertNavigator ("#4", nav, XPathNodeType.Element, "", "img", "", "img", "", true, false, true);

			Assert.IsTrue (nav.MoveToAttribute ("alt", ""));
			AssertNavigator ("#5", nav, XPathNodeType.Attribute, "", "alt", "", "alt", "image Fooooooo!", false, false, false);
			Assert.IsTrue (!nav.MoveToAttribute ("src", ""));	// On attributes, it fails.
			Assert.IsTrue (nav.MoveToParent ());
			Assert.IsTrue (nav.MoveToAttribute ("src", ""));
			AssertNavigator ("#6", nav, XPathNodeType.Attribute, "", "src", "", "src", "foo.png", false, false, false);

			nav.MoveToRoot ();
			AssertNavigator ("#7", nav, XPathNodeType.Root, "", "", "", "", "", false, true, false);
		}
		private void XmlSimpleElementContent (XPathNavigator nav)
		{
			AssertNavigator (nav, XPathNodeType.Root, "", "", "", "", "", false, true, false);
			Assert (nav.MoveToFirstChild ());
			AssertNavigator (nav, XPathNodeType.Element, "", "foo", "", "foo", "", false, true, false);
			Assert (!nav.MoveToNext ());
			Assert (!nav.MoveToPrevious ());

			Assert (nav.MoveToFirstChild ());
			AssertNavigator (nav, XPathNodeType.Element, "", "bar", "", "bar", "", false, false, true);

			Assert (nav.MoveToParent ());
			AssertNavigator (nav, XPathNodeType.Element, "", "foo", "", "foo", "", false, true, false);

			nav.MoveToRoot ();
			AssertNavigator (nav, XPathNodeType.Root, "", "", "", "", "", false, true, false);
			Assert (!nav.MoveToNext ());
		}
예제 #33
0
		public string CreateNamespace(string prefix, string namespaceUri, XPathNavigator source)
		{
			if (string.IsNullOrEmpty(namespaceUri) == false)
			{
				source = source.Clone();
				source.MoveToRoot();
				source.MoveToChild(XPathNodeType.Element);

				if (string.IsNullOrEmpty(prefix))
					prefix = AddNamespace(namespaceUri);

				var existing = source.GetNamespace(prefix);
				if (existing == namespaceUri) return prefix;
				if (string.IsNullOrEmpty(existing) == false) return null;

				source.CreateAttribute("xmlns", prefix, "", namespaceUri);
			}
			return prefix;
		}
 internal static string ExtractFromNavigator(XPathNavigator nav)
 {
     nav.MoveToRoot();
     if (nav.MoveToFirstChild())
     {
         string ns = nav.NamespaceURI;
         if (nav.LocalName != XPathMessageContext.EnvelopeE || (ns != XPathMessageContext.S11NS && ns != XPathMessageContext.S12NS))
         {
             return string.Empty;
         }
         else
         {
             return ns;
         }
     }
     else
     {
         return string.Empty;
     }
 }
예제 #35
0
        public virtual XmlNodeOrder ComparePosition(XPathNavigator nav)
        {
            if (IsSamePosition(nav))
            {
                return(XmlNodeOrder.Same);
            }

            // quick check for direct descendant
            if (IsDescendant(nav))
            {
                return(XmlNodeOrder.Before);
            }

            // quick check for direct ancestor
            if (nav.IsDescendant(this))
            {
                return(XmlNodeOrder.After);
            }

            XPathNavigator nav1 = Clone();
            XPathNavigator nav2 = nav.Clone();

            // check if document instance is the same.
            nav1.MoveToRoot();
            nav2.MoveToRoot();
            if (!nav1.IsSamePosition(nav2))
            {
                return(XmlNodeOrder.Unknown);
            }
            nav1.MoveTo(this);
            nav2.MoveTo(nav);

            int depth1 = 0;

            while (nav1.MoveToParent())
            {
                depth1++;
            }
            nav1.MoveTo(this);
            int depth2 = 0;

            while (nav2.MoveToParent())
            {
                depth2++;
            }
            nav2.MoveTo(nav);

            // find common parent depth
            int common = depth1;

            for (; common > depth2; common--)
            {
                nav1.MoveToParent();
            }
            for (int i = depth2; i > common; i--)
            {
                nav2.MoveToParent();
            }
            while (!nav1.IsSamePosition(nav2))
            {
                nav1.MoveToParent();
                nav2.MoveToParent();
                common--;
            }

            // For each this and target, move to the node that is
            // ancestor of the node and child of the common parent.
            nav1.MoveTo(this);
            for (int i = depth1; i > common + 1; i--)
            {
                nav1.MoveToParent();
            }
            nav2.MoveTo(nav);
            for (int i = depth2; i > common + 1; i--)
            {
                nav2.MoveToParent();
            }

            // Those children of common parent are comparable.
            // namespace nodes precede to attributes, and they
            // precede to other nodes.
            if (nav1.NodeType == XPathNodeType.Namespace)
            {
                if (nav2.NodeType != XPathNodeType.Namespace)
                {
                    return(XmlNodeOrder.Before);
                }
                while (nav1.MoveToNextNamespace())
                {
                    if (nav1.IsSamePosition(nav2))
                    {
                        return(XmlNodeOrder.Before);
                    }
                }
                return(XmlNodeOrder.After);
            }
            if (nav2.NodeType == XPathNodeType.Namespace)
            {
                return(XmlNodeOrder.After);
            }
            if (nav1.NodeType == XPathNodeType.Attribute)
            {
                if (nav2.NodeType != XPathNodeType.Attribute)
                {
                    return(XmlNodeOrder.Before);
                }
                while (nav1.MoveToNextAttribute())
                {
                    if (nav1.IsSamePosition(nav2))
                    {
                        return(XmlNodeOrder.Before);
                    }
                }
                return(XmlNodeOrder.After);
            }
            while (nav1.MoveToNext())
            {
                if (nav1.IsSamePosition(nav2))
                {
                    return(XmlNodeOrder.Before);
                }
            }
            return(XmlNodeOrder.After);
        }
예제 #36
0
		public void MixedContentAndDepth ()
		{
			string xml = @"<one>  <two>Some data.<three>more</three> done.</two>  </one>";

			nav = GetXmlDocumentNavigator (xml);
			MixedContentAndDepth (nav, "#1.");

			nav.MoveToRoot ();
			nav.MoveToFirstChild ();
			MixedContentAndDepth (nav, "#2.");

			nav = GetXPathDocumentNavigator (document);
			MixedContentAndDepth (nav, "#3.");

			nav.MoveToRoot ();
			nav.MoveToFirstChild ();
			MixedContentAndDepth (nav, "#4.");
		}