[Test] //ExSkip public void NodeXPathNavigator() { // Create a blank document Document doc = new Document(); // A document is a composite node so we can make a navigator straight away System.Xml.XPath.XPathNavigator navigator = doc.CreateNavigator(); // Our root is the document node with 1 child, which is the first section Assert.AreEqual("Document", navigator.Name); Assert.AreEqual(false, navigator.MoveToNext()); Assert.AreEqual(1, navigator.SelectChildren(XPathNodeType.All).Count); // The document tree has the document, first section, body and first paragraph as nodes, with each being an only child of the previous // We can add a few more to give the tree some branches for the navigator to traverse DocumentBuilder docBuilder = new DocumentBuilder(doc); docBuilder.Write("Section 1, Paragraph 1. "); docBuilder.InsertParagraph(); docBuilder.Write("Section 1, Paragraph 2. "); doc.AppendChild(new Section(doc)); docBuilder.MoveToSection(1); docBuilder.Write("Section 2, Paragraph 1. "); // Use our navigator to print a map of all the nodes in the document to the console StringBuilder stringBuilder = new StringBuilder(); MapDocument(navigator, stringBuilder, 0); Console.Write(stringBuilder.ToString()); }
private static void Traverse(TextWriter writer, XPathNavigator nav, int depth = 0) { var leadIn = new string(Constants.Tab, depth); if (nav.NodeType == XPathNodeType.Root) nav.MoveToFirstChild(); do { switch (nav.NodeType) { case XPathNodeType.Element: WriteElement(writer, nav, depth, leadIn); break; case XPathNodeType.Text: WriteTextData(writer, nav, leadIn); break; case XPathNodeType.Comment: WriteComment(writer, nav, leadIn); break; default: throw new InvalidDataException("Encountered unsupported node type of " + nav.NodeType); } } while (nav.MoveToNext()); }
public static string GetStringXML(XPathNavigator xPathNavigator) { if (xPathNavigator.MoveToNext ()) { return xPathNavigator.Value; } return null; }
internal static bool MoveToAddressingHeaderSibling(XPathNavigator nav, string name) { while (nav.MoveToNext()) { if ((nav.LocalName == name) && ((nav.NamespaceURI == "http://www.w3.org/2005/08/addressing") || (nav.NamespaceURI == "http://schemas.xmlsoap.org/ws/2004/08/addressing"))) { return true; } } return false; }
public static IEnumerable<XPathNavigator> EnumerateChildren(XPathNavigator navigator) { if (navigator.MoveToFirstChild()) { do { yield return navigator; } while (navigator.MoveToNext()); navigator.MoveToParent(); } }
public void ReadXml(XPathNavigator node) { if (node.MoveToFirstAttribute()) { do { if (String.IsNullOrEmpty(node.NamespaceURI)) { switch (node.LocalName) { case "method": switch (node.Value) { case "xml": this.Method = XmlSerializationOptions.Methods.Xml; break; case "html": this.Method = XmlSerializationOptions.Methods.Html; break; case "xhtml": this.Method = XmlSerializationOptions.Methods.XHtml; break; case "text": this.Method = XmlSerializationOptions.Methods.Text; break; } break; default: break; } } } while (node.MoveToNextAttribute()); node.MoveToParent(); } if (node.MoveToFirstChild()) { do { if (node.NodeType == XPathNodeType.Element || node.NodeType == XPathNodeType.Text) { this.Content = node.Clone(); break; } } while (node.MoveToNext()); node.MoveToParent(); } }
/// <summary> /// Updates all of the <c>Torrent</c> object's properties. /// </summary> /// <param name="node">Torrent XML node</param> public void update(XPathNavigator node) { node.MoveToFirstChild(); hash = node.Value; node.MoveToNext(); status = Convert.ToInt64(node.Value); node.MoveToNext(); name = node.Value; node.MoveToNext(); size = Convert.ToInt64(node.Value); node.MoveToNext(); percent_progress = Convert.ToInt64(node.Value); // skip a tonne of properties for (int i = 0; i < 17; i++) node.MoveToNext(); status_message = node.Value; calculateStatus(); last_modified = DateTime.Now; // be kind, rewind node.MoveToParent(); }
//creates a dictionary of values found in XML private static Dictionary<string, string> ResourceDataToDictionary(XPathNavigator xPathNavigator) { Dictionary<string, string> dict = new Dictionary<string, string>(); if (xPathNavigator.MoveToFirstChild()) //children { dict.Add(xPathNavigator.Name, xPathNavigator.Value); while (xPathNavigator.MoveToNext()) { dict.Add(xPathNavigator.Name, xPathNavigator.Value); } } xPathNavigator.MoveToParent(); return dict; }
/// <summary> /// Walks the XPathNavigator tree recursively /// </summary> /// <param name="myXPathNavigator"></param> public static void DisplayTree(XPathNavigator myXPathNavigator) { if (myXPathNavigator.HasChildren) { myXPathNavigator.MoveToFirstChild(); Format(myXPathNavigator); DisplayTree(myXPathNavigator); myXPathNavigator.MoveToParent(); } while (myXPathNavigator.MoveToNext()) { Format(myXPathNavigator); DisplayTree(myXPathNavigator); } }
internal static bool MoveToAddressingHeader(XPathNavigator nav, string name) { if (MoveToHeader(nav)) { if (!nav.MoveToFirstChild()) { return false; } do { if ((nav.LocalName == name) && (((nav.NamespaceURI == "http://www.w3.org/2005/08/addressing") || (nav.NamespaceURI == "http://schemas.xmlsoap.org/ws/2004/08/addressing")) || (nav.NamespaceURI == "http://schemas.microsoft.com/ws/2005/05/addressing/none"))) { return true; } } while (nav.MoveToNext()); } return false; }
/// <summary> /// WebDav Property. /// </summary> /// <param name="property"></param> public DavProperty(XPathNavigator property) { if (property == null) throw new ArgumentNullException("property", InternalFunctions.GetResourceString("ArgumentNullException", "Property")); else if (property.NodeType != XPathNodeType.Element) throw new ArgumentException(InternalFunctions.GetResourceString("XPathNavigatorElementArgumentException", "Property"), "property"); base.Name = property.LocalName; base.Namespace = property.NamespaceURI; if (property.HasAttributes) { //TODO: Support element attributes //string _here = ""; //Add the attributes first // foreach (XmlAttribute _xmlAttribute in property.Attributes) // Attributes.Add(new DavPropertyAttribute(_xmlAttribute)); } if (property.MoveToFirstChild()) { if (property.NodeType == XPathNodeType.Element) { NestedProperties.Add(new DavProperty(property.Clone())); while (property.MoveToNext()) { if (property.NodeType == XPathNodeType.Element) NestedProperties.Add(new DavProperty(property.Clone())); } } else if (property.NodeType == XPathNodeType.Text) { base.Value = property.Value; property.MoveToParent(); } } }
public CreateLine(System.Xml.XPath.XPathNavigator navigator, GEMSSingle parent) : base(navigator, parent) { navigator.MoveToChild("Positions", string.Empty); navigator.MoveToFirstChild(); //Start Point of line startPoint = new Vector3WithUnit(); startPoint.X = new Length(navigator.GetAttribute("x", string.Empty), navigator.GetAttribute("ux", string.Empty)); startPoint.Y = new Length(navigator.GetAttribute("y", string.Empty), navigator.GetAttribute("uy", string.Empty)); startPoint.Z = new Length(navigator.GetAttribute("z", string.Empty), navigator.GetAttribute("uz", string.Empty)); //End Point of line navigator.MoveToNext(); endPoint = new Vector3WithUnit(); endPoint.X = new Length(navigator.GetAttribute("x", string.Empty), navigator.GetAttribute("ux", string.Empty)); endPoint.Y = new Length(navigator.GetAttribute("y", string.Empty), navigator.GetAttribute("uy", string.Empty)); endPoint.Z = new Length(navigator.GetAttribute("z", string.Empty), navigator.GetAttribute("uz", string.Empty)); navigator.MoveToParent(); navigator.MoveToParent(); }
public void RecursiveWalkThroughXpath(XPathNavigator navigator) { switch (navigator.NodeType) { case XPathNodeType.Root: //TODO: do this better ie parse xml or html decelration if (IncludeDocType) { textWriter.Write("!!!"); textWriter.Write(Environment.NewLine); } break; case XPathNodeType.Element: ProcessElement(navigator); break; case XPathNodeType.Text: ProcessText(navigator); break; } if (navigator.MoveToFirstChild()) { do { RecursiveWalkThroughXpath(navigator); } while (navigator.MoveToNext()); navigator.MoveToParent(); CheckUnIndent(navigator); } else { CheckUnIndent(navigator); } }
public virtual XmlWriter InsertAfter() { switch (NodeType) { case XPathNodeType.Root: case XPathNodeType.Attribute: case XPathNodeType.Namespace: throw new InvalidOperationException(String.Format("Insertion after {0} is not allowed.", NodeType)); } XPathNavigator nav = Clone(); if (nav.MoveToNext()) { return(nav.InsertBefore()); } else if (nav.MoveToParent()) { return(nav.AppendChild()); } else { throw new InvalidOperationException("Could not move to parent to insert sibling node"); } }
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 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 ()); }
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 ()); }
protected XPathNavigator MatchNode(XPathNavigator current, IQuery query) { XPathNavigator context; if (current != null) { context = query.MatchNode(current); if (context != null) { if (_opnd.ReturnType() == XPathResultType.Number) { if (_opnd.getName() == Querytype.Constant) { XPathNavigator result = current.Clone(); int i = 0; if (query.getName() == Querytype.Child) { result.MoveToParent(); result.MoveToFirstChild(); while (true) { if (((ChildrenQuery)query).matches(result)) { i++; if (current.IsSamePosition(result)) { if (XmlConvert.ToXPathDouble(_opnd.getValue(current, null)) == i) { return(context); } else { return(null); } } } if (!result.MoveToNext()) { return(null); } } } if (query.getName() == Querytype.Attribute) { result.MoveToParent(); result.MoveToFirstAttribute(); while (true) { if (((AttributeQuery)query).matches(result)) { i++; } if (current.IsSamePosition(result)) { if (XmlConvert.ToXPathDouble(_opnd.getValue(current, null)) == i) { return(context); } else { return(null); } } if (!result.MoveToNextAttribute()) { return(null); } } } } else { setContext(context.Clone()); XPathNavigator result = advance(); while (result != null) { if (result.IsSamePosition(current)) { return(context); } result = advance(); } } } if (_opnd.ReturnType() == XPathResultType.NodeSet) { _opnd.setContext(current); if (_opnd.advance() != null) { return(context); } else { return(null); } } if (_opnd.ReturnType() == XPathResultType.Boolean) { if (noPosition) { if ((bool)_opnd.getValue(current, null)) { return(context); } return(null); } setContext(context.Clone()); XPathNavigator result = advance(); while (result != null) { if (result.IsSamePosition(current)) { return(context); } result = advance(); } return(null); } if (_opnd.ReturnType() == XPathResultType.String) { if (_opnd.getValue(context, null).ToString().Length > 0) { return(context); } else { return(null); } } } else { return(null); } } return(null); }
public static void WriteNode(this XmlWriter writer, XPathNavigator navigator, bool defattr) { if (navigator == null) { throw new ArgumentNullException(nameof(navigator)); } int iLevel = 0; navigator = navigator.Clone(); while (true) { bool mayHaveChildren = false; XPathNodeType nodeType = navigator.NodeType; switch (nodeType) { case XPathNodeType.Element: writer.WriteStartElement(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); // Copy attributes if (navigator.MoveToFirstAttribute()) { do { writer.WriteStartAttribute(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); // copy string value to writer writer.WriteString(navigator.Value); writer.WriteEndAttribute(); } while (navigator.MoveToNextAttribute()); navigator.MoveToParent(); } // Copy namespaces if (navigator.MoveToFirstNamespace(XPathNamespaceScope.Local)) { writer.WriteLocalNamespaces(navigator); navigator.MoveToParent(); } mayHaveChildren = true; break; case XPathNodeType.Attribute: // do nothing on root level attribute break; case XPathNodeType.Text: writer.WriteString(navigator.Value); break; case XPathNodeType.SignificantWhitespace: case XPathNodeType.Whitespace: writer.WriteWhitespace(navigator.Value); break; case XPathNodeType.Root: mayHaveChildren = true; break; case XPathNodeType.Comment: writer.WriteComment(navigator.Value); break; case XPathNodeType.ProcessingInstruction: writer.WriteProcessingInstruction(navigator.LocalName, navigator.Value); break; case XPathNodeType.Namespace: // do nothing on root level namespace break; default: Debug.Fail("Unmatched state in switch"); break; } if (mayHaveChildren) { // If children exist, move down to next level if (navigator.MoveToFirstChild()) { iLevel++; continue; } else { // EndElement if (navigator.NodeType == XPathNodeType.Element) { if (navigator.IsEmptyElement) { writer.WriteEndElement(); } else { writer.WriteFullEndElement(); } } } } // No children while (true) { if (iLevel == 0) { // The entire subtree has been copied return; } if (navigator.MoveToNext()) { // Found a sibling, so break to outer loop break; } // No siblings, so move up to previous level iLevel--; navigator.MoveToParent(); // EndElement if (navigator.NodeType == XPathNodeType.Element) { writer.WriteFullEndElement(); } } } }
/// <summary> /// Move to the next reader state. Return false if that is ReaderState.Closed. /// </summary> public override bool Read() { _attrCount = -1; switch (_state) { case State.Error: case State.Closed: case State.EOF: return(false); case State.Initial: // Starting state depends on the navigator's item type _nav = _navToRead; _state = State.Content; if (XPathNodeType.Root == _nav.NodeType) { if (!_nav.MoveToFirstChild()) { SetEOF(); return(false); } _readEntireDocument = true; } else if (XPathNodeType.Attribute == _nav.NodeType) { _state = State.Attribute; } _nodeType = ToXmlNodeType(_nav.NodeType); break; case State.Content: if (_nav.MoveToFirstChild()) { _nodeType = ToXmlNodeType(_nav.NodeType); _depth++; _state = State.Content; } else if (_nodeType == XmlNodeType.Element && !_nav.IsEmptyElement) { _nodeType = XmlNodeType.EndElement; _state = State.EndElement; } else { goto case State.EndElement; } break; case State.EndElement: if (0 == _depth && !_readEntireDocument) { SetEOF(); return(false); } else if (_nav.MoveToNext()) { _nodeType = ToXmlNodeType(_nav.NodeType); _state = State.Content; } else if (_depth > 0 && _nav.MoveToParent()) { Debug.Assert(_nav.NodeType == XPathNodeType.Element, _nav.NodeType.ToString() + " == XPathNodeType.Element"); _nodeType = XmlNodeType.EndElement; _state = State.EndElement; _depth--; } else { SetEOF(); return(false); } break; case State.Attribute: case State.AttrVal: if (!_nav.MoveToParent()) { SetEOF(); return(false); } _nodeType = ToXmlNodeType(_nav.NodeType); _depth--; if (_state == State.AttrVal) { _depth--; } goto case State.Content; case State.InReadBinary: _state = _savedState; _readBinaryHelper.Finish(); return(Read()); } return(true); }
private void GetNamespaceConsistentTree (XPathNavigator nav) { nav.MoveToFirstChild (); nav.MoveToFirstChild (); nav.MoveToNext (); Assert.AreEqual ("ns1", nav.GetNamespace (""), "#1." + nav.GetType ()); nav.MoveToNext (); nav.MoveToNext (); Assert.AreEqual ("", nav.GetNamespace (""), "#2." + nav.GetType ()); }
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); }
public void ReadXml(XPathNavigator node, XmlResolver resolver) { if (node.NodeType == XPathNodeType.Element) { if (node.MoveToFirstAttribute()) { do { switch (node.LocalName) { case "media-type": this.MediaType = node.Value; break; case "boundary": this.Boundary = node.Value; break; } } while (node.MoveToNextAttribute()); node.MoveToParent(); } if (node.MoveToChild(XPathNodeType.Element)) { XPathHttpMultipartItem currentItem = null; do { if (node.NamespaceURI == XPathHttpClient.Namespace) { switch (node.LocalName) { case "header": if (currentItem == null) { currentItem = new XPathHttpMultipartItem(); } currentItem.Headers.Add(node.GetAttribute("name", ""), node.GetAttribute("value", "")); break; case "body": if (currentItem == null) { currentItem = new XPathHttpMultipartItem(); } currentItem.Body = new XPathHttpBody(); currentItem.Body.ReadXml(node, resolver); this.Items.Add(currentItem); currentItem = null; break; } } } while (node.MoveToNext(XPathNodeType.Element)); node.MoveToParent(); } } }
internal override XPathNavigator advance() { if (_eLast == null) { XPathNavigator temp = null; _eLast = m_qyInput.advance(); if (_eLast == null) { return(null); } while (_eLast != null) { _eLast = _eLast.Clone(); temp = _eLast; _eLast = m_qyInput.advance(); if (!temp.IsDescendant(_eLast)) { break; } } _eLast = temp; } while (true) { if (_first) { _first = false; if (_eLast.NodeType == XPathNodeType.Attribute || _eLast.NodeType == XPathNodeType.Namespace) { _eLast.MoveToParent(); if (_fMatchName) { _qy = _eLast.SelectDescendants(m_Name, m_URN, false); } else { _qy = _eLast.SelectDescendants(m_Type, false); } } else { while (true) { if (!_eLast.MoveToNext()) { if (!_eLast.MoveToParent()) { _first = true; return(null); } } else { break; } } if (_fMatchName) { _qy = _eLast.SelectDescendants(m_Name, m_URN, true); } else { _qy = _eLast.SelectDescendants(m_Type, true); } } } if (_qy.MoveNext()) { _position++; m_eNext = _qy.Current; return(m_eNext); } else { _first = true; } } }
/// <summary> /// Copy the navigator subtree to the raw writer. /// </summary> private void CopyNode(XPathNavigator nav) { XPathNodeType nodeType; int iLevel = 0; while (true) { if (CopyShallowNode(nav)) { nodeType = nav.NodeType; if (nodeType == XPathNodeType.Element) { // Copy attributes if (nav.MoveToFirstAttribute()) { do { CopyShallowNode(nav); } while (nav.MoveToNextAttribute()); nav.MoveToParent(); } // Copy namespaces in document order (navigator returns them in reverse document order) XPathNamespaceScope nsScope = (iLevel == 0) ? XPathNamespaceScope.ExcludeXml : XPathNamespaceScope.Local; if (nav.MoveToFirstNamespace(nsScope)) { CopyNamespaces(nav, nsScope); nav.MoveToParent(); } this.xwrt.StartElementContent(); } // If children exist, move down to next level if (nav.MoveToFirstChild()) { iLevel++; continue; } else { // EndElement if (nav.NodeType == XPathNodeType.Element) this.xwrt.WriteEndElement(nav.Prefix, nav.LocalName, nav.NamespaceURI); } } // No children while (true) { if (iLevel == 0) { // The entire subtree has been copied return; } if (nav.MoveToNext()) { // Found a sibling, so break to outer loop break; } // No siblings, so move up to previous level iLevel--; nav.MoveToParent(); // EndElement if (nav.NodeType == XPathNodeType.Element) this.xwrt.WriteFullEndElement(nav.Prefix, nav.LocalName, nav.NamespaceURI); } } }
/// <summary> /// Deep copy the subtree that is rooted at this navigator's current position to output. If the current /// item is an element, copy all in-scope namespace nodes. /// </summary> private void CopyNode(XPathNavigator navigator) { XPathNodeType nodeType; int depthStart = this.depth; Debug.Assert(navigator != null); while (true) { if (StartCopy(navigator, this.depth == depthStart)) { nodeType = navigator.NodeType; Debug.Assert(nodeType == XPathNodeType.Element, "StartCopy should return true only for Element nodes."); // Copy attributes if (navigator.MoveToFirstAttribute()) { do { StartCopy(navigator, false); } while (navigator.MoveToNextAttribute()); navigator.MoveToParent(); } // Copy namespaces in document order (navigator returns them in reverse document order) CopyNamespaces(navigator, (this.depth - 1 == depthStart) ? XPathNamespaceScope.ExcludeXml : XPathNamespaceScope.Local); StartElementContentUnchecked(); // If children exist, move down to next level if (navigator.MoveToFirstChild()) continue; EndCopy(navigator, (this.depth - 1) == depthStart); } // No children while (true) { if (this.depth == depthStart) { // The entire subtree has been copied return; } if (navigator.MoveToNext()) { // Found a sibling, so break to outer loop break; } // No siblings, so move up to previous level navigator.MoveToParent(); EndCopy(navigator, (this.depth - 1) == depthStart); } } }
/// <summary> /// Copy a node by value to output according to Xslt rules: /// 1. Identity is never preserved /// 2. If the item is an Rtf, preserve serialization hints when copying. /// 3. If the item is a Root node, copy the children of the Root /// </summary> public void XsltCopyOf(XPathNavigator navigator) { RtfNavigator navRtf = navigator as RtfNavigator; if (navRtf != null) { // Copy Rtf navRtf.CopyToWriter(this); } else if (navigator.NodeType == XPathNodeType.Root) { // Copy children of root if (navigator.MoveToFirstChild()) { do { CopyNode(navigator); } while (navigator.MoveToNext()); navigator.MoveToParent(); } } else { // Copy node CopyNode(navigator); } }
protected virtual ContentItem OnReadingItem(XPathNavigator navigator) { Dictionary<string, string> attributes = GetAttributes(navigator); ItemDefinition definition = FindDefinition(attributes); ContentItem item = engine.Resolve<ContentActivator>().CreateInstance(definition.ItemType, null); OnSettingDefaultAttributes(attributes, item); //authorizedRoles navigator.MoveToFirstChild(); OnReadingAuthorizedRoles(navigator, item); //details navigator.MoveToNext(); OnReadingDetails(navigator, item); //detailCollections navigator.MoveToNext(); OnReadingDetailCollections(navigator, item); //children navigator.MoveToNext(); OnReadingChildren(navigator, item); navigator.MoveToParent(); return item; }
private void OnReadingChildren(XPathNavigator navigator, ContentItem item) { if (navigator.MoveToFirstChild()) { do { ContentItem child = OnReadingItem(navigator); child.AddTo(item); } while (navigator.MoveToNext()); navigator.MoveToParent(); } }
/// <summary> /// Reference: https://support.microsoft.com/en-us/kb/308343 /// </summary> /// <param name="xNav"></param> public void TraverseChildren(XPathNavigator xNav) { xNav.MoveToFirstChild(); do { //Find the first element. if (xNav.NodeType == XPathNodeType.Element) { //Determine whether children exist. if (xNav.HasChildren == true) { //Console.Write("The XML string for this child "); //Console.WriteLine("is {0} = {1}", xNav.Name, xNav.Value); switch (xNav.Name) { case "timestamp_format" : Config.TimestampFormat = xNav.Value; break; case "output_file_path": Config.OutputFilePath = xNav.Value; break; case "screenshots_folder": Config.ScreenshotsFolder = xNav.Value; break; case "screenshot_on_every_message": Config.ScreenshotOnEveryMessage = Convert.ToBoolean(xNav.Value); break; case "screenshot_on_every_pass": Config.ScreenshotOnEveryPass = Convert.ToBoolean(xNav.Value); break; case "screenshot_on_every_fail": Config.ScreenshotOnEveryFail = Convert.ToBoolean(xNav.Value); break; case "screenshot_on_every_error": Config.ScreenshotOnEveryError = Convert.ToBoolean(xNav.Value); break; case "force_throw_exception_on_assert_fail": Config.ScreenshotOnEveryFail = Convert.ToBoolean(xNav.Value); break; case "on_click_event": _ParentNode = "OnClick"; break; case "log_function_start": if (_ParentNode == "OnClick") Config.OnClick_LogFunctionStart = Convert.ToBoolean(xNav.Value); break; case "log_function_end": if (_ParentNode == "OnClick") Config.OnClick_LogFunctionEnd = Convert.ToBoolean(xNav.Value); break; case "screenshot_on_start": if (_ParentNode == "OnClick") Config.OnClick_ScreenshotOnStart = Convert.ToBoolean(xNav.Value); break; case "screenshot_on_end": if (_ParentNode == "OnClick") Config.OnClick_ScreenshotOnEnd = Convert.ToBoolean(xNav.Value); break; default: break; } // end switch TraverseChildren(xNav); xNav.MoveToParent(); } } } while (xNav.MoveToNext()); }
bool IReflectorPersistance.Load(System.Xml.XPath.XPathNavigator r) { if (r.NodeType == XPathNodeType.Element) { osalot.AssemblyTracker tracker = new osalot.AssemblyTracker(); string location = null; switch (r.Name) { case "Plugins": bool everokay = false; bool okay; for (okay = r.MoveToFirstAttribute(); okay; okay = r.MoveToNextAttribute()) { everokay = true; switch (r.Name) { case "Location": location = r.Value; break; } } if (everokay) { r.MoveToParent(); } everokay = false; for (okay = r.MoveToFirstChild(); okay; okay = r.MoveToNext()) { everokay = true; switch (r.Name) { case "System Mask": tracker.allow_on_system.Add(r.Value); break; } } if (everokay) { r.MoveToParent(); } if (tracker.allow_on_system.Count == 0) { core_common.LoadAssembly(location, tracker); } else { foreach (String s in tracker.allow_on_system) { Match m = Regex.Match(SystemInformation.ComputerName, s); if (m.Success) { core_common.LoadAssembly(location, tracker); break; } } } return(true); } return(false); } return(false); }
virtual bool MoveToFollowing(string localName, string namespaceURI, XPathNavigator end) { if (localName == null) { throw new ArgumentNullException("localName"); } if (namespaceURI == null) { throw new ArgumentNullException("namespaceURI"); } localName = NameTable.Get(localName); if (localName == null) { return(false); } namespaceURI = NameTable.Get(namespaceURI); if (namespaceURI == null) { return(false); } XPathNavigator nav = Clone(); switch (nav.NodeType) { case XPathNodeType.Attribute: case XPathNodeType.Namespace: nav.MoveToParent(); break; } do { if (!nav.MoveToFirstChild()) { do { if (!nav.MoveToNext()) { if (!nav.MoveToParent()) { return(false); } } else { break; } } while (true); } if (end != null && end.IsSamePosition(nav)) { return(false); } if (object.ReferenceEquals(localName, nav.LocalName) && object.ReferenceEquals(namespaceURI, nav.NamespaceURI)) { MoveTo(nav); return(true); } } while (true); }
// Copies the current node from the given XPathNavigator to the writer (including child nodes). public virtual void WriteNode(XPathNavigator navigator, bool defattr) { if (navigator == null) { throw new ArgumentNullException(nameof(navigator)); } int iLevel = 0; navigator = navigator.Clone(); while (true) { bool mayHaveChildren = false; XPathNodeType nodeType = navigator.NodeType; switch (nodeType) { case XPathNodeType.Element: WriteStartElement(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); // Copy attributes if (navigator.MoveToFirstAttribute()) { do { IXmlSchemaInfo schemaInfo = navigator.SchemaInfo; if (defattr || (schemaInfo == null || !schemaInfo.IsDefault)) { WriteStartAttribute(navigator.Prefix, navigator.LocalName, navigator.NamespaceURI); // copy string value to writer WriteString(navigator.Value); WriteEndAttribute(); } } while (navigator.MoveToNextAttribute()); navigator.MoveToParent(); } // Copy namespaces if (navigator.MoveToFirstNamespace(XPathNamespaceScope.Local)) { WriteLocalNamespaces(navigator); navigator.MoveToParent(); } mayHaveChildren = true; break; case XPathNodeType.Attribute: // do nothing on root level attribute break; case XPathNodeType.Text: WriteString(navigator.Value); break; case XPathNodeType.SignificantWhitespace: case XPathNodeType.Whitespace: WriteWhitespace(navigator.Value); break; case XPathNodeType.Root: mayHaveChildren = true; break; case XPathNodeType.Comment: WriteComment(navigator.Value); break; case XPathNodeType.ProcessingInstruction: WriteProcessingInstruction(navigator.LocalName, navigator.Value); break; case XPathNodeType.Namespace: // do nothing on root level namespace break; default: Debug.Assert(false); break; } if (mayHaveChildren) { // If children exist, move down to next level if (navigator.MoveToFirstChild()) { iLevel++; continue; } else { // EndElement if (navigator.NodeType == XPathNodeType.Element) { if (navigator.IsEmptyElement) { WriteEndElement(); } else { WriteFullEndElement(); } } } } // No children while (true) { if (iLevel == 0) { // The entire subtree has been copied return; } if (navigator.MoveToNext()) { // Found a sibling, so break to outer loop break; } // No siblings, so move up to previous level iLevel--; navigator.MoveToParent(); // EndElement if (navigator.NodeType == XPathNodeType.Element) WriteFullEndElement(); } } }
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); }
// Begin: GetNodeInfo private void GetNodeInfo(XPathNavigator nav1) { if (nav1 != null && nav1.Name != null && nav1.Name.ToString(CultureInfo.CurrentCulture).Equals("images", StringComparison.CurrentCulture)) { using (var xmlReader = nav1.ReadSubtree()) { var searchResults = new SearchResults(); while (xmlReader.Read()) { if (xmlReader.NodeType == XmlNodeType.Element) { switch (xmlReader.Name) { case "id": searchResults = new SearchResults(); searchResults.Id = xmlReader.ReadString(); continue; case "album": searchResults.Album = xmlReader.ReadString(); continue; case "title": searchResults.Title = xmlReader.ReadString(); continue; case "alias": searchResults.AddAlias(xmlReader.ReadString()); continue; case "mbid": searchResults.MBID = xmlReader.ReadString(); continue; case "votes": alSearchResults.Add(searchResults); continue; default: continue; } } } } } if (nav1 != null && nav1.HasChildren) { nav1.MoveToFirstChild(); while (nav1.MoveToNext()) { GetNodeInfo(nav1); nav1.MoveToParent(); } } else { if (nav1 == null || !nav1.MoveToNext()) return; GetNodeInfo(nav1); } }
/// <summary> /// Move to the next reader state. Return false if that is ReaderState.Closed. /// </summary> public override bool Read() { _attrCount = -1; switch (_state) { case State.Error: case State.Closed: case State.EOF: return false; case State.Initial: // Starting state depends on the navigator's item type _nav = _navToRead; _state = State.Content; if (XPathNodeType.Root == _nav.NodeType) { if (!_nav.MoveToFirstChild()) { SetEOF(); return false; } _readEntireDocument = true; } else if (XPathNodeType.Attribute == _nav.NodeType) { _state = State.Attribute; } _nodeType = ToXmlNodeType(_nav.NodeType); break; case State.Content: if (_nav.MoveToFirstChild()) { _nodeType = ToXmlNodeType(_nav.NodeType); _depth++; _state = State.Content; } else if (_nodeType == XmlNodeType.Element && !_nav.IsEmptyElement) { _nodeType = XmlNodeType.EndElement; _state = State.EndElement; } else goto case State.EndElement; break; case State.EndElement: if (0 == _depth && !_readEntireDocument) { SetEOF(); return false; } else if (_nav.MoveToNext()) { _nodeType = ToXmlNodeType(_nav.NodeType); _state = State.Content; } else if (_depth > 0 && _nav.MoveToParent()) { Debug.Assert(_nav.NodeType == XPathNodeType.Element, _nav.NodeType.ToString() + " == XPathNodeType.Element"); _nodeType = XmlNodeType.EndElement; _state = State.EndElement; _depth--; } else { SetEOF(); return false; } break; case State.Attribute: case State.AttrVal: if (!_nav.MoveToParent()) { SetEOF(); return false; } _nodeType = ToXmlNodeType(_nav.NodeType); _depth--; if (_state == State.AttrVal) _depth--; goto case State.Content; case State.InReadBinary: _state = _savedState; _readBinaryHelper.Finish(); return Read(); } return true; }
protected override IPredicate BuildPredicate(XPathNavigator predicateElement, bool inHead, bool resolveImmediatly) { IPredicate predicate; string predicateName = predicateElement.Name; string predicateValue = predicateElement.Value; switch(predicateName) { // --------- IND predicates -------- case "Ind": string predicateURI = predicateElement.GetAttribute("uri", String.Empty).ToLower(); switch(predicateURI) { case "nxbre://expression": if (inHead) { if (resolveImmediatly) predicate = new Individual(Compilation.Evaluate(predicateValue)); else predicate = new Formula(Formula.FormulaResolutionType.NxBRE, Binder, predicateValue); } else { predicate = new Function(Function.FunctionResolutionType.Binder, predicateValue, new ExpressionEvaluator(predicateValue), String.Empty, String.Empty); } break; case "nxbre://operator": // NxBRE operators must follow this pattern: operator(uniqueargument) ObjectPair operatorCall = Parameter.ParseOperatorCall(predicateValue); predicate = new Function(Function.FunctionResolutionType.NxBRE, predicateValue, null, (string)operatorCall.First, (string)operatorCall.Second); break; case "nxbre://binder": if (Binder == null) throw new BREException("No binder available for Individual: " + predicateValue); if (inHead) predicate = new Formula(Formula.FormulaResolutionType.Binder, Binder, predicateValue); else predicate = Binder.AnalyzeIndividualPredicate(new Individual(predicateValue)); break; case "": predicate = new Individual(predicateValue); break; default: // there is a predicateURI but it is not recognized by the engine so we assimilate it as // a web reference predicate = new Individual(new HyperLink(predicateValue, predicateURI)); break; } break; // --------- VAR predicates -------- case "Var": predicate = new Variable(predicateValue); break; // --------- DATA predicates -------- case "Data": string schemaType = predicateElement.GetAttribute("type", "http://www.w3.org/2001/XMLSchema-instance"); if (schemaType != String.Empty) { // remove any preceding namespace, like in "xs:string" if (schemaType.IndexOf(':')>=0) schemaType = schemaType.Split(':')[1]; // this is a strongly typed individual predicate = new Individual(Xml.ToClr(predicateValue, schemaType), schemaType); } else { // this is just a string based predicate, using Data was not so wise... predicate = new Individual(predicateValue); } break; // --------- SLOT predicates -------- case "slot": // the first child must be an Ind, we do not support other slot name holders if (predicateElement.MoveToFirstChild()) { if (predicateElement.Name != "Ind") throw new BREException("Only Ind is accepted as a slot name holder"); string slotName = predicateElement.Value; if (!predicateElement.MoveToNext()) throw new BREException("A slot should contain two children"); predicate = new Slot(slotName, BuildPredicate(predicateElement, inHead, resolveImmediatly)); } else { throw new BREException("A slot can not be empty"); } break; // --------- UNKNOWN predicates -------- default: throw new BREException("Unsupported predicate type: " + predicateName); } return predicate; }
static void NavigatorValues(XPathNavigator nav, bool native) { // in non-native we can't have Value dump everything, else // we'd dump the entire database? Makes not much sense. Assert.AreEqual(native ? "\n blah\n blah\n bam\n " : string.Empty, nav.Value.Lf()); // !! Assert.IsTrue(nav.MoveToFirstChild()); Assert.AreEqual("root", nav.Name); Assert.AreEqual(native ? "\n blah\n blah\n bam\n " : string.Empty, nav.Value.Lf()); // !! Assert.IsTrue(nav.MoveToFirstChild()); Assert.AreEqual("wrap", nav.Name); Assert.AreEqual(native ? "\n blah\n blah\n bam\n " : string.Empty, nav.Value.Lf()); // !! Assert.IsTrue(nav.MoveToFirstChild()); Assert.AreEqual("item1", nav.Name); Assert.AreEqual(string.Empty, nav.Value); Assert.IsFalse(nav.MoveToFirstChild()); Assert.IsTrue(nav.MoveToNext()); Assert.AreEqual("item2", nav.Name); Assert.AreEqual(string.Empty, nav.Value); Assert.IsFalse(nav.MoveToFirstChild()); // !! Assert.IsTrue(nav.MoveToNext()); Assert.AreEqual("item2a", nav.Name); Assert.AreEqual(string.Empty, nav.Value); Assert.IsFalse(nav.MoveToFirstChild()); // !! Assert.IsTrue(nav.MoveToNext()); Assert.AreEqual("item2b", nav.Name); Assert.AreEqual(string.Empty, nav.Value); Assert.IsFalse(nav.MoveToFirstChild()); // !! // we have no way to tell the navigable that a value is CDATA // so the rule is, if it's null it's not there, anything else is there // and the filtering has to be done when building the content Assert.IsTrue(nav.MoveToNext()); Assert.AreEqual("item2c", nav.Name); Assert.AreEqual("\n ", nav.Value.Lf()); // ok since it's a property Assert.IsTrue(nav.MoveToFirstChild()); Assert.AreEqual(XPathNodeType.Text, nav.NodeType); Assert.AreEqual(string.Empty, nav.Name); Assert.AreEqual("\n ", nav.Value.Lf()); Assert.IsTrue(nav.MoveToParent()); Assert.IsTrue(nav.MoveToNext()); Assert.AreEqual("item3", nav.Name); Assert.AreEqual("blah", nav.Value); // ok since it's a property Assert.IsTrue(nav.MoveToFirstChild()); Assert.AreEqual(XPathNodeType.Text, nav.NodeType); Assert.AreEqual(string.Empty, nav.Name); Assert.AreEqual("blah", nav.Value); Assert.IsTrue(nav.MoveToParent()); Assert.IsTrue(nav.MoveToNext()); Assert.AreEqual("item3a", nav.Name); Assert.AreEqual("\n blah\n ", nav.Value.Lf()); // ok since it's a property Assert.IsTrue(nav.MoveToFirstChild()); Assert.AreEqual(XPathNodeType.Text, nav.NodeType); Assert.AreEqual(string.Empty, nav.Name); Assert.AreEqual("\n blah\n ", nav.Value.Lf()); Assert.IsTrue(nav.MoveToParent()); Assert.IsTrue(nav.MoveToNext()); Assert.AreEqual("item4", nav.Name); Assert.AreEqual("bam", nav.Value); // ok since it's a property Assert.IsTrue(nav.MoveToFirstChild()); Assert.AreEqual("subitem", nav.Name); Assert.AreEqual("bam", nav.Value); // ok since we're in a fragment Assert.IsTrue(nav.MoveToFirstChild()); Assert.AreEqual(XPathNodeType.Text, nav.NodeType); Assert.AreEqual(string.Empty, nav.Name); Assert.AreEqual("bam", nav.Value); Assert.IsFalse(nav.MoveToNext()); Assert.IsTrue(nav.MoveToParent()); Assert.AreEqual("subitem", nav.Name); Assert.IsFalse(nav.MoveToNext()); Assert.IsTrue(nav.MoveToParent()); Assert.AreEqual("item4", nav.Name); Assert.IsTrue(nav.MoveToNext()); Assert.AreEqual("item5", nav.Name); Assert.AreEqual("\n ", nav.Value.Lf()); Assert.IsTrue(nav.MoveToFirstChild()); Assert.AreEqual(XPathNodeType.Text, nav.NodeType); Assert.AreEqual("\n ", nav.Value.Lf()); }
private XmlNodeOrder CompareSiblings(XPathNavigator n1, XPathNavigator n2) { int num = 0; switch (n1.NodeType) { case XPathNodeType.Attribute: num++; break; case XPathNodeType.Namespace: break; default: num += 2; break; } switch (n2.NodeType) { case XPathNodeType.Attribute: num--; if (num == 0) { while (n1.MoveToNextAttribute()) { if (n1.IsSamePosition(n2)) { return XmlNodeOrder.Before; } } } break; case XPathNodeType.Namespace: if (num == 0) { while (n1.MoveToNextNamespace()) { if (n1.IsSamePosition(n2)) { return XmlNodeOrder.Before; } } } break; default: num -= 2; if (num == 0) { while (n1.MoveToNext()) { if (n1.IsSamePosition(n2)) { return XmlNodeOrder.Before; } } } break; } if (num >= 0) { return XmlNodeOrder.After; } return XmlNodeOrder.Before; }
/// <summary> /// Reads an XmlConfigurationCategoryCollection using the specified XPathNavigator /// </summary> /// <param name="navigator"></param> /// <returns></returns> private XmlConfigurationCategoryCollection ReadCategories(XPathNavigator navigator, XmlConfigurationCategoryCollection categories) { if (navigator.HasChildren) { if (navigator.MoveToFirstChild()) { // is this element a category node? if (string.Compare(navigator.Name, @"Category", true) == 0) { // so read it XmlConfigurationCategory category = new XmlConfigurationCategory(); category.BeginInit(); category.Parent = categories; this.ReadCategory(navigator, category); // and add it to the current collection of categories categories.Add(category); category.EndInit(); } } } while (navigator.MoveToNext()) { // is this element a category node? if (string.Compare(navigator.Name, @"Category", true) == 0) { // so read it XmlConfigurationCategory category = new XmlConfigurationCategory(); category.BeginInit(); category.Parent = categories; this.ReadCategory(navigator, category); // and add it to the current collection of categories categories.Add(category); category.EndInit(); } } return categories; }
private void WriteNextNode(XmlWriter writer, XPathNavigator nav, bool iterateSiblings) { if (nav.Name == "ScatterFile") { writer.WriteStartElement(nav.Name, nav.NamespaceURI); } else { writer.WriteStartElement(nav.Name); } XPathNavigator attrib = nav.CreateNavigator(); if (attrib.MoveToFirstAttribute()) { do { writer.WriteAttributeString(attrib.Name, attrib.Value); } while (attrib.MoveToNextAttribute()); } if (nav.Name == "LoadRegion") { string lrName = nav.GetAttribute("Name", ""); foreach (ExecRegion er in (m_execRegionOrderMap[lrName] as SortedList).Values) { WriteNextNode(writer, m_execRegionsToNavNode[lrName + ":" + er.Name] as XPathNavigator, false); } } /* else if (nav.Name == "ExecRegion") { string erName = nav.GetAttribute("Name", ""); foreach (FileMapping fm in (m_symOrderMap[erName] as SortedList).Values) { WriteNextNode(writer, m_symToNavNode[erName + ":" + fm.Name] as XPathNavigator, false); } } */ else { XPathNodeIterator children = nav.SelectChildren(XPathNodeType.Element); while (children.MoveNext()) { WriteNextNode(writer, children.Current, iterateSiblings); } } writer.WriteEndElement(); if (iterateSiblings && nav.MoveToNext()) { WriteNextNode(writer, nav, iterateSiblings); } }