2942 references to XmlNodeType
Microsoft.AspNetCore.Mvc.Formatters.Xml (3)
ProblemDetailsWrapper.cs (1)
57
while (reader.NodeType !=
XmlNodeType
.EndElement)
SerializableErrorWrapper.cs (1)
65
while (reader.NodeType !=
XmlNodeType
.EndElement)
ValidationProblemDetailsWrapper.cs (1)
61
while (reader.NodeType !=
XmlNodeType
.EndElement)
Microsoft.AspNetCore.OpenApi.SourceGenerators (3)
XmlComments\XmlComment.InheritDoc.cs (3)
108
if (node.NodeType ==
XmlNodeType
.Element)
379
if (node.NodeType ==
XmlNodeType
.Document)
400
if (copyAttributeAnnotations && node.NodeType ==
XmlNodeType
.Element)
Microsoft.CodeAnalysis (3)
DocumentationComments\XmlDocumentationCommentTextReader.XmlStream.cs (1)
77
&& reader.NodeType ==
XmlNodeType
.EndElement
InternalUtilities\XmlUtilities.cs (2)
22
if (node.NodeType ==
XmlNodeType
.Document)
43
if (copyAttributeAnnotations && node.NodeType ==
XmlNodeType
.Element)
Microsoft.CodeAnalysis.CSharp (2)
Compiler\DocumentationCommentCompiler.IncludeElementExpander.cs (2)
177
if (node.NodeType ==
XmlNodeType
.Element)
213
if (container.NodeType ==
XmlNodeType
.Element && originatingSyntax != null)
Microsoft.CodeAnalysis.Features (3)
DocumentationComments\AbstractDocumentationCommentFormattingService.cs (3)
312
if (node.NodeType is
XmlNodeType
.Text or
XmlNodeType
.CDATA)
318
if (node.NodeType !=
XmlNodeType
.Element)
Microsoft.CodeAnalysis.VisualBasic (2)
Compilation\DocumentationComments\DocumentationCommentCompiler.Includes.vb (2)
272
If node.NodeType =
XmlNodeType
.Element Then
301
If container.NodeType =
XmlNodeType
.Element AndAlso originatingSyntax IsNot Nothing Then
Microsoft.CodeAnalysis.Workspaces (5)
Shared\Extensions\ISymbolExtensions.cs (3)
299
if (node.NodeType ==
XmlNodeType
.Element)
568
if (node.NodeType ==
XmlNodeType
.Document)
589
if (copyAttributeAnnotations && node.NodeType ==
XmlNodeType
.Element)
Shared\Utilities\DocumentationComment.cs (1)
230
if (reader.NodeType ==
XmlNodeType
.Element)
Shared\Utilities\XmlFragmentParser.cs (1)
106
&& _xmlReader.NodeType ==
XmlNodeType
.EndElement
Microsoft.CodeAnalysis.Workspaces.MSBuild.BuildHost (2)
src\Compilers\Core\Portable\InternalUtilities\XmlUtilities.cs (2)
22
if (node.NodeType ==
XmlNodeType
.Document)
43
if (copyAttributeAnnotations && node.NodeType ==
XmlNodeType
.Element)
Microsoft.Extensions.Configuration.Xml (12)
XmlStreamConfigurationProvider.cs (12)
56
XmlNodeType
preNodeType = reader.NodeType;
62
case
XmlNodeType
.Element:
128
case
XmlNodeType
.EndElement:
135
if (preNodeType ==
XmlNodeType
.Element)
145
case
XmlNodeType
.CDATA:
146
case
XmlNodeType
.Text:
158
case
XmlNodeType
.XmlDeclaration:
159
case
XmlNodeType
.ProcessingInstruction:
160
case
XmlNodeType
.Comment:
161
case
XmlNodeType
.Whitespace:
173
if (preNodeType ==
XmlNodeType
.Element && reader.IsEmptyElement)
175
preNodeType =
XmlNodeType
.EndElement;
Microsoft.Extensions.FileProviders.Embedded (2)
Manifest\ManifestParser.cs (2)
83
if (element.NodeType !=
XmlNodeType
.Element)
142
element.FirstNode?.NodeType ==
XmlNodeType
.Text)
Microsoft.Maui.Controls.Build.Tasks (4)
XamlTask.cs (4)
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)
Microsoft.Maui.Controls.Xaml (22)
XamlLoader.cs (9)
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)
XamlParser.cs (13)
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);
Microsoft.Maui.Graphics (4)
Text\XmlAttributedTextReader.cs (4)
42
case
XmlNodeType
.CDATA:
45
case
XmlNodeType
.Text:
48
case
XmlNodeType
.Element:
51
case
XmlNodeType
.EndElement:
netstandard (1)
netstandard.cs (1)
2490
[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Xml.
XmlNodeType
))]
PresentationBuildTasks (66)
Microsoft\Build\Tasks\Windows\UidManager.cs (2)
491
XmlNodeType
.Document, // parsing document
499
case
XmlNodeType
.Element :
MS\Internal\MarkupCompiler\MarkupCompiler.cs (6)
786
XmlNodeType
currNodeType = xmlReader.NodeType;
789
case
XmlNodeType
.Element:
842
case
XmlNodeType
.EndElement:
849
case
XmlNodeType
.CDATA:
850
case
XmlNodeType
.Text:
865
ThrowCompilerException(nameof(SR.IllegalCDataTextScoping), DefinitionNSPrefix, LocalName, (currNodeType ==
XmlNodeType
.CDATA ? "a CDATA section" : "text content"));
MS\Internal\MarkupCompiler\ParserExtension.cs (2)
416
string attrName = (xmlReader.NodeType ==
XmlNodeType
.Attribute) ? xmlReader.Name : null;
715
while (!xamlDefTagNode.IsEmptyElement && xamlDefTagNode.XmlReader.NodeType !=
XmlNodeType
.EndElement)
src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlParser.cs (2)
72
multipleRoots ?
XmlNodeType
.Element :
XmlNodeType
.Document,
src\Microsoft.DotNet.Wpf\src\PresentationFramework\System\Windows\Markup\XamlReaderHelper.cs (50)
379
case
XmlNodeType
.Element:
382
case
XmlNodeType
.EndElement:
1238
case
XmlNodeType
.SignificantWhitespace:
1239
case
XmlNodeType
.Text:
1240
case
XmlNodeType
.CDATA:
1241
case
XmlNodeType
.Whitespace:
1258
case
XmlNodeType
.Element:
1277
case
XmlNodeType
.EndElement:
1305
case
XmlNodeType
.Attribute: // review this.
1310
case
XmlNodeType
.Comment:
1313
case
XmlNodeType
.ProcessingInstruction:
1984
CompileBamlTag(
XmlNodeType
.Element, ref endTagHasBeenRead);
1997
CompileBamlTag(
XmlNodeType
.EndElement, ref endTagHasBeenRead);
2036
CompileBamlTag(
XmlNodeType
.EndElement,
2086
case
XmlNodeType
.Text:
2087
case
XmlNodeType
.CDATA:
2088
case
XmlNodeType
.SignificantWhitespace:
2089
case
XmlNodeType
.Whitespace:
2094
case
XmlNodeType
.ProcessingInstruction:
2100
case
XmlNodeType
.EntityReference:
2123
XmlNodeType
xmlNodeType,
2131
case
XmlNodeType
.Element:
2143
case
XmlNodeType
.EndElement:
2146
case
XmlNodeType
.Text:
2147
case
XmlNodeType
.CDATA:
2148
case
XmlNodeType
.SignificantWhitespace:
2149
case
XmlNodeType
.Whitespace:
3566
XmlNodeType
xmlNodeType, // Type of xml node we are processing.
3587
case
XmlNodeType
.Element:
3744
case
XmlNodeType
.EndElement:
3793
case
XmlNodeType
.CDATA:
3794
case
XmlNodeType
.Text:
3795
case
XmlNodeType
.SignificantWhitespace:
3796
case
XmlNodeType
.Whitespace:
3806
case
XmlNodeType
.ProcessingInstruction:
3813
case
XmlNodeType
.Comment:
3820
case
XmlNodeType
.EntityReference:
4110
CompileText(
XmlNodeType
.None, textValue);
5050
private void CompileText(
XmlNodeType
xmlNodeType, string textValue)
5054
Debug.Assert( xmlNodeType ==
XmlNodeType
.Text ||
5055
xmlNodeType ==
XmlNodeType
.Whitespace ||
5056
xmlNodeType ==
XmlNodeType
.SignificantWhitespace ||
5057
xmlNodeType ==
XmlNodeType
.CDATA ||
5058
xmlNodeType ==
XmlNodeType
.None,
5062
case
XmlNodeType
.Text:
5066
case
XmlNodeType
.Whitespace:
5067
case
XmlNodeType
.SignificantWhitespace:
5071
case
XmlNodeType
.CDATA:
5072
case
XmlNodeType
.None:
5220
0 == XmlReader.Depth && XmlReader.NodeType ==
XmlNodeType
.None))
src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlCompatibilityReader.cs (3)
172
case
XmlNodeType
.Element:
183
case
XmlNodeType
.EndElement:
750
_inAttribute = (Reader.NodeType ==
XmlNodeType
.Attribute);
src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlWrappingReader.cs (1)
42
public override
XmlNodeType
NodeType { get { return _reader.NodeType; } }
PresentationCore (16)
MS\Internal\FontFace\CompositeFontParser.cs (16)
198
if (_reader.NodeType ==
XmlNodeType
.Attribute)
205
if (_reader.NodeType ==
XmlNodeType
.Attribute)
283
private
XmlNodeType
MoveToContent()
291
case
XmlNodeType
.CDATA:
292
case
XmlNodeType
.Element:
293
case
XmlNodeType
.EndElement:
294
case
XmlNodeType
.EntityReference:
295
case
XmlNodeType
.EndEntity:
401
while (MoveToContent() !=
XmlNodeType
.EndElement)
403
if (_reader.NodeType ==
XmlNodeType
.Element && _reader.NamespaceURI == CompositeFontNamespace)
416
while (MoveToContent() ==
XmlNodeType
.Element)
567
while (MoveToContent() !=
XmlNodeType
.EndElement)
569
if (_reader.NodeType ==
XmlNodeType
.Element && _reader.NamespaceURI == CompositeFontNamespace)
584
while (MoveToContent() ==
XmlNodeType
.Element)
815
while (MoveToContent() !=
XmlNodeType
.EndElement)
817
if (_reader.NodeType ==
XmlNodeType
.Element && _reader.NamespaceURI == CompositeFontNamespace)
PresentationFramework (27)
MS\Internal\Globalization\BamlTreeMap.cs (1)
642
if (node.NodeType ==
XmlNodeType
.Element)
MS\Internal\Globalization\BamlTreeUpdater.cs (2)
459
if (node.NodeType ==
XmlNodeType
.Text)
469
else if (node.NodeType ==
XmlNodeType
.Element)
MS\Internal\IO\Packaging\XamlFilter.cs (5)
396
case
XmlNodeType
.Text:
397
case
XmlNodeType
.SignificantWhitespace:
398
case
XmlNodeType
.CDATA:
405
case
XmlNodeType
.Element:
410
case
XmlNodeType
.EndElement:
System\Windows\Annotations\Annotation.cs (6)
282
while (!(
XmlNodeType
.EndElement == reader.NodeType && AnnotationXmlConstants.Elements.Annotation == reader.LocalName))
291
while (!(AnnotationXmlConstants.Elements.AnchorCollection == reader.LocalName &&
XmlNodeType
.EndElement == reader.NodeType))
306
while (!(AnnotationXmlConstants.Elements.CargoCollection == reader.LocalName &&
XmlNodeType
.EndElement == reader.NodeType))
321
while (!(AnnotationXmlConstants.Elements.AuthorCollection == reader.LocalName &&
XmlNodeType
.EndElement == reader.NodeType))
323
if (!(AnnotationXmlConstants.Elements.StringAuthor == reader.LocalName &&
XmlNodeType
.Element == reader.NodeType))
515
if (reader.NodeType ==
XmlNodeType
.Attribute)
System\Windows\Annotations\AnnotationResource.cs (2)
169
while (!(AnnotationXmlConstants.Elements.Resource == reader.LocalName &&
XmlNodeType
.EndElement == reader.NodeType))
181
else if (
XmlNodeType
.Element == reader.NodeType)
System\Windows\Annotations\LocatorGroup.cs (1)
133
while (!(AnnotationXmlConstants.Elements.ContentLocatorGroup == reader.LocalName &&
XmlNodeType
.EndElement == reader.NodeType))
System\Windows\Annotations\LocatorPartList.cs (4)
203
while (!(AnnotationXmlConstants.Elements.ContentLocator == reader.LocalName &&
XmlNodeType
.EndElement == reader.NodeType))
205
if (
XmlNodeType
.Element != reader.NodeType)
221
while (!(
XmlNodeType
.EndElement == reader.NodeType && part.PartType.Name == reader.LocalName))
264
if (!(
XmlNodeType
.EndElement == reader.NodeType && AnnotationXmlConstants.Elements.Item == reader.LocalName))
System\Windows\Documents\FixedFindEngine.cs (1)
387
case
XmlNodeType
.Element:
System\Windows\Documents\FixedSchema.cs (2)
36
if (base.NodeType ==
XmlNodeType
.XmlDeclaration)
210
if ( (Reader.NodeType ==
XmlNodeType
.Element) && !_rootXMLNSChecked )
System\Windows\Markup\BamlRecordReader.cs (1)
2014
XmlNodeType
.Element,
System\Windows\Markup\FilteredXmlReader.cs (1)
231
internal FilteredXmlReader( string xmlFragment,
XmlNodeType
fragmentType, XmlParserContext context ) :
System\Windows\Markup\XamlReader.cs (1)
293
XmlTextReader reader = new XmlTextReader(stream,
XmlNodeType
.Document, parserContext)
PresentationFramework-SystemXml (2)
SystemXmlExtension.cs (2)
148
if (node.NodeType ==
XmlNodeType
.Element)
152
if (node.ChildNodes[i].NodeType ==
XmlNodeType
.Text)
ReachFramework (18)
Packaging\XpsFixedDocumentReaderWriter.cs (4)
953
if (reader.NodeType ==
XmlNodeType
.Element && reader.Name == XpsS0Markup.PageContent)
1072
if (reader.NodeType ==
XmlNodeType
.Element &&
1092
if( reader.NodeType ==
XmlNodeType
.Element &&
1101
if( reader.NodeType ==
XmlNodeType
.EndElement &&
Packaging\XpsFixedDocumentSequenceReaderWriter.cs (1)
552
if (reader.NodeType ==
XmlNodeType
.Element && reader.Name == XpsS0Markup.DocumentReference)
Packaging\XPSSignatureDefinition.cs (5)
413
if( reader.NodeType !=
XmlNodeType
.Element ||
431
case
XmlNodeType
.Element:
435
case
XmlNodeType
.EndElement:
576
case
XmlNodeType
.Text:
581
case
XmlNodeType
.EndElement:
PrintConfig\PrtCap_Reader.cs (3)
46
if ((_xmlReader.MoveToContent() !=
XmlNodeType
.Element) ||
125
if ((_xmlReader.NodeType ==
XmlNodeType
.EndElement) &&
133
if ((_xmlReader.NodeType !=
XmlNodeType
.Element) ||
PrintConfig\PrtTicket_Base.cs (2)
820
(valueNode.FirstChild.NodeType !=
XmlNodeType
.Text))
1285
(valueNode.FirstChild.NodeType !=
XmlNodeType
.Text))
PrintConfig\PrtTicket_Editor.cs (3)
100
if ((rootChild.NodeType !=
XmlNodeType
.Element) ||
248
if ((child.NodeType !=
XmlNodeType
.Element) ||
312
if ((child.NodeType !=
XmlNodeType
.Element) ||
System.Configuration.ConfigurationManager (106)
System\Configuration\AppSettingsSection.cs (2)
122
XmlNodeType
t = xmlUtil.Reader.NodeType;
123
if (t !=
XmlNodeType
.Comment)
System\Configuration\BaseConfigurationRecord.cs (16)
1528
XmlNodeType
t = xmlUtil.Reader.NodeType;
1529
if (t !=
XmlNodeType
.Comment)
1757
if ((xmlUtil.Reader.NodeType !=
XmlNodeType
.Element) || (xmlUtil.Reader.Name != ConfigurationTag))
2572
XmlNodeType
t = xmlUtil.Reader.NodeType;
2573
if (t ==
XmlNodeType
.EndElement)
2576
if (t ==
XmlNodeType
.Comment) continue;
2583
if (t ==
XmlNodeType
.Element)
2625
if (xmlUtil.Reader.NodeType !=
XmlNodeType
.Element)
3569
XmlNodeType
nodeType;
3588
if ((nodeType ==
XmlNodeType
.Element) && (clone.Name == "EncryptedData"))
3594
if (nodeType ==
XmlNodeType
.EndElement)
3597
if ((nodeType !=
XmlNodeType
.Comment) && (nodeType !=
XmlNodeType
.Whitespace))
3625
if (nodeType ==
XmlNodeType
.EndElement) break;
3627
if ((nodeType !=
XmlNodeType
.Comment) && (nodeType !=
XmlNodeType
.Whitespace))
System\Configuration\ConfigurationElement.cs (4)
1503
if (reader.NodeType ==
XmlNodeType
.Element)
1553
if (reader.NodeType ==
XmlNodeType
.EndElement) break;
1555
if ((reader.NodeType ==
XmlNodeType
.CDATA) || (reader.NodeType ==
XmlNodeType
.Text))
System\Configuration\ConfigurationSection.cs (1)
39
if (!reader.Read() || (reader.NodeType !=
XmlNodeType
.Element))
System\Configuration\DefaultSection.cs (1)
51
if (!xmlReader.Read() || (xmlReader.NodeType !=
XmlNodeType
.Element))
System\Configuration\DpapiProtectedConfigurationProvider.cs (2)
20
if (encryptedNode.NodeType !=
XmlNodeType
.Element ||
107
if (child.NodeType !=
XmlNodeType
.Element)
System\Configuration\HandlerBase.cs (3)
151
if (node.NodeType !=
XmlNodeType
.Element)
159
if (node.NodeType ==
XmlNodeType
.Comment || node.NodeType ==
XmlNodeType
.Whitespace)
System\Configuration\IgnoreSection.cs (1)
51
if (!xmlReader.Read() || (xmlReader.NodeType !=
XmlNodeType
.Element))
System\Configuration\LocalFileSettingsProvider.cs (1)
472
if (child.NodeType ==
XmlNodeType
.XmlDeclaration)
System\Configuration\MgmtConfigurationRecord.cs (20)
602
reader = new XmlTextReader(xmlElement,
XmlNodeType
.Element, context);
606
if (reader.NodeType !=
XmlNodeType
.Element)
632
case
XmlNodeType
.XmlDeclaration:
633
case
XmlNodeType
.DocumentType:
639
if ((reader.Depth <= 0) && (reader.NodeType !=
XmlNodeType
.EndElement))
2183
if ((xmlUtil.Reader.NodeType ==
XmlNodeType
.Element) && utilWriter.IsLastLineBlank)
2209
Debug.Assert((reader.NodeType ==
XmlNodeType
.Element) && (reader.Name == ConfigurationTag),
2245
if ((reader.NodeType ==
XmlNodeType
.Element) && (reader.Name == ConfigSectionsTag))
2271
(reader.NodeType ==
XmlNodeType
.EndElement) &&
2312
bool skipFirstIndent = (reader.Depth > 0) && (reader.NodeType ==
XmlNodeType
.Element);
2347
((reader.NodeType ==
XmlNodeType
.EndElement) && (reader.Name == ConfigurationTag)),
2386
case
XmlNodeType
.Element:
2390
case
XmlNodeType
.EndElement:
2424
if (reader.NodeType ==
XmlNodeType
.Element)
2613
if (reader.NodeType ==
XmlNodeType
.Element)
2620
if (reader.NodeType ==
XmlNodeType
.EndElement)
2662
if (reader.NodeType ==
XmlNodeType
.Element)
2937
if (reader.NodeType ==
XmlNodeType
.EndElement)
3102
if (reader.NodeType ==
XmlNodeType
.Element)
3128
if (reader.IsEmptyElement || (reader.NodeType ==
XmlNodeType
.EndElement)) reader.Read();
System\Configuration\RuntimeConfigurationRecord.cs (1)
135
if (xmlNode.NodeType ==
XmlNodeType
.Element) CheckForLockAttributes(sectionName, child);
System\Configuration\XmlUtil.cs (53)
84
case
XmlNodeType
.XmlDeclaration:
85
case
XmlNodeType
.Comment:
86
case
XmlNodeType
.DocumentType:
88
case
XmlNodeType
.Element:
127
private static int GetPositionOffset(
XmlNodeType
nodeType)
157
if (Reader.MoveToContent() ==
XmlNodeType
.Element)
174
while (!Reader.EOF && (Reader.NodeType !=
XmlNodeType
.Element))
189
if (Reader.NodeType ==
XmlNodeType
.Element) return;
203
while (!Reader.EOF && (Reader.NodeType !=
XmlNodeType
.Element))
221
while (!Reader.EOF && (Reader.NodeType !=
XmlNodeType
.EndElement))
233
XmlNodeType
nodeType = Reader.NodeType;
235
if ((nodeType !=
XmlNodeType
.Comment) && (nodeType !=
XmlNodeType
.EndElement))
364
Debug.Assert(Reader.NodeType ==
XmlNodeType
.Element, "Reader.NodeType == XmlNodeType.Element");
371
while (Reader.NodeType !=
XmlNodeType
.EndElement)
372
if (Reader.NodeType ==
XmlNodeType
.Element)
381
if (Reader.NodeType ==
XmlNodeType
.Whitespace) Reader.Skip();
417
if (Reader.NodeType ==
XmlNodeType
.EndElement)
427
if (Reader.NodeType ==
XmlNodeType
.Element)
452
Debug.Assert(Reader.NodeType ==
XmlNodeType
.Element, "_reader.NodeType == XmlNodeType.Element");
473
if (Reader.NodeType !=
XmlNodeType
.Whitespace)
493
if (Reader.NodeType ==
XmlNodeType
.Element)
507
Debug.Assert(Reader.NodeType ==
XmlNodeType
.Element, "_reader.NodeType== XmlNodeType.Element");
561
XmlNodeType
nodeType = Reader.NodeType;
562
if (nodeType ==
XmlNodeType
.Whitespace) utilWriter.Write(Reader.Value);
565
if (nodeType ==
XmlNodeType
.Element)
613
if (nodeType ==
XmlNodeType
.EndElement)
629
if (nodeType ==
XmlNodeType
.Comment) utilWriter.AppendComment(Reader.Value);
632
if (nodeType ==
XmlNodeType
.Text) utilWriter.AppendEscapeTextString(Reader.Value);
635
if (nodeType ==
XmlNodeType
.XmlDeclaration)
686
if (nodeType ==
XmlNodeType
.SignificantWhitespace) utilWriter.Write(Reader.Value);
689
if (nodeType ==
XmlNodeType
.ProcessingInstruction)
705
if (nodeType ==
XmlNodeType
.EntityReference)
709
if (nodeType ==
XmlNodeType
.CDATA)
713
if (nodeType ==
XmlNodeType
.DocumentType)
831
Debug.Assert(Reader.NodeType ==
XmlNodeType
.Element,
866
Debug.Assert(Reader.NodeType ==
XmlNodeType
.Element, "_reader.NodeType == NodeType.Element");
952
(Reader.NodeType ==
XmlNodeType
.Whitespace))
975
XmlTextReader reader = new XmlTextReader(xmlElement,
XmlNodeType
.Element, context);
991
XmlNodeType
nodeType = reader.NodeType;
1003
case
XmlNodeType
.CDATA:
1004
case
XmlNodeType
.Element:
1005
case
XmlNodeType
.EndElement:
1006
case
XmlNodeType
.Comment:
1025
case
XmlNodeType
.Whitespace:
1027
case
XmlNodeType
.SignificantWhitespace:
1030
case
XmlNodeType
.CDATA:
1033
case
XmlNodeType
.ProcessingInstruction:
1036
case
XmlNodeType
.Comment:
1039
case
XmlNodeType
.Text:
1043
case
XmlNodeType
.Element:
1088
case
XmlNodeType
.EndElement:
1093
case
XmlNodeType
.EntityReference:
System\Configuration\XmlUtilWriter.cs (1)
226
if (reader.NodeType ==
XmlNodeType
.Text)
System.Data.Common (209)
System\Data\Common\ObjectStorage.cs (1)
430
if (type == typeof(string) && xmlReader.NodeType ==
XmlNodeType
.Element && xmlReader.IsEmptyElement)
System\Data\DataSet.cs (26)
202
if (reader.NodeType ==
XmlNodeType
.Element)
1590
if (reader.NodeType ==
XmlNodeType
.Element)
1689
if (reader.NodeType ==
XmlNodeType
.Element)
1696
if (reader.NodeType ==
XmlNodeType
.Element)
1784
while (!reader.EOF && reader.NodeType !=
XmlNodeType
.EndElement && reader.NodeType !=
XmlNodeType
.Element && reader.Depth > depth)
1788
return (reader.NodeType ==
XmlNodeType
.Element);
1793
while (!reader.EOF && reader.NodeType !=
XmlNodeType
.EndElement && reader.NodeType !=
XmlNodeType
.Element)
1800
while (reader.NodeType ==
XmlNodeType
.Whitespace)
1804
if (reader.NodeType ==
XmlNodeType
.None)
1808
else if (reader.NodeType ==
XmlNodeType
.EndElement)
1845
while (reader.NodeType ==
XmlNodeType
.Whitespace)
2113
if (reader.NodeType ==
XmlNodeType
.Element)
2118
if (reader.NodeType ==
XmlNodeType
.Element)
2218
while (!reader.EOF && reader.NodeType ==
XmlNodeType
.Whitespace)
2220
if (reader.NodeType !=
XmlNodeType
.Element)
2483
if (reader.NodeType ==
XmlNodeType
.Whitespace)
2498
if (reader.NodeType ==
XmlNodeType
.Whitespace)
2509
if (reader.NodeType ==
XmlNodeType
.Whitespace)
2514
Debug.Assert(reader.NodeType !=
XmlNodeType
.Whitespace, "Should not be on Whitespace node");
2625
if ((mode != XmlReadMode.Fragment) && (reader.NodeType ==
XmlNodeType
.Element))
2633
if (reader.NodeType ==
XmlNodeType
.Element)
2845
XmlTextReader reader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(stream,
XmlNodeType
.Element, null) : new XmlTextReader(stream);
2860
XmlTextReader xmlreader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(reader.ReadToEnd(),
XmlNodeType
.Element, null) : new XmlTextReader(reader);
2874
xr = new XmlTextReader(stream,
XmlNodeType
.Element, null);
System\Data\DataTable.cs (10)
5789
if (reader.NodeType ==
XmlNodeType
.Element)
6016
if ((mode != XmlReadMode.Fragment) && (reader.NodeType ==
XmlNodeType
.Element))
6033
if (reader.NodeType ==
XmlNodeType
.Element)
6272
while (reader.NodeType ==
XmlNodeType
.Whitespace)
6276
if (reader.NodeType ==
XmlNodeType
.None)
6280
else if (reader.NodeType ==
XmlNodeType
.EndElement)
6294
while (!reader.EOF && reader.NodeType !=
XmlNodeType
.EndElement && reader.NodeType !=
XmlNodeType
.Element && reader.Depth > depth)
6298
return (reader.NodeType ==
XmlNodeType
.Element);
6334
if (reader.NodeType ==
XmlNodeType
.Whitespace)
System\Data\DataViewManager.cs (1)
119
if (r.NodeType !=
XmlNodeType
.Element)
System\Data\XmlDataLoader.cs (29)
103
if (n.NodeType ==
XmlNodeType
.Element)
142
while (n != null && (n.NodeType ==
XmlNodeType
.Whitespace || !IsTextLikeNode(n.NodeType)))
176
while (n.NodeType ==
XmlNodeType
.Whitespace)
261
internal static bool IsTextLikeNode(
XmlNodeType
n)
265
case
XmlNodeType
.EntityReference:
268
case
XmlNodeType
.Text:
269
case
XmlNodeType
.Whitespace:
270
case
XmlNodeType
.SignificantWhitespace:
271
case
XmlNodeType
.CDATA:
398
if (n.NodeType ==
XmlNodeType
.Element)
631
if (reader.NodeType !=
XmlNodeType
.Element)
746
case
XmlNodeType
.Element: // It's an element
796
case
XmlNodeType
.EntityReference: // Oops. No support for Entity Reference
798
case
XmlNodeType
.Text: // It looks like a text.
799
case
XmlNodeType
.Whitespace: // This actually could be
800
case
XmlNodeType
.CDATA: // if we have XmlText in our table
801
case
XmlNodeType
.SignificantWhitespace:
975
case
XmlNodeType
.Element: // It's an element
1031
case
XmlNodeType
.EntityReference: // Oops. No support for Entity Reference
1033
case
XmlNodeType
.Text: // It looks like a text.
1034
case
XmlNodeType
.Whitespace: // This actually could be
1035
case
XmlNodeType
.CDATA: // if we have XmlText in our table
1036
case
XmlNodeType
.SignificantWhitespace:
1245
case
XmlNodeType
.Text: // It looks like a text. And we need it.
1246
case
XmlNodeType
.Whitespace:
1247
case
XmlNodeType
.CDATA:
1248
case
XmlNodeType
.SignificantWhitespace:
1274
case
XmlNodeType
.Element:
1335
case
XmlNodeType
.EntityReference: // Oops. No support for Entity Reference
System\Data\XMLDiffLoader.cs (11)
203
if (
XmlNodeType
.Element == ssync.NodeType)
214
while ((ssync.NodeType ==
XmlNodeType
.EndElement) && (iSsyncDepth < ssync.Depth))
258
if (
XmlNodeType
.Element == ssync.NodeType)
268
while ((ssync.NodeType ==
XmlNodeType
.EndElement) && (iSsyncDepth < ssync.Depth))
357
if (currentDepth == iRowDepth && row.NodeType ==
XmlNodeType
.EndElement)
382
while ((row.NodeType !=
XmlNodeType
.EndElement) && (row.LocalName != ln) && (row.NamespaceURI != ns))
435
if (row.NodeType ==
XmlNodeType
.Text || row.NodeType ==
XmlNodeType
.Whitespace || row.NodeType ==
XmlNodeType
.SignificantWhitespace)
459
while (reader.NodeType ==
XmlNodeType
.Whitespace || reader.NodeType ==
XmlNodeType
.SignificantWhitespace)
System\Data\xmlsaver.cs (1)
3341
public override
XmlNodeType
NodeType
System\Data\XmlToDatasetMap.cs (3)
441
XmlNode? nodeRegion = (node.NodeType ==
XmlNodeType
.Attribute) ? ((XmlAttribute)node).OwnerElement : node.ParentNode;
445
if (nodeRegion == null || nodeRegion.NodeType !=
XmlNodeType
.Element)
479
if (node.NodeType ==
XmlNodeType
.Element)
System\Xml\DataPointer.cs (45)
297
else if (_node.NodeType ==
XmlNodeType
.Attribute)
320
if (_column == null && _node.NodeType ==
XmlNodeType
.Element)
347
if ((_column == null || _column.ColumnMapping == MappingType.Attribute) && _node.NodeType ==
XmlNodeType
.Element)
372
internal
XmlNodeType
NodeType
380
return
XmlNodeType
.None;
388
return
XmlNodeType
.Text;
392
return
XmlNodeType
.Attribute;
396
return
XmlNodeType
.Element;
502
private static bool IsLocalNameEmpty(
XmlNodeType
nt)
506
case
XmlNodeType
.None:
507
case
XmlNodeType
.Text:
508
case
XmlNodeType
.CDATA:
509
case
XmlNodeType
.Comment:
510
case
XmlNodeType
.Document:
511
case
XmlNodeType
.DocumentFragment:
512
case
XmlNodeType
.Whitespace:
513
case
XmlNodeType
.SignificantWhitespace:
514
case
XmlNodeType
.EndElement:
515
case
XmlNodeType
.EndEntity:
517
case
XmlNodeType
.Element:
518
case
XmlNodeType
.Attribute:
519
case
XmlNodeType
.EntityReference:
520
case
XmlNodeType
.Entity:
521
case
XmlNodeType
.ProcessingInstruction:
522
case
XmlNodeType
.DocumentType:
523
case
XmlNodeType
.Notation:
524
case
XmlNodeType
.XmlDeclaration:
609
if (_node.NodeType ==
XmlNodeType
.Element)
624
if (_node != null && _column == null && _node.NodeType ==
XmlNodeType
.Attribute)
700
XmlNodeType
nt = NodeType;
703
case
XmlNodeType
.DocumentType:
708
case
XmlNodeType
.Entity:
713
case
XmlNodeType
.Notation:
727
XmlNodeType
nt = NodeType;
730
case
XmlNodeType
.DocumentType:
735
case
XmlNodeType
.Entity:
740
case
XmlNodeType
.Notation:
754
if (NodeType ==
XmlNodeType
.DocumentType)
768
if (child != null && child.NodeType ==
XmlNodeType
.XmlDeclaration)
778
if (NodeType ==
XmlNodeType
.XmlDeclaration)
783
else if (NodeType ==
XmlNodeType
.Document)
799
if (NodeType ==
XmlNodeType
.XmlDeclaration)
804
else if (NodeType ==
XmlNodeType
.Document)
820
if (NodeType ==
XmlNodeType
.XmlDeclaration)
825
else if (NodeType ==
XmlNodeType
.Document)
System\Xml\DataSetMappper.cs (8)
138
if (n.NodeType ==
XmlNodeType
.Element)
169
if (node.NodeType ==
XmlNodeType
.Attribute && mt == MappingType.Attribute)
174
if (node.NodeType ==
XmlNodeType
.Element && mt == MappingType.Element)
224
if (node.NodeType ==
XmlNodeType
.Attribute)
279
if (fc == null || fc.NodeType !=
XmlNodeType
.Text || fc.NextSibling != null)
291
if (n.NodeType !=
XmlNodeType
.Element)
324
if (fc == null || fc.NodeType !=
XmlNodeType
.Text || fc.NextSibling != null)
334
if (n.NodeType !=
XmlNodeType
.Element)
System\Xml\RegionIterator.cs (4)
123
Debug.Assert(CurrentNode.NodeType ==
XmlNodeType
.Element);
126
if (CurrentNode.NodeType ==
XmlNodeType
.Element && DataSetMapper.GetTableSchemaForElement((XmlElement)(CurrentNode)) != null)
169
while (n.NodeType ==
XmlNodeType
.Whitespace)
190
if (n.NodeType !=
XmlNodeType
.Whitespace)
System\Xml\XmlBoundElement.cs (5)
267
Debug.Assert(dp.NodeType ==
XmlNodeType
.Element);
307
Debug.Assert(dp.NodeType ==
XmlNodeType
.Element);
351
case
XmlNodeType
.Attribute:
371
case
XmlNodeType
.Element:
375
case
XmlNodeType
.Text:
System\Xml\XmlDataDocument.cs (30)
764
if (node.NodeType !=
XmlNodeType
.Element)
997
if (newNode.NodeType ==
XmlNodeType
.Element)
1039
if (dp.NodeType ==
XmlNodeType
.Element)
1059
XmlNodeType
.DocumentFragment => CreateDocumentFragment(),
1060
XmlNodeType
.DocumentType => CreateDocumentType(dp.Name, dp.PublicId, dp.SystemId, dp.InternalSubset),
1061
XmlNodeType
.XmlDeclaration => CreateXmlDeclaration(dp.Version!, dp.Encoding, dp.Standalone),
1064
XmlNodeType
.Text => CreateTextNode(dp.Value),
1065
XmlNodeType
.CDATA => CreateCDataSection(dp.Value),
1066
XmlNodeType
.ProcessingInstruction => CreateProcessingInstruction(dp.Name, dp.Value!),
1067
XmlNodeType
.Comment => CreateComment(dp.Value),
1068
XmlNodeType
.Whitespace => CreateWhitespace(dp.Value),
1069
XmlNodeType
.SignificantWhitespace => CreateSignificantWhitespace(dp.Value),
1072
XmlNodeType
.Element => CreateElement(dp.Prefix, dp.LocalName, dp.NamespaceURI),
1073
XmlNodeType
.Attribute => CreateAttribute(dp.Prefix, dp.LocalName, dp.NamespaceURI),
1074
XmlNodeType
.EntityReference => CreateEntityReference(dp.Name),
1088
case
XmlNodeType
.Text:
1089
case
XmlNodeType
.CDATA:
1090
case
XmlNodeType
.Whitespace:
1091
case
XmlNodeType
.SignificantWhitespace:
1094
case
XmlNodeType
.EntityReference:
1103
internal static bool IsTextNode(
XmlNodeType
nt)
1107
case
XmlNodeType
.Text:
1108
case
XmlNodeType
.CDATA:
1109
case
XmlNodeType
.Whitespace:
1110
case
XmlNodeType
.SignificantWhitespace:
1515
if (iter.CurrentNode!.NodeType ==
XmlNodeType
.Element)
2275
Debug.Assert(parent.NodeType !=
XmlNodeType
.Attribute); // We need to get the grand-parent region
2330
while (n != null && n.NodeType ==
XmlNodeType
.Whitespace)
2335
if (n.NodeType ==
XmlNodeType
.Text)
2953
if (parent != null && parent.NodeType ==
XmlNodeType
.Attribute)
System\Xml\XPathNodePointer.cs (35)
58
case
XmlNodeType
.Whitespace:
60
case
XmlNodeType
.SignificantWhitespace:
63
case
XmlNodeType
.Text:
64
case
XmlNodeType
.CDATA:
91
private static bool IsNamespaceNode(
XmlNodeType
nt, string ns) => nt ==
XmlNodeType
.Attribute && ns == StrReservedXmlns;
134
if (_node.NodeType ==
XmlNodeType
.Element)
190
XmlNodeType
nt = _node.NodeType;
193
if (nt ==
XmlNodeType
.Element || nt ==
XmlNodeType
.Attribute || nt ==
XmlNodeType
.ProcessingInstruction)
219
XmlNodeType
nt = _node.NodeType;
227
if (nt ==
XmlNodeType
.Element || nt ==
XmlNodeType
.Attribute || nt ==
XmlNodeType
.ProcessingInstruction)
354
if (_node.NodeType ==
XmlNodeType
.Document)
423
if (curNode.NodeType ==
XmlNodeType
.Attribute)
521
if (_column == null && _node.NodeType ==
XmlNodeType
.Element)
592
if ((_column == null || _column.ColumnMapping == MappingType.Attribute) && _node.NodeType ==
XmlNodeType
.Element)
627
if (bFirst && (_column != null || _node.NodeType !=
XmlNodeType
.Element))
633
if (_column == null && _node.NodeType !=
XmlNodeType
.Attribute)
998
if (_node.NodeType ==
XmlNodeType
.Attribute)
1074
XmlNode? parent = ((curNode.NodeType ==
XmlNodeType
.Attribute) ? (((XmlAttribute)curNode).OwnerElement) : (curNode.ParentNode));
1183
curNode1 = ((curNode1.NodeType ==
XmlNodeType
.Attribute) ? (((XmlAttribute)curNode1).OwnerElement) : (curNode1.ParentNode));
1193
curNode2 = ((curNode2.NodeType ==
XmlNodeType
.Attribute) ? (((XmlAttribute)curNode2).OwnerElement) : (curNode2.ParentNode));
1370
XmlNodeType
nt;
1375
while (node != null && ((nt = node.NodeType) !=
XmlNodeType
.Element))
1377
if (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);
1603
else if (_node.NodeType ==
XmlNodeType
.Attribute)
1620
} while (node != null && node.NodeType !=
XmlNodeType
.Element);
1633
} while (node != null && node.NodeType ==
XmlNodeType
.Element);
System.IO.Packaging (23)
System\IO\Packaging\InternalRelationshipCollection.cs (5)
245
if (reader.NodeType ==
XmlNodeType
.Element
266
if (reader.NodeType ==
XmlNodeType
.None)
269
if (reader.NodeType ==
XmlNodeType
.Element
298
if (!((reader.LocalName == RelationshipsTagName) && (reader.NodeType ==
XmlNodeType
.EndElement)))
373
if (reader.NodeType ==
XmlNodeType
.EndElement && reader.LocalName == RelationshipTagName)
System\IO\Packaging\PackagingUtilities.cs (2)
34
if (reader.Read() && reader.NodeType ==
XmlNodeType
.XmlDeclaration && reader.Depth == 0)
86
Debug.Assert(reader.NodeType ==
XmlNodeType
.Element, "XmlReader should be positioned at an Element");
System\IO\Packaging\PartBasedPackageProperties.cs (6)
494
if (reader.MoveToContent() !=
XmlNodeType
.Element
515
while (reader.Read() && reader.MoveToContent() !=
XmlNodeType
.None)
518
if (reader.NodeType ==
XmlNodeType
.EndElement)
522
if (reader.NodeType !=
XmlNodeType
.Element)
642
if (reader.MoveToContent() ==
XmlNodeType
.EndElement)
646
if (reader.NodeType !=
XmlNodeType
.Text)
System\IO\Packaging\XmlCompatibilityReader.cs (3)
155
case
XmlNodeType
.Element:
164
case
XmlNodeType
.EndElement:
689
_inAttribute = (Reader.NodeType ==
XmlNodeType
.Attribute);
System\IO\Packaging\XmlWrappingReader.cs (1)
26
public override
XmlNodeType
NodeType { get { return _reader.NodeType; } }
System\IO\Packaging\ZipPackage.cs (6)
980
if ((reader.NodeType ==
XmlNodeType
.Element)
1001
if (reader.NodeType ==
XmlNodeType
.None)
1006
if (reader.NodeType ==
XmlNodeType
.Element
1013
else if (reader.NodeType ==
XmlNodeType
.Element
1020
else if (reader.NodeType ==
XmlNodeType
.EndElement && reader.Depth == 0 && reader.Name == TypesTagName)
1226
if (reader.NodeType ==
XmlNodeType
.EndElement && elementName == reader.LocalName)
System.Private.DataContractSerialization (203)
System\Runtime\Serialization\DataContractSerializer.cs (1)
487
throw XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.Format(SR.ExpectingElementAtDeserialize,
XmlNodeType
.Element), xmlReader);
System\Runtime\Serialization\ExtensionDataReader.cs (9)
35
private
XmlNodeType
_nodeType;
113
public override
XmlNodeType
NodeType { get { return IsXmlDataNode ? _xmlNodeReader.NodeType : _nodeType; } }
162
_nodeType =
XmlNodeType
.Attribute;
210
if (_nodeType !=
XmlNodeType
.Attribute)
219
_nodeType =
XmlNodeType
.Element;
289
if (_nodeType ==
XmlNodeType
.Attribute && MoveToNextAttribute())
304
_nodeType =
XmlNodeType
.Text;
313
_nodeType =
XmlNodeType
.EndElement;
326
_nodeType =
XmlNodeType
.None;
System\Runtime\Serialization\Json\DataContractJsonSerializer.cs (1)
458
throw XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.Format(SR.ExpectingElementAtDeserialize,
XmlNodeType
.Element), xmlReader);
System\Runtime\Serialization\Json\JsonFormatReaderGenerator.cs (7)
768
LocalBuilder nodeType = _ilg.DeclareLocal(typeof(
XmlNodeType
));
774
_ilg.Load(
XmlNodeType
.EndElement);
778
_ilg.Load(
XmlNodeType
.Element);
780
ThrowUnexpectedStateException(
XmlNodeType
.Element);
1034
ThrowUnexpectedStateException(
XmlNodeType
.Element);
1052
_ilg.Load(
XmlNodeType
.EndElement);
1056
private void ThrowUnexpectedStateException(
XmlNodeType
expectedState)
System\Runtime\Serialization\Json\ReflectionJsonFormatReader.cs (4)
189
XmlNodeType
nodeType = xmlReader.MoveToContent();
190
if (nodeType ==
XmlNodeType
.EndElement)
194
if (nodeType !=
XmlNodeType
.Element)
196
throw XmlObjectSerializerReadContext.CreateUnexpectedStateException(
XmlNodeType
.Element, xmlReader);
System\Runtime\Serialization\Json\XmlJsonReader.cs (4)
319
return (this.Node.NodeType ==
XmlNodeType
.Attribute || this.Node is XmlAttributeTextNode);
336
(this.Node.NodeType ==
XmlNodeType
.Text));
569
else if (this.Node.NodeType ==
XmlNodeType
.Element)
582
else if (this.Node.NodeType ==
XmlNodeType
.EndElement)
System\Runtime\Serialization\ReflectionReader.cs (2)
168
if (xmlReader.NodeType ==
XmlNodeType
.EndElement)
175
throw XmlObjectSerializerReadContext.CreateUnexpectedStateException(
XmlNodeType
.Element, xmlReader);
System\Runtime\Serialization\SchemaImporter.cs (1)
1417
if (child.NodeType ==
XmlNodeType
.Element)
System\Runtime\Serialization\XmlFormatGeneratorStatics.cs (1)
663
s_createUnexpectedStateExceptionMethod = typeof(XmlObjectSerializerReadContext).GetMethod("CreateUnexpectedStateException", Globals.ScanAllMembers, new Type[] { typeof(
XmlNodeType
), typeof(XmlReaderDelegator) });
System\Runtime\Serialization\XmlFormatReaderGenerator.cs (3)
954
ThrowUnexpectedStateException(
XmlNodeType
.Element);
972
_ilg.Load(
XmlNodeType
.EndElement);
976
private void ThrowUnexpectedStateException(
XmlNodeType
expectedState)
System\Runtime\Serialization\XmlObjectSerializerReadContext.cs (41)
216
return (xmlReader.MoveToContent() !=
XmlNodeType
.EndElement);
269
if (xmlReader.NodeType !=
XmlNodeType
.Element)
270
throw CreateUnexpectedStateException(
XmlNodeType
.Element, xmlReader);
482
if (xmlReader.NodeType ==
XmlNodeType
.EndElement)
490
if (xmlReader.NodeType !=
XmlNodeType
.EndElement)
491
throw CreateUnexpectedStateException(
XmlNodeType
.EndElement, xmlReader);
523
throw CreateUnexpectedStateException(
XmlNodeType
.Element, xmlReader);
548
XmlNodeType
nodeType;
549
while ((nodeType = xmlReader.MoveToContent()) !=
XmlNodeType
.EndElement)
551
if (nodeType !=
XmlNodeType
.Element)
553
throw CreateUnexpectedStateException(
XmlNodeType
.Element, xmlReader);
726
case
XmlNodeType
.Text:
728
case
XmlNodeType
.Element:
734
case
XmlNodeType
.EndElement:
743
throw CreateUnexpectedStateException(
XmlNodeType
.Element, xmlReader);
792
XmlNodeType
nodeType;
793
while ((nodeType = xmlReader.MoveToContent()) !=
XmlNodeType
.EndElement)
795
if (nodeType !=
XmlNodeType
.Element)
796
throw CreateUnexpectedStateException(
XmlNodeType
.Element, xmlReader);
815
XmlNodeType
nodeType;
816
while ((nodeType = xmlReader.MoveToContent()) !=
XmlNodeType
.EndElement)
818
if (nodeType !=
XmlNodeType
.Element)
819
throw CreateUnexpectedStateException(
XmlNodeType
.Element, xmlReader);
874
XmlNodeType
nodeType;
875
while ((nodeType = xmlReader.MoveToContent()) !=
XmlNodeType
.EndElement)
877
if (nodeType !=
XmlNodeType
.Element)
878
throw CreateUnexpectedStateException(
XmlNodeType
.Element, xmlReader);
903
if (xmlReader.NodeType ==
XmlNodeType
.EndElement)
909
XmlNodeType
nodeType = xmlReader.MoveToContent();
910
if (nodeType !=
XmlNodeType
.Text)
924
while (xmlReader.MoveToContent() !=
XmlNodeType
.EndElement)
963
XmlNodeType
nodeType;
964
while ((nodeType = xmlReader.NodeType) !=
XmlNodeType
.EndElement)
966
if (nodeType ==
XmlNodeType
.Element)
1025
private static bool IsContentNode(
XmlNodeType
nodeType)
1029
case
XmlNodeType
.Whitespace:
1030
case
XmlNodeType
.SignificantWhitespace:
1031
case
XmlNodeType
.Comment:
1032
case
XmlNodeType
.ProcessingInstruction:
1033
case
XmlNodeType
.DocumentType:
1080
internal static Exception CreateUnexpectedStateException(
XmlNodeType
expectedState, XmlReaderDelegator xmlReader)
System\Runtime\Serialization\XmlReaderDelegator.cs (4)
167
internal
XmlNodeType
NodeType
169
get { return isEndOfEmptyElement ?
XmlNodeType
.EndElement : reader.NodeType; }
188
internal
XmlNodeType
MoveToContent()
191
return
XmlNodeType
.EndElement;
System\Runtime\Serialization\XmlSerializableReader.cs (7)
27
if (xmlReader.NodeType !=
XmlNodeType
.Element)
28
throw XmlObjectSerializerReadContext.CreateUnexpectedStateException(
XmlNodeType
.Element, xmlReader);
46
throw XmlObjectSerializerReadContext.CreateUnexpectedStateException(
XmlNodeType
.EndElement, _xmlReader);
56
if (reader.NodeType ==
XmlNodeType
.EndElement ||
57
(reader.NodeType ==
XmlNodeType
.Element && reader.IsEmptyElement))
71
public override
XmlNodeType
NodeType { get { return InnerReader.NodeType; } }
114
public override
XmlNodeType
MoveToContent() { return InnerReader.MoveToContent(); }
System\Runtime\Serialization\XmlSerializableServices.cs (1)
36
while (xmlReader.Depth > startDepth && xmlReader.NodeType !=
XmlNodeType
.EndElement)
System\Xml\ArrayHelper.cs (1)
44
if (read < array.Length || reader.NodeType ==
XmlNodeType
.EndElement)
System\Xml\XmlBaseReader.cs (57)
221
_whitespaceTextNode.NodeType =
XmlNodeType
.SignificantWhitespace;
223
_whitespaceTextNode.NodeType =
XmlNodeType
.Whitespace;
820
public override
XmlNodeType
MoveToContent()
826
if (_node.NodeType !=
XmlNodeType
.Text && _node.NodeType !=
XmlNodeType
.CDATA)
847
if (_node.NodeType ==
XmlNodeType
.Attribute)
921
public sealed override
XmlNodeType
NodeType
993
XmlNodeType
nodeType = _node.NodeType;
994
if (nodeType ==
XmlNodeType
.Element)
996
if (nodeType ==
XmlNodeType
.EndElement)
998
if (nodeType ==
XmlNodeType
.None)
1001
if (_node.NodeType ==
XmlNodeType
.Element)
1004
return (MoveToContent() ==
XmlNodeType
.Element);
1024
return (_node.NodeType ==
XmlNodeType
.Element || IsStartElement()) && _node.Prefix == prefix && _node.LocalName == localName;
1033
return (_node.NodeType ==
XmlNodeType
.Element || IsStartElement()) && _node.LocalName == localName && _node.IsNamespaceUri(namespaceUri);
1041
return (_node.NodeType ==
XmlNodeType
.Element || IsStartElement()) && _node.LocalName == localName && _node.IsNamespaceUri(namespaceUri);
1183
if (_node.NodeType !=
XmlNodeType
.Element)
1231
if (_node.NodeType !=
XmlNodeType
.Element)
1250
if (_node.NodeType !=
XmlNodeType
.EndElement && MoveToContent() !=
XmlNodeType
.EndElement)
1252
int nodeDepth = _node.NodeType ==
XmlNodeType
.Element ? _depth - 1 : _depth;
1359
while (_node.NodeType !=
XmlNodeType
.Comment && _node.Value.TryReadBase64(buffer, offset, count, out actual))
1367
XmlNodeType
nodeType = _node.NodeType;
1368
if (nodeType ==
XmlNodeType
.Element || nodeType ==
XmlNodeType
.EndElement)
1431
XmlNodeType
nodeType = _node.NodeType;
1432
if (nodeType ==
XmlNodeType
.Element || nodeType ==
XmlNodeType
.EndElement)
1726
if ((_node.NodeType ==
XmlNodeType
.Element || MoveToElement()) && !IsEmptyElement)
1734
if (_node.NodeType ==
XmlNodeType
.EndElement)
1952
case
XmlNodeType
.None:
1954
case
XmlNodeType
.Element:
1960
case
XmlNodeType
.Text:
1961
case
XmlNodeType
.Whitespace:
1962
case
XmlNodeType
.SignificantWhitespace:
1963
case
XmlNodeType
.CDATA:
1966
case
XmlNodeType
.XmlDeclaration:
1969
case
XmlNodeType
.Comment:
1972
case
XmlNodeType
.EndElement:
2036
private
XmlNodeType
_nodeType;
2066
protected XmlNode(
XmlNodeType
nodeType,
2088
_exitScope = (nodeType ==
XmlNodeType
.EndElement);
2114
public
XmlNodeType
NodeType
2360
: base(
XmlNodeType
.Element,
2404
: base(
XmlNodeType
.Attribute,
2419
: base(
XmlNodeType
.EndElement,
2433
protected 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,
System\Xml\XmlBinaryReader.cs (12)
91
if (this.Node.NodeType !=
XmlNodeType
.Element)
119
if (this.Node.NodeType !=
XmlNodeType
.Element)
150
if (this.Node.NodeType !=
XmlNodeType
.Element)
196
if (this.Node.NodeType !=
XmlNodeType
.Element)
210
if (this.Node.NodeType !=
XmlNodeType
.Element)
224
if (this.Node.NodeType !=
XmlNodeType
.Element)
238
if (this.Node.NodeType !=
XmlNodeType
.Element)
252
if (this.Node.NodeType !=
XmlNodeType
.Element)
266
if (this.Node.NodeType !=
XmlNodeType
.Element)
280
if (this.Node.NodeType !=
XmlNodeType
.Element)
1123
if (this.Node.NodeType !=
XmlNodeType
.Element)
1128
if (this.Node.NodeType !=
XmlNodeType
.EndElement)
System\Xml\XmlDictionaryReader.cs (25)
395
case
XmlNodeType
.Attribute:
398
case
XmlNodeType
.Text:
399
case
XmlNodeType
.Whitespace:
400
case
XmlNodeType
.SignificantWhitespace:
401
case
XmlNodeType
.CDATA:
416
case
XmlNodeType
.ProcessingInstruction:
417
case
XmlNodeType
.Comment:
418
case
XmlNodeType
.EndEntity:
421
case
XmlNodeType
.EntityReference:
428
case
XmlNodeType
.Element:
429
case
XmlNodeType
.EndElement:
457
if (this.NodeType !=
XmlNodeType
.Element)
459
if (this.NodeType ==
XmlNodeType
.Element)
465
if (this.NodeType ==
XmlNodeType
.EndElement)
546
protected bool IsTextNode(
XmlNodeType
nodeType)
548
return nodeType ==
XmlNodeType
.Text ||
549
nodeType ==
XmlNodeType
.Whitespace ||
550
nodeType ==
XmlNodeType
.SignificantWhitespace ||
551
nodeType ==
XmlNodeType
.CDATA ||
552
nodeType ==
XmlNodeType
.Attribute;
560
XmlNodeType
nodeType = this.NodeType;
562
if (nodeType ==
XmlNodeType
.Element || nodeType ==
XmlNodeType
.EndElement)
572
if (nodeType ==
XmlNodeType
.Attribute /* || inAttributeText */)
1487
public override
XmlNodeType
NodeType
System\Xml\XmlDictionaryWriter.cs (15)
269
if (reader.NodeType ==
XmlNodeType
.EntityReference)
387
int d = (reader.NodeType ==
XmlNodeType
.None ? -1 : reader.Depth);
390
XmlNodeType
nodeType = reader.NodeType;
392
if (nodeType ==
XmlNodeType
.Text || nodeType ==
XmlNodeType
.Whitespace || nodeType ==
XmlNodeType
.SignificantWhitespace)
406
case
XmlNodeType
.Element:
409
case
XmlNodeType
.CDATA:
412
case
XmlNodeType
.EntityReference:
415
case
XmlNodeType
.XmlDeclaration:
416
case
XmlNodeType
.ProcessingInstruction:
419
case
XmlNodeType
.DocumentType:
422
case
XmlNodeType
.Comment:
425
case
XmlNodeType
.EndElement:
433
while (d < reader.Depth || (d == reader.Depth && reader.NodeType ==
XmlNodeType
.EndElement));
System\Xml\XmlExceptionHelper.cs (7)
67
case
XmlNodeType
.Element:
69
case
XmlNodeType
.EndElement:
71
case
XmlNodeType
.Text:
72
case
XmlNodeType
.Whitespace:
73
case
XmlNodeType
.SignificantWhitespace:
75
case
XmlNodeType
.Comment:
77
case
XmlNodeType
.CDATA:
System.Private.Xml (1922)
System\Xml\BinaryXml\XmlBinaryReader.cs (64)
275
private
XmlNodeType
_nodetype;
283
private
XmlNodeType
_parentNodeType; // use for MoveToElement()
338
_nodetype =
XmlNodeType
.None;
419
public override
XmlNodeType
NodeType
476
case
XmlNodeType
.DocumentType:
477
case
XmlNodeType
.ProcessingInstruction:
478
case
XmlNodeType
.Comment:
481
case
XmlNodeType
.CDATA:
484
case
XmlNodeType
.XmlDeclaration:
487
case
XmlNodeType
.Text:
488
case
XmlNodeType
.Whitespace:
489
case
XmlNodeType
.SignificantWhitespace:
519
if (_nodetype ==
XmlNodeType
.Element
520
|| _nodetype ==
XmlNodeType
.EndElement)
530
if (_parentNodeType !=
XmlNodeType
.Element)
535
if (_parentNodeType !=
XmlNodeType
.Element)
802
if (
XmlNodeType
.Element == _parentNodeType)
804
else if (
XmlNodeType
.XmlDeclaration == _parentNodeType)
806
else if (
XmlNodeType
.DocumentType == _parentNodeType)
859
_nodetype =
XmlNodeType
.Text;
877
_nodetype =
XmlNodeType
.None;
951
_nodetype =
XmlNodeType
.None;
997
if (this.NodeType ==
XmlNodeType
.EndElement)
999
if (this.NodeType ==
XmlNodeType
.ProcessingInstruction || this.NodeType ==
XmlNodeType
.Comment)
1001
while (Read() && (this.NodeType ==
XmlNodeType
.ProcessingInstruction || this.NodeType ==
XmlNodeType
.Comment))
1003
if (this.NodeType ==
XmlNodeType
.EndElement)
1032
if (this.NodeType !=
XmlNodeType
.Element && this.NodeType !=
XmlNodeType
.EndElement)
1040
case
XmlNodeType
.ProcessingInstruction:
1041
case
XmlNodeType
.Comment:
1044
case
XmlNodeType
.Element:
1045
case
XmlNodeType
.EndElement:
1728
if (this.NodeType ==
XmlNodeType
.Element || this.NodeType ==
XmlNodeType
.EndElement)
1767
if (this.NodeType ==
XmlNodeType
.Element || this.NodeType ==
XmlNodeType
.EndElement)
2403
_nodetype =
XmlNodeType
.Attribute;
2570
_nodetype =
XmlNodeType
.XmlDeclaration;
2805
case
XmlNodeType
.CDATA:
2808
case
XmlNodeType
.EndElement:
2811
case
XmlNodeType
.Element:
2822
_nodetype =
XmlNodeType
.None;
2935
if (
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)
3333
private
XmlNodeType
ScanOverValue(BinXmlToken token, bool attr, bool checkChars)
3356
return
XmlNodeType
.Text;
3365
private
XmlNodeType
ScanOverAnyValue(BinXmlToken token, bool attr, bool checkChars)
3480
return
XmlNodeType
.Text;
3483
private
XmlNodeType
CheckText(bool attr)
3499
return _xmlspacePreserve ?
XmlNodeType
.SignificantWhitespace :
XmlNodeType
.Whitespace;
3512
return
XmlNodeType
.Text;
3538
private
XmlNodeType
CheckTextIsWS()
3560
return
XmlNodeType
.SignificantWhitespace;
3561
return
XmlNodeType
.Whitespace;
3563
return
XmlNodeType
.Text;
System\Xml\Core\ReadContentAsBinaryHelper.cs (15)
159
if (_reader.NodeType !=
XmlNodeType
.Element)
202
if (_reader.NodeType !=
XmlNodeType
.Element)
242
if (_reader.NodeType !=
XmlNodeType
.EndElement)
276
Debug.Assert(_reader.NodeType ==
XmlNodeType
.Element);
289
if (_reader.NodeType !=
XmlNodeType
.EndElement)
401
if (_reader.NodeType !=
XmlNodeType
.EndElement)
418
case
XmlNodeType
.Attribute:
420
case
XmlNodeType
.Text:
421
case
XmlNodeType
.Whitespace:
422
case
XmlNodeType
.SignificantWhitespace:
423
case
XmlNodeType
.CDATA:
429
case
XmlNodeType
.ProcessingInstruction:
430
case
XmlNodeType
.Comment:
431
case
XmlNodeType
.EndEntity:
434
case
XmlNodeType
.EntityReference:
System\Xml\Core\ReadContentAsBinaryHelperAsync.cs (15)
112
if (_reader.NodeType !=
XmlNodeType
.Element)
156
if (_reader.NodeType !=
XmlNodeType
.Element)
197
if (_reader.NodeType !=
XmlNodeType
.EndElement)
224
Debug.Assert(_reader.NodeType ==
XmlNodeType
.Element);
237
if (_reader.NodeType !=
XmlNodeType
.EndElement)
323
if (_reader.NodeType !=
XmlNodeType
.EndElement)
340
case
XmlNodeType
.Attribute:
342
case
XmlNodeType
.Text:
343
case
XmlNodeType
.Whitespace:
344
case
XmlNodeType
.SignificantWhitespace:
345
case
XmlNodeType
.CDATA:
351
case
XmlNodeType
.ProcessingInstruction:
352
case
XmlNodeType
.Comment:
353
case
XmlNodeType
.EndEntity:
356
case
XmlNodeType
.EntityReference:
System\Xml\Core\ValidatingReaderNodeData.cs (5)
26
private
XmlNodeType
_nodeType;
33
Clear(
XmlNodeType
.None);
36
public ValidatingReaderNodeData(
XmlNodeType
nodeType)
130
public
XmlNodeType
NodeType
174
internal void Clear(
XmlNodeType
nodeType)
System\Xml\Core\XmlAsyncCheckReader.cs (3)
82
public override
XmlNodeType
NodeType
619
public override
XmlNodeType
MoveToContent()
891
public override Task<
XmlNodeType
> MoveToContentAsync()
System\Xml\Core\XmlCharCheckingReader.cs (17)
41
private
XmlNodeType
_lastNodeType;
61
_lastNodeType =
XmlNodeType
.None;
192
XmlNodeType
nodeType = base.reader.NodeType;
198
case
XmlNodeType
.Comment:
204
case
XmlNodeType
.Whitespace:
210
case
XmlNodeType
.ProcessingInstruction:
216
case
XmlNodeType
.DocumentType:
233
case
XmlNodeType
.Element:
253
case
XmlNodeType
.Text:
254
case
XmlNodeType
.CDATA:
261
case
XmlNodeType
.EntityReference:
269
case
XmlNodeType
.ProcessingInstruction:
281
case
XmlNodeType
.Comment:
292
case
XmlNodeType
.DocumentType:
325
case
XmlNodeType
.Whitespace:
336
case
XmlNodeType
.SignificantWhitespace:
343
case
XmlNodeType
.EndElement:
System\Xml\Core\XmlCharCheckingReaderAsync.cs (15)
54
XmlNodeType
nodeType = base.reader.NodeType;
60
case
XmlNodeType
.Comment:
66
case
XmlNodeType
.Whitespace:
72
case
XmlNodeType
.ProcessingInstruction:
78
case
XmlNodeType
.DocumentType:
95
case
XmlNodeType
.Element:
115
case
XmlNodeType
.Text:
116
case
XmlNodeType
.CDATA:
123
case
XmlNodeType
.EntityReference:
131
case
XmlNodeType
.ProcessingInstruction:
143
case
XmlNodeType
.Comment:
154
case
XmlNodeType
.DocumentType:
186
case
XmlNodeType
.Whitespace:
197
case
XmlNodeType
.SignificantWhitespace:
204
case
XmlNodeType
.EndElement:
System\Xml\Core\XmlReader.cs (151)
93
public abstract
XmlNodeType
NodeType { get; }
693
if (NodeType ==
XmlNodeType
.Element)
704
if (NodeType ==
XmlNodeType
.EndElement)
724
public virtual
XmlNodeType
MoveToContent()
730
case
XmlNodeType
.Attribute:
733
case
XmlNodeType
.Element:
734
case
XmlNodeType
.EndElement:
735
case
XmlNodeType
.CDATA:
736
case
XmlNodeType
.Text:
737
case
XmlNodeType
.EntityReference:
738
case
XmlNodeType
.EndEntity:
748
if (MoveToContent() !=
XmlNodeType
.Element)
758
if (MoveToContent() !=
XmlNodeType
.Element)
776
if (MoveToContent() !=
XmlNodeType
.Element)
796
if (MoveToContent() !=
XmlNodeType
.Element)
804
if (NodeType !=
XmlNodeType
.EndElement)
823
if (MoveToContent() !=
XmlNodeType
.Element)
836
if (NodeType !=
XmlNodeType
.EndElement)
855
if (MoveToContent() !=
XmlNodeType
.Element)
868
if (NodeType !=
XmlNodeType
.EndElement)
885
if (MoveToContent() !=
XmlNodeType
.EndElement)
895
return MoveToContent() ==
XmlNodeType
.Element;
902
return MoveToContent() ==
XmlNodeType
.Element && Name == name;
909
return MoveToContent() ==
XmlNodeType
.Element && LocalName == localname && NamespaceURI == ns;
923
if (NodeType ==
XmlNodeType
.Element && Ref.Equal(name, Name))
944
if (NodeType ==
XmlNodeType
.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI))
959
if (NodeType !=
XmlNodeType
.Element)
983
if (NodeType ==
XmlNodeType
.Element && Ref.Equal(name, Name))
988
Debug.Assert(NodeType ==
XmlNodeType
.EndElement || NodeType ==
XmlNodeType
.None || ReadState == ReadState.Error);
1000
if (NodeType !=
XmlNodeType
.Element)
1025
if (NodeType ==
XmlNodeType
.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI))
1030
Debug.Assert(NodeType ==
XmlNodeType
.EndElement);
1043
XmlNodeType
nt;
1051
if (nt ==
XmlNodeType
.Element && Ref.Equal(name, Name))
1055
} while (nt !=
XmlNodeType
.EndElement && !EOF);
1070
XmlNodeType
nt;
1078
if (nt ==
XmlNodeType
.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI))
1082
} while (nt !=
XmlNodeType
.EndElement && !EOF);
1110
if (NodeType !=
XmlNodeType
.Attribute && NodeType !=
XmlNodeType
.Element)
1121
if (NodeType ==
XmlNodeType
.Attribute)
1127
if (NodeType ==
XmlNodeType
.Element)
1139
int d = NodeType ==
XmlNodeType
.None ? -1 : Depth;
1144
case
XmlNodeType
.Element:
1153
case
XmlNodeType
.Text:
1156
case
XmlNodeType
.Whitespace:
1157
case
XmlNodeType
.SignificantWhitespace:
1160
case
XmlNodeType
.CDATA:
1163
case
XmlNodeType
.EntityReference:
1166
case
XmlNodeType
.XmlDeclaration:
1167
case
XmlNodeType
.ProcessingInstruction:
1170
case
XmlNodeType
.DocumentType:
1173
case
XmlNodeType
.Comment:
1176
case
XmlNodeType
.EndElement:
1181
if (d == Depth && NodeType ==
XmlNodeType
.EndElement)
1193
if (NodeType ==
XmlNodeType
.EntityReference)
1213
if (NodeType !=
XmlNodeType
.Attribute && NodeType !=
XmlNodeType
.Element)
1224
if (NodeType ==
XmlNodeType
.Attribute)
1269
if (NodeType !=
XmlNodeType
.Element)
1301
internal static bool IsTextualNode(
XmlNodeType
nodeType)
1306
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.None)));
1307
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.Element)));
1308
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.Attribute)));
1309
Debug.Assert(0 != (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.Text)));
1310
Debug.Assert(0 != (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.CDATA)));
1311
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.EntityReference)));
1312
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.Entity)));
1313
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.ProcessingInstruction)));
1314
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.Comment)));
1315
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.Document)));
1316
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.DocumentType)));
1317
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.DocumentFragment)));
1318
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.Notation)));
1319
Debug.Assert(0 != (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.Whitespace)));
1320
Debug.Assert(0 != (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.SignificantWhitespace)));
1321
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.EndElement)));
1322
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.EndEntity)));
1323
Debug.Assert(0 == (IsTextualNodeBitmap & (1 << (int)
XmlNodeType
.XmlDeclaration)));
1328
internal static bool CanReadContentAs(
XmlNodeType
nodeType)
1333
Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.None)));
1334
Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.Element)));
1335
Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.Attribute)));
1336
Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.Text)));
1337
Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.CDATA)));
1338
Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.EntityReference)));
1339
Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.Entity)));
1340
Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.ProcessingInstruction)));
1341
Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.Comment)));
1342
Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.Document)));
1343
Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.DocumentType)));
1344
Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.DocumentFragment)));
1345
Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.Notation)));
1346
Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.Whitespace)));
1347
Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.SignificantWhitespace)));
1348
Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.EndElement)));
1349
Debug.Assert(0 != (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.EndEntity)));
1350
Debug.Assert(0 == (CanReadContentAsBitmap & (1 << (int)
XmlNodeType
.XmlDeclaration)));
1355
internal static bool HasValueInternal(
XmlNodeType
nodeType)
1360
Debug.Assert(0 == (HasValueBitmap & (1 << (int)
XmlNodeType
.None)));
1361
Debug.Assert(0 == (HasValueBitmap & (1 << (int)
XmlNodeType
.Element)));
1362
Debug.Assert(0 != (HasValueBitmap & (1 << (int)
XmlNodeType
.Attribute)));
1363
Debug.Assert(0 != (HasValueBitmap & (1 << (int)
XmlNodeType
.Text)));
1364
Debug.Assert(0 != (HasValueBitmap & (1 << (int)
XmlNodeType
.CDATA)));
1365
Debug.Assert(0 == (HasValueBitmap & (1 << (int)
XmlNodeType
.EntityReference)));
1366
Debug.Assert(0 == (HasValueBitmap & (1 << (int)
XmlNodeType
.Entity)));
1367
Debug.Assert(0 != (HasValueBitmap & (1 << (int)
XmlNodeType
.ProcessingInstruction)));
1368
Debug.Assert(0 != (HasValueBitmap & (1 << (int)
XmlNodeType
.Comment)));
1369
Debug.Assert(0 == (HasValueBitmap & (1 << (int)
XmlNodeType
.Document)));
1370
Debug.Assert(0 != (HasValueBitmap & (1 << (int)
XmlNodeType
.DocumentType)));
1371
Debug.Assert(0 == (HasValueBitmap & (1 << (int)
XmlNodeType
.DocumentFragment)));
1372
Debug.Assert(0 == (HasValueBitmap & (1 << (int)
XmlNodeType
.Notation)));
1373
Debug.Assert(0 != (HasValueBitmap & (1 << (int)
XmlNodeType
.Whitespace)));
1374
Debug.Assert(0 != (HasValueBitmap & (1 << (int)
XmlNodeType
.SignificantWhitespace)));
1375
Debug.Assert(0 == (HasValueBitmap & (1 << (int)
XmlNodeType
.EndElement)));
1376
Debug.Assert(0 == (HasValueBitmap & (1 << (int)
XmlNodeType
.EndEntity)));
1377
Debug.Assert(0 != (HasValueBitmap & (1 << (int)
XmlNodeType
.XmlDeclaration)));
1389
if (NodeType ==
XmlNodeType
.Element && !IsEmptyElement)
1399
if (NodeType ==
XmlNodeType
.EndElement)
1415
if (NodeType !=
XmlNodeType
.Element)
1441
internal static Exception CreateReadContentAsException(string methodName,
XmlNodeType
nodeType, IXmlLineInfo? lineInfo)
1446
internal static Exception CreateReadElementContentAsException(string methodName,
XmlNodeType
nodeType, IXmlLineInfo? lineInfo)
1473
case
XmlNodeType
.Attribute:
1475
case
XmlNodeType
.Text:
1476
case
XmlNodeType
.Whitespace:
1477
case
XmlNodeType
.SignificantWhitespace:
1478
case
XmlNodeType
.CDATA:
1490
case
XmlNodeType
.ProcessingInstruction:
1491
case
XmlNodeType
.Comment:
1492
case
XmlNodeType
.EndEntity:
1495
case
XmlNodeType
.EntityReference:
1513
if (NodeType !=
XmlNodeType
.Element)
1528
XmlNodeType
nodeType = NodeType;
1530
if (nodeType ==
XmlNodeType
.EndElement)
1537
if (nodeType ==
XmlNodeType
.Element)
1547
if (NodeType !=
XmlNodeType
.EndElement)
1779
XmlNodeType
nt = _reader.NodeType;
1783
case
XmlNodeType
.Element:
1784
case
XmlNodeType
.EndElement:
1785
case
XmlNodeType
.EntityReference:
1786
case
XmlNodeType
.EndEntity:
1789
case
XmlNodeType
.Attribute:
1790
case
XmlNodeType
.ProcessingInstruction:
1793
case
XmlNodeType
.Text:
1794
case
XmlNodeType
.Whitespace:
1795
case
XmlNodeType
.SignificantWhitespace:
1796
case
XmlNodeType
.Comment:
1797
case
XmlNodeType
.XmlDeclaration:
1798
case
XmlNodeType
.CDATA:
1801
case
XmlNodeType
.DocumentType:
System\Xml\Core\XmlReaderAsync.cs (44)
157
public virtual async Task<
XmlNodeType
> MoveToContentAsync()
163
case
XmlNodeType
.Attribute:
166
case
XmlNodeType
.Element:
167
case
XmlNodeType
.EndElement:
168
case
XmlNodeType
.CDATA:
169
case
XmlNodeType
.Text:
170
case
XmlNodeType
.EntityReference:
171
case
XmlNodeType
.EndEntity:
185
if (NodeType !=
XmlNodeType
.Attribute && NodeType !=
XmlNodeType
.Element)
195
if (NodeType ==
XmlNodeType
.Attribute)
201
if (NodeType ==
XmlNodeType
.Element)
213
int d = NodeType ==
XmlNodeType
.None ? -1 : Depth;
218
case
XmlNodeType
.Element:
227
case
XmlNodeType
.Text:
230
case
XmlNodeType
.Whitespace:
231
case
XmlNodeType
.SignificantWhitespace:
234
case
XmlNodeType
.CDATA:
237
case
XmlNodeType
.EntityReference:
240
case
XmlNodeType
.XmlDeclaration:
241
case
XmlNodeType
.ProcessingInstruction:
244
case
XmlNodeType
.DocumentType:
247
case
XmlNodeType
.Comment:
250
case
XmlNodeType
.EndElement:
255
if (d == Depth && NodeType ==
XmlNodeType
.EndElement)
268
if (NodeType !=
XmlNodeType
.Attribute && NodeType !=
XmlNodeType
.Element)
278
if (NodeType ==
XmlNodeType
.Attribute)
300
if (NodeType ==
XmlNodeType
.Element && !IsEmptyElement)
310
if (NodeType ==
XmlNodeType
.EndElement)
329
case
XmlNodeType
.Attribute:
331
case
XmlNodeType
.Text:
332
case
XmlNodeType
.Whitespace:
333
case
XmlNodeType
.SignificantWhitespace:
334
case
XmlNodeType
.CDATA:
346
case
XmlNodeType
.ProcessingInstruction:
347
case
XmlNodeType
.Comment:
348
case
XmlNodeType
.EndEntity:
351
case
XmlNodeType
.EntityReference:
369
if (NodeType !=
XmlNodeType
.Element)
384
XmlNodeType
nodeType = NodeType;
385
if (nodeType ==
XmlNodeType
.EndElement)
391
if (nodeType ==
XmlNodeType
.Element)
400
if (NodeType !=
XmlNodeType
.EndElement)
System\Xml\Core\XmlSubtreeReader.cs (43)
20
internal
XmlNodeType
type;
27
internal NodeData(
XmlNodeType
nodeType, string localName, string prefix, string name, string namespaceUri, string value)
37
internal 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);
115
public override
XmlNodeType
NodeType
170
if (_curNode.type ==
XmlNodeType
.Text)
432
Debug.Assert(reader.NodeType ==
XmlNodeType
.Element);
451
else if (_curNode.type ==
XmlNodeType
.Text)
457
Debug.Assert(_curNode.type ==
XmlNodeType
.Attribute);
458
_tmpNode.type =
XmlNodeType
.Text;
482
if (reader.NodeType ==
XmlNodeType
.EndElement ||
483
(reader.NodeType ==
XmlNodeType
.Element && reader.IsEmptyElement))
489
Debug.Assert(reader.NodeType ==
XmlNodeType
.Element && !reader.IsEmptyElement);
552
if (reader.Depth == _initialDepth && reader.NodeType ==
XmlNodeType
.Element && !reader.IsEmptyElement)
590
if (reader.NodeType ==
XmlNodeType
.Element && !reader.IsEmptyElement)
595
while (reader.NodeType !=
XmlNodeType
.EndElement && reader.Depth > _initialDepth)
601
Debug.Assert(reader.NodeType ==
XmlNodeType
.EndElement ||
602
reader.NodeType ==
XmlNodeType
.Element && reader.IsEmptyElement ||
609
if (reader.NodeType ==
XmlNodeType
.Element && !reader.IsEmptyElement)
839
case
XmlNodeType
.Element:
841
case
XmlNodeType
.EndElement:
843
case
XmlNodeType
.Attribute:
873
goto case
XmlNodeType
.Text;
874
case
XmlNodeType
.Text:
931
if (NodeType !=
XmlNodeType
.EndElement)
977
case
XmlNodeType
.Element:
979
case
XmlNodeType
.EndElement:
981
case
XmlNodeType
.Attribute:
1011
goto case
XmlNodeType
.Text;
1012
case
XmlNodeType
.Text:
1068
if (NodeType !=
XmlNodeType
.EndElement)
1248
case
XmlNodeType
.Element:
1292
case
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);
1375
if (NodeType !=
XmlNodeType
.Element)
1390
case
XmlNodeType
.Element:
1392
case
XmlNodeType
.EndElement:
1418
if (NodeType !=
XmlNodeType
.EndElement)
1510
_tmpNode.type =
XmlNodeType
.None;
1566
case
XmlNodeType
.Element:
1570
case
XmlNodeType
.EndElement:
1574
case
XmlNodeType
.Attribute:
System\Xml\Core\XmlSubtreeReaderAsync.cs (24)
45
if (reader.NodeType ==
XmlNodeType
.EndElement ||
46
(reader.NodeType ==
XmlNodeType
.Element && reader.IsEmptyElement))
52
Debug.Assert(reader.NodeType ==
XmlNodeType
.Element && !reader.IsEmptyElement);
116
if (reader.NodeType ==
XmlNodeType
.Element && !reader.IsEmptyElement)
121
while (reader.NodeType !=
XmlNodeType
.EndElement && reader.Depth > _initialDepth)
127
Debug.Assert(reader.NodeType ==
XmlNodeType
.EndElement ||
128
reader.NodeType ==
XmlNodeType
.Element && reader.IsEmptyElement ||
135
if (reader.NodeType ==
XmlNodeType
.Element && !reader.IsEmptyElement)
245
case
XmlNodeType
.Element:
247
case
XmlNodeType
.EndElement:
249
case
XmlNodeType
.Attribute:
279
goto case
XmlNodeType
.Text;
280
case
XmlNodeType
.Text:
337
if (NodeType !=
XmlNodeType
.EndElement)
383
case
XmlNodeType
.Element:
385
case
XmlNodeType
.EndElement:
387
case
XmlNodeType
.Attribute:
417
goto case
XmlNodeType
.Text;
418
case
XmlNodeType
.Text:
474
if (NodeType !=
XmlNodeType
.EndElement)
559
if (NodeType !=
XmlNodeType
.Element)
574
case
XmlNodeType
.Element:
576
case
XmlNodeType
.EndElement:
602
if (NodeType !=
XmlNodeType
.EndElement)
System\Xml\Core\XmlTextReader.cs (3)
86
public XmlTextReader(Stream xmlFragment,
XmlNodeType
fragType, XmlParserContext? context)
92
public XmlTextReader([StringSyntax(StringSyntaxAttribute.Xml)] string xmlFragment,
XmlNodeType
fragType, XmlParserContext? context)
112
public override
XmlNodeType
NodeType
System\Xml\Core\XmlTextReaderImpl.cs (142)
220
private
XmlNodeType
_fragmentType =
XmlNodeType
.Document;
431
_fragmentType =
XmlNodeType
.None;
435
_fragmentType =
XmlNodeType
.Element;
439
_fragmentType =
XmlNodeType
.Document;
505
internal XmlTextReaderImpl(Stream xmlFragment,
XmlNodeType
fragType, XmlParserContext? context)
528
internal XmlTextReaderImpl(string xmlFragment,
XmlNodeType
fragType, XmlParserContext? context)
556
InitFragmentReader(
XmlNodeType
.XmlDeclaration, context, true);
835
case
XmlNodeType
.None: settings.ConformanceLevel = ConformanceLevel.Auto; break;
836
case
XmlNodeType
.Element: settings.ConformanceLevel = ConformanceLevel.Fragment; break;
837
case
XmlNodeType
.Document: settings.ConformanceLevel = ConformanceLevel.Document; break;
838
default: Debug.Fail($"Unexpected fragment type {_fragmentType}"); goto case
XmlNodeType
.None;
857
public override
XmlNodeType
NodeType
964
return _curNode.type ==
XmlNodeType
.Attribute ? _curNode.quoteChar : '"';
1182
else if (_curNode.type !=
XmlNodeType
.Attribute)
1270
Debug.Assert(_curNode.type ==
XmlNodeType
.Element);
1292
_curNode.SetValueNode(
XmlNodeType
.Text, string.Empty);
1385
case
XmlNodeType
.Element:
1394
Debug.Assert(_curNode.type ==
XmlNodeType
.EndElement);
1398
case
XmlNodeType
.Attribute:
1400
goto case
XmlNodeType
.Element;
1424
if (_curNode.type !=
XmlNodeType
.Attribute)
1444
simpleValueNode.SetValueNode(
XmlNodeType
.Text, _curNode.StringValue);
1493
if (_curNode.type !=
XmlNodeType
.EntityReference)
1566
if (_outerReader.NodeType ==
XmlNodeType
.EntityReference &&
1713
if (_curNode.type !=
XmlNodeType
.Element)
1760
if (_curNode.type !=
XmlNodeType
.Element)
2151
_curNode.Clear(
XmlNodeType
.None);
2221
if (_curNode.type !=
XmlNodeType
.Element)
2255
if (_curNode.type !=
XmlNodeType
.Element)
2289
if (_curNode.type !=
XmlNodeType
.Element)
2498
ParseCDataOrComment(
XmlNodeType
.Comment);
2506
ParseCDataOrComment(
XmlNodeType
.Comment);
2966
private void InitFragmentReader(
XmlNodeType
fragmentType, XmlParserContext? parserContext, bool allowXmlDeclFragment)
2998
case
XmlNodeType
.Attribute:
3003
case
XmlNodeType
.Element:
3007
case
XmlNodeType
.Document:
3011
case
XmlNodeType
.XmlDeclaration:
3603
_curNode.SetNamedNode(
XmlNodeType
.XmlDeclaration, _xml);
3939
if (_fragmentType !=
XmlNodeType
.Document)
3950
if (_fragmentType ==
XmlNodeType
.None)
3952
_fragmentType =
XmlNodeType
.Element;
3969
if (_fragmentType ==
XmlNodeType
.Document || _fragmentType ==
XmlNodeType
.None)
3971
_fragmentType =
XmlNodeType
.Document;
3999
if (_fragmentType ==
XmlNodeType
.Document)
4003
if (_fragmentType ==
XmlNodeType
.None)
4005
_fragmentType =
XmlNodeType
.Element;
4016
if (_fragmentType ==
XmlNodeType
.Document)
4022
if (_fragmentType ==
XmlNodeType
.None)
4024
_fragmentType =
XmlNodeType
.Element;
4056
if (_fragmentType ==
XmlNodeType
.Document)
4067
if (_fragmentType ==
XmlNodeType
.None && _curNode.type ==
XmlNodeType
.Text)
4069
_fragmentType =
XmlNodeType
.Element;
4099
if (!_rootElementParsed && _fragmentType ==
XmlNodeType
.Document)
4104
if (_fragmentType ==
XmlNodeType
.None)
4106
_fragmentType = _rootElementParsed ?
XmlNodeType
.Document :
XmlNodeType
.Element;
4242
if (_index == 0 && _fragmentType !=
XmlNodeType
.Document)
4260
if (_index == 0 && _curNode.type !=
XmlNodeType
.Element)
4271
if (el.type !=
XmlNodeType
.Element)
4366
_curNode.SetNamedNode(
XmlNodeType
.Element,
4375
_curNode.SetNamedNode(
XmlNodeType
.Element,
4382
_curNode.SetNamedNode(
XmlNodeType
.Element,
4452
Debug.Assert(_curNode.type ==
XmlNodeType
.Element);
4641
startTagNode.type =
XmlNodeType
.EndElement;
4651
if (startTag.type ==
XmlNodeType
.Element)
4666
Debug.Assert(startTag.type ==
XmlNodeType
.EntityReference);
4728
Debug.Assert(_curNode.type ==
XmlNodeType
.Element);
4736
Debug.Assert(_curNode.type ==
XmlNodeType
.Element);
4962
Debug.Assert(_curNode.type ==
XmlNodeType
.Element);
4978
if (at.type ==
XmlNodeType
.Attribute && at.prefix.Length > 0)
5206
textChunk.SetValueNode(
XmlNodeType
.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen));
5218
entityChunk.SetNamedNode(
XmlNodeType
.EntityReference, entityName);
5250
textChunk.SetValueNode(
XmlNodeType
.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen));
5259
entityChunk.SetNamedNode(
XmlNodeType
.EntityReference, _ps.entity.Name);
5321
if (_fragmentType ==
XmlNodeType
.Attribute)
5358
textChunk.SetValueNode(
XmlNodeType
.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen));
5412
XmlNodeType
nodeType = GetTextNodeType(orChars);
5413
if (nodeType ==
XmlNodeType
.None)
5444
XmlNodeType
nodeType = GetTextNodeType(orChars);
5445
if (nodeType ==
XmlNodeType
.None)
5465
_curNode.SetValueNode(
XmlNodeType
.Text, _ps.chars, startPos, endPos - startPos);
5486
XmlNodeType
nodeType = (_stringBuilder.Length < MinWhitespaceLookahedCount) ? GetTextNodeType(orChars) :
XmlNodeType
.Text;
5487
if (nodeType ==
XmlNodeType
.None)
5890
if (_curNode.type !=
XmlNodeType
.EndElement)
5902
XmlNodeType
nodeType = GetWhitespaceType();
5905
if (nodeType ==
XmlNodeType
.None)
5947
_curNode.SetNamedNode(
XmlNodeType
.EntityReference, ParseEntityName());
6170
_curNode.SetNamedNode(
XmlNodeType
.EndEntity, _lastEntity.Name);
6182
Debug.Assert(_curNode.type ==
XmlNodeType
.EntityReference);
6186
_curNode.type =
XmlNodeType
.EndEntity;
6220
_curNode.SetNamedNode(
XmlNodeType
.ProcessingInstruction, target);
6453
ParseCDataOrComment(
XmlNodeType
.Comment);
6459
ParseCDataOrComment(
XmlNodeType
.Comment);
6466
ParseCDataOrComment(
XmlNodeType
.CDATA);
6470
private void ParseCDataOrComment(
XmlNodeType
type)
6502
private bool ParseCDataOrComment(
XmlNodeType
type, out int outStartPos, out int outEndPos)
6509
Throw(SR.Xml_UnexpectedEOF, (type ==
XmlNodeType
.Comment) ? "Comment" : "CDATA");
6518
char stopChar = (type ==
XmlNodeType
.Comment) ? '-' : ']';
6553
else if (type ==
XmlNodeType
.Comment)
6737
_curNode.SetNamedNode(
XmlNodeType
.DocumentType, _dtdInfo.Name.ToString(), string.Empty, null);
7654
newAttr.SetNamedNode(
XmlNodeType
.Attribute, _nameTable.Add(name));
7696
newAttr.SetNamedNode(
XmlNodeType
.Attribute, localName, prefix, nameWPrefix);
7714
Debug.Assert(attr.type ==
XmlNodeType
.Attribute);
7751
_curNode.Clear(
XmlNodeType
.None);
7856
private
XmlNodeType
GetWhitespaceType()
7862
return
XmlNodeType
.SignificantWhitespace;
7867
return
XmlNodeType
.Whitespace;
7871
return
XmlNodeType
.None;
7874
private
XmlNodeType
GetTextNodeType(int orChars)
7878
return
XmlNodeType
.Text;
8229
if (ParseCDataOrComment(
XmlNodeType
.Comment, out startPos, out pos))
8237
if (ParseCDataOrComment(
XmlNodeType
.CDATA, out startPos, out pos))
8246
_nextParsingFunction = (_index > 0 || _fragmentType !=
XmlNodeType
.Document) ? ParsingFunction.ElementContent
8534
Debug.Assert(_fragmentType ==
XmlNodeType
.Attribute);
8537
if (_curNode.type ==
XmlNodeType
.None)
8539
_curNode.type =
XmlNodeType
.Attribute;
8574
_curNode.SetValueNode(
XmlNodeType
.Text, string.Empty);
8637
_curNode.SetNamedNode(
XmlNodeType
.EntityReference, ParseEntityName());
8719
_curNode.SetValueNode(
XmlNodeType
.Text, _stringBuilder.ToString());
8918
Debug.Assert(_curNode.type ==
XmlNodeType
.Element);
8933
if (_curNode.type !=
XmlNodeType
.EndElement)
8954
case
XmlNodeType
.Attribute:
8956
case
XmlNodeType
.Text:
8957
case
XmlNodeType
.Whitespace:
8958
case
XmlNodeType
.SignificantWhitespace:
8959
case
XmlNodeType
.CDATA:
8965
case
XmlNodeType
.ProcessingInstruction:
8966
case
XmlNodeType
.Comment:
8967
case
XmlNodeType
.EndEntity:
8970
case
XmlNodeType
.EntityReference:
9112
internal
XmlNodeType
FragmentType
9120
internal void ChangeCurrentNodeType(
XmlNodeType
newNodeType)
9122
Debug.Assert(_curNode.type ==
XmlNodeType
.Whitespace && newNodeType ==
XmlNodeType
.SignificantWhitespace, "Incorrect node type change!");
9186
return _fragmentType ==
XmlNodeType
.Element ? ConformanceLevel.Fragment : ConformanceLevel.Document;
9298
Debug.Assert(_nodes[_index].type ==
XmlNodeType
.Element);
9316
Debug.Assert(_nodes[_index].type ==
XmlNodeType
.Element);
9456
if (_curNode.type !=
XmlNodeType
.EndElement)
System\Xml\Core\XmlTextReaderImplAsync.cs (85)
203
Debug.Assert(_curNode.type ==
XmlNodeType
.Element);
225
_curNode.SetValueNode(
XmlNodeType
.Text, string.Empty);
347
case
XmlNodeType
.Element:
356
Debug.Assert(_curNode.type ==
XmlNodeType
.EndElement);
360
case
XmlNodeType
.Attribute:
362
goto case
XmlNodeType
.Element;
537
if (_curNode.type !=
XmlNodeType
.Element)
593
if (_curNode.type !=
XmlNodeType
.Element)
770
await ParseCDataOrCommentAsync(
XmlNodeType
.Comment).ConfigureAwait(false);
778
await ParseCDataOrCommentAsync(
XmlNodeType
.Comment).ConfigureAwait(false);
1188
_curNode.SetNamedNode(
XmlNodeType
.XmlDeclaration, _xml);
1510
if (_fragmentType !=
XmlNodeType
.Document)
1535
if (_fragmentType ==
XmlNodeType
.Document || _fragmentType ==
XmlNodeType
.None)
1537
_fragmentType =
XmlNodeType
.Document;
1561
if (_fragmentType ==
XmlNodeType
.Document)
1565
if (_fragmentType ==
XmlNodeType
.None)
1567
_fragmentType =
XmlNodeType
.Element;
1587
if (_fragmentType ==
XmlNodeType
.Document)
1603
if (_fragmentType ==
XmlNodeType
.None)
1605
_fragmentType =
XmlNodeType
.Element;
1614
if (_fragmentType ==
XmlNodeType
.Document)
1621
if (_fragmentType ==
XmlNodeType
.None)
1623
_fragmentType =
XmlNodeType
.Element;
1659
if (_fragmentType ==
XmlNodeType
.None && _curNode.type ==
XmlNodeType
.Text)
1661
_fragmentType =
XmlNodeType
.Element;
1680
if (_fragmentType ==
XmlNodeType
.None && _curNode.type ==
XmlNodeType
.Text)
1682
_fragmentType =
XmlNodeType
.Element;
1714
if (!_rootElementParsed && _fragmentType ==
XmlNodeType
.Document)
1718
if (_fragmentType ==
XmlNodeType
.None)
1720
_fragmentType = _rootElementParsed ?
XmlNodeType
.Document :
XmlNodeType
.Element;
1839
if (_index == 0 && _fragmentType !=
XmlNodeType
.Document)
1959
_curNode.SetNamedNode(
XmlNodeType
.Element,
1968
_curNode.SetNamedNode(
XmlNodeType
.Element,
1975
_curNode.SetNamedNode(
XmlNodeType
.Element,
2259
startTagNode.type =
XmlNodeType
.EndElement;
2282
if (startTag.type ==
XmlNodeType
.Element)
2299
Debug.Assert(startTag.type ==
XmlNodeType
.EntityReference);
2361
Debug.Assert(_curNode.type ==
XmlNodeType
.Element);
2369
Debug.Assert(_curNode.type ==
XmlNodeType
.Element);
2722
textChunk.SetValueNode(
XmlNodeType
.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen));
2734
entityChunk.SetNamedNode(
XmlNodeType
.EntityReference, entityName);
2766
textChunk.SetValueNode(
XmlNodeType
.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen));
2774
entityChunk.SetNamedNode(
XmlNodeType
.EntityReference, _ps.entity!.Name);
2836
if (_fragmentType ==
XmlNodeType
.Attribute)
2875
textChunk.SetValueNode(
XmlNodeType
.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen));
2924
XmlNodeType
nodeType = GetTextNodeType(orChars);
2925
if (nodeType ==
XmlNodeType
.None)
2983
XmlNodeType
nodeType = GetTextNodeType(orChars);
2984
if (nodeType ==
XmlNodeType
.None)
3020
XmlNodeType
nodeType = GetTextNodeType(orChars);
3021
if (nodeType ==
XmlNodeType
.None)
3040
_curNode.SetValueNode(
XmlNodeType
.Text, _ps.chars, startPos, endPos - startPos);
3067
XmlNodeType
nodeType = (_stringBuilder.Length < MinWhitespaceLookahedCount) ? GetTextNodeType(orChars) :
XmlNodeType
.Text;
3068
if (nodeType ==
XmlNodeType
.None)
3667
if (_curNode.type !=
XmlNodeType
.EndElement)
3679
XmlNodeType
nodeType = GetWhitespaceType();
3681
if (nodeType ==
XmlNodeType
.None)
3722
_curNode.SetNamedNode(
XmlNodeType
.EntityReference, await ParseEntityNameAsync().ConfigureAwait(false));
3924
_curNode.SetNamedNode(
XmlNodeType
.ProcessingInstruction, target);
4178
await ParseCDataOrCommentAsync(
XmlNodeType
.Comment).ConfigureAwait(false);
4184
await ParseCDataOrCommentAsync(
XmlNodeType
.Comment).ConfigureAwait(false);
4191
return ParseCDataOrCommentAsync(
XmlNodeType
.CDATA);
4195
private async Task ParseCDataOrCommentAsync(
XmlNodeType
type)
4242
private async Task<(int, int, bool)> ParseCDataOrCommentTupleAsync(
XmlNodeType
type)
4252
Throw(SR.Xml_UnexpectedEOF, (type ==
XmlNodeType
.Comment) ? "Comment" : "CDATA");
4260
char stopChar = (type ==
XmlNodeType
.Comment) ? '-' : ']';
4296
else if (type ==
XmlNodeType
.Comment)
4478
_curNode.SetNamedNode(
XmlNodeType
.DocumentType, _dtdInfo.Name.ToString(), string.Empty, null);
5297
Debug.Assert(_curNode.type ==
XmlNodeType
.Element);
5311
if (_curNode.type !=
XmlNodeType
.EndElement)
5330
case
XmlNodeType
.Attribute:
5332
case
XmlNodeType
.Text:
5333
case
XmlNodeType
.Whitespace:
5334
case
XmlNodeType
.SignificantWhitespace:
5335
case
XmlNodeType
.CDATA:
5341
case
XmlNodeType
.ProcessingInstruction:
5342
case
XmlNodeType
.Comment:
5343
case
XmlNodeType
.EndEntity:
5346
case
XmlNodeType
.EntityReference:
5465
if (_curNode.type !=
XmlNodeType
.EndElement)
System\Xml\Core\XmlTextReaderImplHelpers.cs (11)
344
internal
XmlNodeType
type;
389
Clear(
XmlNodeType
.None);
413
return type ==
XmlNodeType
.Element && _isEmptyOrDefault;
417
Debug.Assert(type ==
XmlNodeType
.Element);
426
return type ==
XmlNodeType
.Attribute && _isEmptyOrDefault;
430
Debug.Assert(type ==
XmlNodeType
.Attribute);
477
internal void Clear(
XmlNodeType
type)
509
internal void SetValueNode(
XmlNodeType
type, string value)
519
internal void SetValueNode(
XmlNodeType
type, char[] chars, int startPos, int len)
530
internal void SetNamedNode(
XmlNodeType
type, string localName)
535
internal void SetNamedNode(
XmlNodeType
type, string localName, string prefix, string? nameWPrefix)
System\Xml\Core\XmlValidatingReader.cs (3)
31
public XmlValidatingReader([StringSyntax(StringSyntaxAttribute.Xml)] string xmlFragment,
XmlNodeType
fragType, XmlParserContext context)
39
public XmlValidatingReader(Stream xmlFragment,
XmlNodeType
fragType, XmlParserContext context)
50
public override
XmlNodeType
NodeType
System\Xml\Core\XmlValidatingReaderImpl.cs (21)
164
internal XmlValidatingReaderImpl(string xmlFragment,
XmlNodeType
fragType, XmlParserContext? context)
182
internal XmlValidatingReaderImpl(Stream xmlFragment,
XmlNodeType
fragType, XmlParserContext? context)
287
public override
XmlNodeType
NodeType
754
if (_outerReader.NodeType ==
XmlNodeType
.EntityReference && _parsingFunction != ParsingFunction.ResolveEntityInternally)
954
case
XmlNodeType
.Attribute:
956
case
XmlNodeType
.Element:
974
XmlNodeType
type = _outerReader.NodeType;
975
if (type !=
XmlNodeType
.CDATA && type !=
XmlNodeType
.Text &&
976
type !=
XmlNodeType
.Whitespace && type !=
XmlNodeType
.SignificantWhitespace &&
977
type !=
XmlNodeType
.Comment && type !=
XmlNodeType
.ProcessingInstruction)
983
if (_outerReader.NodeType !=
XmlNodeType
.EndElement)
992
case
XmlNodeType
.EndElement:
1052
Debug.Assert(_coreReader.NodeType ==
XmlNodeType
.EntityReference);
1098
case
XmlNodeType
.Whitespace:
1099
if (_coreReader.Depth > 0 || _coreReaderImpl.FragmentType !=
XmlNodeType
.Document)
1103
_coreReaderImpl.ChangeCurrentNodeType(
XmlNodeType
.SignificantWhitespace);
1107
case
XmlNodeType
.DocumentType:
1110
case
XmlNodeType
.EntityReference:
System\Xml\Core\XmlValidatingReaderImplAsync.cs (1)
193
Debug.Assert(_coreReader.NodeType ==
XmlNodeType
.EntityReference);
System\Xml\Core\XmlWrappingReader.cs (1)
34
public override
XmlNodeType
NodeType { get { return reader.NodeType; } }
System\Xml\Core\XmlWriter.cs (17)
317
if (reader.NodeType is
XmlNodeType
.Element or
XmlNodeType
.XmlDeclaration)
325
else if (reader.NodeType !=
XmlNodeType
.Attribute)
340
if (reader.NodeType ==
XmlNodeType
.EntityReference)
363
int d = reader.NodeType ==
XmlNodeType
.None ? -1 : reader.Depth;
368
case
XmlNodeType
.Element:
376
case
XmlNodeType
.Text:
391
case
XmlNodeType
.Whitespace:
392
case
XmlNodeType
.SignificantWhitespace:
397
case
XmlNodeType
.CDATA:
400
case
XmlNodeType
.EntityReference:
403
case
XmlNodeType
.XmlDeclaration:
404
case
XmlNodeType
.ProcessingInstruction:
407
case
XmlNodeType
.DocumentType:
411
case
XmlNodeType
.Comment:
414
case
XmlNodeType
.EndElement:
418
} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType ==
XmlNodeType
.EndElement)));
System\Xml\Core\XmlWriterAsync.cs (30)
238
if (reader.NodeType is
XmlNodeType
.Element or
XmlNodeType
.XmlDeclaration)
246
else if (reader.NodeType !=
XmlNodeType
.Attribute)
261
if (reader.NodeType ==
XmlNodeType
.EntityReference)
299
int d = reader.NodeType ==
XmlNodeType
.None ? -1 : reader.Depth;
304
case
XmlNodeType
.Element:
312
case
XmlNodeType
.Text:
327
case
XmlNodeType
.Whitespace:
328
case
XmlNodeType
.SignificantWhitespace:
331
case
XmlNodeType
.CDATA:
334
case
XmlNodeType
.EntityReference:
337
case
XmlNodeType
.XmlDeclaration:
338
case
XmlNodeType
.ProcessingInstruction:
341
case
XmlNodeType
.DocumentType:
345
case
XmlNodeType
.Comment:
348
case
XmlNodeType
.EndElement:
352
} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType ==
XmlNodeType
.EndElement)));
361
int d = reader.NodeType ==
XmlNodeType
.None ? -1 : reader.Depth;
366
case
XmlNodeType
.Element:
374
case
XmlNodeType
.Text:
390
case
XmlNodeType
.Whitespace:
391
case
XmlNodeType
.SignificantWhitespace:
394
case
XmlNodeType
.CDATA:
397
case
XmlNodeType
.EntityReference:
400
case
XmlNodeType
.XmlDeclaration:
401
case
XmlNodeType
.ProcessingInstruction:
404
case
XmlNodeType
.DocumentType:
408
case
XmlNodeType
.Comment:
411
case
XmlNodeType
.EndElement:
415
} while (await reader.ReadAsync().ConfigureAwait(false) && (d < reader.Depth || (d == reader.Depth && reader.NodeType ==
XmlNodeType
.EndElement)));
System\Xml\Core\XsdCachingReader.cs (29)
81
if (_coreReader.NodeType ==
XmlNodeType
.Element)
108
public override
XmlNodeType
NodeType
387
if (_cacheState != CachingReaderState.Replay || _cachedNode!.NodeType !=
XmlNodeType
.Attribute)
413
case
XmlNodeType
.Element:
418
case
XmlNodeType
.EndElement:
424
case
XmlNodeType
.Comment:
425
case
XmlNodeType
.ProcessingInstruction:
426
case
XmlNodeType
.Text:
427
case
XmlNodeType
.CDATA:
428
case
XmlNodeType
.Whitespace:
429
case
XmlNodeType
.SignificantWhitespace:
453
if (_coreReader.NodeType !=
XmlNodeType
.Element || _readAhead)
474
ValidatingReaderNodeData textNode = AddContent(
XmlNodeType
.Text);
483
Debug.Assert(_coreReader.NodeType ==
XmlNodeType
.EndElement || (_coreReader.NodeType ==
XmlNodeType
.Element && _coreReader.IsEmptyElement));
488
Debug.Assert(endElementNode.NodeType ==
XmlNodeType
.EndElement);
495
ValidatingReaderNodeData recordedNode = AddContent(
XmlNodeType
.EndElement);
496
Debug.Assert(_coreReader.NodeType ==
XmlNodeType
.EndElement || (_coreReader.NodeType ==
XmlNodeType
.Element && _coreReader.IsEmptyElement));
544
case
XmlNodeType
.Element:
545
if (_coreReader.NodeType !=
XmlNodeType
.EndElement && !_readAhead)
556
case
XmlNodeType
.Attribute:
558
goto case
XmlNodeType
.Element;
592
if (_cachedNode!.NodeType !=
XmlNodeType
.Attribute)
657
attInfo.Clear(
XmlNodeType
.Attribute);
666
return _attributeEvents[attIndex] ??= new ValidatingReaderNodeData(
XmlNodeType
.Attribute);
669
private ValidatingReaderNodeData AddContent(
XmlNodeType
nodeType)
692
Debug.Assert(_coreReader.NodeType ==
XmlNodeType
.Element);
752
_textNode ??= new ValidatingReaderNodeData(
XmlNodeType
.Text);
System\Xml\Core\XsdCachingReaderAsync.cs (13)
45
case
XmlNodeType
.Element:
50
case
XmlNodeType
.EndElement:
56
case
XmlNodeType
.Comment:
57
case
XmlNodeType
.ProcessingInstruction:
58
case
XmlNodeType
.Text:
59
case
XmlNodeType
.CDATA:
60
case
XmlNodeType
.Whitespace:
61
case
XmlNodeType
.SignificantWhitespace:
85
if (_coreReader.NodeType !=
XmlNodeType
.Element || _readAhead)
110
case
XmlNodeType
.Element:
111
if (_coreReader.NodeType !=
XmlNodeType
.EndElement && !_readAhead)
122
case
XmlNodeType
.Attribute:
124
goto case
XmlNodeType
.Element;
System\Xml\Core\XsdValidatingReader.cs (90)
213
public override
XmlNodeType
NodeType
224
XmlNodeType
nodeType = _coreReader.NodeType;
226
if (nodeType ==
XmlNodeType
.Whitespace && (_validator.CurrentContentType == XmlSchemaContentType.TextOnly || _validator.CurrentContentType == XmlSchemaContentType.Mixed))
228
return
XmlNodeType
.SignificantWhitespace;
421
case
XmlNodeType
.Element:
422
case
XmlNodeType
.EndElement:
431
case
XmlNodeType
.Attribute:
464
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
498
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
532
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
566
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
600
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
634
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
668
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
703
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
739
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
774
if (this.NodeType !=
XmlNodeType
.Element)
785
if (this.NodeType !=
XmlNodeType
.Element)
820
if (this.NodeType !=
XmlNodeType
.Element)
855
if (this.NodeType !=
XmlNodeType
.Element)
890
if (this.NodeType !=
XmlNodeType
.Element)
925
if (this.NodeType !=
XmlNodeType
.Element)
960
if (this.NodeType !=
XmlNodeType
.Element)
995
if (this.NodeType !=
XmlNodeType
.Element)
1030
if (this.NodeType !=
XmlNodeType
.Element)
1065
if (this.NodeType !=
XmlNodeType
.Element)
1512
case
XmlNodeType
.Element:
1535
case
XmlNodeType
.Attribute:
1537
goto case
XmlNodeType
.Element;
1575
if (NodeType ==
XmlNodeType
.Attribute)
1716
case
XmlNodeType
.Element:
1724
case
XmlNodeType
.EndElement:
1727
case
XmlNodeType
.Attribute:
1749
case
XmlNodeType
.Element:
1750
case
XmlNodeType
.EndElement:
1767
case
XmlNodeType
.Element:
1781
case
XmlNodeType
.EndElement:
1784
case
XmlNodeType
.Attribute:
1803
case
XmlNodeType
.Element:
1811
case
XmlNodeType
.EndElement:
1814
case
XmlNodeType
.Attribute:
1834
case
XmlNodeType
.Element:
1835
case
XmlNodeType
.EndElement:
1838
case
XmlNodeType
.Attribute:
1856
if (NodeType ==
XmlNodeType
.Element || NodeType ==
XmlNodeType
.EndElement)
1869
if (NodeType ==
XmlNodeType
.Attribute)
2007
case
XmlNodeType
.Element:
2012
case
XmlNodeType
.Whitespace:
2013
case
XmlNodeType
.SignificantWhitespace:
2017
case
XmlNodeType
.Text: // text inside a node
2018
case
XmlNodeType
.CDATA: // <![CDATA[...]]>
2022
case
XmlNodeType
.EndElement:
2027
case
XmlNodeType
.EntityReference:
2030
case
XmlNodeType
.DocumentType:
2333
if (_coreReader.NodeType ==
XmlNodeType
.Element)
2366
XmlNodeType
nodeType = this.NodeType;
2367
if (nodeType ==
XmlNodeType
.Attribute)
2386
else if (nodeType ==
XmlNodeType
.EndElement)
2440
Debug.Assert(this.NodeType ==
XmlNodeType
.Element);
2467
if (this.NodeType ==
XmlNodeType
.EndElement)
2491
else if (this.NodeType ==
XmlNodeType
.Element)
2501
if (this.NodeType !=
XmlNodeType
.EndElement)
2529
case
XmlNodeType
.Element:
2533
case
XmlNodeType
.Text:
2534
case
XmlNodeType
.CDATA:
2538
case
XmlNodeType
.Whitespace:
2539
case
XmlNodeType
.SignificantWhitespace:
2543
case
XmlNodeType
.Comment:
2544
case
XmlNodeType
.ProcessingInstruction:
2547
case
XmlNodeType
.EndElement:
2587
Debug.Assert(_coreReader.NodeType ==
XmlNodeType
.EndElement);
2597
case
XmlNodeType
.Element:
2601
case
XmlNodeType
.Text:
2602
case
XmlNodeType
.CDATA:
2606
case
XmlNodeType
.Whitespace:
2607
case
XmlNodeType
.SignificantWhitespace:
2611
case
XmlNodeType
.Comment:
2612
case
XmlNodeType
.ProcessingInstruction:
2615
case
XmlNodeType
.EndElement:
2658
case
XmlNodeType
.Element:
2662
case
XmlNodeType
.Text:
2663
case
XmlNodeType
.CDATA:
2667
case
XmlNodeType
.Whitespace:
2668
case
XmlNodeType
.SignificantWhitespace:
2672
case
XmlNodeType
.Comment:
2673
case
XmlNodeType
.ProcessingInstruction:
2676
case
XmlNodeType
.EndElement:
2740
Debug.Assert(NodeType !=
XmlNodeType
.Attribute);
2764
_textNode ??= new ValidatingReaderNodeData(
XmlNodeType
.Text);
System\Xml\Core\XsdValidatingReaderAsync.cs (32)
49
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
89
XmlSchemaType? xmlType = NodeType ==
XmlNodeType
.Attribute ? AttributeXmlType : ElementXmlType;
124
if (this.NodeType !=
XmlNodeType
.Element)
136
if (this.NodeType !=
XmlNodeType
.Element)
176
if (this.NodeType !=
XmlNodeType
.Element)
350
case
XmlNodeType
.Element:
373
case
XmlNodeType
.Attribute:
375
goto case
XmlNodeType
.Element;
502
case
XmlNodeType
.Element:
506
case
XmlNodeType
.Whitespace:
507
case
XmlNodeType
.SignificantWhitespace:
511
case
XmlNodeType
.Text: // text inside a node
512
case
XmlNodeType
.CDATA: // <![CDATA[...]]>
516
case
XmlNodeType
.EndElement:
520
case
XmlNodeType
.EntityReference:
523
case
XmlNodeType
.DocumentType:
656
if (_coreReader.NodeType ==
XmlNodeType
.Element)
692
XmlNodeType
nodeType = this.NodeType;
693
if (nodeType ==
XmlNodeType
.Attribute)
712
else if (nodeType ==
XmlNodeType
.EndElement)
776
Debug.Assert(this.NodeType ==
XmlNodeType
.Element);
801
if (this.NodeType ==
XmlNodeType
.EndElement)
826
else if (this.NodeType ==
XmlNodeType
.Element)
839
if (this.NodeType !=
XmlNodeType
.EndElement)
867
case
XmlNodeType
.Element:
871
case
XmlNodeType
.Text:
872
case
XmlNodeType
.CDATA:
876
case
XmlNodeType
.Whitespace:
877
case
XmlNodeType
.SignificantWhitespace:
881
case
XmlNodeType
.Comment:
882
case
XmlNodeType
.ProcessingInstruction:
885
case
XmlNodeType
.EndElement:
System\Xml\Dom\DocumentSchemaValidator.cs (27)
94
case
XmlNodeType
.Document:
98
case
XmlNodeType
.DocumentFragment:
101
case
XmlNodeType
.Element: //Validate children of this element
123
if (nodeToValidate.ParentNode!.NodeType ==
XmlNodeType
.Document)
140
case
XmlNodeType
.Attribute:
179
case
XmlNodeType
.Element:
210
case
XmlNodeType
.Attribute:
266
case
XmlNodeType
.Document:
276
case
XmlNodeType
.DocumentFragment:
277
case
XmlNodeType
.EntityReference:
285
case
XmlNodeType
.Element:
289
case
XmlNodeType
.Attribute: //Top-level attribute
298
case
XmlNodeType
.Text:
302
case
XmlNodeType
.CDATA:
306
case
XmlNodeType
.Whitespace:
307
case
XmlNodeType
.SignificantWhitespace:
311
case
XmlNodeType
.Comment:
312
case
XmlNodeType
.ProcessingInstruction:
485
Debug.Assert(elementToValidate.ParentNode!.NodeType !=
XmlNodeType
.Document); //Handle if it is the documentElement separately
730
case
XmlNodeType
.EntityReference:
734
case
XmlNodeType
.Element: //Flat validation, do not drill down into children
738
case
XmlNodeType
.Text:
739
case
XmlNodeType
.CDATA:
743
case
XmlNodeType
.Whitespace:
744
case
XmlNodeType
.SignificantWhitespace:
748
case
XmlNodeType
.Comment:
749
case
XmlNodeType
.ProcessingInstruction:
System\Xml\Dom\DocumentXmlWriter.cs (6)
538
XmlNodeType
nodeType =
XmlNodeType
.None;
550
if (nodeType ==
XmlNodeType
.Document)
554
else if (nodeType ==
XmlNodeType
.DocumentFragment)
563
if (nodeType ==
XmlNodeType
.Document)
567
else if (nodeType ==
XmlNodeType
.DocumentFragment)
System\Xml\Dom\DocumentXPathNavigator.cs (126)
50
case
XmlNodeType
.Attribute:
57
case
XmlNodeType
.Text:
58
case
XmlNodeType
.CDATA:
59
case
XmlNodeType
.Whitespace:
60
case
XmlNodeType
.SignificantWhitespace:
73
goto case
XmlNodeType
.Element;
74
case
XmlNodeType
.Element:
75
case
XmlNodeType
.ProcessingInstruction:
76
case
XmlNodeType
.Comment:
129
case
XmlNodeType
.Element:
130
case
XmlNodeType
.ProcessingInstruction:
132
case
XmlNodeType
.Attribute:
168
case
XmlNodeType
.Element:
169
case
XmlNodeType
.DocumentFragment:
171
case
XmlNodeType
.Document:
173
case
XmlNodeType
.Text:
174
case
XmlNodeType
.CDATA:
175
case
XmlNodeType
.Whitespace:
176
case
XmlNodeType
.SignificantWhitespace:
367
&& node.NodeType !=
XmlNodeType
.Element)
778
if (_source.NodeType ==
XmlNodeType
.Attribute)
806
case
XmlNodeType
.Element:
813
case
XmlNodeType
.DocumentFragment:
814
case
XmlNodeType
.Document:
906
if (_source.NodeType ==
XmlNodeType
.Attribute)
916
if (child.NodeType ==
XmlNodeType
.Element
932
if (_source.NodeType ==
XmlNodeType
.Attribute)
970
case
XmlNodeType
.Attribute:
982
if (following.NodeType ==
XmlNodeType
.Attribute)
1026
while (following.NodeType !=
XmlNodeType
.Element
1045
case
XmlNodeType
.Attribute:
1064
case
XmlNodeType
.Attribute:
1071
case
XmlNodeType
.Text:
1072
case
XmlNodeType
.CDATA:
1073
case
XmlNodeType
.SignificantWhitespace:
1074
case
XmlNodeType
.Whitespace:
1129
if (sibling.NodeType ==
XmlNodeType
.Element
1184
case
XmlNodeType
.Element:
1191
case
XmlNodeType
.DocumentFragment:
1192
case
XmlNodeType
.Document:
1247
if (_source.NodeType ==
XmlNodeType
.Document)
1453
if (nsAtom == null || _source.NodeType ==
XmlNodeType
.Attribute)
1478
XmlNodeType
curNT = _source.NodeType;
1479
if (curNT !=
XmlNodeType
.Document && curNT !=
XmlNodeType
.Element)
1504
case
XmlNodeType
.Element:
1505
case
XmlNodeType
.Document:
1506
case
XmlNodeType
.DocumentFragment:
1521
case
XmlNodeType
.Element:
1522
case
XmlNodeType
.Document:
1523
case
XmlNodeType
.DocumentFragment:
1540
case
XmlNodeType
.Attribute:
1541
case
XmlNodeType
.Document:
1542
case
XmlNodeType
.DocumentFragment:
1544
case
XmlNodeType
.Text:
1545
case
XmlNodeType
.CDATA:
1546
case
XmlNodeType
.SignificantWhitespace:
1547
case
XmlNodeType
.Whitespace:
1563
case
XmlNodeType
.Attribute:
1564
case
XmlNodeType
.Document:
1565
case
XmlNodeType
.DocumentFragment:
1567
case
XmlNodeType
.Text:
1568
case
XmlNodeType
.CDATA:
1569
case
XmlNodeType
.SignificantWhitespace:
1570
case
XmlNodeType
.Whitespace:
1585
if (_source.NodeType !=
XmlNodeType
.Element)
1613
case
XmlNodeType
.Attribute:
1614
case
XmlNodeType
.Document:
1615
case
XmlNodeType
.DocumentFragment:
1617
case
XmlNodeType
.Text:
1618
case
XmlNodeType
.CDATA:
1619
case
XmlNodeType
.SignificantWhitespace:
1620
case
XmlNodeType
.Whitespace:
1664
case
XmlNodeType
.Attribute:
1677
case
XmlNodeType
.Text:
1678
case
XmlNodeType
.CDATA:
1679
case
XmlNodeType
.SignificantWhitespace:
1680
case
XmlNodeType
.Whitespace:
1682
goto case
XmlNodeType
.Element;
1683
case
XmlNodeType
.Element:
1684
case
XmlNodeType
.ProcessingInstruction:
1685
case
XmlNodeType
.Comment:
1723
case
XmlNodeType
.Attribute:
1736
case
XmlNodeType
.Text:
1737
case
XmlNodeType
.CDATA:
1738
case
XmlNodeType
.SignificantWhitespace:
1739
case
XmlNodeType
.Whitespace:
1744
goto case
XmlNodeType
.Element;
1745
case
XmlNodeType
.Element:
1746
case
XmlNodeType
.ProcessingInstruction:
1747
case
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)
2040
case
XmlNodeType
.EntityReference:
2043
case
XmlNodeType
.Text:
2044
case
XmlNodeType
.CDATA:
2045
case
XmlNodeType
.Whitespace:
2046
case
XmlNodeType
.SignificantWhitespace:
2103
case
XmlNodeType
.Element:
2105
case
XmlNodeType
.DocumentFragment:
2108
case
XmlNodeType
.Element:
2109
case
XmlNodeType
.Text:
2110
case
XmlNodeType
.CDATA:
2111
case
XmlNodeType
.ProcessingInstruction:
2112
case
XmlNodeType
.Comment:
2113
case
XmlNodeType
.Whitespace:
2114
case
XmlNodeType
.SignificantWhitespace:
2118
case
XmlNodeType
.Document:
2121
case
XmlNodeType
.Element:
2122
case
XmlNodeType
.ProcessingInstruction:
2123
case
XmlNodeType
.Comment:
2243
if (node.NodeType ==
XmlNodeType
.Element && Match(node))
2257
Debug.Assert(((XmlNode)nav.UnderlyingObject).NodeType !=
XmlNodeType
.Attribute);
2271
return (node.NodeType ==
XmlNodeType
.Element);
2295
if (node.NodeType ==
XmlNodeType
.Element && Match(node))
2311
Debug.Assert(((XmlNode)nav.UnderlyingObject).NodeType !=
XmlNodeType
.Attribute);
2327
Debug.Assert(node.NodeType ==
XmlNodeType
.Element);
2352
if (node.NodeType ==
XmlNodeType
.Element && Match(node))
2369
Debug.Assert(((XmlNode)nav.UnderlyingObject).NodeType !=
XmlNodeType
.Attribute);
2392
Debug.Assert(node.NodeType ==
XmlNodeType
.Element);
2419
if (node.NodeType ==
XmlNodeType
.Element && Match(node))
System\Xml\Dom\XmlAttribute.cs (5)
94
public override
XmlNodeType
NodeType
96
get { return
XmlNodeType
.Attribute; }
212
internal override bool IsValidChildType(
XmlNodeType
type)
214
return (type ==
XmlNodeType
.Text) || (type ==
XmlNodeType
.EntityReference);
System\Xml\Dom\XmlCDataSection.cs (7)
36
public override
XmlNodeType
NodeType
40
return
XmlNodeType
.CDATA;
50
case
XmlNodeType
.Document:
52
case
XmlNodeType
.Text:
53
case
XmlNodeType
.CDATA:
54
case
XmlNodeType
.Whitespace:
55
case
XmlNodeType
.SignificantWhitespace:
System\Xml\Dom\XmlCharacterData.cs (6)
201
Debug.Assert(XmlDocument.IsTextNode(n.NodeType) || (n.ParentNode != null && n.ParentNode.NodeType ==
XmlNodeType
.EntityReference));
206
case
XmlNodeType
.Whitespace:
208
case
XmlNodeType
.SignificantWhitespace:
211
case
XmlNodeType
.Text:
212
case
XmlNodeType
.CDATA:
215
case
XmlNodeType
.EntityReference:
System\Xml\Dom\XmlComment.cs (2)
29
public override
XmlNodeType
NodeType
31
get { return
XmlNodeType
.Comment; }
System\Xml\Dom\XmlDeclaration.cs (2)
152
public override
XmlNodeType
NodeType
154
get { return
XmlNodeType
.XmlDeclaration; }
System\Xml\Dom\XmlDocument.cs (98)
356
public override
XmlNodeType
NodeType
358
get { return
XmlNodeType
.Document; }
369
get { return (XmlDocumentType?)FindChild(
XmlNodeType
.DocumentType); }
406
get { return (XmlElement?)FindChild(
XmlNodeType
.Element); }
462
internal override bool IsValidChildType(
XmlNodeType
type)
466
case
XmlNodeType
.ProcessingInstruction:
467
case
XmlNodeType
.Comment:
468
case
XmlNodeType
.Whitespace:
469
case
XmlNodeType
.SignificantWhitespace:
472
case
XmlNodeType
.DocumentType:
477
case
XmlNodeType
.Element:
482
case
XmlNodeType
.XmlDeclaration:
493
private static bool HasNodeTypeInPrevSiblings(
XmlNodeType
nt, XmlNode? refNode)
514
private static bool HasNodeTypeInNextSiblings(
XmlNodeType
nt, XmlNode? refNode)
535
case
XmlNodeType
.XmlDeclaration:
538
case
XmlNodeType
.ProcessingInstruction:
539
case
XmlNodeType
.Comment:
540
return refChild.NodeType !=
XmlNodeType
.XmlDeclaration;
542
case
XmlNodeType
.DocumentType:
544
if (refChild.NodeType !=
XmlNodeType
.XmlDeclaration)
548
return !HasNodeTypeInPrevSiblings(
XmlNodeType
.Element, refChild.PreviousSibling);
553
case
XmlNodeType
.Element:
555
if (refChild.NodeType !=
XmlNodeType
.XmlDeclaration)
559
return !HasNodeTypeInNextSiblings(
XmlNodeType
.DocumentType, refChild);
577
case
XmlNodeType
.ProcessingInstruction:
578
case
XmlNodeType
.Comment:
579
case
XmlNodeType
.Whitespace:
580
case
XmlNodeType
.SignificantWhitespace:
583
case
XmlNodeType
.DocumentType:
587
return !HasNodeTypeInPrevSiblings(
XmlNodeType
.Element, refChild);
590
case
XmlNodeType
.Element:
592
return !HasNodeTypeInNextSiblings(
XmlNodeType
.DocumentType, refChild.NextSibling);
761
XmlNodeType
nodeType = node.NodeType;
763
XmlNodeType
parentType;
767
case
XmlNodeType
.EntityReference:
768
case
XmlNodeType
.Entity:
769
case
XmlNodeType
.DocumentType:
770
case
XmlNodeType
.Notation:
771
case
XmlNodeType
.XmlDeclaration:
773
case
XmlNodeType
.Text:
774
case
XmlNodeType
.CDATA:
775
case
XmlNodeType
.SignificantWhitespace:
782
if (parentType ==
XmlNodeType
.Attribute)
786
else if (parentType ==
XmlNodeType
.EntityReference)
799
case
XmlNodeType
.Whitespace:
806
if (parentType ==
XmlNodeType
.Document
807
|| parentType ==
XmlNodeType
.Attribute)
811
else if (parentType ==
XmlNodeType
.EntityReference)
830
internal static bool IsTextNode(
XmlNodeType
nt)
834
case
XmlNodeType
.Text:
835
case
XmlNodeType
.CDATA:
836
case
XmlNodeType
.Whitespace:
837
case
XmlNodeType
.SignificantWhitespace:
859
if (intnode.ParentNode != null && intnode.ParentNode.NodeType ==
XmlNodeType
.EntityReference)
881
while (n.NodeType ==
XmlNodeType
.EntityReference)
969
case
XmlNodeType
.Element:
976
case
XmlNodeType
.Attribute:
982
case
XmlNodeType
.Text:
985
case
XmlNodeType
.Comment:
988
case
XmlNodeType
.ProcessingInstruction:
991
case
XmlNodeType
.XmlDeclaration:
995
case
XmlNodeType
.CDATA:
998
case
XmlNodeType
.DocumentType:
1002
case
XmlNodeType
.DocumentFragment:
1008
case
XmlNodeType
.EntityReference:
1014
case
XmlNodeType
.Whitespace:
1018
case
XmlNodeType
.SignificantWhitespace:
1042
Debug.Assert(toNode.NodeType !=
XmlNodeType
.EntityReference);
1111
public virtual XmlNode CreateNode(
XmlNodeType
type, string? prefix, string name, string? namespaceURI)
1115
case
XmlNodeType
.Element:
1121
case
XmlNodeType
.Attribute:
1127
case
XmlNodeType
.Text:
1130
case
XmlNodeType
.CDATA:
1133
case
XmlNodeType
.EntityReference:
1136
case
XmlNodeType
.ProcessingInstruction:
1139
case
XmlNodeType
.XmlDeclaration:
1142
case
XmlNodeType
.Comment:
1145
case
XmlNodeType
.DocumentFragment:
1148
case
XmlNodeType
.DocumentType:
1151
case
XmlNodeType
.Document:
1154
case
XmlNodeType
.SignificantWhitespace:
1157
case
XmlNodeType
.Whitespace:
1174
public virtual XmlNode CreateNode(
XmlNodeType
type, string name, string? namespaceURI)
1198
internal static
XmlNodeType
ConvertToNodeType(string nodeTypeString)
1202
return
XmlNodeType
.Element;
1206
return
XmlNodeType
.Attribute;
1210
return
XmlNodeType
.Text;
1214
return
XmlNodeType
.CDATA;
1218
return
XmlNodeType
.EntityReference;
1222
return
XmlNodeType
.Entity;
1226
return
XmlNodeType
.ProcessingInstruction;
1230
return
XmlNodeType
.Comment;
1234
return
XmlNodeType
.Document;
1238
return
XmlNodeType
.DocumentType;
1242
return
XmlNodeType
.DocumentFragment;
1246
return
XmlNodeType
.Notation;
1250
return
XmlNodeType
.SignificantWhitespace;
1254
return
XmlNodeType
.Whitespace;
System\Xml\Dom\XmlDocumentFragment.cs (16)
69
public override
XmlNodeType
NodeType
71
get { return
XmlNodeType
.DocumentFragment; }
102
loader.ParsePartialContent(this, value,
XmlNodeType
.Element);
128
internal override bool IsValidChildType(
XmlNodeType
type)
132
case
XmlNodeType
.Element:
133
case
XmlNodeType
.Text:
134
case
XmlNodeType
.EntityReference:
135
case
XmlNodeType
.Comment:
136
case
XmlNodeType
.Whitespace:
137
case
XmlNodeType
.SignificantWhitespace:
138
case
XmlNodeType
.ProcessingInstruction:
139
case
XmlNodeType
.CDATA:
142
case
XmlNodeType
.XmlDeclaration:
145
if (firstNode == null || firstNode.NodeType !=
XmlNodeType
.XmlDeclaration)
156
if (newChild.NodeType ==
XmlNodeType
.XmlDeclaration)
172
if (newChild.NodeType ==
XmlNodeType
.XmlDeclaration)
System\Xml\Dom\XmlDocumentType.cs (2)
53
public override
XmlNodeType
NodeType
55
get { return
XmlNodeType
.DocumentType; }
System\Xml\Dom\XmlElement.cs (12)
110
public override
XmlNodeType
NodeType
112
get { return
XmlNodeType
.Element; }
217
internal override bool IsValidChildType(
XmlNodeType
type)
221
case
XmlNodeType
.Element:
222
case
XmlNodeType
.Text:
223
case
XmlNodeType
.EntityReference:
224
case
XmlNodeType
.Comment:
225
case
XmlNodeType
.Whitespace:
226
case
XmlNodeType
.SignificantWhitespace:
227
case
XmlNodeType
.ProcessingInstruction:
228
case
XmlNodeType
.CDATA:
601
linkedNode.NodeType ==
XmlNodeType
.Text && //which is text node
System\Xml\Dom\XmlElementList.cs (3)
30
Debug.Assert(parent.NodeType ==
XmlNodeType
.Element || parent.NodeType ==
XmlNodeType
.Document);
160
if (curNode.NodeType ==
XmlNodeType
.Element)
System\Xml\Dom\XmlEntity.cs (11)
90
internal override bool IsValidChildType(
XmlNodeType
type)
92
return (type ==
XmlNodeType
.Text ||
93
type ==
XmlNodeType
.Element ||
94
type ==
XmlNodeType
.ProcessingInstruction ||
95
type ==
XmlNodeType
.Comment ||
96
type ==
XmlNodeType
.CDATA ||
97
type ==
XmlNodeType
.Whitespace ||
98
type ==
XmlNodeType
.SignificantWhitespace ||
99
type ==
XmlNodeType
.EntityReference);
103
public override
XmlNodeType
NodeType
105
get { return
XmlNodeType
.Entity; }
System\Xml\Dom\XmlEntityReference.cs (11)
76
public override
XmlNodeType
NodeType
78
get { return
XmlNodeType
.EntityReference; }
132
internal override bool IsValidChildType(
XmlNodeType
type)
136
case
XmlNodeType
.Element:
137
case
XmlNodeType
.Text:
138
case
XmlNodeType
.EntityReference:
139
case
XmlNodeType
.Comment:
140
case
XmlNodeType
.Whitespace:
141
case
XmlNodeType
.SignificantWhitespace:
142
case
XmlNodeType
.ProcessingInstruction:
143
case
XmlNodeType
.CDATA:
System\Xml\Dom\XmlLoader.cs (53)
89
if (n.NodeType !=
XmlNodeType
.Attribute)
109
case
XmlNodeType
.Element:
144
case
XmlNodeType
.EndElement:
149
Debug.Assert(parent.NodeType ==
XmlNodeType
.Element);
166
case
XmlNodeType
.EntityReference:
170
case
XmlNodeType
.EndEntity:
174
case
XmlNodeType
.Attribute:
178
case
XmlNodeType
.Text:
182
case
XmlNodeType
.SignificantWhitespace:
186
case
XmlNodeType
.Whitespace:
201
case
XmlNodeType
.CDATA:
206
case
XmlNodeType
.XmlDeclaration:
210
case
XmlNodeType
.ProcessingInstruction:
214
case
XmlNodeType
.Comment:
218
case
XmlNodeType
.DocumentType:
252
Debug.Assert(_reader!.NodeType ==
XmlNodeType
.Attribute);
272
case
XmlNodeType
.Text:
275
case
XmlNodeType
.EntityReference:
329
case
XmlNodeType
.Text:
332
case
XmlNodeType
.EndEntity:
334
case
XmlNodeType
.EntityReference:
359
Debug.Assert(_reader!.NodeType ==
XmlNodeType
.EntityReference);
364
while (_reader.Read() && _reader.NodeType !=
XmlNodeType
.EndEntity)
382
Debug.Assert(_reader!.NodeType ==
XmlNodeType
.XmlDeclaration);
420
Debug.Assert(_reader!.NodeType ==
XmlNodeType
.DocumentType);
466
case
XmlNodeType
.Element:
494
case
XmlNodeType
.EndElement:
495
Debug.Assert(parent!.NodeType ==
XmlNodeType
.Element);
504
case
XmlNodeType
.EntityReference:
508
case
XmlNodeType
.EndEntity:
511
case
XmlNodeType
.Attribute:
515
case
XmlNodeType
.SignificantWhitespace:
519
case
XmlNodeType
.Whitespace:
530
case
XmlNodeType
.Text:
534
case
XmlNodeType
.CDATA:
538
case
XmlNodeType
.ProcessingInstruction:
542
case
XmlNodeType
.Comment:
598
XmlTextReaderImpl tr = new XmlTextReaderImpl("",
XmlNodeType
.Element, pc);
747
internal XmlNamespaceManager ParsePartialContent(XmlNode parentNode, string innerxmltext,
XmlNodeType
nt)
750
Debug.Assert(parentNode.NodeType !=
XmlNodeType
.Document);
761
if (nt ==
XmlNodeType
.Entity)
791
XmlNamespaceManager mgr = ParsePartialContent(node, innerxmltext,
XmlNodeType
.Element);
799
ParsePartialContent(node, innerxmltext,
XmlNodeType
.Attribute);
871
ParsePartialContent(ent, EntitizeName(ent.Name),
XmlNodeType
.Entity);
910
ParsePartialContent(eref, EntitizeName(eref.Name),
XmlNodeType
.EntityReference);
929
private static XmlTextReaderImpl CreateInnerXmlReader(string xmlFragment,
XmlNodeType
nt, XmlParserContext context, XmlDocument doc)
931
XmlNodeType
contentNT = nt;
932
if (contentNT ==
XmlNodeType
.Entity || contentNT ==
XmlNodeType
.EntityReference)
933
contentNT =
XmlNodeType
.Element;
967
if (nt ==
XmlNodeType
.Entity || nt ==
XmlNodeType
.EntityReference)
1001
internal static Exception UnexpectedNodeType(
XmlNodeType
nodetype)
System\Xml\Dom\XmlNamedNodemap.cs (2)
145
if (node.NodeType ==
XmlNodeType
.Attribute)
212
if (node.NodeType ==
XmlNodeType
.Attribute)
System\Xml\Dom\XmlNode.cs (62)
118
public abstract
XmlNodeType
NodeType
130
if (parentNode.NodeType !=
XmlNodeType
.Document)
188
if (parentNode.NodeType ==
XmlNodeType
.Document)
242
while (parent != null && !(parent.NodeType ==
XmlNodeType
.Document))
276
if (newChild.NodeType ==
XmlNodeType
.DocumentFragment)
390
if (newChild.NodeType ==
XmlNodeType
.DocumentFragment)
596
if (newChild.NodeType ==
XmlNodeType
.DocumentFragment)
694
internal virtual bool IsValidChildType(
XmlNodeType
type)
742
case
XmlNodeType
.Text:
743
case
XmlNodeType
.Whitespace:
744
case
XmlNodeType
.SignificantWhitespace:
761
case
XmlNodeType
.Element:
791
Debug.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);
797
if (firstNode.NodeType ==
XmlNodeType
.Text)
799
if (secondNode.NodeType ==
XmlNodeType
.Text)
801
if (firstNode.NodeType ==
XmlNodeType
.SignificantWhitespace)
803
if (secondNode.NodeType ==
XmlNodeType
.SignificantWhitespace)
805
if (firstNode.NodeType ==
XmlNodeType
.Whitespace)
807
if (secondNode.NodeType ==
XmlNodeType
.Whitespace)
861
case
XmlNodeType
.EntityReference:
862
case
XmlNodeType
.Entity:
865
case
XmlNodeType
.Attribute:
906
if (child.NodeType ==
XmlNodeType
.Text || child.NodeType ==
XmlNodeType
.CDATA
907
|| child.NodeType ==
XmlNodeType
.Whitespace || child.NodeType ==
XmlNodeType
.SignificantWhitespace)
930
XmlNodeType
nodeType = fc.NodeType;
933
case
XmlNodeType
.Text:
934
case
XmlNodeType
.CDATA:
935
case
XmlNodeType
.Whitespace:
936
case
XmlNodeType
.SignificantWhitespace:
951
&& firstChild.NodeType ==
XmlNodeType
.Text)//which is a text node
1022
XmlNodeType
nt = curNode.NodeType;
1025
if (nt ==
XmlNodeType
.EntityReference)
1027
if (nt ==
XmlNodeType
.Document
1028
|| nt ==
XmlNodeType
.Entity
1029
|| nt ==
XmlNodeType
.Attribute)
1062
if (NodeType ==
XmlNodeType
.Document)
1091
if (node.NodeType ==
XmlNodeType
.Element)
1136
else if (node.NodeType ==
XmlNodeType
.Attribute)
1176
if (node.NodeType ==
XmlNodeType
.Element)
1215
else if (node.NodeType ==
XmlNodeType
.Attribute)
1244
if (n.NodeType ==
XmlNodeType
.Element && n.Name == name)
1260
if (n.NodeType ==
XmlNodeType
.Element && n.LocalName == localname && n.NamespaceURI == ns)
1300
internal virtual XmlNode? FindChild(
XmlNodeType
type)
1461
XmlNodeType
nodeType = _node.NodeType;
1465
case
XmlNodeType
.Element:
1466
case
XmlNodeType
.EntityReference:
1469
case
XmlNodeType
.Attribute:
1470
case
XmlNodeType
.ProcessingInstruction:
1473
case
XmlNodeType
.Text:
1474
case
XmlNodeType
.CDATA:
1475
case
XmlNodeType
.Comment:
1476
case
XmlNodeType
.Whitespace:
1477
case
XmlNodeType
.SignificantWhitespace:
1478
case
XmlNodeType
.XmlDeclaration:
1481
case
XmlNodeType
.DocumentType:
System\Xml\Dom\XmlNodeReader.cs (135)
75
XmlNodeType
nt = _curNode.NodeType;
76
if (nt ==
XmlNodeType
.Attribute)
89
if (nt ==
XmlNodeType
.Document)
103
public
XmlNodeType
NodeType
107
XmlNodeType
nt = _curNode.NodeType;
110
Debug.Assert(nt ==
XmlNodeType
.XmlDeclaration || nt ==
XmlNodeType
.DocumentType);
112
return
XmlNodeType
.Text;
114
return
XmlNodeType
.Attribute;
131
Debug.Assert(_curNode.NodeType ==
XmlNodeType
.XmlDeclaration || _curNode.NodeType ==
XmlNodeType
.DocumentType);
137
if (_curNode.NodeType ==
XmlNodeType
.XmlDeclaration)
170
private static bool IsLocalNameEmpty(
XmlNodeType
nt)
174
case
XmlNodeType
.None:
175
case
XmlNodeType
.Text:
176
case
XmlNodeType
.CDATA:
177
case
XmlNodeType
.Comment:
178
case
XmlNodeType
.Document:
179
case
XmlNodeType
.DocumentFragment:
180
case
XmlNodeType
.Whitespace:
181
case
XmlNodeType
.SignificantWhitespace:
182
case
XmlNodeType
.EndElement:
183
case
XmlNodeType
.EndEntity:
185
case
XmlNodeType
.Element:
186
case
XmlNodeType
.Attribute:
187
case
XmlNodeType
.EntityReference:
188
case
XmlNodeType
.Entity:
189
case
XmlNodeType
.ProcessingInstruction:
190
case
XmlNodeType
.DocumentType:
191
case
XmlNodeType
.Notation:
192
case
XmlNodeType
.XmlDeclaration:
214
Debug.Assert(_curNode.NodeType ==
XmlNodeType
.XmlDeclaration || _curNode.NodeType ==
XmlNodeType
.DocumentType);
218
if (_curNode.Value != null || _curNode.NodeType ==
XmlNodeType
.DocumentType)
230
XmlNodeType
nt = _curNode.NodeType;
235
Debug.Assert(nt ==
XmlNodeType
.XmlDeclaration || nt ==
XmlNodeType
.DocumentType);
237
return _curNode.NodeType ==
XmlNodeType
.XmlDeclaration ?
242
if (nt ==
XmlNodeType
.DocumentType)
246
else if (nt ==
XmlNodeType
.XmlDeclaration)
293
if (_curNode.NodeType ==
XmlNodeType
.Element)
305
if (_curNode.NodeType ==
XmlNodeType
.Attribute)
332
XmlNodeType
nt = _curNode.NodeType;
333
if (nt ==
XmlNodeType
.Element)
335
else if (nt ==
XmlNodeType
.Attribute
336
|| (_bOnAttrVal && nt !=
XmlNodeType
.XmlDeclaration && nt !=
XmlNodeType
.DocumentType))
338
else if (nt ==
XmlNodeType
.XmlDeclaration)
345
else if (nt ==
XmlNodeType
.DocumentType)
494
XmlNodeType
.Element => GetAttributeFromElement((XmlElement)_curNode!, name),
495
XmlNodeType
.Attribute => GetAttributeFromElement((XmlElement)_elemNode!, name),
496
XmlNodeType
.XmlDeclaration => GetDeclarationAttr((XmlDeclaration)_curNode, name),
497
XmlNodeType
.DocumentType => GetDocumentTypeAttr((XmlDocumentType)_curNode, name),
516
XmlNodeType
.Element => GetAttributeFromElement((XmlElement)_curNode, name, ns),
517
XmlNodeType
.Attribute => GetAttributeFromElement((XmlElement)_elemNode!, name, ns),
518
XmlNodeType
.XmlDeclaration => (ns.Length == 0) ? GetDeclarationAttr((XmlDeclaration)_curNode, name) : null,
519
XmlNodeType
.DocumentType => (ns.Length == 0) ? GetDocumentTypeAttr((XmlDocumentType)_curNode, name) : null,
530
case
XmlNodeType
.Element:
533
case
XmlNodeType
.Attribute:
536
case
XmlNodeType
.XmlDeclaration:
541
case
XmlNodeType
.DocumentType:
574
XmlNodeType
nt = _curNode.NodeType;
575
return (nt ==
XmlNodeType
.XmlDeclaration || nt ==
XmlNodeType
.DocumentType);
593
while (_curNode.NodeType !=
XmlNodeType
.Attribute && ((_curNode = _curNode.ParentNode!) != null))
601
public void ResetMove(ref int level, ref
XmlNodeType
nt)
620
if (_bOnAttrVal && _curNode.NodeType !=
XmlNodeType
.Attribute)
622
if (_curNode.NodeType ==
XmlNodeType
.Attribute)
627
nt =
XmlNodeType
.Element;
629
if (_curNode.NodeType ==
XmlNodeType
.Element)
662
XmlNodeType
nt = _curNode.NodeType;
663
if (nt ==
XmlNodeType
.Element)
665
else if (nt ==
XmlNodeType
.Attribute)
667
else if (nt ==
XmlNodeType
.XmlDeclaration && namespaceURI.Length == 0)
675
else if (nt ==
XmlNodeType
.DocumentType && namespaceURI.Length == 0)
693
case
XmlNodeType
.Element:
703
case
XmlNodeType
.Attribute:
712
case
XmlNodeType
.XmlDeclaration:
713
case
XmlNodeType
.DocumentType:
724
XmlNodeType
nt = _curNode.NodeType;
725
if (nt ==
XmlNodeType
.Attribute)
735
else if (nt ==
XmlNodeType
.Element)
746
else if (nt ==
XmlNodeType
.XmlDeclaration)
759
else if (nt ==
XmlNodeType
.DocumentType)
818
if (_curNode.NodeType !=
XmlNodeType
.Attribute)
830
case
XmlNodeType
.Attribute:
838
case
XmlNodeType
.XmlDeclaration:
839
case
XmlNodeType
.DocumentType:
875
if (node.NodeType ==
XmlNodeType
.Element)
887
else if (node.NodeType ==
XmlNodeType
.Attribute)
943
if (node.NodeType ==
XmlNodeType
.Element)
973
else if (node.NodeType ==
XmlNodeType
.Attribute)
995
if (node.NodeType ==
XmlNodeType
.Element)
1026
else if (node.NodeType ==
XmlNodeType
.Attribute)
1049
public bool ReadAttributeValue(ref int level, ref bool bResolveEntity, ref
XmlNodeType
nt)
1053
Debug.Assert(_curNode.NodeType ==
XmlNodeType
.XmlDeclaration || _curNode.NodeType ==
XmlNodeType
.DocumentType);
1058
nt =
XmlNodeType
.Text;
1063
if (_curNode.NodeType ==
XmlNodeType
.Attribute)
1078
if (_curNode.NodeType ==
XmlNodeType
.EntityReference && bResolveEntity)
1094
if (parentNode != null && parentNode.NodeType ==
XmlNodeType
.EntityReference)
1098
nt =
XmlNodeType
.EndEntity;
1130
private
XmlNodeType
_nodeType; // nodeType of the node that the reader is currently positioned on
1152
_nodeType =
XmlNodeType
.None;
1168
public override
XmlNodeType
NodeType
1170
get { return (IsInReadingStates()) ? _nodeType :
XmlNodeType
.None; }
1329
if (!IsInReadingStates() || _nodeType ==
XmlNodeType
.EndElement)
1457
if (!IsInReadingStates() || _nodeType ==
XmlNodeType
.EndElement)
1513
if ((_readerNav.NodeType ==
XmlNodeType
.Document) || (_readerNav.NodeType ==
XmlNodeType
.DocumentFragment))
1547
_nodeType =
XmlNodeType
.None;
1556
_nodeType =
XmlNodeType
.None;
1561
XmlNodeType
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));
1580
else if (_readerNav.NodeType ==
XmlNodeType
.Element
1583
_nodeType =
XmlNodeType
.EndElement;
1586
else if (_readerNav.NodeType ==
XmlNodeType
.EntityReference && _bResolveEntity)
1589
_nodeType =
XmlNodeType
.EndEntity;
1597
if (_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;
1667
if (_readerNav.NodeType ==
XmlNodeType
.Element)
1670
_nodeType =
XmlNodeType
.EndElement;
1673
else if (_readerNav.NodeType ==
XmlNodeType
.EntityReference)
1677
_nodeType =
XmlNodeType
.EndEntity;
1724
if ((this.NodeType ==
XmlNodeType
.EntityReference) && _bResolveEntity)
1774
if (!IsInReadingStates() || (_nodeType !=
XmlNodeType
.EntityReference))
System\Xml\Dom\XmlNotation.cs (2)
36
public override
XmlNodeType
NodeType
38
get { return
XmlNodeType
.Notation; }
System\Xml\Dom\XmlProcessingInstruction.cs (2)
77
public override
XmlNodeType
NodeType =>
XmlNodeType
.ProcessingInstruction;
System\Xml\Dom\XmlSignificantWhiteSpace.cs (7)
37
public override
XmlNodeType
NodeType
41
return
XmlNodeType
.SignificantWhitespace;
51
case
XmlNodeType
.Document:
53
case
XmlNodeType
.Text:
54
case
XmlNodeType
.CDATA:
55
case
XmlNodeType
.Whitespace:
56
case
XmlNodeType
.SignificantWhitespace:
System\Xml\Dom\XmlText.cs (8)
40
public override
XmlNodeType
NodeType
44
return
XmlNodeType
.Text;
54
case
XmlNodeType
.Document:
56
case
XmlNodeType
.Text:
57
case
XmlNodeType
.CDATA:
58
case
XmlNodeType
.Whitespace:
59
case
XmlNodeType
.SignificantWhitespace:
91
if (parent != null && parent.NodeType ==
XmlNodeType
.Attribute)
System\Xml\Dom\XmlWhitespace.cs (7)
38
public override
XmlNodeType
NodeType
42
return
XmlNodeType
.Whitespace;
52
case
XmlNodeType
.Document:
54
case
XmlNodeType
.Text:
55
case
XmlNodeType
.CDATA:
56
case
XmlNodeType
.Whitespace:
57
case
XmlNodeType
.SignificantWhitespace:
System\Xml\Schema\AutoValidator.cs (1)
67
if (reader.NodeType ==
XmlNodeType
.Element)
System\Xml\Schema\DtdValidator.cs (12)
62
case
XmlNodeType
.Element:
66
goto case
XmlNodeType
.EndElement;
69
case
XmlNodeType
.Whitespace:
70
case
XmlNodeType
.SignificantWhitespace:
76
case
XmlNodeType
.ProcessingInstruction:
77
case
XmlNodeType
.Comment:
81
case
XmlNodeType
.Text: // text inside a node
82
case
XmlNodeType
.CDATA: // <![CDATA[...]]>
85
case
XmlNodeType
.EntityReference:
91
case
XmlNodeType
.EndElement:
99
reader.NodeType ==
XmlNodeType
.Element)
149
Debug.Assert(reader.NodeType ==
XmlNodeType
.Element);
System\Xml\Schema\Inference\Infer.cs (32)
186
while (_xtr.NodeType !=
XmlNodeType
.Element && _xtr.Read()) ;
189
if (_xtr.NodeType ==
XmlNodeType
.Element)
693
if (_xtr.NodeType ==
XmlNodeType
.Whitespace)
697
if (_xtr.NodeType ==
XmlNodeType
.EntityReference)
701
} while ((!_xtr.EOF) && (_xtr.NodeType !=
XmlNodeType
.EndElement) && (_xtr.NodeType !=
XmlNodeType
.CDATA) && (_xtr.NodeType !=
XmlNodeType
.Element) && (_xtr.NodeType !=
XmlNodeType
.Text));
703
if (_xtr.NodeType ==
XmlNodeType
.EndElement)
768
while (!_xtr.EOF && (_xtr.NodeType !=
XmlNodeType
.EndElement))
772
if ((_xtr.NodeType ==
XmlNodeType
.Text) || (_xtr.NodeType ==
XmlNodeType
.CDATA)) //node can be simple type, complex with simple content or complex with mixed content
782
do { _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)));
784
if (_xtr.NodeType ==
XmlNodeType
.EndElement)
791
if ((_xtr.NodeType ==
XmlNodeType
.Text) && (iChildNumber == 1))
822
if (_xtr.NodeType ==
XmlNodeType
.Text)
853
if (_xtr.NodeType ==
XmlNodeType
.Text)
863
else if (_xtr.NodeType ==
XmlNodeType
.Text)
889
else if (_xtr.NodeType ==
XmlNodeType
.Element)
944
else if (_xtr.NodeType ==
XmlNodeType
.Text)
952
if (_xtr.NodeType ==
XmlNodeType
.EntityReference)
964
} while ((!_xtr.EOF) && (_xtr.NodeType !=
XmlNodeType
.EndElement) && (_xtr.NodeType !=
XmlNodeType
.CDATA) && (_xtr.NodeType !=
XmlNodeType
.Element) && (_xtr.NodeType !=
XmlNodeType
.Text));
1202
Debug.Assert(_xtr!.NodeType ==
XmlNodeType
.Attribute);
System\Xml\Schema\Parser.cs (25)
70
while (reader.NodeType !=
XmlNodeType
.Element && reader.Read()) { }
176
else if (_reader.NodeType ==
XmlNodeType
.Element)
222
else if (_reader.NodeType ==
XmlNodeType
.Text)
229
else if (_reader.NodeType ==
XmlNodeType
.EntityReference ||
230
_reader.NodeType ==
XmlNodeType
.SignificantWhitespace ||
231
_reader.NodeType ==
XmlNodeType
.CDATA)
235
else if (_reader.NodeType ==
XmlNodeType
.EndElement)
276
case
XmlNodeType
.Element:
288
case
XmlNodeType
.Text:
292
case
XmlNodeType
.SignificantWhitespace:
296
case
XmlNodeType
.CDATA:
300
case
XmlNodeType
.EntityReference:
304
case
XmlNodeType
.Comment:
308
case
XmlNodeType
.ProcessingInstruction:
312
case
XmlNodeType
.EndEntity:
315
case
XmlNodeType
.Whitespace:
318
case
XmlNodeType
.EndElement:
333
Debug.Assert(_reader!.NodeType ==
XmlNodeType
.Element);
418
Debug.Assert(_reader!.NodeType ==
XmlNodeType
.Attribute);
428
case
XmlNodeType
.Text:
431
case
XmlNodeType
.EntityReference:
444
Debug.Assert(_reader!.NodeType ==
XmlNodeType
.EntityReference);
457
case
XmlNodeType
.Text:
460
case
XmlNodeType
.EndEntity:
466
case
XmlNodeType
.EntityReference:
System\Xml\Schema\ParserAsync.cs (1)
30
while (reader.NodeType !=
XmlNodeType
.Element && await reader.ReadAsync().ConfigureAwait(false)) { }
System\Xml\Schema\XdrValidator.cs (7)
69
case
XmlNodeType
.Element:
73
goto case
XmlNodeType
.EndElement;
76
case
XmlNodeType
.Whitespace:
79
case
XmlNodeType
.Text: // text inside a node
80
case
XmlNodeType
.CDATA: // <![CDATA[...]]>
81
case
XmlNodeType
.SignificantWhitespace:
84
case
XmlNodeType
.EndElement:
System\Xml\Schema\XmlSchemaValidator.cs (1)
1054
attrData.NodeType =
XmlNodeType
.Attribute;
System\Xml\Schema\XsdValidator.cs (7)
106
case
XmlNodeType
.Element:
110
goto case
XmlNodeType
.EndElement;
113
case
XmlNodeType
.Whitespace:
116
case
XmlNodeType
.Text: // text inside a node
117
case
XmlNodeType
.CDATA: // <![CDATA[...]]>
118
case
XmlNodeType
.SignificantWhitespace:
121
case
XmlNodeType
.EndElement:
System\Xml\Serialization\_Events.cs (1)
139
public
XmlNodeType
NodeType
System\Xml\Serialization\PrimitiveXmlSerializers.cs (20)
252
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
281
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
305
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
329
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
353
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
377
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
401
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
425
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
449
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
473
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
503
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
527
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
551
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
575
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
599
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
623
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
652
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
676
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
706
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
730
if (Reader.NodeType == System.Xml.
XmlNodeType
.Element)
System\Xml\Serialization\ReflectionXmlSerializationReader.cs (18)
105
while (Reader.NodeType !=
XmlNodeType
.EndElement && Reader.NodeType !=
XmlNodeType
.None)
266
while (Reader.NodeType !=
XmlNodeType
.EndElement && Reader.NodeType !=
XmlNodeType
.None)
325
while (Reader.NodeType ==
XmlNodeType
.Element)
386
while (Reader.NodeType !=
XmlNodeType
.EndElement && Reader.NodeType !=
XmlNodeType
.None)
480
if (Reader.NodeType ==
XmlNodeType
.Element)
533
while (Reader.NodeType !=
XmlNodeType
.EndElement && Reader.NodeType !=
XmlNodeType
.None)
678
if ((Reader.NodeType ==
XmlNodeType
.Text ||
679
Reader.NodeType ==
XmlNodeType
.CDATA ||
680
Reader.NodeType ==
XmlNodeType
.Whitespace ||
681
Reader.NodeType ==
XmlNodeType
.SignificantWhitespace))
1151
while (Reader.NodeType !=
XmlNodeType
.EndElement && Reader.NodeType !=
XmlNodeType
.None)
1380
while (Reader.NodeType !=
XmlNodeType
.EndElement && Reader.NodeType !=
XmlNodeType
.None)
System\Xml\Serialization\XmlSerializationReader.cs (37)
821
while (_r.NodeType !=
XmlNodeType
.EndElement)
898
if (_r.NodeType !=
XmlNodeType
.EndElement)
900
while (_r.NodeType !=
XmlNodeType
.EndElement)
1204
if (_r.NodeType ==
XmlNodeType
.None || _r.NodeType ==
XmlNodeType
.Whitespace)
1209
if (_r.NodeType ==
XmlNodeType
.EndElement)
1215
else if (_r.NodeType ==
XmlNodeType
.Attribute && _events.OnUnknownAttribute == null)
1219
else if (_r.NodeType ==
XmlNodeType
.Element && _events.OnUnknownElement == null)
1234
if (unknownNode.NodeType !=
XmlNodeType
.None && unknownNode.NodeType !=
XmlNodeType
.Whitespace && _events.OnUnknownNode != null)
1241
if (unknownNode.NodeType ==
XmlNodeType
.Attribute)
1245
else if (unknownNode.NodeType ==
XmlNodeType
.Element)
1274
XmlNodeType
.Element => $"<{_r.LocalName} xmlns='{_r.NamespaceURI}'>",
1275
XmlNodeType
.EndElement => ">",
1276
XmlNodeType
.Text => _r.Value,
1277
XmlNodeType
.CDATA => "CDATA",
1278
XmlNodeType
.Comment => "<--",
1279
XmlNodeType
.ProcessingInstruction => "<?",
1406
while (_r.NodeType ==
XmlNodeType
.Whitespace) _r.Skip();
1407
if (_r.NodeType ==
XmlNodeType
.None) _r.Skip();
1408
if (_r.NodeType ==
XmlNodeType
.EndElement && _r.LocalName == name && _r.NamespaceURI == ns)
1670
while (_r.NodeType !=
XmlNodeType
.EndElement)
1686
while (_r.NodeType !=
XmlNodeType
.EndElement)
1762
while (_r.NodeType !=
XmlNodeType
.EndElement && _r.NodeType !=
XmlNodeType
.None)
1867
while (_r.NodeType ==
XmlNodeType
.Whitespace) _r.Skip();
1868
if (_r.NodeType ==
XmlNodeType
.None) _r.Skip();
1882
if (Reader.NodeType ==
XmlNodeType
.Attribute)
1943
while (Reader.NodeType != System.Xml.
XmlNodeType
.EndElement)
4016
Writer.Write(typeof(
XmlNodeType
).FullName);
4046
Writer.Write(typeof(
XmlNodeType
).FullName);
4049
Writer.Write(typeof(
XmlNodeType
).FullName);
4052
Writer.Write(typeof(
XmlNodeType
).FullName);
4055
Writer.Write(typeof(
XmlNodeType
).FullName);
4954
Writer.Write(typeof(
XmlNodeType
).FullName);
4956
Writer.Write(typeof(
XmlNodeType
).FullName);
4980
Writer.Write(typeof(
XmlNodeType
).FullName);
System\Xml\Serialization\XmlSerializationReaderILGen.cs (4)
2280
ilg.Ldc(
XmlNodeType
.Text);
2286
ilg.Ldc(
XmlNodeType
.CDATA);
2292
ilg.Ldc(
XmlNodeType
.Whitespace);
2298
ilg.Ldc(
XmlNodeType
.SignificantWhitespace);
System\Xml\XPath\XPathDocument.cs (14)
194
case
XmlNodeType
.Element:
232
case
XmlNodeType
.EndElement:
236
case
XmlNodeType
.Text:
237
case
XmlNodeType
.CDATA:
241
case
XmlNodeType
.SignificantWhitespace:
246
goto case
XmlNodeType
.Whitespace;
249
case
XmlNodeType
.Whitespace:
261
case
XmlNodeType
.Comment:
265
case
XmlNodeType
.ProcessingInstruction:
269
case
XmlNodeType
.EntityReference:
273
case
XmlNodeType
.DocumentType:
280
case
XmlNodeType
.EndEntity:
281
case
XmlNodeType
.None:
282
case
XmlNodeType
.XmlDeclaration:
System\Xml\XPath\XPathNavigator.cs (15)
2016
XmlTextReader reader = new XmlTextReader(xml,
XmlNodeType
.Element, context);
2044
case
XmlNodeType
.Element:
2083
case
XmlNodeType
.EndElement:
2088
case
XmlNodeType
.Text:
2089
case
XmlNodeType
.CDATA:
2092
case
XmlNodeType
.SignificantWhitespace:
2093
case
XmlNodeType
.Whitespace:
2096
case
XmlNodeType
.Comment:
2099
case
XmlNodeType
.ProcessingInstruction:
2102
case
XmlNodeType
.EntityReference:
2105
case
XmlNodeType
.EndEntity:
2106
case
XmlNodeType
.None:
2107
case
XmlNodeType
.DocumentType:
2108
case
XmlNodeType
.XmlDeclaration:
2110
case
XmlNodeType
.Attribute:
System\Xml\XPath\XPathNavigatorReader.cs (36)
34
private
XmlNodeType
_nodeType;
46
private static ReadOnlySpan<
XmlNodeType
> ConvertFromXPathNodeType =>
48
XmlNodeType
.Document, // XPathNodeType.Root
49
XmlNodeType
.Element, // XPathNodeType.Element
50
XmlNodeType
.Attribute, // XPathNodeType.Attribute
51
XmlNodeType
.Attribute, // XPathNodeType.Namespace
52
XmlNodeType
.Text, // XPathNodeType.Text
53
XmlNodeType
.SignificantWhitespace, // XPathNodeType.SignificantWhitespace
54
XmlNodeType
.Whitespace, // XPathNodeType.Whitespace
55
XmlNodeType
.ProcessingInstruction, // XPathNodeType.ProcessingInstruction
56
XmlNodeType
.Comment, // XPathNodeType.Comment
57
XmlNodeType
.None // XPathNodeType.All
64
internal static
XmlNodeType
ToXmlNodeType(XPathNodeType typ)
182
if (_nodeType ==
XmlNodeType
.Text)
193
public override
XmlNodeType
NodeType
206
if (this.NodeType ==
XmlNodeType
.Text)
220
if (this.NodeType ==
XmlNodeType
.Text)
234
if (this.NodeType ==
XmlNodeType
.Text)
297
if ((_nodeType !=
XmlNodeType
.Element)
298
&& (_nodeType !=
XmlNodeType
.Document)
299
&& (_nodeType !=
XmlNodeType
.EndElement)
300
&& (_nodeType !=
XmlNodeType
.None))
310
if ((_nodeType !=
XmlNodeType
.Element)
311
&& (_nodeType !=
XmlNodeType
.Document)
312
&& (_nodeType !=
XmlNodeType
.EndElement)
313
&& (_nodeType !=
XmlNodeType
.None))
347
if (_nodeType ==
XmlNodeType
.Element)
377
_nodeType =
XmlNodeType
.Attribute;
686
_nodeType =
XmlNodeType
.Attribute;
771
_nodeType =
XmlNodeType
.Element;
833
_nodeType =
XmlNodeType
.Text;
1005
else if (_nodeType ==
XmlNodeType
.Element
1008
_nodeType =
XmlNodeType
.EndElement;
1029
_nodeType =
XmlNodeType
.EndElement;
1067
_nodeType =
XmlNodeType
.None;
1078
_nodeType =
XmlNodeType
.None;
System\Xml\Xsl\Runtime\WhitespaceRuleReader.cs (8)
83
case
XmlNodeType
.Element:
94
case
XmlNodeType
.EndElement:
99
case
XmlNodeType
.Text:
100
case
XmlNodeType
.CDATA:
109
goto case
XmlNodeType
.Whitespace;
121
case
XmlNodeType
.Whitespace:
122
case
XmlNodeType
.SignificantWhitespace:
138
case
XmlNodeType
.EndEntity:
System\Xml\Xsl\Xslt\XsltInput.cs (73)
32
private
XmlNodeType
_nodeType;
55
_nodeType =
XmlNodeType
.Document;
59
public
XmlNodeType
NodeType { get { return _nodeType ==
XmlNodeType
.Element && 0 < _currentRecord ?
XmlNodeType
.Attribute : _nodeType; } }
122
while (MoveToNextSibling() && _nodeType ==
XmlNodeType
.Whitespace) ;
125
if (_nodeType ==
XmlNodeType
.Element)
202
_reader.NodeType ==
XmlNodeType
.Whitespace || _reader.NodeType ==
XmlNodeType
.SignificantWhitespace ||
203
_reader.NodeType ==
XmlNodeType
.Text || _reader.NodeType ==
XmlNodeType
.CDATA
213
bool isCDATA = (_reader.NodeType ==
XmlNodeType
.CDATA);
244
Debug.Assert(_reader.NodeType ==
XmlNodeType
.EntityReference);
258
Debug.Assert(_reader.NodeType ==
XmlNodeType
.Text || _reader.NodeType ==
XmlNodeType
.Whitespace || _reader.NodeType ==
XmlNodeType
.SignificantWhitespace);
261
Debug.Assert(_reader.NodeType ==
XmlNodeType
.EndEntity);
273
Debug.Assert(_reader.NodeType ==
XmlNodeType
.Attribute, "reader.NodeType == XmlNodeType.Attribute");
303
int correction = (_reader.NodeType ==
XmlNodeType
.EntityReference) ? -2 : -1;
317
case
XmlNodeType
.EntityReference:
320
case
XmlNodeType
.EndEntity:
323
Debug.Assert(_reader.NodeType ==
XmlNodeType
.Text, "Unexpected node type inside attribute value");
332
Debug.Assert(_reader.NodeType !=
XmlNodeType
.EntityReference);
333
int correction = ((_reader.NodeType ==
XmlNodeType
.EndEntity) ? 1 : lastText.Length) + 1;
348
Debug.Assert(_nodeType ==
XmlNodeType
.Element, "To call MoveToFirstChild() XsltInut should be positioned on an Element.");
358
Debug.Assert(_nodeType !=
XmlNodeType
.Element || IsEmptyElement, "On non-empty elements we should call MoveToFirstChild()");
359
if (_nodeType ==
XmlNodeType
.Element || _nodeType ==
XmlNodeType
.EndElement)
368
if (_nodeType ==
XmlNodeType
.Element && MoveToFirstChild())
386
case
XmlNodeType
.Text:
388
case
XmlNodeType
.CDATA:
393
goto case
XmlNodeType
.SignificantWhitespace;
394
case
XmlNodeType
.Whitespace:
395
case
XmlNodeType
.SignificantWhitespace:
401
case
XmlNodeType
.EntityReference:
423
case
XmlNodeType
.EndEntity:
428
!textIsWhite ?
XmlNodeType
.Text :
429
textPreserveWS ?
XmlNodeType
.SignificantWhitespace :
430
/*default: */
XmlNodeType
.Whitespace
441
Debug.Assert(_nodeType ==
XmlNodeType
.Text || _nodeType ==
XmlNodeType
.Whitespace || _nodeType ==
XmlNodeType
.SignificantWhitespace);
454
case
XmlNodeType
.Text:
455
case
XmlNodeType
.CDATA:
456
case
XmlNodeType
.Whitespace:
457
case
XmlNodeType
.SignificantWhitespace:
458
case
XmlNodeType
.EntityReference:
467
case
XmlNodeType
.Element:
471
case
XmlNodeType
.EndElement:
472
_nodeType =
XmlNodeType
.EndElement;
488
Debug.Assert(_reader.NodeType ==
XmlNodeType
.Element);
492
_nodeType =
XmlNodeType
.Element;
518
Debug.Assert(_nodeType ==
XmlNodeType
.Element, "For MoveToElement() we should be positioned on Element or Attribute");
524
Debug.Assert(_nodeType ==
XmlNodeType
.Element, "For MoveToLiteralAttribute() we should be positioned on Element or Attribute");
539
Debug.Assert(_nodeType ==
XmlNodeType
.Element, "For MoveToLiteralAttribute() we should be positioned on Element or Attribute");
589
Debug.Assert(_nodeType ==
XmlNodeType
.Element || _nodeType ==
XmlNodeType
.EndElement, "Input is positioned on element or attribute");
620
Debug.Assert(_nodeType !=
XmlNodeType
.Element || _attributesRead, "Should first read attributes");
628
Debug.Assert(_nodeType !=
XmlNodeType
.Element || _attributesRead, "Should first read attributes");
637
Debug.Assert(_nodeType !=
XmlNodeType
.Element || _attributesRead, "Should first read attributes");
714
Debug.Assert(NodeType ==
XmlNodeType
.Element);
843
Debug.Assert(NodeType ==
XmlNodeType
.Element);
921
Debug.Assert(NodeType ==
XmlNodeType
.Element && IsXsltNamespace());
1039
private static int PositionAdjustment(
XmlNodeType
nt) =>
1042
XmlNodeType
.Element => 1, // "<"
1043
XmlNodeType
.CDATA => 9, // "<![CDATA["
1044
XmlNodeType
.ProcessingInstruction => 2, // "<?"
1045
XmlNodeType
.Comment => 4, // "<!--"
1046
XmlNodeType
.EndElement => 2, // "</"
1047
XmlNodeType
.EntityReference => 1, // "&"
1179
Debug.Assert(input.NodeType ==
XmlNodeType
.EndElement);
1184
Debug.Assert(input.NodeType ==
XmlNodeType
.Element || input.NodeType ==
XmlNodeType
.Attribute);
System\Xml\Xsl\Xslt\XsltLoader.cs (28)
298
Debug.Assert(_input.NodeType ==
XmlNodeType
.Element);
370
case
XmlNodeType
.Element:
464
case
XmlNodeType
.Whitespace:
465
case
XmlNodeType
.SignificantWhitespace:
468
Debug.Assert(_input.NodeType ==
XmlNodeType
.Text);
1096
case
XmlNodeType
.Element:
1108
case
XmlNodeType
.Whitespace:
1109
case
XmlNodeType
.SignificantWhitespace:
1112
Debug.Assert(_input.NodeType ==
XmlNodeType
.Text);
1380
case
XmlNodeType
.Element:
1449
case
XmlNodeType
.SignificantWhitespace:
1452
case
XmlNodeType
.Whitespace:
1455
Debug.Assert(_input.NodeType ==
XmlNodeType
.Text);
1457
goto case
XmlNodeType
.SignificantWhitespace;
1478
case
XmlNodeType
.Element:
1499
case
XmlNodeType
.Whitespace:
1500
case
XmlNodeType
.SignificantWhitespace:
1503
Debug.Assert(_input.NodeType ==
XmlNodeType
.Text);
1671
case
XmlNodeType
.Element:
1712
case
XmlNodeType
.Whitespace:
1713
case
XmlNodeType
.SignificantWhitespace:
1716
Debug.Assert(_input.NodeType ==
XmlNodeType
.Text);
2027
case
XmlNodeType
.Text:
2028
case
XmlNodeType
.Whitespace:
2029
case
XmlNodeType
.SignificantWhitespace:
2034
Debug.Assert(_input.NodeType ==
XmlNodeType
.Element);
2480
Debug.Assert(_input.NodeType ==
XmlNodeType
.Element);
3061
if (_input.NodeType !=
XmlNodeType
.Whitespace)
System\Xml\Xsl\XsltOld\BuilderInfo.cs (3)
21
private
XmlNodeType
_nodeType;
85
Debug.Assert(info.NodeType !=
XmlNodeType
.Text || XmlCharType.IsOnlyWhitespace(info.Value));
184
internal
XmlNodeType
NodeType
System\Xml\Xsl\XsltOld\NavigatorOutput.cs (8)
34
case
XmlNodeType
.Element:
62
case
XmlNodeType
.Text:
65
case
XmlNodeType
.Whitespace:
67
case
XmlNodeType
.SignificantWhitespace:
71
case
XmlNodeType
.ProcessingInstruction:
74
case
XmlNodeType
.Comment:
78
case
XmlNodeType
.Document:
81
case
XmlNodeType
.EndElement:
System\Xml\Xsl\XsltOld\ReaderOutput.cs (21)
53
public override
XmlNodeType
NodeType
296
if (NodeType ==
XmlNodeType
.Attribute || _currentInfo == _attributeValue)
338
case
XmlNodeType
.Text:
341
_currentInfo.NodeType =
XmlNodeType
.Whitespace;
342
goto case
XmlNodeType
.Whitespace;
346
case
XmlNodeType
.Whitespace:
353
_currentInfo.NodeType =
XmlNodeType
.SignificantWhitespace;
391
if (NodeType ==
XmlNodeType
.Element || NodeType ==
XmlNodeType
.Attribute || _currentInfo == _attributeValue)
410
case
XmlNodeType
.Text:
411
case
XmlNodeType
.Whitespace:
412
case
XmlNodeType
.SignificantWhitespace:
437
if (NodeType ==
XmlNodeType
.Element && !IsEmptyElement)
450
Debug.Assert(NodeType ==
XmlNodeType
.EndElement);
456
else if (NodeType ==
XmlNodeType
.Attribute)
472
if (NodeType ==
XmlNodeType
.Element)
498
else if (NodeType ==
XmlNodeType
.Attribute)
536
Debug.Assert(NodeType !=
XmlNodeType
.EntityReference);
538
if (NodeType !=
XmlNodeType
.EntityReference)
546
if (ReadState != ReadState.Interactive || NodeType !=
XmlNodeType
.Attribute)
554
_attributeValue.NodeType =
XmlNodeType
.Text;
System\Xml\Xsl\XsltOld\RecordBuilder.cs (17)
195
_currentInfo.NodeType =
XmlNodeType
.Text;
286
_currentInfo!.NodeType =
XmlNodeType
.Element;
301
_currentInfo!.NodeType =
XmlNodeType
.EndElement;
332
attribute.NodeType =
XmlNodeType
.Attribute;
377
_currentInfo.NodeType =
XmlNodeType
.Attribute;
382
_currentInfo!.NodeType =
XmlNodeType
.ProcessingInstruction;
392
_currentInfo!.NodeType =
XmlNodeType
.Comment;
422
_currentInfo.NodeType =
XmlNodeType
.None;
487
Debug.Assert(_mainNode.NodeType ==
XmlNodeType
.Element);
512
Debug.Assert(_mainNode.NodeType ==
XmlNodeType
.Element);
614
Debug.Assert(_mainNode.NodeType ==
XmlNodeType
.Comment);
667
Debug.Assert(_mainNode.NodeType ==
XmlNodeType
.ProcessingInstruction || _mainNode.NodeType ==
XmlNodeType
.XmlDeclaration);
718
case
XmlNodeType
.Element:
727
case
XmlNodeType
.Comment:
730
case
XmlNodeType
.ProcessingInstruction:
762
ns.NodeType =
XmlNodeType
.Attribute;
System\Xml\Xsl\XsltOld\SequentialOutput.cs (27)
109
Debug.Assert(record.MainNode.NodeType ==
XmlNodeType
.Element);
366
case
XmlNodeType
.Element:
372
case
XmlNodeType
.Text:
373
case
XmlNodeType
.Whitespace:
374
case
XmlNodeType
.SignificantWhitespace:
427
case
XmlNodeType
.Element:
430
case
XmlNodeType
.Text:
431
case
XmlNodeType
.Whitespace:
432
case
XmlNodeType
.SignificantWhitespace:
435
case
XmlNodeType
.CDATA:
438
case
XmlNodeType
.EntityReference:
443
case
XmlNodeType
.ProcessingInstruction:
446
case
XmlNodeType
.Comment:
452
case
XmlNodeType
.Document:
454
case
XmlNodeType
.DocumentType:
457
case
XmlNodeType
.EndElement:
476
case
XmlNodeType
.Element:
479
case
XmlNodeType
.Text:
480
case
XmlNodeType
.Whitespace:
481
case
XmlNodeType
.SignificantWhitespace:
484
case
XmlNodeType
.CDATA:
487
case
XmlNodeType
.EntityReference:
492
case
XmlNodeType
.ProcessingInstruction:
495
case
XmlNodeType
.Comment:
500
case
XmlNodeType
.Document:
502
case
XmlNodeType
.DocumentType:
505
case
XmlNodeType
.EndElement:
System\Xml\Xsl\XsltOld\TextOnlyOutput.cs (3)
53
case
XmlNodeType
.Text:
54
case
XmlNodeType
.Whitespace:
55
case
XmlNodeType
.SignificantWhitespace:
System\Xml\Xsl\XsltOld\WriterOutput.cs (17)
30
case
XmlNodeType
.Element:
40
case
XmlNodeType
.Text:
41
case
XmlNodeType
.Whitespace:
42
case
XmlNodeType
.SignificantWhitespace:
45
case
XmlNodeType
.CDATA:
49
case
XmlNodeType
.EntityReference:
52
case
XmlNodeType
.ProcessingInstruction:
55
case
XmlNodeType
.Comment:
58
case
XmlNodeType
.Document:
60
case
XmlNodeType
.DocumentType:
63
case
XmlNodeType
.EndElement:
67
case
XmlNodeType
.None:
68
case
XmlNodeType
.Attribute:
69
case
XmlNodeType
.Entity:
70
case
XmlNodeType
.Notation:
71
case
XmlNodeType
.DocumentFragment:
72
case
XmlNodeType
.EndEntity:
System.Private.Xml.Linq (160)
System\Xml\Linq\XAttribute.cs (2)
123
public override
XmlNodeType
NodeType
127
return
XmlNodeType
.Attribute;
System\Xml\Linq\XCData.cs (2)
34
public override
XmlNodeType
NodeType
38
return
XmlNodeType
.CDATA;
System\Xml\Linq\XComment.cs (2)
59
public override
XmlNodeType
NodeType
63
return
XmlNodeType
.Comment;
System\Xml\Linq\XContainer.cs (46)
668
if (n.NodeType !=
XmlNodeType
.Text) return null;
678
while (n != null && n.NodeType ==
XmlNodeType
.Text)
905
case
XmlNodeType
.Element:
921
case
XmlNodeType
.EndElement:
926
case
XmlNodeType
.Text:
927
case
XmlNodeType
.SignificantWhitespace:
928
case
XmlNodeType
.Whitespace:
931
case
XmlNodeType
.CDATA:
934
case
XmlNodeType
.Comment:
937
case
XmlNodeType
.ProcessingInstruction:
940
case
XmlNodeType
.DocumentType:
943
case
XmlNodeType
.EntityReference:
947
case
XmlNodeType
.EndEntity:
959
case
XmlNodeType
.Element:
977
case
XmlNodeType
.EndElement:
982
case
XmlNodeType
.Text:
983
case
XmlNodeType
.SignificantWhitespace:
984
case
XmlNodeType
.Whitespace:
987
case
XmlNodeType
.CDATA:
990
case
XmlNodeType
.Comment:
993
case
XmlNodeType
.ProcessingInstruction:
996
case
XmlNodeType
.DocumentType:
999
case
XmlNodeType
.EntityReference:
1003
case
XmlNodeType
.EndEntity:
1018
case
XmlNodeType
.Element:
1053
case
XmlNodeType
.EndElement:
1072
case
XmlNodeType
.Text:
1073
case
XmlNodeType
.SignificantWhitespace:
1074
case
XmlNodeType
.Whitespace:
1085
case
XmlNodeType
.CDATA:
1088
case
XmlNodeType
.Comment:
1091
case
XmlNodeType
.ProcessingInstruction:
1094
case
XmlNodeType
.DocumentType:
1097
case
XmlNodeType
.EntityReference:
1101
case
XmlNodeType
.EndEntity:
1132
case
XmlNodeType
.Element:
1169
case
XmlNodeType
.EndElement:
1188
case
XmlNodeType
.Text:
1189
case
XmlNodeType
.SignificantWhitespace:
1190
case
XmlNodeType
.Whitespace:
1201
case
XmlNodeType
.CDATA:
1204
case
XmlNodeType
.Comment:
1207
case
XmlNodeType
.ProcessingInstruction:
1210
case
XmlNodeType
.DocumentType:
1213
case
XmlNodeType
.EntityReference:
1217
case
XmlNodeType
.EndEntity:
System\Xml\Linq\XDocument.cs (20)
138
public override
XmlNodeType
NodeType
142
return
XmlNodeType
.Document;
499
if (reader.NodeType ==
XmlNodeType
.XmlDeclaration)
900
case
XmlNodeType
.Text:
903
case
XmlNodeType
.Element:
904
ValidateDocument(previous,
XmlNodeType
.DocumentType,
XmlNodeType
.None);
906
case
XmlNodeType
.DocumentType:
907
ValidateDocument(previous,
XmlNodeType
.None,
XmlNodeType
.Element);
909
case
XmlNodeType
.CDATA:
910
throw new ArgumentException(SR.Format(SR.Argument_AddNode,
XmlNodeType
.CDATA));
911
case
XmlNodeType
.Document:
912
throw new ArgumentException(SR.Format(SR.Argument_AddNode,
XmlNodeType
.Document));
916
private void ValidateDocument(XNode? previous,
XmlNodeType
allowBefore,
XmlNodeType
allowAfter)
925
XmlNodeType
nt = n.NodeType;
926
if (nt ==
XmlNodeType
.Element || nt ==
XmlNodeType
.DocumentType)
929
allowBefore =
XmlNodeType
.None;
System\Xml\Linq\XDocumentType.cs (2)
96
public override
XmlNodeType
NodeType
100
return
XmlNodeType
.DocumentType;
System\Xml\Linq\XElement.cs (10)
288
public override
XmlNodeType
NodeType
292
return
XmlNodeType
.Element;
811
if (reader.MoveToContent() !=
XmlNodeType
.Element) throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ExpectedNodeType,
XmlNodeType
.Element, reader.NodeType));
846
if (await reader.MoveToContentAsync().ConfigureAwait(false) !=
XmlNodeType
.Element) throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ExpectedNodeType,
XmlNodeType
.Element, reader.NodeType));
1883
if (reader.MoveToContent() !=
XmlNodeType
.Element) throw new InvalidOperationException(SR.Format(SR.InvalidOperation_ExpectedNodeType,
XmlNodeType
.Element, reader.NodeType));
2125
if (node is XDocument) throw new ArgumentException(SR.Format(SR.Argument_AddNode,
XmlNodeType
.Document));
2126
if (node is XDocumentType) throw new ArgumentException(SR.Format(SR.Argument_AddNode,
XmlNodeType
.DocumentType));
System\Xml\Linq\XNode.cs (16)
433
case
XmlNodeType
.Text:
434
case
XmlNodeType
.SignificantWhitespace:
435
case
XmlNodeType
.Whitespace:
437
case
XmlNodeType
.CDATA:
439
case
XmlNodeType
.Comment:
441
case
XmlNodeType
.DocumentType:
443
case
XmlNodeType
.Element:
445
case
XmlNodeType
.ProcessingInstruction:
481
case
XmlNodeType
.Text:
482
case
XmlNodeType
.SignificantWhitespace:
483
case
XmlNodeType
.Whitespace:
486
case
XmlNodeType
.CDATA:
489
case
XmlNodeType
.Comment:
492
case
XmlNodeType
.DocumentType:
500
case
XmlNodeType
.Element:
502
case
XmlNodeType
.ProcessingInstruction:
System\Xml\Linq\XNodeReader.cs (21)
165
case
XmlNodeType
.Attribute:
166
case
XmlNodeType
.Text:
167
case
XmlNodeType
.CDATA:
168
case
XmlNodeType
.Comment:
169
case
XmlNodeType
.ProcessingInstruction:
170
case
XmlNodeType
.DocumentType:
274
public override
XmlNodeType
NodeType
280
return
XmlNodeType
.None;
287
return
XmlNodeType
.EndElement;
289
XmlNodeType
nt = o.NodeType;
290
if (nt !=
XmlNodeType
.Text)
296
return
XmlNodeType
.Whitespace;
298
return
XmlNodeType
.Text;
302
return
XmlNodeType
.Whitespace;
304
return
XmlNodeType
.Text;
369
case
XmlNodeType
.Attribute:
371
case
XmlNodeType
.Text:
372
case
XmlNodeType
.CDATA:
374
case
XmlNodeType
.Comment:
376
case
XmlNodeType
.ProcessingInstruction:
378
case
XmlNodeType
.DocumentType:
System\Xml\Linq\XObject.cs (1)
63
public abstract
XmlNodeType
NodeType { get; }
System\Xml\Linq\XProcessingInstruction.cs (2)
85
public override
XmlNodeType
NodeType
89
return
XmlNodeType
.ProcessingInstruction;
System\Xml\Linq\XText.cs (2)
51
public override
XmlNodeType
NodeType
55
return
XmlNodeType
.Text;
System\Xml\Schema\XNodeValidator.cs (5)
45
XmlNodeType
nt = source.NodeType;
48
case
XmlNodeType
.Document:
53
case
XmlNodeType
.Element:
55
case
XmlNodeType
.Attribute:
77
if (nt ==
XmlNodeType
.Attribute)
System\Xml\XPath\XNodeNavigator.cs (29)
16
(1 << (int)
XmlNodeType
.Element) |
17
(1 << (int)
XmlNodeType
.ProcessingInstruction) |
18
(1 << (int)
XmlNodeType
.Comment);
22
(1 << (int)
XmlNodeType
.Element), // Element
25
(1 << (int)
XmlNodeType
.CDATA) |
26
(1 << (int)
XmlNodeType
.Text), // Text
29
(1 << (int)
XmlNodeType
.ProcessingInstruction), // ProcessingInstruction
30
(1 << (int)
XmlNodeType
.Comment), // Comment
31
(1 << (int)
XmlNodeType
.Element) |
32
(1 << (int)
XmlNodeType
.CDATA) |
33
(1 << (int)
XmlNodeType
.Text) |
34
(1 << (int)
XmlNodeType
.ProcessingInstruction) |
35
(1 << (int)
XmlNodeType
.Comment) // All
38
(1 << (int)
XmlNodeType
.CDATA) |
39
(1 << (int)
XmlNodeType
.Text);
206
case
XmlNodeType
.Element:
208
case
XmlNodeType
.Attribute:
211
case
XmlNodeType
.Document:
213
case
XmlNodeType
.Comment:
215
case
XmlNodeType
.ProcessingInstruction:
274
case
XmlNodeType
.Element:
276
case
XmlNodeType
.Attribute:
278
case
XmlNodeType
.Document:
281
case
XmlNodeType
.Text:
282
case
XmlNodeType
.CDATA:
284
case
XmlNodeType
.Comment:
286
case
XmlNodeType
.ProcessingInstruction:
927
if (node is XDocumentType) throw new ArgumentException(SR.Format(SR.Argument_CreateNavigator,
XmlNodeType
.DocumentType));
931
if (text.GetParent() is XDocument) throw new ArgumentException(SR.Format(SR.Argument_CreateNavigator,
XmlNodeType
.Whitespace));
System.Security.Cryptography.Xml (7)
System\Security\Cryptography\Xml\CanonicalXmlDocument.cs (2)
35
if (childNode.NodeType ==
XmlNodeType
.Element)
52
if (childNode.NodeType ==
XmlNodeType
.Element)
System\Security\Cryptography\Xml\EncryptedXml.cs (1)
771
if (parent.NodeType ==
XmlNodeType
.Document)
System\Security\Cryptography\Xml\Utils.cs (3)
97
return n.NodeType ==
XmlNodeType
.Attribute && (n.Prefix.Equals("xmlns") || (n.Prefix.Length == 0 && n.LocalName.Equals("xmlns")));
102
return n.NodeType ==
XmlNodeType
.Attribute && n.Prefix.Equals("xml");
108
bool b1 = n.NodeType ==
XmlNodeType
.Attribute && n.Prefix.Length == 0 && n.LocalName.Equals("xmlns");
System\Security\Cryptography\Xml\XmlDecryptionTransform.cs (1)
175
if (parent.NodeType ==
XmlNodeType
.Document)
System.ServiceModel.Primitives (80)
Extensions\XmlReaderExtensions.cs (2)
13
if (reader.MoveToContent() !=
XmlNodeType
.Element)
24
if (reader.MoveToContent() !=
XmlNodeType
.Element)
Internals\System\Xml\XmlMtomReader.cs (9)
332
if (_xmlReader.NodeType ==
XmlNodeType
.Element)
491
if (NodeType !=
XmlNodeType
.Attribute)
744
public override
XmlNodeType
NodeType
1134
private
XmlNodeType
_nodeType;
1151
_nodeType =
XmlNodeType
.None;
1165
public override
XmlNodeType
NodeType
1180
_nodeType =
XmlNodeType
.Text;
1186
_nodeType =
XmlNodeType
.EndElement;
1194
_nodeType =
XmlNodeType
.None;
System\ServiceModel\Channels\AddressHeader.cs (2)
346
Fx.Assert(reader.NodeType ==
XmlNodeType
.Element, "");
392
while (reader.NodeType !=
XmlNodeType
.EndElement)
System\ServiceModel\Channels\BinaryMessageEncoder.cs (1)
1599
while (reader.NodeType !=
XmlNodeType
.EndElement)
System\ServiceModel\Channels\BodyWriter.cs (1)
168
while (reader.NodeType !=
XmlNodeType
.EndElement)
System\ServiceModel\Channels\Message.cs (14)
644
if (reader.NodeType !=
XmlNodeType
.Element)
649
if (reader.NodeType ==
XmlNodeType
.Element)
654
else if (reader.NodeType ==
XmlNodeType
.EndElement)
986
if (reader.MoveToContent() !=
XmlNodeType
.Element)
1011
XmlNodeType
type = _reader.MoveToContent();
1012
while (!_reader.EOF && type !=
XmlNodeType
.EndElement)
1014
if (type !=
XmlNodeType
.Element)
1267
while (bodyReader.NodeType !=
XmlNodeType
.EndElement && !bodyReader.EOF)
1333
if (reader.NodeType !=
XmlNodeType
.Element)
1369
if (reader.NodeType !=
XmlNodeType
.Element)
1687
if (reader.NodeType !=
XmlNodeType
.Element)
1704
if (reader.NodeType !=
XmlNodeType
.Element)
1717
if (reader.NodeType !=
XmlNodeType
.Element)
1743
while (reader.NodeType !=
XmlNodeType
.EndElement)
System\ServiceModel\Channels\MessageFault.cs (4)
197
if (reader.NodeType !=
XmlNodeType
.EndElement && !reader.EOF)
626
hasDetail = (reader.MoveToContent() !=
XmlNodeType
.EndElement);
654
while (r.NodeType !=
XmlNodeType
.EndElement)
687
while (r.NodeType !=
XmlNodeType
.EndElement)
System\ServiceModel\Channels\MessageHeader.cs (1)
502
while (reader.NodeType !=
XmlNodeType
.EndElement)
System\ServiceModel\Channels\MessageHeaders.cs (8)
486
if (reader.NodeType !=
XmlNodeType
.Element)
488
if (reader.MoveToContent() !=
XmlNodeType
.Element)
886
if (reader.NodeType ==
XmlNodeType
.Element)
895
if (reader.NodeType ==
XmlNodeType
.Element)
919
if (reader.NodeType !=
XmlNodeType
.Element)
938
if (reader.MoveToContent() ==
XmlNodeType
.Element && !reader.IsEmptyElement)
948
if (reader.NodeType ==
XmlNodeType
.EndElement)
1853
while (reader.NodeType !=
XmlNodeType
.EndElement)
System\ServiceModel\Channels\WsrmFault.cs (2)
723
if ((headerReader.NodeType !=
XmlNodeType
.Element)
748
if ((headerReader.NodeType ==
XmlNodeType
.Element)
System\ServiceModel\Dispatcher\EndpointAddressProcessor.cs (6)
29
XmlNodeType
type = reader.MoveToContent();
32
case
XmlNodeType
.Element:
103
case
XmlNodeType
.EndElement:
110
case
XmlNodeType
.CDATA:
119
case
XmlNodeType
.SignificantWhitespace:
120
case
XmlNodeType
.Text:
System\ServiceModel\Dispatcher\FaultFormatter.cs (1)
157
if (detailReader.NodeType !=
XmlNodeType
.EndElement && !detailReader.EOF)
System\ServiceModel\Dispatcher\StreamFormatter.cs (2)
367
if (_reader.NodeType ==
XmlNodeType
.EndElement)
374
if (_reader.MoveToContent() !=
XmlNodeType
.Text)
System\ServiceModel\Dispatcher\XmlSerializerOperationFormatter.cs (1)
455
if (reader.NodeType ==
XmlNodeType
.EndElement)
System\ServiceModel\EndpointAddress.cs (3)
531
else if (reader.NodeType !=
XmlNodeType
.Element)
879
while (reader.NodeType !=
XmlNodeType
.EndElement && !reader.EOF)
934
return (reader.NodeType ==
XmlNodeType
.EndElement || reader.EOF);
System\ServiceModel\EndpointIdentity.cs (1)
190
else if (reader.NodeType ==
XmlNodeType
.Element)
System\ServiceModel\Security\SecurityAppliedMessage.cs (2)
128
while (reader.NodeType !=
XmlNodeType
.EndElement)
155
while (reader.NodeType !=
XmlNodeType
.EndElement)
System\ServiceModel\Security\SecurityVerifiedMessage.cs (6)
210
if (reader.NodeType !=
XmlNodeType
.Element)
219
if (reader.NodeType !=
XmlNodeType
.Element)
227
if (reader.NodeType !=
XmlNodeType
.Element)
250
if (reader.NodeType !=
XmlNodeType
.Element)
380
while (reader.NodeType !=
XmlNodeType
.EndElement)
465
if (reader.NodeType !=
XmlNodeType
.Element)
System\ServiceModel\Security\WSSecureConversation.cs (1)
412
Fx.Assert(reader.NodeType ==
XmlNodeType
.Element, "");
System\ServiceModel\Security\XmlHelper.cs (13)
59
if (child.NodeType ==
XmlNodeType
.Whitespace || child.NodeType ==
XmlNodeType
.Comment)
63
else if (child.NodeType ==
XmlNodeType
.Element && result == null)
75
OnChildNodeTypeMissing(parent,
XmlNodeType
.Element);
92
if (child.NodeType ==
XmlNodeType
.Whitespace || child.NodeType ==
XmlNodeType
.Comment)
96
else if (child.NodeType ==
XmlNodeType
.Element)
129
while (reader.NodeType ==
XmlNodeType
.Whitespace || reader.NodeType ==
XmlNodeType
.SignificantWhitespace)
155
if (reader.NodeType ==
XmlNodeType
.Comment)
159
else if (reader.NodeType ==
XmlNodeType
.Whitespace)
169
internal static void OnChildNodeTypeMissing(string parentName,
XmlNodeType
expectedNodeType)
174
internal static void OnChildNodeTypeMissing(XmlElement parent,
XmlNodeType
expectedNodeType)
System.ServiceModel.Syndication (7)
System\ServiceModel\Syndication\SyndicationFeedFormatter.cs (7)
498
case
XmlNodeType
.Element:
500
case
XmlNodeType
.EndElement:
502
case
XmlNodeType
.Text:
503
case
XmlNodeType
.Whitespace:
504
case
XmlNodeType
.SignificantWhitespace:
506
case
XmlNodeType
.Comment:
508
case
XmlNodeType
.CDATA:
System.Windows.Forms (11)
System\Resources\ResXResourceReader.cs (11)
351
if (reader.NodeType ==
XmlNodeType
.Element)
475
_resHeaderVersion = reader.NodeType ==
XmlNodeType
.Element ? reader.ReadElementString() : reader.Value.Trim();
479
_resHeaderMimeType = reader.NodeType ==
XmlNodeType
.Element ? reader.ReadElementString() : reader.Value.Trim();
483
_resHeaderReaderType = reader.NodeType ==
XmlNodeType
.Element ? reader.ReadElementString() : reader.Value.Trim();
487
_resHeaderWriterType = reader.NodeType ==
XmlNodeType
.Element ? reader.ReadElementString() : reader.Value.Trim();
494
_resHeaderVersion = reader.NodeType ==
XmlNodeType
.Element ? reader.ReadElementString() : reader.Value.Trim();
497
_resHeaderMimeType = reader.NodeType ==
XmlNodeType
.Element ? reader.ReadElementString() : reader.Value.Trim();
500
_resHeaderReaderType = reader.NodeType ==
XmlNodeType
.Element ? reader.ReadElementString() : reader.Value.Trim();
503
_resHeaderWriterType = reader.NodeType ==
XmlNodeType
.Element ? reader.ReadElementString() : reader.Value.Trim();
558
if (reader.NodeType ==
XmlNodeType
.EndElement
566
if (reader.NodeType !=
XmlNodeType
.Element)
System.Xaml (15)
src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlCompatibilityReader.cs (3)
172
case
XmlNodeType
.Element:
183
case
XmlNodeType
.EndElement:
750
_inAttribute = (Reader.NodeType ==
XmlNodeType
.Attribute);
src\Microsoft.DotNet.Wpf\src\Shared\System\Windows\Markup\XmlWrappingReader.cs (1)
42
public override
XmlNodeType
NodeType { get { return _reader.NodeType; } }
System\Xaml\Parser\XamlScanner.cs (11)
176
XmlNodeType
xmlNodeType = _xmlReader.NodeType;
179
case
XmlNodeType
.Element:
183
case
XmlNodeType
.EndElement:
187
case
XmlNodeType
.Text:
188
case
XmlNodeType
.CDATA:
192
case
XmlNodeType
.SignificantWhitespace:
193
case
XmlNodeType
.Whitespace:
197
case
XmlNodeType
.None:
246
Debug.Assert(_xmlReader.NodeType ==
XmlNodeType
.Element);
283
Debug.Assert(_xmlReader.NodeType ==
XmlNodeType
.Element);
428
Debug.Assert(_xmlReader.NodeType ==
XmlNodeType
.Element);
System.Xml (1)
System.Xml.cs (1)
219
[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Xml.
XmlNodeType
))]
System.Xml.ReaderWriter (1)
artifacts\obj\System.Xml.ReaderWriter\Debug\net10.0\System.Xml.ReaderWriter.Forwards.cs (1)
147
[assembly: System.Runtime.CompilerServices.TypeForwardedTo(typeof(System.Xml.
XmlNodeType
))]