34if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "File")

57while (reader.NodeType != XmlNodeType.EndElement)

65while (reader.NodeType != XmlNodeType.EndElement)

61while (reader.NodeType != XmlNodeType.EndElement)

108if (node.NodeType == XmlNodeType.Element) 379if (node.NodeType == XmlNodeType.Document) 400if (copyAttributeAnnotations && node.NodeType == XmlNodeType.Element)

79if (reader.NodeType == XmlNodeType.Element && reader.Name == "SdkResolver") 113case XmlNodeType.Element: 142case XmlNodeType.EndElement:

369if (XmlElement.ChildNodes.Count == 1 && XmlElement.FirstChild.NodeType == XmlNodeType.Text) 407if (element.XmlElement.ChildNodes.Count == 1 && element.XmlElement.FirstChild.NodeType == XmlNodeType.Text)

527(next.NodeType == XmlNodeType.Comment|| 528(next.NodeType == XmlNodeType.Whitespace && !next.Value.Contains("\n") && !next.Value.Contains("\r")))) 539if (referenceSibling.XmlElement.PreviousSibling?.NodeType == XmlNodeType.Whitespace) 555if (child.XmlElement.PreviousSibling?.NodeType == XmlNodeType.Whitespace) 570if (XmlElement.FirstChild.NodeType == XmlNodeType.Whitespace) 589if (xmlElement.PreviousSibling?.NodeType != XmlNodeType.Whitespace) 625if (previousSibling?.NodeType == XmlNodeType.Whitespace) 637if (XmlElement.ChildNodes.Cast<XmlNode>().All(c => c.NodeType == XmlNodeType.Whitespace))

327if (childNode.NodeType == XmlNodeType.Element)

231if (child.NodeType == XmlNodeType.XmlDeclaration) 238child.NodeType == XmlNodeType.Element && 278if (child.NodeType == XmlNodeType.Element && String.Equals(XMakeElements.import, child.Name, StringComparison.Ordinal)) 288string projectSdk = source.NodeType == XmlNodeType.Element && String.Equals(XMakeElements.project, source.Name, StringComparison.Ordinal) ? ((XmlElement)source).GetAttribute(XMakeAttributes.sdk) : String.Empty; 336if (child.NodeType == XmlNodeType.Element && String.Equals(XMakeElements.importGroup, child.Name, StringComparison.Ordinal)) 353if (clone.NodeType == XmlNodeType.Element && String.Equals(XMakeElements.project, child.Name, StringComparison.Ordinal) && clone.Attributes?[XMakeAttributes.sdk] != null)

632if (childElement.ChildNodes.Count == 1 && childElement.FirstChild.NodeType == XmlNodeType.Text)

138if (xml.XmlElement.ChildNodes.Count == 1 && xml.XmlElement.FirstChild.NodeType == XmlNodeType.Text)

206if (isSingleChild && firstChild.NodeType == XmlNodeType.Whitespace) 211if (isSingleChild && (firstChild.NodeType == XmlNodeType.Text || firstChild.NodeType == XmlNodeType.CDATA))

82case XmlNodeType.Comment: 83case XmlNodeType.Whitespace: 87case XmlNodeType.Element: 91if (child.NodeType == XmlNodeType.Text && String.IsNullOrWhiteSpace(child.InnerText))

84if (dependencyNode.NodeType != XmlNodeType.Element)

83if (reader.NodeType == XmlNodeType.Element && StringEquals(reader.Name, "runtime"))

54if (reader.NodeType == XmlNodeType.EndElement && AppConfig.StringEquals(reader.Name, "dependentassembly")) 60if (reader.NodeType == XmlNodeType.Element && AppConfig.StringEquals(reader.Name, "assemblyIdentity")) 104if (reader.NodeType == XmlNodeType.Element && AppConfig.StringEquals(reader.Name, "bindingRedirect"))

23if (reader.NodeType == XmlNodeType.EndElement && AppConfig.StringEquals(reader.Name, "runtime")) 29if (reader.NodeType == XmlNodeType.Element && AppConfig.StringEquals(reader.Name, "dependentAssembly"))

1238if (nextNode.NodeType == XmlNodeType.Element)

38case XmlNodeType.Element: 77case XmlNodeType.EndElement: 81case XmlNodeType.Comment: 85case XmlNodeType.CDATA: 89case XmlNodeType.Text:

232} while (r.NodeType != XmlNodeType.Element);

122permissionSetElement.ParentNode.NodeType == XmlNodeType.Document) 267if (previousNode?.NodeType == XmlNodeType.Comment)

48if (node.NodeType == XmlNodeType.Element) 53else if (node.NodeType == XmlNodeType.Comment)

710if (reader.NodeType == XmlNodeType.Element) 775if (reader.NodeType == XmlNodeType.Element) 809if (reader.NodeType == XmlNodeType.EndElement && string.Equals(reader.Name, "From", StringComparison.OrdinalIgnoreCase)) 815if (reader.NodeType == XmlNodeType.EndElement && string.Equals(reader.Name, "Remap", StringComparison.OrdinalIgnoreCase)) 829if (reader.NodeType == XmlNodeType.Element) 859if (reader.NodeType == XmlNodeType.EndElement && string.Equals(reader.Name, "FileList", StringComparison.OrdinalIgnoreCase))

352.Where(i => i.NodeType != XmlNodeType.Comment && i.NodeType != XmlNodeType.Whitespace)) 356case XmlNodeType.Element:

112if (childNode.NodeType == XmlNodeType.Element &&

330if (childNode.NodeType == XmlNodeType.Element &&

3143if (reader.NodeType == XmlNodeType.Element)

77&& reader.NodeType == XmlNodeType.EndElement

22if (node.NodeType == XmlNodeType.Document) 43if (copyAttributeAnnotations && node.NodeType == XmlNodeType.Element)

177if (node.NodeType == XmlNodeType.Element) 213if (container.NodeType == XmlNodeType.Element && originatingSyntax != null)

321if (textNode.NodeType == XmlNodeType.Text) 325else if (textNode.NodeType == XmlNodeType.CDATA) 335if (node.NodeType != XmlNodeType.Element)

272If node.NodeType = XmlNodeType.Element Then 301If container.NodeType = XmlNodeType.Element AndAlso originatingSyntax IsNot Nothing Then

299if (node.NodeType == XmlNodeType.Element) 568if (node.NodeType == XmlNodeType.Document) 589if (copyAttributeAnnotations && node.NodeType == XmlNodeType.Element)

230if (reader.NodeType == XmlNodeType.Element)

106&& _xmlReader.NodeType == XmlNodeType.EndElement

71if (xmlReader is { NodeType: XmlNodeType.Element, Name: "member" })

56XmlNodeType preNodeType = reader.NodeType; 62case XmlNodeType.Element: 128case XmlNodeType.EndElement: 135if (preNodeType == XmlNodeType.Element) 145case XmlNodeType.CDATA: 146case XmlNodeType.Text: 158case XmlNodeType.XmlDeclaration: 159case XmlNodeType.ProcessingInstruction: 160case XmlNodeType.Comment: 161case XmlNodeType.Whitespace: 173if (preNodeType == XmlNodeType.Element && reader.IsEmptyElement) 175preNodeType = XmlNodeType.EndElement;

83if (element.NodeType != XmlNodeType.Element) 142element.FirstNode?.NodeType == XmlNodeType.Text)

50 if (reader.NodeType == XmlNodeType.Whitespace) 52 if (reader.NodeType != XmlNodeType.Element) 80 while (reader.Read() && reader.NodeType != XmlNodeType.Element) 83 if (reader.NodeType != XmlNodeType.Element)

68 if (reader.NodeType == XmlNodeType.Whitespace) 70 if (reader.NodeType == XmlNodeType.XmlDeclaration) 72 if (reader.NodeType != XmlNodeType.Element) 110 if (reader.NodeType == XmlNodeType.Whitespace) 112 if (reader.NodeType == XmlNodeType.XmlDeclaration) 114 if (reader.NodeType != XmlNodeType.Element) 151 if (reader.NodeType == XmlNodeType.Whitespace) 153 if (reader.NodeType == XmlNodeType.XmlDeclaration) 155 if (reader.NodeType != XmlNodeType.Element)

54 Debug.Assert(reader.NodeType == XmlNodeType.Element); 66 case XmlNodeType.EndElement: 69 case XmlNodeType.Element: 120 case XmlNodeType.Whitespace: 122 case XmlNodeType.Text: 123 case XmlNodeType.CDATA: 139 Debug.Assert(reader.NodeType == XmlNodeType.Element); 150 case XmlNodeType.EndElement: 158 case XmlNodeType.Element: 179 case XmlNodeType.Text: 180 case XmlNodeType.CDATA: 185 case XmlNodeType.Whitespace: 206 Debug.Assert(reader.NodeType == XmlNodeType.Element);

42 case XmlNodeType.CDATA: 45 case XmlNodeType.Text: 48 case XmlNodeType.Element: 51 case XmlNodeType.EndElement:

69var xmlDeclaration = xmlDocument.CreateNode(XmlNodeType.XmlDeclaration, string.Empty, string.Empty);

57var node = doc.CreateNode(XmlNodeType.Element, RunsettingsDirectory, string.Empty);

153while (reader.NodeType == XmlNodeType.Element) 210while (reader.NodeType == XmlNodeType.Element)

202while (reader.NodeType == XmlNodeType.Element)

113while (reader.NodeType == XmlNodeType.Element) 169while (reader.NodeType == XmlNodeType.Element)

205while (reader.NodeType == XmlNodeType.Element)

632while (reader.NodeType == XmlNodeType.Element)

36while (reader.NodeType == XmlNodeType.Element)

22while (!reader.EOF && reader.Read() && reader.NodeType != XmlNodeType.Element) 36if (reader.NodeType != XmlNodeType.Element)

181var xmlDeclaration = doc.CreateNode(XmlNodeType.XmlDeclaration, string.Empty, string.Empty);

113case XmlNodeType.Element: 116case XmlNodeType.Whitespace: 119case XmlNodeType.Comment: 120case XmlNodeType.Entity: 123case XmlNodeType.ProcessingInstruction: 124case XmlNodeType.CDATA: 125case XmlNodeType.Text: 126case XmlNodeType.EntityReference: 127case XmlNodeType.DocumentType: 128case XmlNodeType.XmlDeclaration: 173if (iter != null && iter.NodeType != XmlNodeType.Whitespace) { 181case XmlNodeType.Whitespace: 185case XmlNodeType.Element: 361&& node.NodeType == XmlNodeType.Whitespace; 366&& node.NodeType == XmlNodeType.Text;

489if (xmlNode == null || xmlNode.NodeType == XmlNodeType.Document)

2490[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Xml.XmlNodeType))]

200return element.Nodes().Any(node => node.NodeType == XmlNodeType.Comment &&

122return element.Nodes().Any(node => node.NodeType == XmlNodeType.Comment &&

491XmlNodeType.Document, // parsing document 499case XmlNodeType.Element :

773XmlNodeType currNodeType = xmlReader.NodeType; 776case XmlNodeType.Element: 829case XmlNodeType.EndElement: 836case XmlNodeType.CDATA: 837case XmlNodeType.Text: 852ThrowCompilerException(nameof(SR.IllegalCDataTextScoping), DefinitionNSPrefix, LocalName, (currNodeType == XmlNodeType.CDATA ? "a CDATA section" : "text content"));

416string attrName = (xmlReader.NodeType == XmlNodeType.Attribute) ? xmlReader.Name : null; 711while (!xamlDefTagNode.IsEmptyElement && xamlDefTagNode.XmlReader.NodeType != XmlNodeType.EndElement)

72multipleRoots ? XmlNodeType.Element : XmlNodeType.Document,

376case XmlNodeType.Element: 379case XmlNodeType.EndElement: 1235case XmlNodeType.SignificantWhitespace: 1236case XmlNodeType.Text: 1237case XmlNodeType.CDATA: 1238case XmlNodeType.Whitespace: 1255case XmlNodeType.Element: 1274case XmlNodeType.EndElement: 1302case XmlNodeType.Attribute: // review this. 1307case XmlNodeType.Comment: 1310case XmlNodeType.ProcessingInstruction: 1981CompileBamlTag(XmlNodeType.Element, ref endTagHasBeenRead); 1994CompileBamlTag(XmlNodeType.EndElement, ref endTagHasBeenRead); 2033CompileBamlTag(XmlNodeType.EndElement, 2083case XmlNodeType.Text: 2084case XmlNodeType.CDATA: 2085case XmlNodeType.SignificantWhitespace: 2086case XmlNodeType.Whitespace: 2091case XmlNodeType.ProcessingInstruction: 2097case XmlNodeType.EntityReference: 2120XmlNodeType xmlNodeType, 2128case XmlNodeType.Element: 2140case XmlNodeType.EndElement: 2143case XmlNodeType.Text: 2144case XmlNodeType.CDATA: 2145case XmlNodeType.SignificantWhitespace: 2146case XmlNodeType.Whitespace: 3563XmlNodeType xmlNodeType, // Type of xml node we are processing. 3584case XmlNodeType.Element: 3741case XmlNodeType.EndElement: 3790case XmlNodeType.CDATA: 3791case XmlNodeType.Text: 3792case XmlNodeType.SignificantWhitespace: 3793case XmlNodeType.Whitespace: 3803case XmlNodeType.ProcessingInstruction: 3810case XmlNodeType.Comment: 3817case XmlNodeType.EntityReference: 4107CompileText(XmlNodeType.None, textValue); 5047private void CompileText(XmlNodeType xmlNodeType, string textValue) 5051Debug.Assert( xmlNodeType == XmlNodeType.Text || 5052xmlNodeType == XmlNodeType.Whitespace || 5053xmlNodeType == XmlNodeType.SignificantWhitespace || 5054xmlNodeType == XmlNodeType.CDATA || 5055xmlNodeType == XmlNodeType.None, 5059case XmlNodeType.Text: 5063case XmlNodeType.Whitespace: 5064case XmlNodeType.SignificantWhitespace: 5068case XmlNodeType.CDATA: 5069case XmlNodeType.None: 52170 == XmlReader.Depth && XmlReader.NodeType == XmlNodeType.None))

172case XmlNodeType.Element: 183case XmlNodeType.EndElement: 750_inAttribute = (Reader.NodeType == XmlNodeType.Attribute);

42public override XmlNodeType NodeType { get { return _reader.NodeType; } }

198if (_reader.NodeType == XmlNodeType.Attribute) 205if (_reader.NodeType == XmlNodeType.Attribute) 283private XmlNodeType MoveToContent() 291case XmlNodeType.CDATA: 292case XmlNodeType.Element: 293case XmlNodeType.EndElement: 294case XmlNodeType.EntityReference: 295case XmlNodeType.EndEntity: 401while (MoveToContent() != XmlNodeType.EndElement) 403if (_reader.NodeType == XmlNodeType.Element && _reader.NamespaceURI == CompositeFontNamespace) 416while (MoveToContent() == XmlNodeType.Element) 567while (MoveToContent() != XmlNodeType.EndElement) 569if (_reader.NodeType == XmlNodeType.Element && _reader.NamespaceURI == CompositeFontNamespace) 584while (MoveToContent() == XmlNodeType.Element) 815while (MoveToContent() != XmlNodeType.EndElement) 817if (_reader.NodeType == XmlNodeType.Element && _reader.NamespaceURI == CompositeFontNamespace)

642if (node.NodeType == XmlNodeType.Element)

459if (node.NodeType == XmlNodeType.Text) 469else if (node.NodeType == XmlNodeType.Element)

396case XmlNodeType.Text: 397case XmlNodeType.SignificantWhitespace: 398case XmlNodeType.CDATA: 405case XmlNodeType.Element: 410case XmlNodeType.EndElement:

282while (!(XmlNodeType.EndElement == reader.NodeType && AnnotationXmlConstants.Elements.Annotation == reader.LocalName)) 291while (!(AnnotationXmlConstants.Elements.AnchorCollection == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) 306while (!(AnnotationXmlConstants.Elements.CargoCollection == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) 321while (!(AnnotationXmlConstants.Elements.AuthorCollection == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) 323if (!(AnnotationXmlConstants.Elements.StringAuthor == reader.LocalName && XmlNodeType.Element == reader.NodeType)) 515if (reader.NodeType == XmlNodeType.Attribute)

169while (!(AnnotationXmlConstants.Elements.Resource == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) 181else if (XmlNodeType.Element == reader.NodeType)

133while (!(AnnotationXmlConstants.Elements.ContentLocatorGroup == reader.LocalName && XmlNodeType.EndElement == reader.NodeType))

203while (!(AnnotationXmlConstants.Elements.ContentLocator == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) 205if (XmlNodeType.Element != reader.NodeType) 221while (!(XmlNodeType.EndElement == reader.NodeType && part.PartType.Name == reader.LocalName)) 264if (!(XmlNodeType.EndElement == reader.NodeType && AnnotationXmlConstants.Elements.Item == reader.LocalName))

387case XmlNodeType.Element:

36if (base.NodeType == XmlNodeType.XmlDeclaration) 210if ( (Reader.NodeType == XmlNodeType.Element) && !_rootXMLNSChecked )

2014XmlNodeType.Element,

231internal FilteredXmlReader( string xmlFragment, XmlNodeType fragmentType, XmlParserContext context ) :

293XmlTextReader reader = new XmlTextReader(stream, XmlNodeType.Document, parserContext)

148if (node.NodeType == XmlNodeType.Element) 152if (node.ChildNodes[i].NodeType == XmlNodeType.Text)

953if (reader.NodeType == XmlNodeType.Element && reader.Name == XpsS0Markup.PageContent) 1072if (reader.NodeType == XmlNodeType.Element && 1092if( reader.NodeType == XmlNodeType.Element && 1101if( reader.NodeType == XmlNodeType.EndElement &&

552if (reader.NodeType == XmlNodeType.Element && reader.Name == XpsS0Markup.DocumentReference)

413if( reader.NodeType != XmlNodeType.Element || 431case XmlNodeType.Element: 435case XmlNodeType.EndElement: 576case XmlNodeType.Text: 581case XmlNodeType.EndElement:

46if ((_xmlReader.MoveToContent() != XmlNodeType.Element) || 125if ((_xmlReader.NodeType == XmlNodeType.EndElement) && 133if ((_xmlReader.NodeType != XmlNodeType.Element) ||

820(valueNode.FirstChild.NodeType != XmlNodeType.Text)) 1285(valueNode.FirstChild.NodeType != XmlNodeType.Text))

100if ((rootChild.NodeType != XmlNodeType.Element) || 248if ((child.NodeType != XmlNodeType.Element) || 312if ((child.NodeType != XmlNodeType.Element) ||

122XmlNodeType t = xmlUtil.Reader.NodeType; 123if (t != XmlNodeType.Comment)

1524XmlNodeType t = xmlUtil.Reader.NodeType; 1525if (t != XmlNodeType.Comment) 1753if ((xmlUtil.Reader.NodeType != XmlNodeType.Element) || (xmlUtil.Reader.Name != ConfigurationTag)) 2568XmlNodeType t = xmlUtil.Reader.NodeType; 2569if (t == XmlNodeType.EndElement) 2572if (t == XmlNodeType.Comment) continue; 2579if (t == XmlNodeType.Element) 2621if (xmlUtil.Reader.NodeType != XmlNodeType.Element) 3565XmlNodeType nodeType; 3584if ((nodeType == XmlNodeType.Element) && (clone.Name == "EncryptedData")) 3590if (nodeType == XmlNodeType.EndElement) 3593if ((nodeType != XmlNodeType.Comment) && (nodeType != XmlNodeType.Whitespace)) 3621if (nodeType == XmlNodeType.EndElement) break; 3623if ((nodeType != XmlNodeType.Comment) && (nodeType != XmlNodeType.Whitespace))

1503if (reader.NodeType == XmlNodeType.Element) 1553if (reader.NodeType == XmlNodeType.EndElement) break; 1555if ((reader.NodeType == XmlNodeType.CDATA) || (reader.NodeType == XmlNodeType.Text))

39if (!reader.Read() || (reader.NodeType != XmlNodeType.Element))

51if (!xmlReader.Read() || (xmlReader.NodeType != XmlNodeType.Element))

20if (encryptedNode.NodeType != XmlNodeType.Element || 107if (child.NodeType != XmlNodeType.Element)

151if (node.NodeType != XmlNodeType.Element) 159if (node.NodeType == XmlNodeType.Comment || node.NodeType == XmlNodeType.Whitespace)

51if (!xmlReader.Read() || (xmlReader.NodeType != XmlNodeType.Element))

472if (child.NodeType == XmlNodeType.XmlDeclaration)

602reader = new XmlTextReader(xmlElement, XmlNodeType.Element, context); 606if (reader.NodeType != XmlNodeType.Element) 632case XmlNodeType.XmlDeclaration: 633case XmlNodeType.DocumentType: 639if ((reader.Depth <= 0) && (reader.NodeType != XmlNodeType.EndElement)) 2183if ((xmlUtil.Reader.NodeType == XmlNodeType.Element) && utilWriter.IsLastLineBlank) 2209Debug.Assert((reader.NodeType == XmlNodeType.Element) && (reader.Name == ConfigurationTag), 2245if ((reader.NodeType == XmlNodeType.Element) && (reader.Name == ConfigSectionsTag)) 2271(reader.NodeType == XmlNodeType.EndElement) && 2312bool skipFirstIndent = (reader.Depth > 0) && (reader.NodeType == XmlNodeType.Element); 2347((reader.NodeType == XmlNodeType.EndElement) && (reader.Name == ConfigurationTag)), 2386case XmlNodeType.Element: 2390case XmlNodeType.EndElement: 2424if (reader.NodeType == XmlNodeType.Element) 2613if (reader.NodeType == XmlNodeType.Element) 2620if (reader.NodeType == XmlNodeType.EndElement) 2662if (reader.NodeType == XmlNodeType.Element) 2937if (reader.NodeType == XmlNodeType.EndElement) 3102if (reader.NodeType == XmlNodeType.Element) 3128if (reader.IsEmptyElement || (reader.NodeType == XmlNodeType.EndElement)) reader.Read();

135if (xmlNode.NodeType == XmlNodeType.Element) CheckForLockAttributes(sectionName, child);

84case XmlNodeType.XmlDeclaration: 85case XmlNodeType.Comment: 86case XmlNodeType.DocumentType: 88case XmlNodeType.Element: 127private static int GetPositionOffset(XmlNodeType nodeType) 157if (Reader.MoveToContent() == XmlNodeType.Element) 174while (!Reader.EOF && (Reader.NodeType != XmlNodeType.Element)) 189if (Reader.NodeType == XmlNodeType.Element) return; 203while (!Reader.EOF && (Reader.NodeType != XmlNodeType.Element)) 221while (!Reader.EOF && (Reader.NodeType != XmlNodeType.EndElement)) 233XmlNodeType nodeType = Reader.NodeType; 235if ((nodeType != XmlNodeType.Comment) && (nodeType != XmlNodeType.EndElement)) 364Debug.Assert(Reader.NodeType == XmlNodeType.Element, "Reader.NodeType == XmlNodeType.Element"); 371while (Reader.NodeType != XmlNodeType.EndElement) 372if (Reader.NodeType == XmlNodeType.Element) 381if (Reader.NodeType == XmlNodeType.Whitespace) Reader.Skip(); 417if (Reader.NodeType == XmlNodeType.EndElement) 427if (Reader.NodeType == XmlNodeType.Element) 452Debug.Assert(Reader.NodeType == XmlNodeType.Element, "_reader.NodeType == XmlNodeType.Element"); 473if (Reader.NodeType != XmlNodeType.Whitespace) 493if (Reader.NodeType == XmlNodeType.Element) 507Debug.Assert(Reader.NodeType == XmlNodeType.Element, "_reader.NodeType== XmlNodeType.Element"); 561XmlNodeType nodeType = Reader.NodeType; 562if (nodeType == XmlNodeType.Whitespace) utilWriter.Write(Reader.Value); 565if (nodeType == XmlNodeType.Element) 613if (nodeType == XmlNodeType.EndElement) 629if (nodeType == XmlNodeType.Comment) utilWriter.AppendComment(Reader.Value); 632if (nodeType == XmlNodeType.Text) utilWriter.AppendEscapeTextString(Reader.Value); 635if (nodeType == XmlNodeType.XmlDeclaration) 686if (nodeType == XmlNodeType.SignificantWhitespace) utilWriter.Write(Reader.Value); 689if (nodeType == XmlNodeType.ProcessingInstruction) 705if (nodeType == XmlNodeType.EntityReference) 709if (nodeType == XmlNodeType.CDATA) 713if (nodeType == XmlNodeType.DocumentType) 831Debug.Assert(Reader.NodeType == XmlNodeType.Element, 866Debug.Assert(Reader.NodeType == XmlNodeType.Element, "_reader.NodeType == NodeType.Element"); 952(Reader.NodeType == XmlNodeType.Whitespace)) 975XmlTextReader reader = new XmlTextReader(xmlElement, XmlNodeType.Element, context); 991XmlNodeType nodeType = reader.NodeType; 1003case XmlNodeType.CDATA: 1004case XmlNodeType.Element: 1005case XmlNodeType.EndElement: 1006case XmlNodeType.Comment: 1025case XmlNodeType.Whitespace: 1027case XmlNodeType.SignificantWhitespace: 1030case XmlNodeType.CDATA: 1033case XmlNodeType.ProcessingInstruction: 1036case XmlNodeType.Comment: 1039case XmlNodeType.Text: 1043case XmlNodeType.Element: 1088case XmlNodeType.EndElement: 1093case XmlNodeType.EntityReference:

226if (reader.NodeType == XmlNodeType.Text)

430if (type == typeof(string) && xmlReader.NodeType == XmlNodeType.Element && xmlReader.IsEmptyElement)

202if (reader.NodeType == XmlNodeType.Element) 1587if (reader.NodeType == XmlNodeType.Element) 1686if (reader.NodeType == XmlNodeType.Element) 1693if (reader.NodeType == XmlNodeType.Element) 1781while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Element && reader.Depth > depth) 1785return (reader.NodeType == XmlNodeType.Element); 1790while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Element) 1797while (reader.NodeType == XmlNodeType.Whitespace) 1801if (reader.NodeType == XmlNodeType.None) 1805else if (reader.NodeType == XmlNodeType.EndElement) 1842while (reader.NodeType == XmlNodeType.Whitespace) 2110if (reader.NodeType == XmlNodeType.Element) 2115if (reader.NodeType == XmlNodeType.Element) 2215while (!reader.EOF && reader.NodeType == XmlNodeType.Whitespace) 2217if (reader.NodeType != XmlNodeType.Element) 2480if (reader.NodeType == XmlNodeType.Whitespace) 2495if (reader.NodeType == XmlNodeType.Whitespace) 2506if (reader.NodeType == XmlNodeType.Whitespace) 2511Debug.Assert(reader.NodeType != XmlNodeType.Whitespace, "Should not be on Whitespace node"); 2622if ((mode != XmlReadMode.Fragment) && (reader.NodeType == XmlNodeType.Element)) 2630if (reader.NodeType == XmlNodeType.Element) 2842XmlTextReader reader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(stream, XmlNodeType.Element, null) : new XmlTextReader(stream); 2857XmlTextReader xmlreader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(reader.ReadToEnd(), XmlNodeType.Element, null) : new XmlTextReader(reader); 2871xr = new XmlTextReader(stream, XmlNodeType.Element, null);

5789if (reader.NodeType == XmlNodeType.Element) 6016if ((mode != XmlReadMode.Fragment) && (reader.NodeType == XmlNodeType.Element)) 6033if (reader.NodeType == XmlNodeType.Element) 6272while (reader.NodeType == XmlNodeType.Whitespace) 6276if (reader.NodeType == XmlNodeType.None) 6280else if (reader.NodeType == XmlNodeType.EndElement) 6294while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Element && reader.Depth > depth) 6298return (reader.NodeType == XmlNodeType.Element); 6334if (reader.NodeType == XmlNodeType.Whitespace)

119if (r.NodeType != XmlNodeType.Element)

103if (n.NodeType == XmlNodeType.Element) 142while (n != null && (n.NodeType == XmlNodeType.Whitespace || !IsTextLikeNode(n.NodeType))) 176while (n.NodeType == XmlNodeType.Whitespace) 261internal static bool IsTextLikeNode(XmlNodeType n) 265case XmlNodeType.EntityReference: 268case XmlNodeType.Text: 269case XmlNodeType.Whitespace: 270case XmlNodeType.SignificantWhitespace: 271case XmlNodeType.CDATA: 398if (n.NodeType == XmlNodeType.Element) 631if (reader.NodeType != XmlNodeType.Element) 746case XmlNodeType.Element: // It's an element 796case XmlNodeType.EntityReference: // Oops. No support for Entity Reference 798case XmlNodeType.Text: // It looks like a text. 799case XmlNodeType.Whitespace: // This actually could be 800case XmlNodeType.CDATA: // if we have XmlText in our table 801case XmlNodeType.SignificantWhitespace: 975case XmlNodeType.Element: // It's an element 1031case XmlNodeType.EntityReference: // Oops. No support for Entity Reference 1033case XmlNodeType.Text: // It looks like a text. 1034case XmlNodeType.Whitespace: // This actually could be 1035case XmlNodeType.CDATA: // if we have XmlText in our table 1036case XmlNodeType.SignificantWhitespace: 1245case XmlNodeType.Text: // It looks like a text. And we need it. 1246case XmlNodeType.Whitespace: 1247case XmlNodeType.CDATA: 1248case XmlNodeType.SignificantWhitespace: 1274case XmlNodeType.Element: 1335case XmlNodeType.EntityReference: // Oops. No support for Entity Reference

203if (XmlNodeType.Element == ssync.NodeType) 214while ((ssync.NodeType == XmlNodeType.EndElement) && (iSsyncDepth < ssync.Depth)) 258if (XmlNodeType.Element == ssync.NodeType) 268while ((ssync.NodeType == XmlNodeType.EndElement) && (iSsyncDepth < ssync.Depth)) 357if (currentDepth == iRowDepth && row.NodeType == XmlNodeType.EndElement) 382while ((row.NodeType != XmlNodeType.EndElement) && (row.LocalName != ln) && (row.NamespaceURI != ns)) 435if (row.NodeType == XmlNodeType.Text || row.NodeType == XmlNodeType.Whitespace || row.NodeType == XmlNodeType.SignificantWhitespace) 459while (reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.SignificantWhitespace)

3341public override XmlNodeType NodeType

441XmlNode? nodeRegion = (node.NodeType == XmlNodeType.Attribute) ? ((XmlAttribute)node).OwnerElement : node.ParentNode; 445if (nodeRegion == null || nodeRegion.NodeType != XmlNodeType.Element) 479if (node.NodeType == XmlNodeType.Element)

297else if (_node.NodeType == XmlNodeType.Attribute) 320if (_column == null && _node.NodeType == XmlNodeType.Element) 347if ((_column == null || _column.ColumnMapping == MappingType.Attribute) && _node.NodeType == XmlNodeType.Element) 372internal XmlNodeType NodeType 380return XmlNodeType.None; 388return XmlNodeType.Text; 392return XmlNodeType.Attribute; 396return XmlNodeType.Element; 502private static bool IsLocalNameEmpty(XmlNodeType nt) 506case XmlNodeType.None: 507case XmlNodeType.Text: 508case XmlNodeType.CDATA: 509case XmlNodeType.Comment: 510case XmlNodeType.Document: 511case XmlNodeType.DocumentFragment: 512case XmlNodeType.Whitespace: 513case XmlNodeType.SignificantWhitespace: 514case XmlNodeType.EndElement: 515case XmlNodeType.EndEntity: 517case XmlNodeType.Element: 518case XmlNodeType.Attribute: 519case XmlNodeType.EntityReference: 520case XmlNodeType.Entity: 521case XmlNodeType.ProcessingInstruction: 522case XmlNodeType.DocumentType: 523case XmlNodeType.Notation: 524case XmlNodeType.XmlDeclaration: 609if (_node.NodeType == XmlNodeType.Element) 624if (_node != null && _column == null && _node.NodeType == XmlNodeType.Attribute) 700XmlNodeType nt = NodeType; 703case XmlNodeType.DocumentType: 708case XmlNodeType.Entity: 713case XmlNodeType.Notation: 727XmlNodeType nt = NodeType; 730case XmlNodeType.DocumentType: 735case XmlNodeType.Entity: 740case XmlNodeType.Notation: 754if (NodeType == XmlNodeType.DocumentType) 768if (child != null && child.NodeType == XmlNodeType.XmlDeclaration) 778if (NodeType == XmlNodeType.XmlDeclaration) 783else if (NodeType == XmlNodeType.Document) 799if (NodeType == XmlNodeType.XmlDeclaration) 804else if (NodeType == XmlNodeType.Document) 820if (NodeType == XmlNodeType.XmlDeclaration) 825else if (NodeType == XmlNodeType.Document)

138if (n.NodeType == XmlNodeType.Element) 169if (node.NodeType == XmlNodeType.Attribute && mt == MappingType.Attribute) 174if (node.NodeType == XmlNodeType.Element && mt == MappingType.Element) 224if (node.NodeType == XmlNodeType.Attribute) 279if (fc == null || fc.NodeType != XmlNodeType.Text || fc.NextSibling != null) 291if (n.NodeType != XmlNodeType.Element) 324if (fc == null || fc.NodeType != XmlNodeType.Text || fc.NextSibling != null) 334if (n.NodeType != XmlNodeType.Element)

123Debug.Assert(CurrentNode.NodeType == XmlNodeType.Element); 126if (CurrentNode.NodeType == XmlNodeType.Element && DataSetMapper.GetTableSchemaForElement((XmlElement)(CurrentNode)) != null) 169while (n.NodeType == XmlNodeType.Whitespace) 190if (n.NodeType != XmlNodeType.Whitespace)

267Debug.Assert(dp.NodeType == XmlNodeType.Element); 307Debug.Assert(dp.NodeType == XmlNodeType.Element); 351case XmlNodeType.Attribute: 371case XmlNodeType.Element: 375case XmlNodeType.Text:

764if (node.NodeType != XmlNodeType.Element) 997if (newNode.NodeType == XmlNodeType.Element) 1039if (dp.NodeType == XmlNodeType.Element) 1059XmlNodeType.DocumentFragment => CreateDocumentFragment(), 1060XmlNodeType.DocumentType => CreateDocumentType(dp.Name, dp.PublicId, dp.SystemId, dp.InternalSubset), 1061XmlNodeType.XmlDeclaration => CreateXmlDeclaration(dp.Version!, dp.Encoding, dp.Standalone), 1064XmlNodeType.Text => CreateTextNode(dp.Value), 1065XmlNodeType.CDATA => CreateCDataSection(dp.Value), 1066XmlNodeType.ProcessingInstruction => CreateProcessingInstruction(dp.Name, dp.Value!), 1067XmlNodeType.Comment => CreateComment(dp.Value), 1068XmlNodeType.Whitespace => CreateWhitespace(dp.Value), 1069XmlNodeType.SignificantWhitespace => CreateSignificantWhitespace(dp.Value), 1072XmlNodeType.Element => CreateElement(dp.Prefix, dp.LocalName, dp.NamespaceURI), 1073XmlNodeType.Attribute => CreateAttribute(dp.Prefix, dp.LocalName, dp.NamespaceURI), 1074XmlNodeType.EntityReference => CreateEntityReference(dp.Name), 1088case XmlNodeType.Text: 1089case XmlNodeType.CDATA: 1090case XmlNodeType.Whitespace: 1091case XmlNodeType.SignificantWhitespace: 1094case XmlNodeType.EntityReference: 1103internal static bool IsTextNode(XmlNodeType nt) 1107case XmlNodeType.Text: 1108case XmlNodeType.CDATA: 1109case XmlNodeType.Whitespace: 1110case XmlNodeType.SignificantWhitespace: 1514if (iter.CurrentNode!.NodeType == XmlNodeType.Element) 2273Debug.Assert(parent.NodeType != XmlNodeType.Attribute); // We need to get the grand-parent region 2328while (n != null && n.NodeType == XmlNodeType.Whitespace) 2333if (n.NodeType == XmlNodeType.Text) 2951if (parent != null && parent.NodeType == XmlNodeType.Attribute)

58case XmlNodeType.Whitespace: 60case XmlNodeType.SignificantWhitespace: 63case XmlNodeType.Text: 64case XmlNodeType.CDATA: 91private static bool IsNamespaceNode(XmlNodeType nt, string ns) => nt == XmlNodeType.Attribute && ns == StrReservedXmlns; 134if (_node.NodeType == XmlNodeType.Element) 190XmlNodeType nt = _node.NodeType; 193if (nt == XmlNodeType.Element || nt == XmlNodeType.Attribute || nt == XmlNodeType.ProcessingInstruction) 219XmlNodeType nt = _node.NodeType; 227if (nt == XmlNodeType.Element || nt == XmlNodeType.Attribute || nt == XmlNodeType.ProcessingInstruction) 354if (_node.NodeType == XmlNodeType.Document) 423if (curNode.NodeType == XmlNodeType.Attribute) 521if (_column == null && _node.NodeType == XmlNodeType.Element) 592if ((_column == null || _column.ColumnMapping == MappingType.Attribute) && _node.NodeType == XmlNodeType.Element) 627if (bFirst && (_column != null || _node.NodeType != XmlNodeType.Element)) 633if (_column == null && _node.NodeType != XmlNodeType.Attribute) 998if (_node.NodeType == XmlNodeType.Attribute) 1074XmlNode? parent = ((curNode.NodeType == XmlNodeType.Attribute) ? (((XmlAttribute)curNode).OwnerElement) : (curNode.ParentNode)); 1183curNode1 = ((curNode1.NodeType == XmlNodeType.Attribute) ? (((XmlAttribute)curNode1).OwnerElement) : (curNode1.ParentNode)); 1193curNode2 = ((curNode2.NodeType == XmlNodeType.Attribute) ? (((XmlAttribute)curNode2).OwnerElement) : (curNode2.ParentNode)); 1370XmlNodeType nt; 1375while (node != null && ((nt = node.NodeType) != XmlNodeType.Element)) 1377if (nt == XmlNodeType.Attribute) 1444} while (node != null && node.NodeType != XmlNodeType.Element); 1530} while (node != null && node.NodeType != XmlNodeType.Element); 1560} while (node != null && node.NodeType != XmlNodeType.Element); 1601} while (node != null && node.NodeType != XmlNodeType.Element); 1603else if (_node.NodeType == XmlNodeType.Attribute) 1620} while (node != null && node.NodeType != XmlNodeType.Element); 1633} while (node != null && node.NodeType == XmlNodeType.Element);

245if (reader.NodeType == XmlNodeType.Element 266if (reader.NodeType == XmlNodeType.None) 269if (reader.NodeType == XmlNodeType.Element 298if (!((reader.LocalName == RelationshipsTagName) && (reader.NodeType == XmlNodeType.EndElement))) 373if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == RelationshipTagName)

34if (reader.Read() && reader.NodeType == XmlNodeType.XmlDeclaration && reader.Depth == 0) 86Debug.Assert(reader.NodeType == XmlNodeType.Element, "XmlReader should be positioned at an Element");

494if (reader.MoveToContent() != XmlNodeType.Element 515while (reader.Read() && reader.MoveToContent() != XmlNodeType.None) 518if (reader.NodeType == XmlNodeType.EndElement) 522if (reader.NodeType != XmlNodeType.Element) 642if (reader.MoveToContent() == XmlNodeType.EndElement) 646if (reader.NodeType != XmlNodeType.Text)

155case XmlNodeType.Element: 164case XmlNodeType.EndElement: 689_inAttribute = (Reader.NodeType == XmlNodeType.Attribute);

26public override XmlNodeType NodeType { get { return _reader.NodeType; } }

980if ((reader.NodeType == XmlNodeType.Element) 1001if (reader.NodeType == XmlNodeType.None) 1006if (reader.NodeType == XmlNodeType.Element 1013else if (reader.NodeType == XmlNodeType.Element 1020else if (reader.NodeType == XmlNodeType.EndElement && reader.Depth == 0 && reader.Name == TypesTagName) 1226if (reader.NodeType == XmlNodeType.EndElement && elementName == reader.LocalName)

487throw XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.Format(SR.ExpectingElementAtDeserialize, XmlNodeType.Element), xmlReader);

35private XmlNodeType _nodeType; 113public override XmlNodeType NodeType { get { return IsXmlDataNode ? _xmlNodeReader.NodeType : _nodeType; } } 162_nodeType = XmlNodeType.Attribute; 210if (_nodeType != XmlNodeType.Attribute) 219_nodeType = XmlNodeType.Element; 289if (_nodeType == XmlNodeType.Attribute && MoveToNextAttribute()) 304_nodeType = XmlNodeType.Text; 313_nodeType = XmlNodeType.EndElement; 326_nodeType = XmlNodeType.None;

467throw XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.Format(SR.ExpectingElementAtDeserialize, XmlNodeType.Element), xmlReader);

768LocalBuilder nodeType = _ilg.DeclareLocal(typeof(XmlNodeType)); 774_ilg.Load(XmlNodeType.EndElement); 778_ilg.Load(XmlNodeType.Element); 780ThrowUnexpectedStateException(XmlNodeType.Element); 1034ThrowUnexpectedStateException(XmlNodeType.Element); 1052_ilg.Load(XmlNodeType.EndElement); 1056private void ThrowUnexpectedStateException(XmlNodeType expectedState)

189XmlNodeType nodeType = xmlReader.MoveToContent(); 190if (nodeType == XmlNodeType.EndElement) 194if (nodeType != XmlNodeType.Element) 196throw XmlObjectSerializerReadContext.CreateUnexpectedStateException(XmlNodeType.Element, xmlReader);

319return (this.Node.NodeType == XmlNodeType.Attribute || this.Node is XmlAttributeTextNode); 336(this.Node.NodeType == XmlNodeType.Text)); 569else if (this.Node.NodeType == XmlNodeType.Element) 582else if (this.Node.NodeType == XmlNodeType.EndElement)

168if (xmlReader.NodeType == XmlNodeType.EndElement) 175throw XmlObjectSerializerReadContext.CreateUnexpectedStateException(XmlNodeType.Element, xmlReader);

1416if (child.NodeType == XmlNodeType.Element)

658s_createUnexpectedStateExceptionMethod = typeof(XmlObjectSerializerReadContext).GetMethod("CreateUnexpectedStateException", Globals.ScanAllMembers, new Type[] { typeof(XmlNodeType), typeof(XmlReaderDelegator) });

954ThrowUnexpectedStateException(XmlNodeType.Element); 972_ilg.Load(XmlNodeType.EndElement); 976private void ThrowUnexpectedStateException(XmlNodeType expectedState)

214return (xmlReader.MoveToContent() != XmlNodeType.EndElement); 267if (xmlReader.NodeType != XmlNodeType.Element) 268throw CreateUnexpectedStateException(XmlNodeType.Element, xmlReader); 480if (xmlReader.NodeType == XmlNodeType.EndElement) 488if (xmlReader.NodeType != XmlNodeType.EndElement) 489throw CreateUnexpectedStateException(XmlNodeType.EndElement, xmlReader); 521throw CreateUnexpectedStateException(XmlNodeType.Element, xmlReader); 546XmlNodeType nodeType; 547while ((nodeType = xmlReader.MoveToContent()) != XmlNodeType.EndElement) 549if (nodeType != XmlNodeType.Element) 551throw CreateUnexpectedStateException(XmlNodeType.Element, xmlReader); 724case XmlNodeType.Text: 726case XmlNodeType.Element: 732case XmlNodeType.EndElement: 741throw CreateUnexpectedStateException(XmlNodeType.Element, xmlReader); 790XmlNodeType nodeType; 791while ((nodeType = xmlReader.MoveToContent()) != XmlNodeType.EndElement) 793if (nodeType != XmlNodeType.Element) 794throw CreateUnexpectedStateException(XmlNodeType.Element, xmlReader); 813XmlNodeType nodeType; 814while ((nodeType = xmlReader.MoveToContent()) != XmlNodeType.EndElement) 816if (nodeType != XmlNodeType.Element) 817throw CreateUnexpectedStateException(XmlNodeType.Element, xmlReader); 872XmlNodeType nodeType; 873while ((nodeType = xmlReader.MoveToContent()) != XmlNodeType.EndElement) 875if (nodeType != XmlNodeType.Element) 876throw CreateUnexpectedStateException(XmlNodeType.Element, xmlReader); 901if (xmlReader.NodeType == XmlNodeType.EndElement) 907XmlNodeType nodeType = xmlReader.MoveToContent(); 908if (nodeType != XmlNodeType.Text) 922while (xmlReader.MoveToContent() != XmlNodeType.EndElement) 961XmlNodeType nodeType; 962while ((nodeType = xmlReader.NodeType) != XmlNodeType.EndElement) 964if (nodeType == XmlNodeType.Element) 1023private static bool IsContentNode(XmlNodeType nodeType) 1027case XmlNodeType.Whitespace: 1028case XmlNodeType.SignificantWhitespace: 1029case XmlNodeType.Comment: 1030case XmlNodeType.ProcessingInstruction: 1031case XmlNodeType.DocumentType: 1078internal static Exception CreateUnexpectedStateException(XmlNodeType expectedState, XmlReaderDelegator xmlReader)

167internal XmlNodeType NodeType 169get { return isEndOfEmptyElement ? XmlNodeType.EndElement : reader.NodeType; } 188internal XmlNodeType MoveToContent() 191return XmlNodeType.EndElement;

27if (xmlReader.NodeType != XmlNodeType.Element) 28throw XmlObjectSerializerReadContext.CreateUnexpectedStateException(XmlNodeType.Element, xmlReader); 46throw XmlObjectSerializerReadContext.CreateUnexpectedStateException(XmlNodeType.EndElement, _xmlReader); 56if (reader.NodeType == XmlNodeType.EndElement || 57(reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement)) 71public override XmlNodeType NodeType { get { return InnerReader.NodeType; } } 114public override XmlNodeType MoveToContent() { return InnerReader.MoveToContent(); }

36while (xmlReader.Depth > startDepth && xmlReader.NodeType != XmlNodeType.EndElement)

44if (read < array.Length || reader.NodeType == XmlNodeType.EndElement)

221_whitespaceTextNode.NodeType = XmlNodeType.SignificantWhitespace; 223_whitespaceTextNode.NodeType = XmlNodeType.Whitespace; 820public override XmlNodeType MoveToContent() 826if (_node.NodeType != XmlNodeType.Text && _node.NodeType != XmlNodeType.CDATA) 847if (_node.NodeType == XmlNodeType.Attribute) 921public sealed override XmlNodeType NodeType 993XmlNodeType nodeType = _node.NodeType; 994if (nodeType == XmlNodeType.Element) 996if (nodeType == XmlNodeType.EndElement) 998if (nodeType == XmlNodeType.None) 1001if (_node.NodeType == XmlNodeType.Element) 1004return (MoveToContent() == XmlNodeType.Element); 1024return (_node.NodeType == XmlNodeType.Element || IsStartElement()) && _node.Prefix == prefix && _node.LocalName == localName; 1033return (_node.NodeType == XmlNodeType.Element || IsStartElement()) && _node.LocalName == localName && _node.IsNamespaceUri(namespaceUri); 1041return (_node.NodeType == XmlNodeType.Element || IsStartElement()) && _node.LocalName == localName && _node.IsNamespaceUri(namespaceUri); 1183if (_node.NodeType != XmlNodeType.Element) 1231if (_node.NodeType != XmlNodeType.Element) 1250if (_node.NodeType != XmlNodeType.EndElement && MoveToContent() != XmlNodeType.EndElement) 1252int nodeDepth = _node.NodeType == XmlNodeType.Element ? _depth - 1 : _depth; 1359while (_node.NodeType != XmlNodeType.Comment && _node.Value.TryReadBase64(buffer, offset, count, out actual)) 1367XmlNodeType nodeType = _node.NodeType; 1368if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement) 1431XmlNodeType nodeType = _node.NodeType; 1432if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement) 1726if ((_node.NodeType == XmlNodeType.Element || MoveToElement()) && !IsEmptyElement) 1734if (_node.NodeType == XmlNodeType.EndElement) 1952case XmlNodeType.None: 1954case XmlNodeType.Element: 1960case XmlNodeType.Text: 1961case XmlNodeType.Whitespace: 1962case XmlNodeType.SignificantWhitespace: 1963case XmlNodeType.CDATA: 1966case XmlNodeType.XmlDeclaration: 1969case XmlNodeType.Comment: 1972case XmlNodeType.EndElement: 2036private XmlNodeType _nodeType; 2066protected XmlNode(XmlNodeType nodeType, 2088_exitScope = (nodeType == XmlNodeType.EndElement); 2114public XmlNodeType NodeType 2360: base(XmlNodeType.Element, 2404: base(XmlNodeType.Attribute, 2419: base(XmlNodeType.EndElement, 2433protected XmlTextNode(XmlNodeType nodeType, 2450: base(XmlNodeType.Text, 2465: base(XmlNodeType.Text, 2480: base(XmlNodeType.Whitespace, 2495: base(XmlNodeType.CDATA, 2510: base(XmlNodeType.Text, 2525: base(XmlNodeType.None, 2540: base(XmlNodeType.XmlDeclaration, 2555: base(XmlNodeType.Comment, 2570: base(XmlNodeType.None, 2585: base(XmlNodeType.None,

91if (this.Node.NodeType != XmlNodeType.Element) 119if (this.Node.NodeType != XmlNodeType.Element) 150if (this.Node.NodeType != XmlNodeType.Element) 196if (this.Node.NodeType != XmlNodeType.Element) 210if (this.Node.NodeType != XmlNodeType.Element) 224if (this.Node.NodeType != XmlNodeType.Element) 238if (this.Node.NodeType != XmlNodeType.Element) 252if (this.Node.NodeType != XmlNodeType.Element) 266if (this.Node.NodeType != XmlNodeType.Element) 280if (this.Node.NodeType != XmlNodeType.Element) 1123if (this.Node.NodeType != XmlNodeType.Element) 1128if (this.Node.NodeType != XmlNodeType.EndElement)

395case XmlNodeType.Attribute: 398case XmlNodeType.Text: 399case XmlNodeType.Whitespace: 400case XmlNodeType.SignificantWhitespace: 401case XmlNodeType.CDATA: 416case XmlNodeType.ProcessingInstruction: 417case XmlNodeType.Comment: 418case XmlNodeType.EndEntity: 421case XmlNodeType.EntityReference: 428case XmlNodeType.Element: 429case XmlNodeType.EndElement: 457if (this.NodeType != XmlNodeType.Element) 459if (this.NodeType == XmlNodeType.Element) 465if (this.NodeType == XmlNodeType.EndElement) 546protected bool IsTextNode(XmlNodeType nodeType) 548return nodeType == XmlNodeType.Text || 549nodeType == XmlNodeType.Whitespace || 550nodeType == XmlNodeType.SignificantWhitespace || 551nodeType == XmlNodeType.CDATA || 552nodeType == XmlNodeType.Attribute; 560XmlNodeType nodeType = this.NodeType; 562if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement) 572if (nodeType == XmlNodeType.Attribute /* || inAttributeText */) 1487public override XmlNodeType NodeType

269if (reader.NodeType == XmlNodeType.EntityReference) 387int d = (reader.NodeType == XmlNodeType.None ? -1 : reader.Depth); 390XmlNodeType nodeType = reader.NodeType; 392if (nodeType == XmlNodeType.Text || nodeType == XmlNodeType.Whitespace || nodeType == XmlNodeType.SignificantWhitespace) 406case XmlNodeType.Element: 409case XmlNodeType.CDATA: 412case XmlNodeType.EntityReference: 415case XmlNodeType.XmlDeclaration: 416case XmlNodeType.ProcessingInstruction: 419case XmlNodeType.DocumentType: 422case XmlNodeType.Comment: 425case XmlNodeType.EndElement: 433while (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement));

67case XmlNodeType.Element: 69case XmlNodeType.EndElement: 71case XmlNodeType.Text: 72case XmlNodeType.Whitespace: 73case XmlNodeType.SignificantWhitespace: 75case XmlNodeType.Comment: 77case XmlNodeType.CDATA:

275private XmlNodeType _nodetype; 283private XmlNodeType _parentNodeType; // use for MoveToElement() 338_nodetype = XmlNodeType.None; 419public override XmlNodeType NodeType 476case XmlNodeType.DocumentType: 477case XmlNodeType.ProcessingInstruction: 478case XmlNodeType.Comment: 481case XmlNodeType.CDATA: 484case XmlNodeType.XmlDeclaration: 487case XmlNodeType.Text: 488case XmlNodeType.Whitespace: 489case XmlNodeType.SignificantWhitespace: 519if (_nodetype == XmlNodeType.Element 520|| _nodetype == XmlNodeType.EndElement) 530if (_parentNodeType != XmlNodeType.Element) 535if (_parentNodeType != XmlNodeType.Element) 802if (XmlNodeType.Element == _parentNodeType) 804else if (XmlNodeType.XmlDeclaration == _parentNodeType) 806else if (XmlNodeType.DocumentType == _parentNodeType) 859_nodetype = XmlNodeType.Text; 877_nodetype = XmlNodeType.None; 951_nodetype = XmlNodeType.None; 997if (this.NodeType == XmlNodeType.EndElement) 999if (this.NodeType == XmlNodeType.ProcessingInstruction || this.NodeType == XmlNodeType.Comment) 1001while (Read() && (this.NodeType == XmlNodeType.ProcessingInstruction || this.NodeType == XmlNodeType.Comment)) 1003if (this.NodeType == XmlNodeType.EndElement) 1032if (this.NodeType != XmlNodeType.Element && this.NodeType != XmlNodeType.EndElement) 1040case XmlNodeType.ProcessingInstruction: 1041case XmlNodeType.Comment: 1044case XmlNodeType.Element: 1045case XmlNodeType.EndElement: 1728if (this.NodeType == XmlNodeType.Element || this.NodeType == XmlNodeType.EndElement) 1767if (this.NodeType == XmlNodeType.Element || this.NodeType == XmlNodeType.EndElement) 2403_nodetype = XmlNodeType.Attribute; 2570_nodetype = XmlNodeType.XmlDeclaration; 2805case XmlNodeType.CDATA: 2808case XmlNodeType.EndElement: 2811case XmlNodeType.Element: 2822_nodetype = XmlNodeType.None; 2935if (XmlNodeType.Text == _nodetype) 3087_nodetype = XmlNodeType.Element; 3101_nodetype = XmlNodeType.EndElement; 3141_nodetype = XmlNodeType.DocumentType; 3150_nodetype = XmlNodeType.ProcessingInstruction; 3155_nodetype = XmlNodeType.Comment; 3163_nodetype = XmlNodeType.CDATA; 3216|| ((_textXmlReader.NodeType == XmlNodeType.XmlDeclaration) 3333private XmlNodeType ScanOverValue(BinXmlToken token, bool attr, bool checkChars) 3356return XmlNodeType.Text; 3365private XmlNodeType ScanOverAnyValue(BinXmlToken token, bool attr, bool checkChars) 3480return XmlNodeType.Text; 3483private XmlNodeType CheckText(bool attr) 3499return _xmlspacePreserve ? XmlNodeType.SignificantWhitespace : XmlNodeType.Whitespace; 3512return XmlNodeType.Text; 3538private XmlNodeType CheckTextIsWS() 3560return XmlNodeType.SignificantWhitespace; 3561return XmlNodeType.Whitespace; 3563return XmlNodeType.Text;

159if (_reader.NodeType != XmlNodeType.Element) 202if (_reader.NodeType != XmlNodeType.Element) 242if (_reader.NodeType != XmlNodeType.EndElement) 276Debug.Assert(_reader.NodeType == XmlNodeType.Element); 289if (_reader.NodeType != XmlNodeType.EndElement) 401if (_reader.NodeType != XmlNodeType.EndElement) 418case XmlNodeType.Attribute: 420case XmlNodeType.Text: 421case XmlNodeType.Whitespace: 422case XmlNodeType.SignificantWhitespace: 423case XmlNodeType.CDATA: 429case XmlNodeType.ProcessingInstruction: 430case XmlNodeType.Comment: 431case XmlNodeType.EndEntity: 434case XmlNodeType.EntityReference:

112if (_reader.NodeType != XmlNodeType.Element) 156if (_reader.NodeType != XmlNodeType.Element) 197if (_reader.NodeType != XmlNodeType.EndElement) 224Debug.Assert(_reader.NodeType == XmlNodeType.Element); 237if (_reader.NodeType != XmlNodeType.EndElement) 323if (_reader.NodeType != XmlNodeType.EndElement) 340case XmlNodeType.Attribute: 342case XmlNodeType.Text: 343case XmlNodeType.Whitespace: 344case XmlNodeType.SignificantWhitespace: 345case XmlNodeType.CDATA: 351case XmlNodeType.ProcessingInstruction: 352case XmlNodeType.Comment: 353case XmlNodeType.EndEntity: 356case XmlNodeType.EntityReference:

26private XmlNodeType _nodeType; 33Clear(XmlNodeType.None); 36public ValidatingReaderNodeData(XmlNodeType nodeType) 130public XmlNodeType NodeType 174internal void Clear(XmlNodeType nodeType)

82public override XmlNodeType NodeType 619public override XmlNodeType MoveToContent() 891public override Task<XmlNodeType> MoveToContentAsync()

41private XmlNodeType _lastNodeType; 61_lastNodeType = XmlNodeType.None; 192XmlNodeType nodeType = base.reader.NodeType; 198case XmlNodeType.Comment: 204case XmlNodeType.Whitespace: 210case XmlNodeType.ProcessingInstruction: 216case XmlNodeType.DocumentType: 233case XmlNodeType.Element: 253case XmlNodeType.Text: 254case XmlNodeType.CDATA: 261case XmlNodeType.EntityReference: 269case XmlNodeType.ProcessingInstruction: 281case XmlNodeType.Comment: 292case XmlNodeType.DocumentType: 325case XmlNodeType.Whitespace: 336case XmlNodeType.SignificantWhitespace: 343case XmlNodeType.EndElement:

54XmlNodeType nodeType = base.reader.NodeType; 60case XmlNodeType.Comment: 66case XmlNodeType.Whitespace: 72case XmlNodeType.ProcessingInstruction: 78case XmlNodeType.DocumentType: 95case XmlNodeType.Element: 115case XmlNodeType.Text: 116case XmlNodeType.CDATA: 123case XmlNodeType.EntityReference: 131case XmlNodeType.ProcessingInstruction: 143case XmlNodeType.Comment: 154case XmlNodeType.DocumentType: 186case XmlNodeType.Whitespace: 197case XmlNodeType.SignificantWhitespace: 204case XmlNodeType.EndElement:

93public abstract XmlNodeType NodeType { get; } 693if (NodeType == XmlNodeType.Element) 704if (NodeType == XmlNodeType.EndElement) 724public virtual XmlNodeType MoveToContent() 730case XmlNodeType.Attribute: 733case XmlNodeType.Element: 734case XmlNodeType.EndElement: 735case XmlNodeType.CDATA: 736case XmlNodeType.Text: 737case XmlNodeType.EntityReference: 738case XmlNodeType.EndEntity: 748if (MoveToContent() != XmlNodeType.Element) 758if (MoveToContent() != XmlNodeType.Element) 776if (MoveToContent() != XmlNodeType.Element) 796if (MoveToContent() != XmlNodeType.Element) 804if (NodeType != XmlNodeType.EndElement) 823if (MoveToContent() != XmlNodeType.Element) 836if (NodeType != XmlNodeType.EndElement) 855if (MoveToContent() != XmlNodeType.Element) 868if (NodeType != XmlNodeType.EndElement) 885if (MoveToContent() != XmlNodeType.EndElement) 895return MoveToContent() == XmlNodeType.Element; 902return MoveToContent() == XmlNodeType.Element && Name == name; 909return MoveToContent() == XmlNodeType.Element && LocalName == localname && NamespaceURI == ns; 923if (NodeType == XmlNodeType.Element && Ref.Equal(name, Name)) 944if (NodeType == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI)) 959if (NodeType != XmlNodeType.Element) 983if (NodeType == XmlNodeType.Element && Ref.Equal(name, Name)) 988Debug.Assert(NodeType == XmlNodeType.EndElement || NodeType == XmlNodeType.None || ReadState == ReadState.Error); 1000if (NodeType != XmlNodeType.Element) 1025if (NodeType == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI)) 1030Debug.Assert(NodeType == XmlNodeType.EndElement); 1043XmlNodeType nt; 1051if (nt == XmlNodeType.Element && Ref.Equal(name, Name)) 1055} while (nt != XmlNodeType.EndElement && !EOF); 1070XmlNodeType nt; 1078if (nt == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI)) 1082} while (nt != XmlNodeType.EndElement && !EOF); 1110if (NodeType != XmlNodeType.Attribute && NodeType != XmlNodeType.Element) 1121if (NodeType == XmlNodeType.Attribute) 1127if (NodeType == XmlNodeType.Element) 1139int d = NodeType == XmlNodeType.None ? -1 : Depth; 1144case XmlNodeType.Element: 1153case XmlNodeType.Text: 1156case XmlNodeType.Whitespace: 1157case XmlNodeType.SignificantWhitespace: 1160case XmlNodeType.CDATA: 1163case XmlNodeType.EntityReference: 1166case XmlNodeType.XmlDeclaration: 1167case XmlNodeType.ProcessingInstruction: 1170case XmlNodeType.DocumentType: 1173case XmlNodeType.Comment: 1176case XmlNodeType.EndElement: 1181if (d == Depth && NodeType == XmlNodeType.EndElement) 1193if (NodeType == XmlNodeType.EntityReference) 1213if (NodeType != XmlNodeType.Attribute && NodeType != XmlNodeType.Element) 1224if (NodeType == XmlNodeType.Attribute) 1269if (NodeType != XmlNodeType.Element) 1301internal static bool IsTextualNode(XmlNodeType nodeType) 1306Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.None))); 1307Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.Element))); 1308Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.Attribute))); 1309Debug.Assert(0 != (IsTextualNodeBitmap & (1 << (int)XmlNodeType.Text))); 1310Debug.Assert(0 != (IsTextualNodeBitmap & (1 << (int)XmlNodeType.CDATA))); 1311Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.EntityReference))); 1312Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.Entity))); 1313Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.ProcessingInstruction))); 1314Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.Comment))); 1315Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.Document))); 1316Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.DocumentType))); 1317Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.DocumentFragment))); 1318Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.Notation))); 1319Debug.Assert(0 != (IsTextualNodeBitmap & (1 << (int)XmlNodeType.Whitespace))); 1320Debug.Assert(0 != (IsTextualNodeBitmap & (1 << (int)XmlNodeType.SignificantWhitespace))); 1321Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.EndElement))); 1322Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.EndEntity))); 1323Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)XmlNodeType.XmlDeclaration))); 1328internal static bool CanReadContentAs(XmlNodeType nodeType) 1333Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)XmlNodeType.None))); 1334Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)XmlNodeType.Element))); 1335Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)XmlNodeType.Attribute))); 1336Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)XmlNodeType.Text))); 1337Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)XmlNodeType.CDATA))); 1338Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)XmlNodeType.EntityReference))); 1339Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)XmlNodeType.Entity))); 1340Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)XmlNodeType.ProcessingInstruction))); 1341Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)XmlNodeType.Comment))); 1342Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)XmlNodeType.Document))); 1343Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)XmlNodeType.DocumentType))); 1344Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)XmlNodeType.DocumentFragment))); 1345Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)XmlNodeType.Notation))); 1346Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)XmlNodeType.Whitespace))); 1347Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)XmlNodeType.SignificantWhitespace))); 1348Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)XmlNodeType.EndElement))); 1349Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)XmlNodeType.EndEntity))); 1350Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)XmlNodeType.XmlDeclaration))); 1355internal static bool HasValueInternal(XmlNodeType nodeType) 1360Debug.Assert(0 == (HasValueBitmap & (1 << (int)XmlNodeType.None))); 1361Debug.Assert(0 == (HasValueBitmap & (1 << (int)XmlNodeType.Element))); 1362Debug.Assert(0 != (HasValueBitmap & (1 << (int)XmlNodeType.Attribute))); 1363Debug.Assert(0 != (HasValueBitmap & (1 << (int)XmlNodeType.Text))); 1364Debug.Assert(0 != (HasValueBitmap & (1 << (int)XmlNodeType.CDATA))); 1365Debug.Assert(0 == (HasValueBitmap & (1 << (int)XmlNodeType.EntityReference))); 1366Debug.Assert(0 == (HasValueBitmap & (1 << (int)XmlNodeType.Entity))); 1367Debug.Assert(0 != (HasValueBitmap & (1 << (int)XmlNodeType.ProcessingInstruction))); 1368Debug.Assert(0 != (HasValueBitmap & (1 << (int)XmlNodeType.Comment))); 1369Debug.Assert(0 == (HasValueBitmap & (1 << (int)XmlNodeType.Document))); 1370Debug.Assert(0 != (HasValueBitmap & (1 << (int)XmlNodeType.DocumentType))); 1371Debug.Assert(0 == (HasValueBitmap & (1 << (int)XmlNodeType.DocumentFragment))); 1372Debug.Assert(0 == (HasValueBitmap & (1 << (int)XmlNodeType.Notation))); 1373Debug.Assert(0 != (HasValueBitmap & (1 << (int)XmlNodeType.Whitespace))); 1374Debug.Assert(0 != (HasValueBitmap & (1 << (int)XmlNodeType.SignificantWhitespace))); 1375Debug.Assert(0 == (HasValueBitmap & (1 << (int)XmlNodeType.EndElement))); 1376Debug.Assert(0 == (HasValueBitmap & (1 << (int)XmlNodeType.EndEntity))); 1377Debug.Assert(0 != (HasValueBitmap & (1 << (int)XmlNodeType.XmlDeclaration))); 1389if (NodeType == XmlNodeType.Element && !IsEmptyElement) 1399if (NodeType == XmlNodeType.EndElement) 1415if (NodeType != XmlNodeType.Element) 1441internal static Exception CreateReadContentAsException(string methodName, XmlNodeType nodeType, IXmlLineInfo? lineInfo) 1446internal static Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType, IXmlLineInfo? lineInfo) 1473case XmlNodeType.Attribute: 1475case XmlNodeType.Text: 1476case XmlNodeType.Whitespace: 1477case XmlNodeType.SignificantWhitespace: 1478case XmlNodeType.CDATA: 1490case XmlNodeType.ProcessingInstruction: 1491case XmlNodeType.Comment: 1492case XmlNodeType.EndEntity: 1495case XmlNodeType.EntityReference: 1513if (NodeType != XmlNodeType.Element) 1528XmlNodeType nodeType = NodeType; 1530if (nodeType == XmlNodeType.EndElement) 1537if (nodeType == XmlNodeType.Element) 1547if (NodeType != XmlNodeType.EndElement) 1779XmlNodeType nt = _reader.NodeType; 1783case XmlNodeType.Element: 1784case XmlNodeType.EndElement: 1785case XmlNodeType.EntityReference: 1786case XmlNodeType.EndEntity: 1789case XmlNodeType.Attribute: 1790case XmlNodeType.ProcessingInstruction: 1793case XmlNodeType.Text: 1794case XmlNodeType.Whitespace: 1795case XmlNodeType.SignificantWhitespace: 1796case XmlNodeType.Comment: 1797case XmlNodeType.XmlDeclaration: 1798case XmlNodeType.CDATA: 1801case XmlNodeType.DocumentType:

158public virtual async Task<XmlNodeType> MoveToContentAsync() 164case XmlNodeType.Attribute: 167case XmlNodeType.Element: 168case XmlNodeType.EndElement: 169case XmlNodeType.CDATA: 170case XmlNodeType.Text: 171case XmlNodeType.EntityReference: 172case XmlNodeType.EndEntity: 186if (NodeType != XmlNodeType.Attribute && NodeType != XmlNodeType.Element) 196if (NodeType == XmlNodeType.Attribute) 202if (NodeType == XmlNodeType.Element) 214int d = NodeType == XmlNodeType.None ? -1 : Depth; 219case XmlNodeType.Element: 228case XmlNodeType.Text: 231case XmlNodeType.Whitespace: 232case XmlNodeType.SignificantWhitespace: 235case XmlNodeType.CDATA: 238case XmlNodeType.EntityReference: 241case XmlNodeType.XmlDeclaration: 242case XmlNodeType.ProcessingInstruction: 245case XmlNodeType.DocumentType: 248case XmlNodeType.Comment: 251case XmlNodeType.EndElement: 256if (d == Depth && NodeType == XmlNodeType.EndElement) 269if (NodeType != XmlNodeType.Attribute && NodeType != XmlNodeType.Element) 279if (NodeType == XmlNodeType.Attribute) 301if (NodeType == XmlNodeType.Element && !IsEmptyElement) 311if (NodeType == XmlNodeType.EndElement) 330case XmlNodeType.Attribute: 332case XmlNodeType.Text: 333case XmlNodeType.Whitespace: 334case XmlNodeType.SignificantWhitespace: 335case XmlNodeType.CDATA: 347case XmlNodeType.ProcessingInstruction: 348case XmlNodeType.Comment: 349case XmlNodeType.EndEntity: 352case XmlNodeType.EntityReference: 370if (NodeType != XmlNodeType.Element) 385XmlNodeType nodeType = NodeType; 386if (nodeType == XmlNodeType.EndElement) 392if (nodeType == XmlNodeType.Element) 401if (NodeType != XmlNodeType.EndElement)

20internal XmlNodeType type; 27internal NodeData(XmlNodeType nodeType, string localName, string prefix, string name, string namespaceUri, string value) 37internal void Set(XmlNodeType nodeType, string localName, string prefix, string name, string namespaceUri, string value) 107_tmpNode = new NodeData(XmlNodeType.None, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty); 115public override XmlNodeType NodeType 170if (_curNode.type == XmlNodeType.Text) 432Debug.Assert(reader.NodeType == XmlNodeType.Element); 451else if (_curNode.type == XmlNodeType.Text) 457Debug.Assert(_curNode.type == XmlNodeType.Attribute); 458_tmpNode.type = XmlNodeType.Text; 482if (reader.NodeType == XmlNodeType.EndElement || 483(reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement)) 489Debug.Assert(reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement); 552if (reader.Depth == _initialDepth && reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) 590if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) 595while (reader.NodeType != XmlNodeType.EndElement && reader.Depth > _initialDepth) 601Debug.Assert(reader.NodeType == XmlNodeType.EndElement || 602reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement || 609if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) 839case XmlNodeType.Element: 841case XmlNodeType.EndElement: 843case XmlNodeType.Attribute: 873goto case XmlNodeType.Text; 874case XmlNodeType.Text: 931if (NodeType != XmlNodeType.EndElement) 977case XmlNodeType.Element: 979case XmlNodeType.EndElement: 981case XmlNodeType.Attribute: 1011goto case XmlNodeType.Text; 1012case XmlNodeType.Text: 1068if (NodeType != XmlNodeType.EndElement) 1248case XmlNodeType.Element: 1292case XmlNodeType.EndElement: 1331_nsAttributes[index] = new NodeData(XmlNodeType.Attribute, localName, attrPrefix, name, _xmlnsUri, ns); 1335_nsAttributes[index].Set(XmlNodeType.Attribute, localName, attrPrefix, name, _xmlnsUri, ns); 1375if (NodeType != XmlNodeType.Element) 1390case XmlNodeType.Element: 1392case XmlNodeType.EndElement: 1418if (NodeType != XmlNodeType.EndElement) 1510_tmpNode.type = XmlNodeType.None; 1566case XmlNodeType.Element: 1570case XmlNodeType.EndElement: 1574case XmlNodeType.Attribute:

45if (reader.NodeType == XmlNodeType.EndElement || 46(reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement)) 52Debug.Assert(reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement); 116if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) 121while (reader.NodeType != XmlNodeType.EndElement && reader.Depth > _initialDepth) 127Debug.Assert(reader.NodeType == XmlNodeType.EndElement || 128reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement || 135if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) 245case XmlNodeType.Element: 247case XmlNodeType.EndElement: 249case XmlNodeType.Attribute: 279goto case XmlNodeType.Text; 280case XmlNodeType.Text: 337if (NodeType != XmlNodeType.EndElement) 383case XmlNodeType.Element: 385case XmlNodeType.EndElement: 387case XmlNodeType.Attribute: 417goto case XmlNodeType.Text; 418case XmlNodeType.Text: 474if (NodeType != XmlNodeType.EndElement) 559if (NodeType != XmlNodeType.Element) 574case XmlNodeType.Element: 576case XmlNodeType.EndElement: 602if (NodeType != XmlNodeType.EndElement)

86public XmlTextReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext? context) 92public XmlTextReader([StringSyntax(StringSyntaxAttribute.Xml)] string xmlFragment, XmlNodeType fragType, XmlParserContext? context) 112public override XmlNodeType NodeType

220private XmlNodeType _fragmentType = XmlNodeType.Document; 431_fragmentType = XmlNodeType.None; 435_fragmentType = XmlNodeType.Element; 439_fragmentType = XmlNodeType.Document; 505internal XmlTextReaderImpl(Stream xmlFragment, XmlNodeType fragType, XmlParserContext? context) 528internal XmlTextReaderImpl(string xmlFragment, XmlNodeType fragType, XmlParserContext? context) 556InitFragmentReader(XmlNodeType.XmlDeclaration, context, true); 835case XmlNodeType.None: settings.ConformanceLevel = ConformanceLevel.Auto; break; 836case XmlNodeType.Element: settings.ConformanceLevel = ConformanceLevel.Fragment; break; 837case XmlNodeType.Document: settings.ConformanceLevel = ConformanceLevel.Document; break; 838default: Debug.Fail($"Unexpected fragment type {_fragmentType}"); goto case XmlNodeType.None; 857public override XmlNodeType NodeType 964return _curNode.type == XmlNodeType.Attribute ? _curNode.quoteChar : '"'; 1182else if (_curNode.type != XmlNodeType.Attribute) 1270Debug.Assert(_curNode.type == XmlNodeType.Element); 1292_curNode.SetValueNode(XmlNodeType.Text, string.Empty); 1385case XmlNodeType.Element: 1394Debug.Assert(_curNode.type == XmlNodeType.EndElement); 1398case XmlNodeType.Attribute: 1400goto case XmlNodeType.Element; 1424if (_curNode.type != XmlNodeType.Attribute) 1444simpleValueNode.SetValueNode(XmlNodeType.Text, _curNode.StringValue); 1493if (_curNode.type != XmlNodeType.EntityReference) 1566if (_outerReader.NodeType == XmlNodeType.EntityReference && 1713if (_curNode.type != XmlNodeType.Element) 1760if (_curNode.type != XmlNodeType.Element) 2151_curNode.Clear(XmlNodeType.None); 2221if (_curNode.type != XmlNodeType.Element) 2255if (_curNode.type != XmlNodeType.Element) 2289if (_curNode.type != XmlNodeType.Element) 2498ParseCDataOrComment(XmlNodeType.Comment); 2506ParseCDataOrComment(XmlNodeType.Comment); 2966private void InitFragmentReader(XmlNodeType fragmentType, XmlParserContext? parserContext, bool allowXmlDeclFragment) 2998case XmlNodeType.Attribute: 3003case XmlNodeType.Element: 3007case XmlNodeType.Document: 3011case XmlNodeType.XmlDeclaration: 3620_curNode.SetNamedNode(XmlNodeType.XmlDeclaration, _xml); 3956if (_fragmentType != XmlNodeType.Document) 3967if (_fragmentType == XmlNodeType.None) 3969_fragmentType = XmlNodeType.Element; 3986if (_fragmentType == XmlNodeType.Document || _fragmentType == XmlNodeType.None) 3988_fragmentType = XmlNodeType.Document; 4016if (_fragmentType == XmlNodeType.Document) 4020if (_fragmentType == XmlNodeType.None) 4022_fragmentType = XmlNodeType.Element; 4033if (_fragmentType == XmlNodeType.Document) 4039if (_fragmentType == XmlNodeType.None) 4041_fragmentType = XmlNodeType.Element; 4073if (_fragmentType == XmlNodeType.Document) 4084if (_fragmentType == XmlNodeType.None && _curNode.type == XmlNodeType.Text) 4086_fragmentType = XmlNodeType.Element; 4116if (!_rootElementParsed && _fragmentType == XmlNodeType.Document) 4121if (_fragmentType == XmlNodeType.None) 4123_fragmentType = _rootElementParsed ? XmlNodeType.Document : XmlNodeType.Element; 4259if (_index == 0 && _fragmentType != XmlNodeType.Document) 4277if (_index == 0 && _curNode.type != XmlNodeType.Element) 4288if (el.type != XmlNodeType.Element) 4383_curNode.SetNamedNode(XmlNodeType.Element, 4392_curNode.SetNamedNode(XmlNodeType.Element, 4399_curNode.SetNamedNode(XmlNodeType.Element, 4469Debug.Assert(_curNode.type == XmlNodeType.Element); 4658startTagNode.type = XmlNodeType.EndElement; 4668if (startTag.type == XmlNodeType.Element) 4683Debug.Assert(startTag.type == XmlNodeType.EntityReference); 4745Debug.Assert(_curNode.type == XmlNodeType.Element); 4753Debug.Assert(_curNode.type == XmlNodeType.Element); 4979Debug.Assert(_curNode.type == XmlNodeType.Element); 4995if (at.type == XmlNodeType.Attribute && at.prefix.Length > 0) 5223textChunk.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen)); 5235entityChunk.SetNamedNode(XmlNodeType.EntityReference, entityName); 5267textChunk.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen)); 5276entityChunk.SetNamedNode(XmlNodeType.EntityReference, _ps.entity.Name); 5338if (_fragmentType == XmlNodeType.Attribute) 5375textChunk.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen)); 5429XmlNodeType nodeType = GetTextNodeType(orChars); 5430if (nodeType == XmlNodeType.None) 5461XmlNodeType nodeType = GetTextNodeType(orChars); 5462if (nodeType == XmlNodeType.None) 5482_curNode.SetValueNode(XmlNodeType.Text, _ps.chars, startPos, endPos - startPos); 5503XmlNodeType nodeType = (_stringBuilder.Length < MinWhitespaceLookahedCount) ? GetTextNodeType(orChars) : XmlNodeType.Text; 5504if (nodeType == XmlNodeType.None) 5907if (_curNode.type != XmlNodeType.EndElement) 5919XmlNodeType nodeType = GetWhitespaceType(); 5922if (nodeType == XmlNodeType.None) 5964_curNode.SetNamedNode(XmlNodeType.EntityReference, ParseEntityName()); 6187_curNode.SetNamedNode(XmlNodeType.EndEntity, _lastEntity.Name); 6199Debug.Assert(_curNode.type == XmlNodeType.EntityReference); 6203_curNode.type = XmlNodeType.EndEntity; 6237_curNode.SetNamedNode(XmlNodeType.ProcessingInstruction, target); 6470ParseCDataOrComment(XmlNodeType.Comment); 6476ParseCDataOrComment(XmlNodeType.Comment); 6483ParseCDataOrComment(XmlNodeType.CDATA); 6487private void ParseCDataOrComment(XmlNodeType type) 6519private bool ParseCDataOrComment(XmlNodeType type, out int outStartPos, out int outEndPos) 6526Throw(SR.Xml_UnexpectedEOF, (type == XmlNodeType.Comment) ? "Comment" : "CDATA"); 6535char stopChar = (type == XmlNodeType.Comment) ? '-' : ']'; 6570else if (type == XmlNodeType.Comment) 6754_curNode.SetNamedNode(XmlNodeType.DocumentType, _dtdInfo.Name.ToString(), string.Empty, null); 7671newAttr.SetNamedNode(XmlNodeType.Attribute, _nameTable.Add(name)); 7713newAttr.SetNamedNode(XmlNodeType.Attribute, localName, prefix, nameWPrefix); 7731Debug.Assert(attr.type == XmlNodeType.Attribute); 7768_curNode.Clear(XmlNodeType.None); 7873private XmlNodeType GetWhitespaceType() 7879return XmlNodeType.SignificantWhitespace; 7884return XmlNodeType.Whitespace; 7888return XmlNodeType.None; 7891private XmlNodeType GetTextNodeType(int orChars) 7895return XmlNodeType.Text; 8246if (ParseCDataOrComment(XmlNodeType.Comment, out startPos, out pos)) 8254if (ParseCDataOrComment(XmlNodeType.CDATA, out startPos, out pos)) 8263_nextParsingFunction = (_index > 0 || _fragmentType != XmlNodeType.Document) ? ParsingFunction.ElementContent 8551Debug.Assert(_fragmentType == XmlNodeType.Attribute); 8554if (_curNode.type == XmlNodeType.None) 8556_curNode.type = XmlNodeType.Attribute; 8591_curNode.SetValueNode(XmlNodeType.Text, string.Empty); 8654_curNode.SetNamedNode(XmlNodeType.EntityReference, ParseEntityName()); 8736_curNode.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString()); 8935Debug.Assert(_curNode.type == XmlNodeType.Element); 8950if (_curNode.type != XmlNodeType.EndElement) 8971case XmlNodeType.Attribute: 8973case XmlNodeType.Text: 8974case XmlNodeType.Whitespace: 8975case XmlNodeType.SignificantWhitespace: 8976case XmlNodeType.CDATA: 8982case XmlNodeType.ProcessingInstruction: 8983case XmlNodeType.Comment: 8984case XmlNodeType.EndEntity: 8987case XmlNodeType.EntityReference: 9129internal XmlNodeType FragmentType 9137internal void ChangeCurrentNodeType(XmlNodeType newNodeType) 9139Debug.Assert(_curNode.type == XmlNodeType.Whitespace && newNodeType == XmlNodeType.SignificantWhitespace, "Incorrect node type change!"); 9203return _fragmentType == XmlNodeType.Element ? ConformanceLevel.Fragment : ConformanceLevel.Document; 9315Debug.Assert(_nodes[_index].type == XmlNodeType.Element); 9333Debug.Assert(_nodes[_index].type == XmlNodeType.Element); 9473if (_curNode.type != XmlNodeType.EndElement)

203Debug.Assert(_curNode.type == XmlNodeType.Element); 225_curNode.SetValueNode(XmlNodeType.Text, string.Empty); 347case XmlNodeType.Element: 356Debug.Assert(_curNode.type == XmlNodeType.EndElement); 360case XmlNodeType.Attribute: 362goto case XmlNodeType.Element; 537if (_curNode.type != XmlNodeType.Element) 593if (_curNode.type != XmlNodeType.Element) 770await ParseCDataOrCommentAsync(XmlNodeType.Comment).ConfigureAwait(false); 778await ParseCDataOrCommentAsync(XmlNodeType.Comment).ConfigureAwait(false); 1188_curNode.SetNamedNode(XmlNodeType.XmlDeclaration, _xml); 1510if (_fragmentType != XmlNodeType.Document) 1535if (_fragmentType == XmlNodeType.Document || _fragmentType == XmlNodeType.None) 1537_fragmentType = XmlNodeType.Document; 1561if (_fragmentType == XmlNodeType.Document) 1565if (_fragmentType == XmlNodeType.None) 1567_fragmentType = XmlNodeType.Element; 1587if (_fragmentType == XmlNodeType.Document) 1603if (_fragmentType == XmlNodeType.None) 1605_fragmentType = XmlNodeType.Element; 1614if (_fragmentType == XmlNodeType.Document) 1621if (_fragmentType == XmlNodeType.None) 1623_fragmentType = XmlNodeType.Element; 1659if (_fragmentType == XmlNodeType.None && _curNode.type == XmlNodeType.Text) 1661_fragmentType = XmlNodeType.Element; 1680if (_fragmentType == XmlNodeType.None && _curNode.type == XmlNodeType.Text) 1682_fragmentType = XmlNodeType.Element; 1714if (!_rootElementParsed && _fragmentType == XmlNodeType.Document) 1718if (_fragmentType == XmlNodeType.None) 1720_fragmentType = _rootElementParsed ? XmlNodeType.Document : XmlNodeType.Element; 1839if (_index == 0 && _fragmentType != XmlNodeType.Document) 1959_curNode.SetNamedNode(XmlNodeType.Element, 1968_curNode.SetNamedNode(XmlNodeType.Element, 1975_curNode.SetNamedNode(XmlNodeType.Element, 2259startTagNode.type = XmlNodeType.EndElement; 2282if (startTag.type == XmlNodeType.Element) 2299Debug.Assert(startTag.type == XmlNodeType.EntityReference); 2361Debug.Assert(_curNode.type == XmlNodeType.Element); 2369Debug.Assert(_curNode.type == XmlNodeType.Element); 2722textChunk.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen)); 2734entityChunk.SetNamedNode(XmlNodeType.EntityReference, entityName); 2766textChunk.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen)); 2774entityChunk.SetNamedNode(XmlNodeType.EntityReference, _ps.entity!.Name); 2836if (_fragmentType == XmlNodeType.Attribute) 2875textChunk.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen)); 2924XmlNodeType nodeType = GetTextNodeType(orChars); 2925if (nodeType == XmlNodeType.None) 2983XmlNodeType nodeType = GetTextNodeType(orChars); 2984if (nodeType == XmlNodeType.None) 3020XmlNodeType nodeType = GetTextNodeType(orChars); 3021if (nodeType == XmlNodeType.None) 3040_curNode.SetValueNode(XmlNodeType.Text, _ps.chars, startPos, endPos - startPos); 3067XmlNodeType nodeType = (_stringBuilder.Length < MinWhitespaceLookahedCount) ? GetTextNodeType(orChars) : XmlNodeType.Text; 3068if (nodeType == XmlNodeType.None) 3667if (_curNode.type != XmlNodeType.EndElement) 3679XmlNodeType nodeType = GetWhitespaceType(); 3681if (nodeType == XmlNodeType.None) 3722_curNode.SetNamedNode(XmlNodeType.EntityReference, await ParseEntityNameAsync().ConfigureAwait(false)); 3924_curNode.SetNamedNode(XmlNodeType.ProcessingInstruction, target); 4178await ParseCDataOrCommentAsync(XmlNodeType.Comment).ConfigureAwait(false); 4184await ParseCDataOrCommentAsync(XmlNodeType.Comment).ConfigureAwait(false); 4191return ParseCDataOrCommentAsync(XmlNodeType.CDATA); 4195private async Task ParseCDataOrCommentAsync(XmlNodeType type) 4242private async Task<(int, int, bool)> ParseCDataOrCommentTupleAsync(XmlNodeType type) 4252Throw(SR.Xml_UnexpectedEOF, (type == XmlNodeType.Comment) ? "Comment" : "CDATA"); 4260char stopChar = (type == XmlNodeType.Comment) ? '-' : ']'; 4296else if (type == XmlNodeType.Comment) 4478_curNode.SetNamedNode(XmlNodeType.DocumentType, _dtdInfo.Name.ToString(), string.Empty, null); 5297Debug.Assert(_curNode.type == XmlNodeType.Element); 5311if (_curNode.type != XmlNodeType.EndElement) 5330case XmlNodeType.Attribute: 5332case XmlNodeType.Text: 5333case XmlNodeType.Whitespace: 5334case XmlNodeType.SignificantWhitespace: 5335case XmlNodeType.CDATA: 5341case XmlNodeType.ProcessingInstruction: 5342case XmlNodeType.Comment: 5343case XmlNodeType.EndEntity: 5346case XmlNodeType.EntityReference: 5465if (_curNode.type != XmlNodeType.EndElement)

344internal XmlNodeType type; 389Clear(XmlNodeType.None); 413return type == XmlNodeType.Element && _isEmptyOrDefault; 417Debug.Assert(type == XmlNodeType.Element); 426return type == XmlNodeType.Attribute && _isEmptyOrDefault; 430Debug.Assert(type == XmlNodeType.Attribute); 477internal void Clear(XmlNodeType type) 509internal void SetValueNode(XmlNodeType type, string value) 519internal void SetValueNode(XmlNodeType type, char[] chars, int startPos, int len) 530internal void SetNamedNode(XmlNodeType type, string localName) 535internal void SetNamedNode(XmlNodeType type, string localName, string prefix, string? nameWPrefix)

31public XmlValidatingReader([StringSyntax(StringSyntaxAttribute.Xml)] string xmlFragment, XmlNodeType fragType, XmlParserContext context) 39public XmlValidatingReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context) 50public override XmlNodeType NodeType

164internal XmlValidatingReaderImpl(string xmlFragment, XmlNodeType fragType, XmlParserContext? context) 182internal XmlValidatingReaderImpl(Stream xmlFragment, XmlNodeType fragType, XmlParserContext? context) 287public override XmlNodeType NodeType 754if (_outerReader.NodeType == XmlNodeType.EntityReference && _parsingFunction != ParsingFunction.ResolveEntityInternally) 954case XmlNodeType.Attribute: 956case XmlNodeType.Element: 974XmlNodeType type = _outerReader.NodeType; 975if (type != XmlNodeType.CDATA && type != XmlNodeType.Text && 976type != XmlNodeType.Whitespace && type != XmlNodeType.SignificantWhitespace && 977type != XmlNodeType.Comment && type != XmlNodeType.ProcessingInstruction) 983if (_outerReader.NodeType != XmlNodeType.EndElement) 992case XmlNodeType.EndElement: 1052Debug.Assert(_coreReader.NodeType == XmlNodeType.EntityReference); 1098case XmlNodeType.Whitespace: 1099if (_coreReader.Depth > 0 || _coreReaderImpl.FragmentType != XmlNodeType.Document) 1103_coreReaderImpl.ChangeCurrentNodeType(XmlNodeType.SignificantWhitespace); 1107case XmlNodeType.DocumentType: 1110case XmlNodeType.EntityReference:

193Debug.Assert(_coreReader.NodeType == XmlNodeType.EntityReference);

34public override XmlNodeType NodeType { get { return reader.NodeType; } }

317if (reader.NodeType is XmlNodeType.Element or XmlNodeType.XmlDeclaration) 325else if (reader.NodeType != XmlNodeType.Attribute) 340if (reader.NodeType == XmlNodeType.EntityReference) 363int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth; 368case XmlNodeType.Element: 376case XmlNodeType.Text: 391case XmlNodeType.Whitespace: 392case XmlNodeType.SignificantWhitespace: 397case XmlNodeType.CDATA: 400case XmlNodeType.EntityReference: 403case XmlNodeType.XmlDeclaration: 404case XmlNodeType.ProcessingInstruction: 407case XmlNodeType.DocumentType: 411case XmlNodeType.Comment: 414case XmlNodeType.EndElement: 418} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));

238if (reader.NodeType is XmlNodeType.Element or XmlNodeType.XmlDeclaration) 246else if (reader.NodeType != XmlNodeType.Attribute) 261if (reader.NodeType == XmlNodeType.EntityReference) 299int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth; 304case XmlNodeType.Element: 312case XmlNodeType.Text: 327case XmlNodeType.Whitespace: 328case XmlNodeType.SignificantWhitespace: 331case XmlNodeType.CDATA: 334case XmlNodeType.EntityReference: 337case XmlNodeType.XmlDeclaration: 338case XmlNodeType.ProcessingInstruction: 341case XmlNodeType.DocumentType: 345case XmlNodeType.Comment: 348case XmlNodeType.EndElement: 352} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement))); 361int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth; 366case XmlNodeType.Element: 374case XmlNodeType.Text: 390case XmlNodeType.Whitespace: 391case XmlNodeType.SignificantWhitespace: 394case XmlNodeType.CDATA: 397case XmlNodeType.EntityReference: 400case XmlNodeType.XmlDeclaration: 401case XmlNodeType.ProcessingInstruction: 404case XmlNodeType.DocumentType: 408case XmlNodeType.Comment: 411case XmlNodeType.EndElement: 415} while (await reader.ReadAsync().ConfigureAwait(false) && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));

81if (_coreReader.NodeType == XmlNodeType.Element) 108public override XmlNodeType NodeType 387if (_cacheState != CachingReaderState.Replay || _cachedNode!.NodeType != XmlNodeType.Attribute) 413case XmlNodeType.Element: 418case XmlNodeType.EndElement: 424case XmlNodeType.Comment: 425case XmlNodeType.ProcessingInstruction: 426case XmlNodeType.Text: 427case XmlNodeType.CDATA: 428case XmlNodeType.Whitespace: 429case XmlNodeType.SignificantWhitespace: 453if (_coreReader.NodeType != XmlNodeType.Element || _readAhead) 474ValidatingReaderNodeData textNode = AddContent(XmlNodeType.Text); 483Debug.Assert(_coreReader.NodeType == XmlNodeType.EndElement || (_coreReader.NodeType == XmlNodeType.Element && _coreReader.IsEmptyElement)); 488Debug.Assert(endElementNode.NodeType == XmlNodeType.EndElement); 495ValidatingReaderNodeData recordedNode = AddContent(XmlNodeType.EndElement); 496Debug.Assert(_coreReader.NodeType == XmlNodeType.EndElement || (_coreReader.NodeType == XmlNodeType.Element && _coreReader.IsEmptyElement)); 544case XmlNodeType.Element: 545if (_coreReader.NodeType != XmlNodeType.EndElement && !_readAhead) 556case XmlNodeType.Attribute: 558goto case XmlNodeType.Element; 592if (_cachedNode!.NodeType != XmlNodeType.Attribute) 657attInfo.Clear(XmlNodeType.Attribute); 666return _attributeEvents[attIndex] ??= new ValidatingReaderNodeData(XmlNodeType.Attribute); 669private ValidatingReaderNodeData AddContent(XmlNodeType nodeType) 692Debug.Assert(_coreReader.NodeType == XmlNodeType.Element); 752_textNode ??= new ValidatingReaderNodeData(XmlNodeType.Text);

45case XmlNodeType.Element: 50case XmlNodeType.EndElement: 56case XmlNodeType.Comment: 57case XmlNodeType.ProcessingInstruction: 58case XmlNodeType.Text: 59case XmlNodeType.CDATA: 60case XmlNodeType.Whitespace: 61case XmlNodeType.SignificantWhitespace: 85if (_coreReader.NodeType != XmlNodeType.Element || _readAhead) 110case XmlNodeType.Element: 111if (_coreReader.NodeType != XmlNodeType.EndElement && !_readAhead) 122case XmlNodeType.Attribute: 124goto case XmlNodeType.Element;

213public override XmlNodeType NodeType 224XmlNodeType nodeType = _coreReader.NodeType; 226if (nodeType == XmlNodeType.Whitespace && (_validator.CurrentContentType == XmlSchemaContentType.TextOnly || _validator.CurrentContentType == XmlSchemaContentType.Mixed)) 228return XmlNodeType.SignificantWhitespace; 421case XmlNodeType.Element: 422case XmlNodeType.EndElement: 431case XmlNodeType.Attribute: 464XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 498XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 532XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 566XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 600XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 634XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 668XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 703XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 739XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 774if (this.NodeType != XmlNodeType.Element) 785if (this.NodeType != XmlNodeType.Element) 820if (this.NodeType != XmlNodeType.Element) 855if (this.NodeType != XmlNodeType.Element) 890if (this.NodeType != XmlNodeType.Element) 925if (this.NodeType != XmlNodeType.Element) 960if (this.NodeType != XmlNodeType.Element) 995if (this.NodeType != XmlNodeType.Element) 1030if (this.NodeType != XmlNodeType.Element) 1065if (this.NodeType != XmlNodeType.Element) 1512case XmlNodeType.Element: 1535case XmlNodeType.Attribute: 1537goto case XmlNodeType.Element; 1575if (NodeType == XmlNodeType.Attribute) 1716case XmlNodeType.Element: 1724case XmlNodeType.EndElement: 1727case XmlNodeType.Attribute: 1749case XmlNodeType.Element: 1750case XmlNodeType.EndElement: 1767case XmlNodeType.Element: 1781case XmlNodeType.EndElement: 1784case XmlNodeType.Attribute: 1803case XmlNodeType.Element: 1811case XmlNodeType.EndElement: 1814case XmlNodeType.Attribute: 1834case XmlNodeType.Element: 1835case XmlNodeType.EndElement: 1838case XmlNodeType.Attribute: 1856if (NodeType == XmlNodeType.Element || NodeType == XmlNodeType.EndElement) 1869if (NodeType == XmlNodeType.Attribute) 2007case XmlNodeType.Element: 2012case XmlNodeType.Whitespace: 2013case XmlNodeType.SignificantWhitespace: 2017case XmlNodeType.Text: // text inside a node 2018case XmlNodeType.CDATA: // <![CDATA[...]]> 2022case XmlNodeType.EndElement: 2027case XmlNodeType.EntityReference: 2030case XmlNodeType.DocumentType: 2333if (_coreReader.NodeType == XmlNodeType.Element) 2366XmlNodeType nodeType = this.NodeType; 2367if (nodeType == XmlNodeType.Attribute) 2386else if (nodeType == XmlNodeType.EndElement) 2440Debug.Assert(this.NodeType == XmlNodeType.Element); 2467if (this.NodeType == XmlNodeType.EndElement) 2491else if (this.NodeType == XmlNodeType.Element) 2501if (this.NodeType != XmlNodeType.EndElement) 2529case XmlNodeType.Element: 2533case XmlNodeType.Text: 2534case XmlNodeType.CDATA: 2538case XmlNodeType.Whitespace: 2539case XmlNodeType.SignificantWhitespace: 2543case XmlNodeType.Comment: 2544case XmlNodeType.ProcessingInstruction: 2547case XmlNodeType.EndElement: 2587Debug.Assert(_coreReader.NodeType == XmlNodeType.EndElement); 2597case XmlNodeType.Element: 2601case XmlNodeType.Text: 2602case XmlNodeType.CDATA: 2606case XmlNodeType.Whitespace: 2607case XmlNodeType.SignificantWhitespace: 2611case XmlNodeType.Comment: 2612case XmlNodeType.ProcessingInstruction: 2615case XmlNodeType.EndElement: 2658case XmlNodeType.Element: 2662case XmlNodeType.Text: 2663case XmlNodeType.CDATA: 2667case XmlNodeType.Whitespace: 2668case XmlNodeType.SignificantWhitespace: 2672case XmlNodeType.Comment: 2673case XmlNodeType.ProcessingInstruction: 2676case XmlNodeType.EndElement: 2740Debug.Assert(NodeType != XmlNodeType.Attribute); 2764_textNode ??= new ValidatingReaderNodeData(XmlNodeType.Text);

49XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 89XmlSchemaType? xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 124if (this.NodeType != XmlNodeType.Element) 136if (this.NodeType != XmlNodeType.Element) 176if (this.NodeType != XmlNodeType.Element) 350case XmlNodeType.Element: 373case XmlNodeType.Attribute: 375goto case XmlNodeType.Element; 502case XmlNodeType.Element: 506case XmlNodeType.Whitespace: 507case XmlNodeType.SignificantWhitespace: 511case XmlNodeType.Text: // text inside a node 512case XmlNodeType.CDATA: // <![CDATA[...]]> 516case XmlNodeType.EndElement: 520case XmlNodeType.EntityReference: 523case XmlNodeType.DocumentType: 656if (_coreReader.NodeType == XmlNodeType.Element) 692XmlNodeType nodeType = this.NodeType; 693if (nodeType == XmlNodeType.Attribute) 712else if (nodeType == XmlNodeType.EndElement) 776Debug.Assert(this.NodeType == XmlNodeType.Element); 801if (this.NodeType == XmlNodeType.EndElement) 826else if (this.NodeType == XmlNodeType.Element) 839if (this.NodeType != XmlNodeType.EndElement) 867case XmlNodeType.Element: 871case XmlNodeType.Text: 872case XmlNodeType.CDATA: 876case XmlNodeType.Whitespace: 877case XmlNodeType.SignificantWhitespace: 881case XmlNodeType.Comment: 882case XmlNodeType.ProcessingInstruction: 885case XmlNodeType.EndElement:

94case XmlNodeType.Document: 98case XmlNodeType.DocumentFragment: 101case XmlNodeType.Element: //Validate children of this element 123if (nodeToValidate.ParentNode!.NodeType == XmlNodeType.Document) 140case XmlNodeType.Attribute: 179case XmlNodeType.Element: 210case XmlNodeType.Attribute: 266case XmlNodeType.Document: 276case XmlNodeType.DocumentFragment: 277case XmlNodeType.EntityReference: 285case XmlNodeType.Element: 289case XmlNodeType.Attribute: //Top-level attribute 298case XmlNodeType.Text: 302case XmlNodeType.CDATA: 306case XmlNodeType.Whitespace: 307case XmlNodeType.SignificantWhitespace: 311case XmlNodeType.Comment: 312case XmlNodeType.ProcessingInstruction: 485Debug.Assert(elementToValidate.ParentNode!.NodeType != XmlNodeType.Document); //Handle if it is the documentElement separately 730case XmlNodeType.EntityReference: 734case XmlNodeType.Element: //Flat validation, do not drill down into children 738case XmlNodeType.Text: 739case XmlNodeType.CDATA: 743case XmlNodeType.Whitespace: 744case XmlNodeType.SignificantWhitespace: 748case XmlNodeType.Comment: 749case XmlNodeType.ProcessingInstruction:

538XmlNodeType nodeType = XmlNodeType.None; 550if (nodeType == XmlNodeType.Document) 554else if (nodeType == XmlNodeType.DocumentFragment) 563if (nodeType == XmlNodeType.Document) 567else if (nodeType == XmlNodeType.DocumentFragment)

50case XmlNodeType.Attribute: 57case XmlNodeType.Text: 58case XmlNodeType.CDATA: 59case XmlNodeType.Whitespace: 60case XmlNodeType.SignificantWhitespace: 73goto case XmlNodeType.Element; 74case XmlNodeType.Element: 75case XmlNodeType.ProcessingInstruction: 76case XmlNodeType.Comment: 129case XmlNodeType.Element: 130case XmlNodeType.ProcessingInstruction: 132case XmlNodeType.Attribute: 168case XmlNodeType.Element: 169case XmlNodeType.DocumentFragment: 171case XmlNodeType.Document: 173case XmlNodeType.Text: 174case XmlNodeType.CDATA: 175case XmlNodeType.Whitespace: 176case XmlNodeType.SignificantWhitespace: 367&& node.NodeType != XmlNodeType.Element) 778if (_source.NodeType == XmlNodeType.Attribute) 806case XmlNodeType.Element: 813case XmlNodeType.DocumentFragment: 814case XmlNodeType.Document: 906if (_source.NodeType == XmlNodeType.Attribute) 916if (child.NodeType == XmlNodeType.Element 932if (_source.NodeType == XmlNodeType.Attribute) 970case XmlNodeType.Attribute: 982if (following.NodeType == XmlNodeType.Attribute) 1026while (following.NodeType != XmlNodeType.Element 1045case XmlNodeType.Attribute: 1064case XmlNodeType.Attribute: 1071case XmlNodeType.Text: 1072case XmlNodeType.CDATA: 1073case XmlNodeType.SignificantWhitespace: 1074case XmlNodeType.Whitespace: 1129if (sibling.NodeType == XmlNodeType.Element 1184case XmlNodeType.Element: 1191case XmlNodeType.DocumentFragment: 1192case XmlNodeType.Document: 1247if (_source.NodeType == XmlNodeType.Document) 1453if (nsAtom == null || _source.NodeType == XmlNodeType.Attribute) 1478XmlNodeType curNT = _source.NodeType; 1479if (curNT != XmlNodeType.Document && curNT != XmlNodeType.Element) 1504case XmlNodeType.Element: 1505case XmlNodeType.Document: 1506case XmlNodeType.DocumentFragment: 1521case XmlNodeType.Element: 1522case XmlNodeType.Document: 1523case XmlNodeType.DocumentFragment: 1540case XmlNodeType.Attribute: 1541case XmlNodeType.Document: 1542case XmlNodeType.DocumentFragment: 1544case XmlNodeType.Text: 1545case XmlNodeType.CDATA: 1546case XmlNodeType.SignificantWhitespace: 1547case XmlNodeType.Whitespace: 1563case XmlNodeType.Attribute: 1564case XmlNodeType.Document: 1565case XmlNodeType.DocumentFragment: 1567case XmlNodeType.Text: 1568case XmlNodeType.CDATA: 1569case XmlNodeType.SignificantWhitespace: 1570case XmlNodeType.Whitespace: 1585if (_source.NodeType != XmlNodeType.Element) 1613case XmlNodeType.Attribute: 1614case XmlNodeType.Document: 1615case XmlNodeType.DocumentFragment: 1617case XmlNodeType.Text: 1618case XmlNodeType.CDATA: 1619case XmlNodeType.SignificantWhitespace: 1620case XmlNodeType.Whitespace: 1664case XmlNodeType.Attribute: 1677case XmlNodeType.Text: 1678case XmlNodeType.CDATA: 1679case XmlNodeType.SignificantWhitespace: 1680case XmlNodeType.Whitespace: 1682goto case XmlNodeType.Element; 1683case XmlNodeType.Element: 1684case XmlNodeType.ProcessingInstruction: 1685case XmlNodeType.Comment: 1723case XmlNodeType.Attribute: 1736case XmlNodeType.Text: 1737case XmlNodeType.CDATA: 1738case XmlNodeType.SignificantWhitespace: 1739case XmlNodeType.Whitespace: 1744goto case XmlNodeType.Element; 1745case XmlNodeType.Element: 1746case XmlNodeType.ProcessingInstruction: 1747case XmlNodeType.Comment: 1911&& parent.NodeType == XmlNodeType.EntityReference) 1932&& child.NodeType == XmlNodeType.EntityReference) 1957|| current.NodeType != XmlNodeType.EntityReference) 1964&& sibling.NodeType == XmlNodeType.EntityReference) 1989|| current.NodeType != XmlNodeType.EntityReference) 1996&& sibling.NodeType == XmlNodeType.EntityReference) 2030|| current.NodeType != XmlNodeType.EntityReference) 2040case XmlNodeType.EntityReference: 2043case XmlNodeType.Text: 2044case XmlNodeType.CDATA: 2045case XmlNodeType.Whitespace: 2046case XmlNodeType.SignificantWhitespace: 2103case XmlNodeType.Element: 2105case XmlNodeType.DocumentFragment: 2108case XmlNodeType.Element: 2109case XmlNodeType.Text: 2110case XmlNodeType.CDATA: 2111case XmlNodeType.ProcessingInstruction: 2112case XmlNodeType.Comment: 2113case XmlNodeType.Whitespace: 2114case XmlNodeType.SignificantWhitespace: 2118case XmlNodeType.Document: 2121case XmlNodeType.Element: 2122case XmlNodeType.ProcessingInstruction: 2123case XmlNodeType.Comment: 2243if (node.NodeType == XmlNodeType.Element && Match(node)) 2257Debug.Assert(((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute); 2271return (node.NodeType == XmlNodeType.Element); 2295if (node.NodeType == XmlNodeType.Element && Match(node)) 2311Debug.Assert(((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute); 2327Debug.Assert(node.NodeType == XmlNodeType.Element); 2352if (node.NodeType == XmlNodeType.Element && Match(node)) 2369Debug.Assert(((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute); 2392Debug.Assert(node.NodeType == XmlNodeType.Element); 2419if (node.NodeType == XmlNodeType.Element && Match(node))

94public override XmlNodeType NodeType 96get { return XmlNodeType.Attribute; } 212internal override bool IsValidChildType(XmlNodeType type) 214return (type == XmlNodeType.Text) || (type == XmlNodeType.EntityReference);

36public override XmlNodeType NodeType 40return XmlNodeType.CDATA; 50case XmlNodeType.Document: 52case XmlNodeType.Text: 53case XmlNodeType.CDATA: 54case XmlNodeType.Whitespace: 55case XmlNodeType.SignificantWhitespace:

201Debug.Assert(XmlDocument.IsTextNode(n.NodeType) || (n.ParentNode != null && n.ParentNode.NodeType == XmlNodeType.EntityReference)); 206case XmlNodeType.Whitespace: 208case XmlNodeType.SignificantWhitespace: 211case XmlNodeType.Text: 212case XmlNodeType.CDATA: 215case XmlNodeType.EntityReference:

29public override XmlNodeType NodeType 31get { return XmlNodeType.Comment; }

152public override XmlNodeType NodeType 154get { return XmlNodeType.XmlDeclaration; }

355public override XmlNodeType NodeType 357get { return XmlNodeType.Document; } 368get { return (XmlDocumentType?)FindChild(XmlNodeType.DocumentType); } 405get { return (XmlElement?)FindChild(XmlNodeType.Element); } 458internal override bool IsValidChildType(XmlNodeType type) 462case XmlNodeType.ProcessingInstruction: 463case XmlNodeType.Comment: 464case XmlNodeType.Whitespace: 465case XmlNodeType.SignificantWhitespace: 468case XmlNodeType.DocumentType: 473case XmlNodeType.Element: 478case XmlNodeType.XmlDeclaration: 489private static bool HasNodeTypeInPrevSiblings(XmlNodeType nt, XmlNode? refNode) 510private static bool HasNodeTypeInNextSiblings(XmlNodeType nt, XmlNode? refNode) 531case XmlNodeType.XmlDeclaration: 534case XmlNodeType.ProcessingInstruction: 535case XmlNodeType.Comment: 536return refChild.NodeType != XmlNodeType.XmlDeclaration; 538case XmlNodeType.DocumentType: 540if (refChild.NodeType != XmlNodeType.XmlDeclaration) 544return !HasNodeTypeInPrevSiblings(XmlNodeType.Element, refChild.PreviousSibling); 549case XmlNodeType.Element: 551if (refChild.NodeType != XmlNodeType.XmlDeclaration) 555return !HasNodeTypeInNextSiblings(XmlNodeType.DocumentType, refChild); 573case XmlNodeType.ProcessingInstruction: 574case XmlNodeType.Comment: 575case XmlNodeType.Whitespace: 576case XmlNodeType.SignificantWhitespace: 579case XmlNodeType.DocumentType: 583return !HasNodeTypeInPrevSiblings(XmlNodeType.Element, refChild); 586case XmlNodeType.Element: 588return !HasNodeTypeInNextSiblings(XmlNodeType.DocumentType, refChild.NextSibling); 757XmlNodeType nodeType = node.NodeType; 759XmlNodeType parentType; 763case XmlNodeType.EntityReference: 764case XmlNodeType.Entity: 765case XmlNodeType.DocumentType: 766case XmlNodeType.Notation: 767case XmlNodeType.XmlDeclaration: 769case XmlNodeType.Text: 770case XmlNodeType.CDATA: 771case XmlNodeType.SignificantWhitespace: 778if (parentType == XmlNodeType.Attribute) 782else if (parentType == XmlNodeType.EntityReference) 795case XmlNodeType.Whitespace: 802if (parentType == XmlNodeType.Document 803|| parentType == XmlNodeType.Attribute) 807else if (parentType == XmlNodeType.EntityReference) 826internal static bool IsTextNode(XmlNodeType nt) 830case XmlNodeType.Text: 831case XmlNodeType.CDATA: 832case XmlNodeType.Whitespace: 833case XmlNodeType.SignificantWhitespace: 855if (intnode.ParentNode != null && intnode.ParentNode.NodeType == XmlNodeType.EntityReference) 877while (n.NodeType == XmlNodeType.EntityReference) 965case XmlNodeType.Element: 972case XmlNodeType.Attribute: 978case XmlNodeType.Text: 981case XmlNodeType.Comment: 984case XmlNodeType.ProcessingInstruction: 987case XmlNodeType.XmlDeclaration: 991case XmlNodeType.CDATA: 994case XmlNodeType.DocumentType: 998case XmlNodeType.DocumentFragment: 1004case XmlNodeType.EntityReference: 1010case XmlNodeType.Whitespace: 1014case XmlNodeType.SignificantWhitespace: 1038Debug.Assert(toNode.NodeType != XmlNodeType.EntityReference); 1107public virtual XmlNode CreateNode(XmlNodeType type, string? prefix, string name, string? namespaceURI) 1111case XmlNodeType.Element: 1117case XmlNodeType.Attribute: 1123case XmlNodeType.Text: 1126case XmlNodeType.CDATA: 1129case XmlNodeType.EntityReference: 1132case XmlNodeType.ProcessingInstruction: 1135case XmlNodeType.XmlDeclaration: 1138case XmlNodeType.Comment: 1141case XmlNodeType.DocumentFragment: 1144case XmlNodeType.DocumentType: 1147case XmlNodeType.Document: 1150case XmlNodeType.SignificantWhitespace: 1153case XmlNodeType.Whitespace: 1170public virtual XmlNode CreateNode(XmlNodeType type, string name, string? namespaceURI) 1194internal static XmlNodeType ConvertToNodeType(string nodeTypeString) 1198return XmlNodeType.Element; 1202return XmlNodeType.Attribute; 1206return XmlNodeType.Text; 1210return XmlNodeType.CDATA; 1214return XmlNodeType.EntityReference; 1218return XmlNodeType.Entity; 1222return XmlNodeType.ProcessingInstruction; 1226return XmlNodeType.Comment; 1230return XmlNodeType.Document; 1234return XmlNodeType.DocumentType; 1238return XmlNodeType.DocumentFragment; 1242return XmlNodeType.Notation; 1246return XmlNodeType.SignificantWhitespace; 1250return XmlNodeType.Whitespace;

69public override XmlNodeType NodeType 71get { return XmlNodeType.DocumentFragment; } 102loader.ParsePartialContent(this, value, XmlNodeType.Element); 128internal override bool IsValidChildType(XmlNodeType type) 132case XmlNodeType.Element: 133case XmlNodeType.Text: 134case XmlNodeType.EntityReference: 135case XmlNodeType.Comment: 136case XmlNodeType.Whitespace: 137case XmlNodeType.SignificantWhitespace: 138case XmlNodeType.ProcessingInstruction: 139case XmlNodeType.CDATA: 142case XmlNodeType.XmlDeclaration: 145if (firstNode == null || firstNode.NodeType != XmlNodeType.XmlDeclaration) 156if (newChild.NodeType == XmlNodeType.XmlDeclaration) 172if (newChild.NodeType == XmlNodeType.XmlDeclaration)

51public override XmlNodeType NodeType 53get { return XmlNodeType.DocumentType; }

110public override XmlNodeType NodeType 112get { return XmlNodeType.Element; } 217internal override bool IsValidChildType(XmlNodeType type) 221case XmlNodeType.Element: 222case XmlNodeType.Text: 223case XmlNodeType.EntityReference: 224case XmlNodeType.Comment: 225case XmlNodeType.Whitespace: 226case XmlNodeType.SignificantWhitespace: 227case XmlNodeType.ProcessingInstruction: 228case XmlNodeType.CDATA: 601linkedNode.NodeType == XmlNodeType.Text && //which is text node

30Debug.Assert(parent.NodeType == XmlNodeType.Element || parent.NodeType == XmlNodeType.Document); 160if (curNode.NodeType == XmlNodeType.Element)

90internal override bool IsValidChildType(XmlNodeType type) 92return (type == XmlNodeType.Text || 93type == XmlNodeType.Element || 94type == XmlNodeType.ProcessingInstruction || 95type == XmlNodeType.Comment || 96type == XmlNodeType.CDATA || 97type == XmlNodeType.Whitespace || 98type == XmlNodeType.SignificantWhitespace || 99type == XmlNodeType.EntityReference); 103public override XmlNodeType NodeType 105get { return XmlNodeType.Entity; }

76public override XmlNodeType NodeType 78get { return XmlNodeType.EntityReference; } 132internal override bool IsValidChildType(XmlNodeType type) 136case XmlNodeType.Element: 137case XmlNodeType.Text: 138case XmlNodeType.EntityReference: 139case XmlNodeType.Comment: 140case XmlNodeType.Whitespace: 141case XmlNodeType.SignificantWhitespace: 142case XmlNodeType.ProcessingInstruction: 143case XmlNodeType.CDATA:

89if (n.NodeType != XmlNodeType.Attribute) 109case XmlNodeType.Element: 144case XmlNodeType.EndElement: 149Debug.Assert(parent.NodeType == XmlNodeType.Element); 163case XmlNodeType.EntityReference: 167case XmlNodeType.EndEntity: 171case XmlNodeType.Attribute: 175case XmlNodeType.Text: 179case XmlNodeType.SignificantWhitespace: 183case XmlNodeType.Whitespace: 198case XmlNodeType.CDATA: 203case XmlNodeType.XmlDeclaration: 207case XmlNodeType.ProcessingInstruction: 211case XmlNodeType.Comment: 215case XmlNodeType.DocumentType: 249Debug.Assert(_reader!.NodeType == XmlNodeType.Attribute); 269case XmlNodeType.Text: 272case XmlNodeType.EntityReference: 326case XmlNodeType.Text: 329case XmlNodeType.EndEntity: 331case XmlNodeType.EntityReference: 356Debug.Assert(_reader!.NodeType == XmlNodeType.EntityReference); 361while (_reader.Read() && _reader.NodeType != XmlNodeType.EndEntity) 379Debug.Assert(_reader!.NodeType == XmlNodeType.XmlDeclaration); 417Debug.Assert(_reader!.NodeType == XmlNodeType.DocumentType); 463case XmlNodeType.Element: 491case XmlNodeType.EndElement: 492Debug.Assert(parent!.NodeType == XmlNodeType.Element); 501case XmlNodeType.EntityReference: 505case XmlNodeType.EndEntity: 508case XmlNodeType.Attribute: 512case XmlNodeType.SignificantWhitespace: 516case XmlNodeType.Whitespace: 527case XmlNodeType.Text: 531case XmlNodeType.CDATA: 535case XmlNodeType.ProcessingInstruction: 539case XmlNodeType.Comment: 595XmlTextReaderImpl tr = new XmlTextReaderImpl("", XmlNodeType.Element, pc); 744internal XmlNamespaceManager ParsePartialContent(XmlNode parentNode, string innerxmltext, XmlNodeType nt) 747Debug.Assert(parentNode.NodeType != XmlNodeType.Document); 758if (nt == XmlNodeType.Entity) 788XmlNamespaceManager mgr = ParsePartialContent(node, innerxmltext, XmlNodeType.Element); 796ParsePartialContent(node, innerxmltext, XmlNodeType.Attribute); 868ParsePartialContent(ent, EntitizeName(ent.Name), XmlNodeType.Entity); 907ParsePartialContent(eref, EntitizeName(eref.Name), XmlNodeType.EntityReference); 926private static XmlTextReaderImpl CreateInnerXmlReader(string xmlFragment, XmlNodeType nt, XmlParserContext context, XmlDocument doc) 928XmlNodeType contentNT = nt; 929if (contentNT == XmlNodeType.Entity || contentNT == XmlNodeType.EntityReference) 930contentNT = XmlNodeType.Element; 964if (nt == XmlNodeType.Entity || nt == XmlNodeType.EntityReference) 998internal static Exception UnexpectedNodeType(XmlNodeType nodetype)

145if (node.NodeType == XmlNodeType.Attribute) 212if (node.NodeType == XmlNodeType.Attribute)

118public abstract XmlNodeType NodeType 130if (parentNode.NodeType != XmlNodeType.Document) 188if (parentNode.NodeType == XmlNodeType.Document) 242while (parent != null && !(parent.NodeType == XmlNodeType.Document)) 276if (newChild.NodeType == XmlNodeType.DocumentFragment) 390if (newChild.NodeType == XmlNodeType.DocumentFragment) 596if (newChild.NodeType == XmlNodeType.DocumentFragment) 694internal virtual bool IsValidChildType(XmlNodeType type) 742case XmlNodeType.Text: 743case XmlNodeType.Whitespace: 744case XmlNodeType.SignificantWhitespace: 761case XmlNodeType.Element: 791Debug.Assert(firstNode.NodeType == XmlNodeType.Text 792|| firstNode.NodeType == XmlNodeType.SignificantWhitespace 793|| firstNode.NodeType == XmlNodeType.Whitespace 794|| secondNode.NodeType == XmlNodeType.Text 795|| secondNode.NodeType == XmlNodeType.SignificantWhitespace 796|| secondNode.NodeType == XmlNodeType.Whitespace); 797if (firstNode.NodeType == XmlNodeType.Text) 799if (secondNode.NodeType == XmlNodeType.Text) 801if (firstNode.NodeType == XmlNodeType.SignificantWhitespace) 803if (secondNode.NodeType == XmlNodeType.SignificantWhitespace) 805if (firstNode.NodeType == XmlNodeType.Whitespace) 807if (secondNode.NodeType == XmlNodeType.Whitespace) 861case XmlNodeType.EntityReference: 862case XmlNodeType.Entity: 865case XmlNodeType.Attribute: 906if (child.NodeType == XmlNodeType.Text || child.NodeType == XmlNodeType.CDATA 907|| child.NodeType == XmlNodeType.Whitespace || child.NodeType == XmlNodeType.SignificantWhitespace) 930XmlNodeType nodeType = fc.NodeType; 933case XmlNodeType.Text: 934case XmlNodeType.CDATA: 935case XmlNodeType.Whitespace: 936case XmlNodeType.SignificantWhitespace: 951&& firstChild.NodeType == XmlNodeType.Text)//which is a text node 1022XmlNodeType nt = curNode.NodeType; 1025if (nt == XmlNodeType.EntityReference) 1027if (nt == XmlNodeType.Document 1028|| nt == XmlNodeType.Entity 1029|| nt == XmlNodeType.Attribute) 1062if (NodeType == XmlNodeType.Document) 1091if (node.NodeType == XmlNodeType.Element) 1136else if (node.NodeType == XmlNodeType.Attribute) 1176if (node.NodeType == XmlNodeType.Element) 1215else if (node.NodeType == XmlNodeType.Attribute) 1244if (n.NodeType == XmlNodeType.Element && n.Name == name) 1260if (n.NodeType == XmlNodeType.Element && n.LocalName == localname && n.NamespaceURI == ns) 1300internal virtual XmlNode? FindChild(XmlNodeType type) 1461XmlNodeType nodeType = _node.NodeType; 1465case XmlNodeType.Element: 1466case XmlNodeType.EntityReference: 1469case XmlNodeType.Attribute: 1470case XmlNodeType.ProcessingInstruction: 1473case XmlNodeType.Text: 1474case XmlNodeType.CDATA: 1475case XmlNodeType.Comment: 1476case XmlNodeType.Whitespace: 1477case XmlNodeType.SignificantWhitespace: 1478case XmlNodeType.XmlDeclaration: 1481case XmlNodeType.DocumentType:

75XmlNodeType nt = _curNode.NodeType; 76if (nt == XmlNodeType.Attribute) 89if (nt == XmlNodeType.Document) 103public XmlNodeType NodeType 107XmlNodeType nt = _curNode.NodeType; 110Debug.Assert(nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType); 112return XmlNodeType.Text; 114return XmlNodeType.Attribute; 131Debug.Assert(_curNode.NodeType == XmlNodeType.XmlDeclaration || _curNode.NodeType == XmlNodeType.DocumentType); 137if (_curNode.NodeType == XmlNodeType.XmlDeclaration) 170private static bool IsLocalNameEmpty(XmlNodeType nt) 174case XmlNodeType.None: 175case XmlNodeType.Text: 176case XmlNodeType.CDATA: 177case XmlNodeType.Comment: 178case XmlNodeType.Document: 179case XmlNodeType.DocumentFragment: 180case XmlNodeType.Whitespace: 181case XmlNodeType.SignificantWhitespace: 182case XmlNodeType.EndElement: 183case XmlNodeType.EndEntity: 185case XmlNodeType.Element: 186case XmlNodeType.Attribute: 187case XmlNodeType.EntityReference: 188case XmlNodeType.Entity: 189case XmlNodeType.ProcessingInstruction: 190case XmlNodeType.DocumentType: 191case XmlNodeType.Notation: 192case XmlNodeType.XmlDeclaration: 214Debug.Assert(_curNode.NodeType == XmlNodeType.XmlDeclaration || _curNode.NodeType == XmlNodeType.DocumentType); 218if (_curNode.Value != null || _curNode.NodeType == XmlNodeType.DocumentType) 230XmlNodeType nt = _curNode.NodeType; 235Debug.Assert(nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType); 237return _curNode.NodeType == XmlNodeType.XmlDeclaration ? 242if (nt == XmlNodeType.DocumentType) 246else if (nt == XmlNodeType.XmlDeclaration) 293if (_curNode.NodeType == XmlNodeType.Element) 305if (_curNode.NodeType == XmlNodeType.Attribute) 332XmlNodeType nt = _curNode.NodeType; 333if (nt == XmlNodeType.Element) 335else if (nt == XmlNodeType.Attribute 336|| (_bOnAttrVal && nt != XmlNodeType.XmlDeclaration && nt != XmlNodeType.DocumentType)) 338else if (nt == XmlNodeType.XmlDeclaration) 345else if (nt == XmlNodeType.DocumentType) 494XmlNodeType.Element => GetAttributeFromElement((XmlElement)_curNode!, name), 495XmlNodeType.Attribute => GetAttributeFromElement((XmlElement)_elemNode!, name), 496XmlNodeType.XmlDeclaration => GetDeclarationAttr((XmlDeclaration)_curNode, name), 497XmlNodeType.DocumentType => GetDocumentTypeAttr((XmlDocumentType)_curNode, name), 516XmlNodeType.Element => GetAttributeFromElement((XmlElement)_curNode, name, ns), 517XmlNodeType.Attribute => GetAttributeFromElement((XmlElement)_elemNode!, name, ns), 518XmlNodeType.XmlDeclaration => (ns.Length == 0) ? GetDeclarationAttr((XmlDeclaration)_curNode, name) : null, 519XmlNodeType.DocumentType => (ns.Length == 0) ? GetDocumentTypeAttr((XmlDocumentType)_curNode, name) : null, 530case XmlNodeType.Element: 533case XmlNodeType.Attribute: 536case XmlNodeType.XmlDeclaration: 541case XmlNodeType.DocumentType: 574XmlNodeType nt = _curNode.NodeType; 575return (nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType); 593while (_curNode.NodeType != XmlNodeType.Attribute && ((_curNode = _curNode.ParentNode!) != null)) 601public void ResetMove(ref int level, ref XmlNodeType nt) 620if (_bOnAttrVal && _curNode.NodeType != XmlNodeType.Attribute) 622if (_curNode.NodeType == XmlNodeType.Attribute) 627nt = XmlNodeType.Element; 629if (_curNode.NodeType == XmlNodeType.Element) 662XmlNodeType nt = _curNode.NodeType; 663if (nt == XmlNodeType.Element) 665else if (nt == XmlNodeType.Attribute) 667else if (nt == XmlNodeType.XmlDeclaration && namespaceURI.Length == 0) 675else if (nt == XmlNodeType.DocumentType && namespaceURI.Length == 0) 693case XmlNodeType.Element: 703case XmlNodeType.Attribute: 712case XmlNodeType.XmlDeclaration: 713case XmlNodeType.DocumentType: 724XmlNodeType nt = _curNode.NodeType; 725if (nt == XmlNodeType.Attribute) 735else if (nt == XmlNodeType.Element) 746else if (nt == XmlNodeType.XmlDeclaration) 759else if (nt == XmlNodeType.DocumentType) 818if (_curNode.NodeType != XmlNodeType.Attribute) 830case XmlNodeType.Attribute: 838case XmlNodeType.XmlDeclaration: 839case XmlNodeType.DocumentType: 875if (node.NodeType == XmlNodeType.Element) 887else if (node.NodeType == XmlNodeType.Attribute) 943if (node.NodeType == XmlNodeType.Element) 973else if (node.NodeType == XmlNodeType.Attribute) 995if (node.NodeType == XmlNodeType.Element) 1026else if (node.NodeType == XmlNodeType.Attribute) 1049public bool ReadAttributeValue(ref int level, ref bool bResolveEntity, ref XmlNodeType nt) 1053Debug.Assert(_curNode.NodeType == XmlNodeType.XmlDeclaration || _curNode.NodeType == XmlNodeType.DocumentType); 1058nt = XmlNodeType.Text; 1063if (_curNode.NodeType == XmlNodeType.Attribute) 1078if (_curNode.NodeType == XmlNodeType.EntityReference && bResolveEntity) 1094if (parentNode != null && parentNode.NodeType == XmlNodeType.EntityReference) 1098nt = XmlNodeType.EndEntity; 1130private XmlNodeType _nodeType; // nodeType of the node that the reader is currently positioned on 1152_nodeType = XmlNodeType.None; 1168public override XmlNodeType NodeType 1170get { return (IsInReadingStates()) ? _nodeType : XmlNodeType.None; } 1329if (!IsInReadingStates() || _nodeType == XmlNodeType.EndElement) 1457if (!IsInReadingStates() || _nodeType == XmlNodeType.EndElement) 1513if ((_readerNav.NodeType == XmlNodeType.Document) || (_readerNav.NodeType == XmlNodeType.DocumentFragment)) 1547_nodeType = XmlNodeType.None; 1556_nodeType = XmlNodeType.None; 1561XmlNodeType nt = _readerNav.NodeType; 1565&& (_nodeType != XmlNodeType.EndElement) 1566&& (_nodeType != XmlNodeType.EndEntity) 1567&& (nt == XmlNodeType.Element || (nt == XmlNodeType.EntityReference && _bResolveEntity) || 1568(((_readerNav.NodeType == XmlNodeType.Document) || (_readerNav.NodeType == XmlNodeType.DocumentFragment)) && _readState == ReadState.Initial)); 1580else if (_readerNav.NodeType == XmlNodeType.Element 1583_nodeType = XmlNodeType.EndElement; 1586else if (_readerNav.NodeType == XmlNodeType.EntityReference && _bResolveEntity) 1589_nodeType = XmlNodeType.EndEntity; 1597if (_readerNav.NodeType == XmlNodeType.EntityReference && _bResolveEntity) 1609_nodeType = XmlNodeType.EndEntity; 1622_nodeType = XmlNodeType.None; 1629&& _nodeType != XmlNodeType.EndElement 1630&& _readerNav.NodeType == XmlNodeType.Element 1633_nodeType = XmlNodeType.EndElement; 1667if (_readerNav.NodeType == XmlNodeType.Element) 1670_nodeType = XmlNodeType.EndElement; 1673else if (_readerNav.NodeType == XmlNodeType.EntityReference) 1677_nodeType = XmlNodeType.EndEntity; 1724if ((this.NodeType == XmlNodeType.EntityReference) && _bResolveEntity) 1774if (!IsInReadingStates() || (_nodeType != XmlNodeType.EntityReference))

36public override XmlNodeType NodeType 38get { return XmlNodeType.Notation; }

77public override XmlNodeType NodeType => XmlNodeType.ProcessingInstruction;

37public override XmlNodeType NodeType 41return XmlNodeType.SignificantWhitespace; 51case XmlNodeType.Document: 53case XmlNodeType.Text: 54case XmlNodeType.CDATA: 55case XmlNodeType.Whitespace: 56case XmlNodeType.SignificantWhitespace:

40public override XmlNodeType NodeType 44return XmlNodeType.Text; 54case XmlNodeType.Document: 56case XmlNodeType.Text: 57case XmlNodeType.CDATA: 58case XmlNodeType.Whitespace: 59case XmlNodeType.SignificantWhitespace: 91if (parent != null && parent.NodeType == XmlNodeType.Attribute)

38public override XmlNodeType NodeType 42return XmlNodeType.Whitespace; 52case XmlNodeType.Document: 54case XmlNodeType.Text: 55case XmlNodeType.CDATA: 56case XmlNodeType.Whitespace: 57case XmlNodeType.SignificantWhitespace:

67if (reader.NodeType == XmlNodeType.Element)

62case XmlNodeType.Element: 66goto case XmlNodeType.EndElement; 69case XmlNodeType.Whitespace: 70case XmlNodeType.SignificantWhitespace: 76case XmlNodeType.ProcessingInstruction: 77case XmlNodeType.Comment: 81case XmlNodeType.Text: // text inside a node 82case XmlNodeType.CDATA: // <![CDATA[...]]> 85case XmlNodeType.EntityReference: 91case XmlNodeType.EndElement: 99reader.NodeType == XmlNodeType.Element) 149Debug.Assert(reader.NodeType == XmlNodeType.Element);

186while (_xtr.NodeType != XmlNodeType.Element && _xtr.Read()) ; 189if (_xtr.NodeType == XmlNodeType.Element) 693if (_xtr.NodeType == XmlNodeType.Whitespace) 697if (_xtr.NodeType == XmlNodeType.EntityReference) 701} while ((!_xtr.EOF) && (_xtr.NodeType != XmlNodeType.EndElement) && (_xtr.NodeType != XmlNodeType.CDATA) && (_xtr.NodeType != XmlNodeType.Element) && (_xtr.NodeType != XmlNodeType.Text)); 703if (_xtr.NodeType == XmlNodeType.EndElement) 768while (!_xtr.EOF && (_xtr.NodeType != XmlNodeType.EndElement)) 772if ((_xtr.NodeType == XmlNodeType.Text) || (_xtr.NodeType == XmlNodeType.CDATA)) //node can be simple type, complex with simple content or complex with mixed content 782do { _xtr.Read(); } while ((!_xtr.EOF) && ((_xtr.NodeType == XmlNodeType.CDATA) || (_xtr.NodeType == XmlNodeType.Text) || (_xtr.NodeType == XmlNodeType.Comment) || (_xtr.NodeType == XmlNodeType.ProcessingInstruction) || (_xtr.NodeType == XmlNodeType.Whitespace) || (_xtr.NodeType == XmlNodeType.SignificantWhitespace) || (_xtr.NodeType == XmlNodeType.XmlDeclaration))); 784if (_xtr.NodeType == XmlNodeType.EndElement) 791if ((_xtr.NodeType == XmlNodeType.Text) && (iChildNumber == 1)) 822if (_xtr.NodeType == XmlNodeType.Text) 853if (_xtr.NodeType == XmlNodeType.Text) 863else if (_xtr.NodeType == XmlNodeType.Text) 889else if (_xtr.NodeType == XmlNodeType.Element) 944else if (_xtr.NodeType == XmlNodeType.Text) 952if (_xtr.NodeType == XmlNodeType.EntityReference) 964} while ((!_xtr.EOF) && (_xtr.NodeType != XmlNodeType.EndElement) && (_xtr.NodeType != XmlNodeType.CDATA) && (_xtr.NodeType != XmlNodeType.Element) && (_xtr.NodeType != XmlNodeType.Text)); 1202Debug.Assert(_xtr!.NodeType == XmlNodeType.Attribute);

70while (reader.NodeType != XmlNodeType.Element && reader.Read()) { } 176else if (_reader.NodeType == XmlNodeType.Element) 222else if (_reader.NodeType == XmlNodeType.Text) 229else if (_reader.NodeType == XmlNodeType.EntityReference || 230_reader.NodeType == XmlNodeType.SignificantWhitespace || 231_reader.NodeType == XmlNodeType.CDATA) 235else if (_reader.NodeType == XmlNodeType.EndElement) 276case XmlNodeType.Element: 288case XmlNodeType.Text: 292case XmlNodeType.SignificantWhitespace: 296case XmlNodeType.CDATA: 300case XmlNodeType.EntityReference: 304case XmlNodeType.Comment: 308case XmlNodeType.ProcessingInstruction: 312case XmlNodeType.EndEntity: 315case XmlNodeType.Whitespace: 318case XmlNodeType.EndElement: 333Debug.Assert(_reader!.NodeType == XmlNodeType.Element); 418Debug.Assert(_reader!.NodeType == XmlNodeType.Attribute); 428case XmlNodeType.Text: 431case XmlNodeType.EntityReference: 444Debug.Assert(_reader!.NodeType == XmlNodeType.EntityReference); 457case XmlNodeType.Text: 460case XmlNodeType.EndEntity: 466case XmlNodeType.EntityReference:

30while (reader.NodeType != XmlNodeType.Element && await reader.ReadAsync().ConfigureAwait(false)) { }

69case XmlNodeType.Element: 73goto case XmlNodeType.EndElement; 76case XmlNodeType.Whitespace: 79case XmlNodeType.Text: // text inside a node 80case XmlNodeType.CDATA: // <![CDATA[...]]> 81case XmlNodeType.SignificantWhitespace: 84case XmlNodeType.EndElement:

1052attrData.NodeType = XmlNodeType.Attribute;

106case XmlNodeType.Element: 110goto case XmlNodeType.EndElement; 113case XmlNodeType.Whitespace: 116case XmlNodeType.Text: // text inside a node 117case XmlNodeType.CDATA: // <![CDATA[...]]> 118case XmlNodeType.SignificantWhitespace: 121case XmlNodeType.EndElement:

139public XmlNodeType NodeType

276if (Reader.NodeType == System.Xml.XmlNodeType.Element) 305if (Reader.NodeType == System.Xml.XmlNodeType.Element) 329if (Reader.NodeType == System.Xml.XmlNodeType.Element) 353if (Reader.NodeType == System.Xml.XmlNodeType.Element) 377if (Reader.NodeType == System.Xml.XmlNodeType.Element) 401if (Reader.NodeType == System.Xml.XmlNodeType.Element) 425if (Reader.NodeType == System.Xml.XmlNodeType.Element) 449if (Reader.NodeType == System.Xml.XmlNodeType.Element) 473if (Reader.NodeType == System.Xml.XmlNodeType.Element) 497if (Reader.NodeType == System.Xml.XmlNodeType.Element) 527if (Reader.NodeType == System.Xml.XmlNodeType.Element) 557if (Reader.NodeType == System.Xml.XmlNodeType.Element) 587if (Reader.NodeType == System.Xml.XmlNodeType.Element) 611if (Reader.NodeType == System.Xml.XmlNodeType.Element) 635if (Reader.NodeType == System.Xml.XmlNodeType.Element) 659if (Reader.NodeType == System.Xml.XmlNodeType.Element) 683if (Reader.NodeType == System.Xml.XmlNodeType.Element) 707if (Reader.NodeType == System.Xml.XmlNodeType.Element) 736if (Reader.NodeType == System.Xml.XmlNodeType.Element) 760if (Reader.NodeType == System.Xml.XmlNodeType.Element) 790if (Reader.NodeType == System.Xml.XmlNodeType.Element) 814if (Reader.NodeType == System.Xml.XmlNodeType.Element)

105while (Reader.NodeType != XmlNodeType.EndElement && Reader.NodeType != XmlNodeType.None) 266while (Reader.NodeType != XmlNodeType.EndElement && Reader.NodeType != XmlNodeType.None) 325while (Reader.NodeType == XmlNodeType.Element) 386while (Reader.NodeType != XmlNodeType.EndElement && Reader.NodeType != XmlNodeType.None) 480if (Reader.NodeType == XmlNodeType.Element) 533while (Reader.NodeType != XmlNodeType.EndElement && Reader.NodeType != XmlNodeType.None) 678if ((Reader.NodeType == XmlNodeType.Text || 679Reader.NodeType == XmlNodeType.CDATA || 680Reader.NodeType == XmlNodeType.Whitespace || 681Reader.NodeType == XmlNodeType.SignificantWhitespace)) 1161while (Reader.NodeType != XmlNodeType.EndElement && Reader.NodeType != XmlNodeType.None) 1390while (Reader.NodeType != XmlNodeType.EndElement && Reader.NodeType != XmlNodeType.None)

833while (_r.NodeType != XmlNodeType.EndElement) 915if (_r.NodeType != XmlNodeType.EndElement) 917while (_r.NodeType != XmlNodeType.EndElement) 1236if (_r.NodeType == XmlNodeType.None || _r.NodeType == XmlNodeType.Whitespace) 1241if (_r.NodeType == XmlNodeType.EndElement) 1247else if (_r.NodeType == XmlNodeType.Attribute && _events.OnUnknownAttribute == null) 1251else if (_r.NodeType == XmlNodeType.Element && _events.OnUnknownElement == null) 1266if (unknownNode.NodeType != XmlNodeType.None && unknownNode.NodeType != XmlNodeType.Whitespace && _events.OnUnknownNode != null) 1273if (unknownNode.NodeType == XmlNodeType.Attribute) 1277else if (unknownNode.NodeType == XmlNodeType.Element) 1306XmlNodeType.Element => $"<{_r.LocalName} xmlns='{_r.NamespaceURI}'>", 1307XmlNodeType.EndElement => ">", 1308XmlNodeType.Text => _r.Value, 1309XmlNodeType.CDATA => "CDATA", 1310XmlNodeType.Comment => "<--", 1311XmlNodeType.ProcessingInstruction => "<?", 1438while (_r.NodeType == XmlNodeType.Whitespace) _r.Skip(); 1439if (_r.NodeType == XmlNodeType.None) _r.Skip(); 1440if (_r.NodeType == XmlNodeType.EndElement && _r.LocalName == name && _r.NamespaceURI == ns) 1702while (_r.NodeType != XmlNodeType.EndElement) 1718while (_r.NodeType != XmlNodeType.EndElement) 1794while (_r.NodeType != XmlNodeType.EndElement && _r.NodeType != XmlNodeType.None) 1899while (_r.NodeType == XmlNodeType.Whitespace) _r.Skip(); 1903if (_r.NodeType == XmlNodeType.None) 1909if (_r.NodeType == XmlNodeType.EndElement && _r.Depth == 0) 1912else if (_r.NodeType == XmlNodeType.None) 1930if (Reader.NodeType == XmlNodeType.Attribute) 1991while (Reader.NodeType != System.Xml.XmlNodeType.EndElement) 4063Writer.Write(typeof(XmlNodeType).FullName); 4093Writer.Write(typeof(XmlNodeType).FullName); 4096Writer.Write(typeof(XmlNodeType).FullName); 4099Writer.Write(typeof(XmlNodeType).FullName); 4102Writer.Write(typeof(XmlNodeType).FullName); 5010Writer.Write(typeof(XmlNodeType).FullName); 5012Writer.Write(typeof(XmlNodeType).FullName); 5036Writer.Write(typeof(XmlNodeType).FullName);

2279ilg.Ldc(XmlNodeType.Text); 2285ilg.Ldc(XmlNodeType.CDATA); 2291ilg.Ldc(XmlNodeType.Whitespace); 2297ilg.Ldc(XmlNodeType.SignificantWhitespace);

849xmlReader.NodeType == XmlNodeType.EndElement &&

194case XmlNodeType.Element: 232case XmlNodeType.EndElement: 236case XmlNodeType.Text: 237case XmlNodeType.CDATA: 241case XmlNodeType.SignificantWhitespace: 246goto case XmlNodeType.Whitespace; 249case XmlNodeType.Whitespace: 261case XmlNodeType.Comment: 265case XmlNodeType.ProcessingInstruction: 269case XmlNodeType.EntityReference: 273case XmlNodeType.DocumentType: 280case XmlNodeType.EndEntity: 281case XmlNodeType.None: 282case XmlNodeType.XmlDeclaration:

2016XmlTextReader reader = new XmlTextReader(xml, XmlNodeType.Element, context); 2044case XmlNodeType.Element: 2083case XmlNodeType.EndElement: 2088case XmlNodeType.Text: 2089case XmlNodeType.CDATA: 2092case XmlNodeType.SignificantWhitespace: 2093case XmlNodeType.Whitespace: 2096case XmlNodeType.Comment: 2099case XmlNodeType.ProcessingInstruction: 2102case XmlNodeType.EntityReference: 2105case XmlNodeType.EndEntity: 2106case XmlNodeType.None: 2107case XmlNodeType.DocumentType: 2108case XmlNodeType.XmlDeclaration: 2110case XmlNodeType.Attribute:

34private XmlNodeType _nodeType; 46private static ReadOnlySpan<XmlNodeType> ConvertFromXPathNodeType => 48XmlNodeType.Document, // XPathNodeType.Root 49XmlNodeType.Element, // XPathNodeType.Element 50XmlNodeType.Attribute, // XPathNodeType.Attribute 51XmlNodeType.Attribute, // XPathNodeType.Namespace 52XmlNodeType.Text, // XPathNodeType.Text 53XmlNodeType.SignificantWhitespace, // XPathNodeType.SignificantWhitespace 54XmlNodeType.Whitespace, // XPathNodeType.Whitespace 55XmlNodeType.ProcessingInstruction, // XPathNodeType.ProcessingInstruction 56XmlNodeType.Comment, // XPathNodeType.Comment 57XmlNodeType.None // XPathNodeType.All 64internal static XmlNodeType ToXmlNodeType(XPathNodeType typ) 182if (_nodeType == XmlNodeType.Text) 193public override XmlNodeType NodeType 206if (this.NodeType == XmlNodeType.Text) 220if (this.NodeType == XmlNodeType.Text) 234if (this.NodeType == XmlNodeType.Text) 297if ((_nodeType != XmlNodeType.Element) 298&& (_nodeType != XmlNodeType.Document) 299&& (_nodeType != XmlNodeType.EndElement) 300&& (_nodeType != XmlNodeType.None)) 310if ((_nodeType != XmlNodeType.Element) 311&& (_nodeType != XmlNodeType.Document) 312&& (_nodeType != XmlNodeType.EndElement) 313&& (_nodeType != XmlNodeType.None)) 347if (_nodeType == XmlNodeType.Element) 377_nodeType = XmlNodeType.Attribute; 686_nodeType = XmlNodeType.Attribute; 771_nodeType = XmlNodeType.Element; 833_nodeType = XmlNodeType.Text; 1005else if (_nodeType == XmlNodeType.Element 1008_nodeType = XmlNodeType.EndElement; 1029_nodeType = XmlNodeType.EndElement; 1067_nodeType = XmlNodeType.None; 1078_nodeType = XmlNodeType.None;

83case XmlNodeType.Element: 94case XmlNodeType.EndElement: 99case XmlNodeType.Text: 100case XmlNodeType.CDATA: 109goto case XmlNodeType.Whitespace; 121case XmlNodeType.Whitespace: 122case XmlNodeType.SignificantWhitespace: 138case XmlNodeType.EndEntity:

32private XmlNodeType _nodeType; 55_nodeType = XmlNodeType.Document; 59public XmlNodeType NodeType { get { return _nodeType == XmlNodeType.Element && 0 < _currentRecord ? XmlNodeType.Attribute : _nodeType; } } 122while (MoveToNextSibling() && _nodeType == XmlNodeType.Whitespace) ; 125if (_nodeType == XmlNodeType.Element) 202_reader.NodeType == XmlNodeType.Whitespace || _reader.NodeType == XmlNodeType.SignificantWhitespace || 203_reader.NodeType == XmlNodeType.Text || _reader.NodeType == XmlNodeType.CDATA 213bool isCDATA = (_reader.NodeType == XmlNodeType.CDATA); 244Debug.Assert(_reader.NodeType == XmlNodeType.EntityReference); 258Debug.Assert(_reader.NodeType == XmlNodeType.Text || _reader.NodeType == XmlNodeType.Whitespace || _reader.NodeType == XmlNodeType.SignificantWhitespace); 261Debug.Assert(_reader.NodeType == XmlNodeType.EndEntity); 273Debug.Assert(_reader.NodeType == XmlNodeType.Attribute, "reader.NodeType == XmlNodeType.Attribute"); 303int correction = (_reader.NodeType == XmlNodeType.EntityReference) ? -2 : -1; 317case XmlNodeType.EntityReference: 320case XmlNodeType.EndEntity: 323Debug.Assert(_reader.NodeType == XmlNodeType.Text, "Unexpected node type inside attribute value"); 332Debug.Assert(_reader.NodeType != XmlNodeType.EntityReference); 333int correction = ((_reader.NodeType == XmlNodeType.EndEntity) ? 1 : lastText.Length) + 1; 348Debug.Assert(_nodeType == XmlNodeType.Element, "To call MoveToFirstChild() XsltInut should be positioned on an Element."); 358Debug.Assert(_nodeType != XmlNodeType.Element || IsEmptyElement, "On non-empty elements we should call MoveToFirstChild()"); 359if (_nodeType == XmlNodeType.Element || _nodeType == XmlNodeType.EndElement) 368if (_nodeType == XmlNodeType.Element && MoveToFirstChild()) 386case XmlNodeType.Text: 388case XmlNodeType.CDATA: 393goto case XmlNodeType.SignificantWhitespace; 394case XmlNodeType.Whitespace: 395case XmlNodeType.SignificantWhitespace: 401case XmlNodeType.EntityReference: 423case XmlNodeType.EndEntity: 428!textIsWhite ? XmlNodeType.Text : 429textPreserveWS ? XmlNodeType.SignificantWhitespace : 430/*default: */ XmlNodeType.Whitespace 441Debug.Assert(_nodeType == XmlNodeType.Text || _nodeType == XmlNodeType.Whitespace || _nodeType == XmlNodeType.SignificantWhitespace); 454case XmlNodeType.Text: 455case XmlNodeType.CDATA: 456case XmlNodeType.Whitespace: 457case XmlNodeType.SignificantWhitespace: 458case XmlNodeType.EntityReference: 467case XmlNodeType.Element: 471case XmlNodeType.EndElement: 472_nodeType = XmlNodeType.EndElement; 488Debug.Assert(_reader.NodeType == XmlNodeType.Element); 492_nodeType = XmlNodeType.Element; 518Debug.Assert(_nodeType == XmlNodeType.Element, "For MoveToElement() we should be positioned on Element or Attribute"); 524Debug.Assert(_nodeType == XmlNodeType.Element, "For MoveToLiteralAttribute() we should be positioned on Element or Attribute"); 539Debug.Assert(_nodeType == XmlNodeType.Element, "For MoveToLiteralAttribute() we should be positioned on Element or Attribute"); 589Debug.Assert(_nodeType == XmlNodeType.Element || _nodeType == XmlNodeType.EndElement, "Input is positioned on element or attribute"); 620Debug.Assert(_nodeType != XmlNodeType.Element || _attributesRead, "Should first read attributes"); 628Debug.Assert(_nodeType != XmlNodeType.Element || _attributesRead, "Should first read attributes"); 637Debug.Assert(_nodeType != XmlNodeType.Element || _attributesRead, "Should first read attributes"); 714Debug.Assert(NodeType == XmlNodeType.Element); 843Debug.Assert(NodeType == XmlNodeType.Element); 921Debug.Assert(NodeType == XmlNodeType.Element && IsXsltNamespace()); 1039private static int PositionAdjustment(XmlNodeType nt) => 1042XmlNodeType.Element => 1, // "<" 1043XmlNodeType.CDATA => 9, // "<![CDATA[" 1044XmlNodeType.ProcessingInstruction => 2, // "<?" 1045XmlNodeType.Comment => 4, // "<!--" 1046XmlNodeType.EndElement => 2, // "</" 1047XmlNodeType.EntityReference => 1, // "&" 1179Debug.Assert(input.NodeType == XmlNodeType.EndElement); 1184Debug.Assert(input.NodeType == XmlNodeType.Element || input.NodeType == XmlNodeType.Attribute);