247CodeTypeReferenceExpression xmlNodeType = new CodeTypeReferenceExpression(typeof(Microsoft.Xml.XmlNodeType));

297private XmlNodeType _nodetype; 305private XmlNodeType _parentNodeType; // use for MoveToElement() 366_nodetype = XmlNodeType.None; 456public override XmlNodeType NodeType 510case XmlNodeType.DocumentType: 511case XmlNodeType.ProcessingInstruction: 512case XmlNodeType.Comment: 515case XmlNodeType.CDATA: 518case XmlNodeType.XmlDeclaration: 521case XmlNodeType.Text: 522case XmlNodeType.Whitespace: 523case XmlNodeType.SignificantWhitespace: 550if (_nodetype == XmlNodeType.Element 551|| _nodetype == XmlNodeType.EndElement) 560if (_parentNodeType != XmlNodeType.Element) 565if (_parentNodeType != XmlNodeType.Element) 823if (XmlNodeType.Element == _parentNodeType) 825else if (XmlNodeType.XmlDeclaration == _parentNodeType) 827else if (XmlNodeType.DocumentType == _parentNodeType) 879_nodetype = XmlNodeType.Text; 896_nodetype = XmlNodeType.None; 962_nodetype = XmlNodeType.None; 1008if (this.NodeType == XmlNodeType.EndElement) 1010if (this.NodeType == XmlNodeType.ProcessingInstruction || this.NodeType == XmlNodeType.Comment) 1012while (Read() && (this.NodeType == XmlNodeType.ProcessingInstruction || this.NodeType == XmlNodeType.Comment)) 1014if (this.NodeType == XmlNodeType.EndElement) 1043if (this.NodeType != XmlNodeType.Element && this.NodeType != XmlNodeType.EndElement) 1051case XmlNodeType.ProcessingInstruction: 1052case XmlNodeType.Comment: 1055case XmlNodeType.Element: 1056case XmlNodeType.EndElement: 1739if (this.NodeType == XmlNodeType.Element || this.NodeType == XmlNodeType.EndElement) 1778if (this.NodeType == XmlNodeType.Element || this.NodeType == XmlNodeType.EndElement) 2423_nodetype = XmlNodeType.Attribute; 2590_nodetype = XmlNodeType.XmlDeclaration; 2826case XmlNodeType.CDATA: 2829case XmlNodeType.EndElement: 2832case XmlNodeType.Element: 2843_nodetype = XmlNodeType.None; 2956if (XmlNodeType.Text == _nodetype) 3111_nodetype = XmlNodeType.Element; 3125_nodetype = XmlNodeType.EndElement; 3165_nodetype = XmlNodeType.DocumentType; 3174_nodetype = XmlNodeType.ProcessingInstruction; 3179_nodetype = XmlNodeType.Comment; 3187_nodetype = XmlNodeType.CDATA; 3239|| ((_textXmlReader.NodeType == XmlNodeType.XmlDeclaration) 3353private XmlNodeType ScanOverValue(BinXmlToken token, bool attr, bool checkChars) 3376return XmlNodeType.Text; 3385private XmlNodeType ScanOverAnyValue(BinXmlToken token, bool attr, bool checkChars) 3500return XmlNodeType.Text; 3503private unsafe XmlNodeType CheckText(bool attr) 3523return _xmlspacePreserve ? XmlNodeType.SignificantWhitespace : XmlNodeType.Whitespace; 3537return XmlNodeType.Text; 3565private XmlNodeType CheckTextIsWS() 3587return XmlNodeType.SignificantWhitespace; 3588return XmlNodeType.Whitespace; 3590return XmlNodeType.Text;

42public override Task<XmlNodeType> MoveToContentAsync()

202if (_reader.NodeType != XmlNodeType.Element) 258if (_reader.NodeType != XmlNodeType.Element) 299if (_reader.NodeType != XmlNodeType.EndElement) 333Debug.Assert(_reader.NodeType == XmlNodeType.Element); 346if (_reader.NodeType != XmlNodeType.EndElement) 458if (_reader.NodeType != XmlNodeType.EndElement) 475case XmlNodeType.Attribute: 477case XmlNodeType.Text: 478case XmlNodeType.Whitespace: 479case XmlNodeType.SignificantWhitespace: 480case XmlNodeType.CDATA: 486case XmlNodeType.ProcessingInstruction: 487case XmlNodeType.Comment: 488case XmlNodeType.EndEntity: 491case XmlNodeType.EntityReference:

152if (_reader.NodeType != XmlNodeType.Element) 208if (_reader.NodeType != XmlNodeType.Element) 249if (_reader.NodeType != XmlNodeType.EndElement) 276Debug.Assert(_reader.NodeType == XmlNodeType.Element); 289if (_reader.NodeType != XmlNodeType.EndElement) 375if (_reader.NodeType != XmlNodeType.EndElement) 392case XmlNodeType.Attribute: 394case XmlNodeType.Text: 395case XmlNodeType.Whitespace: 396case XmlNodeType.SignificantWhitespace: 397case XmlNodeType.CDATA: 403case XmlNodeType.ProcessingInstruction: 404case XmlNodeType.Comment: 405case XmlNodeType.EndEntity: 408case XmlNodeType.EntityReference:

29private XmlNodeType _nodeType; 36Clear(XmlNodeType.None); 39public ValidatingReaderNodeData(XmlNodeType nodeType) 132public XmlNodeType NodeType 172internal void Clear(XmlNodeType nodeType)

94public override XmlNodeType NodeType 642public override XmlNodeType MoveToContent() 914public override Task<XmlNodeType> MoveToContentAsync()

47private XmlNodeType _lastNodeType; 68_lastNodeType = XmlNodeType.None; 204XmlNodeType nodeType = base.reader.NodeType; 210case XmlNodeType.Comment: 216case XmlNodeType.Whitespace: 222case XmlNodeType.ProcessingInstruction: 228case XmlNodeType.DocumentType: 245case XmlNodeType.Element: 265case XmlNodeType.Text: 266case XmlNodeType.CDATA: 273case XmlNodeType.EntityReference: 281case XmlNodeType.ProcessingInstruction: 293case XmlNodeType.Comment: 304case XmlNodeType.DocumentType: 337case XmlNodeType.Whitespace: 348case XmlNodeType.SignificantWhitespace: 355case XmlNodeType.EndElement:

55XmlNodeType nodeType = base.reader.NodeType; 61case XmlNodeType.Comment: 67case XmlNodeType.Whitespace: 73case XmlNodeType.ProcessingInstruction: 79case XmlNodeType.DocumentType: 96case XmlNodeType.Element: 116case XmlNodeType.Text: 117case XmlNodeType.CDATA: 124case XmlNodeType.EntityReference: 132case XmlNodeType.ProcessingInstruction: 144case XmlNodeType.Comment: 155case XmlNodeType.DocumentType: 188case XmlNodeType.Whitespace: 199case XmlNodeType.SignificantWhitespace: 206case XmlNodeType.EndElement:

107public abstract XmlNodeType NodeType { get; } 785if (this.NodeType == XmlNodeType.Element) 795if (this.NodeType == XmlNodeType.EndElement) 815public virtual XmlNodeType MoveToContent() 821case XmlNodeType.Attribute: 823goto case XmlNodeType.Element; 824case XmlNodeType.Element: 825case XmlNodeType.EndElement: 826case XmlNodeType.CDATA: 827case XmlNodeType.Text: 828case XmlNodeType.EntityReference: 829case XmlNodeType.EndEntity: 839if (MoveToContent() != XmlNodeType.Element) 849if (MoveToContent() != XmlNodeType.Element) 867if (MoveToContent() != XmlNodeType.Element) 887if (MoveToContent() != XmlNodeType.Element) 895if (this.NodeType != XmlNodeType.EndElement) 914if (MoveToContent() != XmlNodeType.Element) 927if (this.NodeType != XmlNodeType.EndElement) 946if (MoveToContent() != XmlNodeType.Element) 959if (this.NodeType != XmlNodeType.EndElement) 975if (MoveToContent() != XmlNodeType.EndElement) 985return MoveToContent() == XmlNodeType.Element; 992return (MoveToContent() == XmlNodeType.Element) && 1000return (MoveToContent() == XmlNodeType.Element) && 1017if (NodeType == XmlNodeType.Element && Ref.Equal(name, Name)) 1044if (NodeType == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI)) 1061if (NodeType != XmlNodeType.Element) 1085if (NodeType == XmlNodeType.Element && Ref.Equal(name, Name)) 1090Debug.Assert(NodeType == XmlNodeType.EndElement || NodeType == XmlNodeType.None || ReadState == ReadState.Error); 1107if (NodeType != XmlNodeType.Element) 1132if (NodeType == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI)) 1137Debug.Assert(NodeType == XmlNodeType.EndElement); 1153XmlNodeType nt; 1161if (nt == XmlNodeType.Element && Ref.Equal(name, Name)) 1165} while (nt != XmlNodeType.EndElement && !EOF); 1186XmlNodeType nt; 1194if (nt == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI)) 1198} while (nt != XmlNodeType.EndElement && !EOF); 1229if ((this.NodeType != XmlNodeType.Attribute) && (this.NodeType != XmlNodeType.Element)) 1240if (this.NodeType == XmlNodeType.Attribute) 1245if (this.NodeType == XmlNodeType.Element) 1261int d = this.NodeType == XmlNodeType.None ? -1 : this.Depth; 1266case XmlNodeType.Element: 1275case XmlNodeType.Text: 1278case XmlNodeType.Whitespace: 1279case XmlNodeType.SignificantWhitespace: 1282case XmlNodeType.CDATA: 1285case XmlNodeType.EntityReference: 1288case XmlNodeType.XmlDeclaration: 1289case XmlNodeType.ProcessingInstruction: 1292case XmlNodeType.DocumentType: 1295case XmlNodeType.Comment: 1298case XmlNodeType.EndElement: 1303if (d == this.Depth && this.NodeType == XmlNodeType.EndElement) 1315if (this.NodeType == XmlNodeType.EntityReference) 1334if ((this.NodeType != XmlNodeType.Attribute) && (this.NodeType != XmlNodeType.Element)) 1345if (this.NodeType == XmlNodeType.Attribute) 1393if (NodeType != XmlNodeType.Element) 1437static internal bool IsTextualNode(XmlNodeType nodeType) 1442Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.None))); 1443Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.Element))); 1444Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.Attribute))); 1445Debug.Assert(0 != (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.Text))); 1446Debug.Assert(0 != (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.CDATA))); 1447Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.EntityReference))); 1448Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.Entity))); 1449Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.ProcessingInstruction))); 1450Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.Comment))); 1451Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.Document))); 1452Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.DocumentType))); 1453Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.DocumentFragment))); 1454Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.Notation))); 1455Debug.Assert(0 != (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.Whitespace))); 1456Debug.Assert(0 != (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.SignificantWhitespace))); 1457Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.EndElement))); 1458Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.EndEntity))); 1459Debug.Assert(0 == (s_isTextualNodeBitmap & (1 << (int)XmlNodeType.XmlDeclaration))); 1464static internal bool CanReadContentAs(XmlNodeType nodeType) 1469Debug.Assert(0 == (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.None))); 1470Debug.Assert(0 == (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.Element))); 1471Debug.Assert(0 != (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.Attribute))); 1472Debug.Assert(0 != (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.Text))); 1473Debug.Assert(0 != (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.CDATA))); 1474Debug.Assert(0 != (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.EntityReference))); 1475Debug.Assert(0 == (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.Entity))); 1476Debug.Assert(0 != (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.ProcessingInstruction))); 1477Debug.Assert(0 != (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.Comment))); 1478Debug.Assert(0 == (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.Document))); 1479Debug.Assert(0 == (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.DocumentType))); 1480Debug.Assert(0 == (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.DocumentFragment))); 1481Debug.Assert(0 == (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.Notation))); 1482Debug.Assert(0 != (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.Whitespace))); 1483Debug.Assert(0 != (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.SignificantWhitespace))); 1484Debug.Assert(0 != (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.EndElement))); 1485Debug.Assert(0 != (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.EndEntity))); 1486Debug.Assert(0 == (s_canReadContentAsBitmap & (1 << (int)XmlNodeType.XmlDeclaration))); 1491static internal bool HasValueInternal(XmlNodeType nodeType) 1496Debug.Assert(0 == (s_hasValueBitmap & (1 << (int)XmlNodeType.None))); 1497Debug.Assert(0 == (s_hasValueBitmap & (1 << (int)XmlNodeType.Element))); 1498Debug.Assert(0 != (s_hasValueBitmap & (1 << (int)XmlNodeType.Attribute))); 1499Debug.Assert(0 != (s_hasValueBitmap & (1 << (int)XmlNodeType.Text))); 1500Debug.Assert(0 != (s_hasValueBitmap & (1 << (int)XmlNodeType.CDATA))); 1501Debug.Assert(0 == (s_hasValueBitmap & (1 << (int)XmlNodeType.EntityReference))); 1502Debug.Assert(0 == (s_hasValueBitmap & (1 << (int)XmlNodeType.Entity))); 1503Debug.Assert(0 != (s_hasValueBitmap & (1 << (int)XmlNodeType.ProcessingInstruction))); 1504Debug.Assert(0 != (s_hasValueBitmap & (1 << (int)XmlNodeType.Comment))); 1505Debug.Assert(0 == (s_hasValueBitmap & (1 << (int)XmlNodeType.Document))); 1506Debug.Assert(0 != (s_hasValueBitmap & (1 << (int)XmlNodeType.DocumentType))); 1507Debug.Assert(0 == (s_hasValueBitmap & (1 << (int)XmlNodeType.DocumentFragment))); 1508Debug.Assert(0 == (s_hasValueBitmap & (1 << (int)XmlNodeType.Notation))); 1509Debug.Assert(0 != (s_hasValueBitmap & (1 << (int)XmlNodeType.Whitespace))); 1510Debug.Assert(0 != (s_hasValueBitmap & (1 << (int)XmlNodeType.SignificantWhitespace))); 1511Debug.Assert(0 == (s_hasValueBitmap & (1 << (int)XmlNodeType.EndElement))); 1512Debug.Assert(0 == (s_hasValueBitmap & (1 << (int)XmlNodeType.EndEntity))); 1513Debug.Assert(0 != (s_hasValueBitmap & (1 << (int)XmlNodeType.XmlDeclaration))); 1525if (NodeType == XmlNodeType.Element && !IsEmptyElement) 1535if (NodeType == XmlNodeType.EndElement) 1556if (NodeType != XmlNodeType.Element) 1581static internal Exception CreateReadContentAsException(string methodName, XmlNodeType nodeType, IXmlLineInfo lineInfo) 1586static internal Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType, IXmlLineInfo lineInfo) 1611case XmlNodeType.Attribute: 1613case XmlNodeType.Text: 1614case XmlNodeType.Whitespace: 1615case XmlNodeType.SignificantWhitespace: 1616case XmlNodeType.CDATA: 1632case XmlNodeType.ProcessingInstruction: 1633case XmlNodeType.Comment: 1634case XmlNodeType.EndEntity: 1637case XmlNodeType.EntityReference: 1644case XmlNodeType.EndElement: 1656if (this.NodeType != XmlNodeType.Element) 1671XmlNodeType nodeType = this.NodeType; 1672if (nodeType == XmlNodeType.EndElement) 1677else if (nodeType == XmlNodeType.Element) 1686if (this.NodeType != XmlNodeType.EndElement) 1978XmlNodeType nt = _reader.NodeType; 1982case XmlNodeType.Element: 1983case XmlNodeType.EndElement: 1984case XmlNodeType.EntityReference: 1985case XmlNodeType.EndEntity: 1988case XmlNodeType.Attribute: 1989case XmlNodeType.ProcessingInstruction: 1992case XmlNodeType.Text: 1993case XmlNodeType.Whitespace: 1994case XmlNodeType.SignificantWhitespace: 1995case XmlNodeType.Comment: 1996case XmlNodeType.XmlDeclaration: 1997case XmlNodeType.CDATA: 2000case XmlNodeType.DocumentType:

174public virtual async Task<XmlNodeType> MoveToContentAsync() 180case XmlNodeType.Attribute: 182goto case XmlNodeType.Element; 183case XmlNodeType.Element: 184case XmlNodeType.EndElement: 185case XmlNodeType.CDATA: 186case XmlNodeType.Text: 187case XmlNodeType.EntityReference: 188case XmlNodeType.EndEntity: 202if ((this.NodeType != XmlNodeType.Attribute) && (this.NodeType != XmlNodeType.Element)) 213if (this.NodeType == XmlNodeType.Attribute) 218if (this.NodeType == XmlNodeType.Element) 234int d = this.NodeType == XmlNodeType.None ? -1 : this.Depth; 239case XmlNodeType.Element: 248case XmlNodeType.Text: 251case XmlNodeType.Whitespace: 252case XmlNodeType.SignificantWhitespace: 255case XmlNodeType.CDATA: 258case XmlNodeType.EntityReference: 261case XmlNodeType.XmlDeclaration: 262case XmlNodeType.ProcessingInstruction: 265case XmlNodeType.DocumentType: 268case XmlNodeType.Comment: 271case XmlNodeType.EndElement: 276if (d == this.Depth && this.NodeType == XmlNodeType.EndElement) 289if ((this.NodeType != XmlNodeType.Attribute) && (this.NodeType != XmlNodeType.Element)) 300if (this.NodeType == XmlNodeType.Attribute) 325if (NodeType == XmlNodeType.Element && !IsEmptyElement) 335if (NodeType == XmlNodeType.EndElement) 354case XmlNodeType.Attribute: 356case XmlNodeType.Text: 357case XmlNodeType.Whitespace: 358case XmlNodeType.SignificantWhitespace: 359case XmlNodeType.CDATA: 375case XmlNodeType.ProcessingInstruction: 376case XmlNodeType.Comment: 377case XmlNodeType.EndEntity: 380case XmlNodeType.EntityReference: 387case XmlNodeType.EndElement: 399if (this.NodeType != XmlNodeType.Element) 414XmlNodeType nodeType = this.NodeType; 415if (nodeType == XmlNodeType.EndElement) 420else if (nodeType == XmlNodeType.Element) 429if (this.NodeType != XmlNodeType.EndElement)

25internal XmlNodeType type; 36internal void Set(XmlNodeType nodeType, string localName, string prefix, string name, string namespaceUri, string value) 107_tmpNode.Set(XmlNodeType.None, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty); 115public override XmlNodeType NodeType 170if (_curNode.type == XmlNodeType.Text) 426Debug.Assert(reader.NodeType == XmlNodeType.Element); 445else if (_curNode.type == XmlNodeType.Text) 451Debug.Assert(_curNode.type == XmlNodeType.Attribute); 452_tmpNode.type = XmlNodeType.Text; 476if (reader.NodeType == XmlNodeType.EndElement || 477(reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement)) 483Debug.Assert(reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement); 546if (reader.Depth == _initialDepth && reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) 584if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) 589while (reader.NodeType != XmlNodeType.EndElement && reader.Depth > _initialDepth) 595Debug.Assert(reader.NodeType == XmlNodeType.EndElement || 596reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement || 603if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) 833case XmlNodeType.Element: 835case XmlNodeType.EndElement: 837case XmlNodeType.Attribute: 865goto case XmlNodeType.Text; 866case XmlNodeType.Text: 923if (NodeType != XmlNodeType.EndElement) 969case XmlNodeType.Element: 971case XmlNodeType.EndElement: 973case XmlNodeType.Attribute: 1001goto case XmlNodeType.Text; 1002case XmlNodeType.Text: 1058if (NodeType != XmlNodeType.EndElement) 1240case XmlNodeType.Element: 1284case XmlNodeType.EndElement: 1312_nsAttributes[index].Set(XmlNodeType.Attribute, _xmlns, string.Empty, _xmlns, _xmlnsUri, ns); 1316_nsAttributes[index].Set(XmlNodeType.Attribute, prefix, _xmlns, reader.NameTable.Add(string.Concat(_xmlns, ":", prefix)), _xmlnsUri, ns); 1356if (NodeType != XmlNodeType.Element) 1371case XmlNodeType.Element: 1373case XmlNodeType.EndElement: 1399if (NodeType != XmlNodeType.EndElement) 1491_tmpNode.type = XmlNodeType.None; 1547case XmlNodeType.Element: 1551case XmlNodeType.EndElement: 1555case XmlNodeType.Attribute:

50if (reader.NodeType == XmlNodeType.EndElement || 51(reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement)) 57Debug.Assert(reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement); 121if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) 126while (reader.NodeType != XmlNodeType.EndElement && reader.Depth > _initialDepth) 132Debug.Assert(reader.NodeType == XmlNodeType.EndElement || 133reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement || 140if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) 250case XmlNodeType.Element: 252case XmlNodeType.EndElement: 254case XmlNodeType.Attribute: 282goto case XmlNodeType.Text; 283case XmlNodeType.Text: 340if (NodeType != XmlNodeType.EndElement) 386case XmlNodeType.Element: 388case XmlNodeType.EndElement: 390case XmlNodeType.Attribute: 418goto case XmlNodeType.Text; 419case XmlNodeType.Text: 475if (NodeType != XmlNodeType.EndElement) 560if (NodeType != XmlNodeType.Element) 575case XmlNodeType.Element: 577case XmlNodeType.EndElement: 603if (NodeType != XmlNodeType.EndElement)

93public XmlTextReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context) 99public XmlTextReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context) 123public override XmlNodeType NodeType

231private XmlNodeType _fragmentType = XmlNodeType.Document; 446_fragmentType = XmlNodeType.None; 450_fragmentType = XmlNodeType.Element; 454_fragmentType = XmlNodeType.Document; 512internal XmlTextReaderImpl(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context) 534internal XmlTextReaderImpl(string xmlFragment, XmlNodeType fragType, XmlParserContext context) 564InitFragmentReader(XmlNodeType.XmlDeclaration, context, true); 845case XmlNodeType.None: settings.ConformanceLevel = ConformanceLevel.Auto; break; 846case XmlNodeType.Element: settings.ConformanceLevel = ConformanceLevel.Fragment; break; 847case XmlNodeType.Document: settings.ConformanceLevel = ConformanceLevel.Document; break; 848default: Debug.Assert(false); goto case XmlNodeType.None; 870public override XmlNodeType NodeType 976return _curNode.type == XmlNodeType.Attribute ? _curNode.quoteChar : '"'; 1192else if (_curNode.type != XmlNodeType.Attribute) 1278Debug.Assert(_curNode.type == XmlNodeType.Element); 1300_curNode.SetValueNode(XmlNodeType.Text, string.Empty); 1393case XmlNodeType.Element: 1402Debug.Assert(_curNode.type == XmlNodeType.EndElement); 1406case XmlNodeType.Attribute: 1408goto case XmlNodeType.Element; 1431if (_curNode.type != XmlNodeType.Attribute) 1451simpleValueNode.SetValueNode(XmlNodeType.Text, _curNode.StringValue); 1500if (_curNode.type != XmlNodeType.EntityReference) 1573if (_outerReader.NodeType == XmlNodeType.EntityReference && 1759if (_curNode.type != XmlNodeType.Element) 1819if (_curNode.type != XmlNodeType.Element) 2212_curNode.Clear(XmlNodeType.None); 2286if (_curNode.type != XmlNodeType.Element) 2323if (_curNode.type != XmlNodeType.Element) 2360if (_curNode.type != XmlNodeType.Element) 2574ParseCDataOrComment(XmlNodeType.Comment); 2582ParseCDataOrComment(XmlNodeType.Comment); 3042private void InitFragmentReader(XmlNodeType fragmentType, XmlParserContext parserContext, bool allowXmlDeclFragment) 3074case XmlNodeType.Attribute: 3079case XmlNodeType.Element: 3083case XmlNodeType.Document: 3087case XmlNodeType.XmlDeclaration: 3655_curNode.SetNamedNode(XmlNodeType.XmlDeclaration, _xml); 4006if (_fragmentType != XmlNodeType.Document) 4017if (_fragmentType == XmlNodeType.None) 4019_fragmentType = XmlNodeType.Element; 4036if (_fragmentType == XmlNodeType.Document || _fragmentType == XmlNodeType.None) 4038_fragmentType = XmlNodeType.Document; 4066if (_fragmentType == XmlNodeType.Document) 4070if (_fragmentType == XmlNodeType.None) 4072_fragmentType = XmlNodeType.Element; 4083if (_fragmentType == XmlNodeType.Document) 4089if (_fragmentType == XmlNodeType.None) 4091_fragmentType = XmlNodeType.Element; 4126if (_fragmentType == XmlNodeType.Document) 4137if (_fragmentType == XmlNodeType.None && _curNode.type == XmlNodeType.Text) 4139_fragmentType = XmlNodeType.Element; 4173if (!_rootElementParsed && _fragmentType == XmlNodeType.Document) 4178if (_fragmentType == XmlNodeType.None) 4180_fragmentType = _rootElementParsed ? XmlNodeType.Document : XmlNodeType.Element; 4318if (_index == 0 && _fragmentType != XmlNodeType.Document) 4336if (_index == 0 && _curNode.type != XmlNodeType.Element) 4347if (el.type != XmlNodeType.Element) 4455_curNode.SetNamedNode(XmlNodeType.Element, 4464_curNode.SetNamedNode(XmlNodeType.Element, 4471_curNode.SetNamedNode(XmlNodeType.Element, 4545Debug.Assert(_curNode.type == XmlNodeType.Element); 4740startTagNode.type = XmlNodeType.EndElement; 4750if (startTag.type == XmlNodeType.Element) 4765Debug.Assert(startTag.type == XmlNodeType.EntityReference); 4837Debug.Assert(_curNode.type == XmlNodeType.Element); 4845Debug.Assert(_curNode.type == XmlNodeType.Element); 5090Debug.Assert(_curNode.type == XmlNodeType.Element); 5106if (at.type == XmlNodeType.Attribute && at.prefix.Length > 0) 5333textChunk.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen)); 5345entityChunk.SetNamedNode(XmlNodeType.EntityReference, entityName); 5377textChunk.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen)); 5385entityChunk.SetNamedNode(XmlNodeType.EntityReference, _ps.entity.Name); 5447if (_fragmentType == XmlNodeType.Attribute) 5484textChunk.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString(valueChunkStartPos, valueChunkLen)); 5537XmlNodeType nodeType = GetTextNodeType(orChars); 5538if (nodeType == XmlNodeType.None) 5567XmlNodeType nodeType = GetTextNodeType(orChars); 5568if (nodeType == XmlNodeType.None) 5587_curNode.SetValueNode(XmlNodeType.Text, _ps.chars, startPos, endPos - startPos); 5608XmlNodeType nodeType = (_stringBuilder.Length < MinWhitespaceLookahedCount) ? GetTextNodeType(orChars) : XmlNodeType.Text; 5609if (nodeType == XmlNodeType.None) 6016if (_curNode.type != XmlNodeType.EndElement) 6028XmlNodeType nodeType = GetWhitespaceType(); 6030if (nodeType == XmlNodeType.None) 6071_curNode.SetNamedNode(XmlNodeType.EntityReference, ParseEntityName()); 6291_curNode.SetNamedNode(XmlNodeType.EndEntity, _lastEntity.Name); 6303Debug.Assert(_curNode.type == XmlNodeType.EntityReference); 6306_curNode.type = XmlNodeType.EndEntity; 6339_curNode.SetNamedNode(XmlNodeType.ProcessingInstruction, target); 6574ParseCDataOrComment(XmlNodeType.Comment); 6580ParseCDataOrComment(XmlNodeType.Comment); 6587ParseCDataOrComment(XmlNodeType.CDATA); 6591private void ParseCDataOrComment(XmlNodeType type) 6621private bool ParseCDataOrComment(XmlNodeType type, out int outStartPos, out int outEndPos) 6628Throw(ResXml.Xml_UnexpectedEOF, (type == XmlNodeType.Comment) ? "Comment" : "CDATA"); 6636char stopChar = (type == XmlNodeType.Comment) ? '-' : ']'; 6675else if (type == XmlNodeType.Comment) 6856_curNode.SetNamedNode(XmlNodeType.DocumentType, _dtdInfo.Name.ToString(), string.Empty, null); 7807newAttr.SetNamedNode(XmlNodeType.Attribute, _nameTable.Add(name)); 7847newAttr.SetNamedNode(XmlNodeType.Attribute, localName, prefix, nameWPrefix); 7865Debug.Assert(attr.type == XmlNodeType.Attribute); 7901_curNode.Clear(XmlNodeType.None); 8002private XmlNodeType GetWhitespaceType() 8008return XmlNodeType.SignificantWhitespace; 8012return XmlNodeType.Whitespace; 8015return XmlNodeType.None; 8018private XmlNodeType GetTextNodeType(int orChars) 8022return XmlNodeType.Text; 8366if (ParseCDataOrComment(XmlNodeType.Comment, out startPos, out pos)) 8374if (ParseCDataOrComment(XmlNodeType.CDATA, out startPos, out pos)) 8383_nextParsingFunction = (_index > 0 || _fragmentType != XmlNodeType.Document) ? ParsingFunction.ElementContent 8676Debug.Assert(_fragmentType == XmlNodeType.Attribute); 8679if (_curNode.type == XmlNodeType.None) 8681_curNode.type = XmlNodeType.Attribute; 8715_curNode.SetValueNode(XmlNodeType.Text, string.Empty); 8780_curNode.SetNamedNode(XmlNodeType.EntityReference, ParseEntityName()); 8858_curNode.SetValueNode(XmlNodeType.Text, _stringBuilder.ToString()); 9043Debug.Assert(_curNode.type == XmlNodeType.Element); 9057if (_curNode.type != XmlNodeType.EndElement) 9076case XmlNodeType.Attribute: 9078case XmlNodeType.Text: 9079case XmlNodeType.Whitespace: 9080case XmlNodeType.SignificantWhitespace: 9081case XmlNodeType.CDATA: 9087case XmlNodeType.ProcessingInstruction: 9088case XmlNodeType.Comment: 9089case XmlNodeType.EndEntity: 9092case XmlNodeType.EntityReference: 9236internal XmlNodeType FragmentType 9244internal void ChangeCurrentNodeType(XmlNodeType newNodeType) 9246Debug.Assert(_curNode.type == XmlNodeType.Whitespace && newNodeType == XmlNodeType.SignificantWhitespace, "Incorrect node type change!"); 9310return _fragmentType == XmlNodeType.Element ? ConformanceLevel.Fragment : ConformanceLevel.Document; 9426Debug.Assert(_nodes[_index].type == XmlNodeType.Element); 9444Debug.Assert(_nodes[_index].type == XmlNodeType.Element); 9579if (_curNode.type != XmlNodeType.EndElement)

362internal XmlNodeType type; 407Clear(XmlNodeType.None); 431return type == XmlNodeType.Element && _isEmptyOrDefault; 435Debug.Assert(type == XmlNodeType.Element); 444return type == XmlNodeType.Attribute && _isEmptyOrDefault; 448Debug.Assert(type == XmlNodeType.Attribute); 487internal void Clear(XmlNodeType type) 516internal void SetValueNode(XmlNodeType type, string value) 526internal void SetValueNode(XmlNodeType type, char[] chars, int startPos, int len) 537internal void SetNamedNode(XmlNodeType type, string localName) 542internal void SetNamedNode(XmlNodeType type, string localName, string prefix, string nameWPrefix)

34public XmlValidatingReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context) 44public XmlValidatingReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context) 57public override XmlNodeType NodeType

169internal XmlValidatingReaderImpl(string xmlFragment, XmlNodeType fragType, XmlParserContext context) 189internal XmlValidatingReaderImpl(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context) 288public override XmlNodeType NodeType 755if (_outerReader.NodeType == XmlNodeType.EntityReference && _parsingFunction != ParsingFunction.ResolveEntityInternally) 954case XmlNodeType.Attribute: 956case XmlNodeType.Element: 972XmlNodeType type = _outerReader.NodeType; 973if (type != XmlNodeType.CDATA && type != XmlNodeType.Text && 974type != XmlNodeType.Whitespace && type != XmlNodeType.SignificantWhitespace && 975type != XmlNodeType.Comment && type != XmlNodeType.ProcessingInstruction) 980if (_outerReader.NodeType != XmlNodeType.EndElement) 989case XmlNodeType.EndElement: 1049Debug.Assert(_coreReader.NodeType == XmlNodeType.EntityReference); 1098case XmlNodeType.Whitespace: 1099if (_coreReader.Depth > 0 || _coreReaderImpl.FragmentType != XmlNodeType.Document) 1103_coreReaderImpl.ChangeCurrentNodeType(XmlNodeType.SignificantWhitespace); 1107case XmlNodeType.DocumentType: 1110case XmlNodeType.EntityReference:

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

359if (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.XmlDeclaration) 367else if (reader.NodeType != XmlNodeType.Attribute) 382if (reader.NodeType == XmlNodeType.EntityReference) 408int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth; 413case XmlNodeType.Element: 422case XmlNodeType.Text: 440case XmlNodeType.Whitespace: 441case XmlNodeType.SignificantWhitespace: 446case XmlNodeType.CDATA: 449case XmlNodeType.EntityReference: 452case XmlNodeType.XmlDeclaration: 453case XmlNodeType.ProcessingInstruction: 456case XmlNodeType.DocumentType: 460case XmlNodeType.Comment: 463case XmlNodeType.EndElement: 467} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));

85if (_coreReader.NodeType == XmlNodeType.Element) 112public override XmlNodeType NodeType 400if (_cacheState != CachingReaderState.Replay || _cachedNode.NodeType != XmlNodeType.Attribute) 425case XmlNodeType.Element: 430case XmlNodeType.EndElement: 436case XmlNodeType.Comment: 437case XmlNodeType.ProcessingInstruction: 438case XmlNodeType.Text: 439case XmlNodeType.CDATA: 440case XmlNodeType.Whitespace: 441case XmlNodeType.SignificantWhitespace: 465if (_coreReader.NodeType != XmlNodeType.Element || _readAhead) 486ValidatingReaderNodeData textNode = AddContent(XmlNodeType.Text); 495Debug.Assert(_coreReader.NodeType == XmlNodeType.EndElement || (_coreReader.NodeType == XmlNodeType.Element && _coreReader.IsEmptyElement)); 500Debug.Assert(endElementNode.NodeType == XmlNodeType.EndElement); 507ValidatingReaderNodeData recordedNode = AddContent(XmlNodeType.EndElement); 508Debug.Assert(_coreReader.NodeType == XmlNodeType.EndElement || (_coreReader.NodeType == XmlNodeType.Element && _coreReader.IsEmptyElement)); 556case XmlNodeType.Element: 557if (_coreReader.NodeType != XmlNodeType.EndElement && !_readAhead) 568case XmlNodeType.Attribute: 570goto case XmlNodeType.Element; 604if (_cachedNode.NodeType != XmlNodeType.Attribute) 668attInfo.Clear(XmlNodeType.Attribute); 680attInfo = new ValidatingReaderNodeData(XmlNodeType.Attribute); 686private ValidatingReaderNodeData AddContent(XmlNodeType nodeType) 714Debug.Assert(_coreReader.NodeType == XmlNodeType.Element); 774_textNode = new ValidatingReaderNodeData(XmlNodeType.Text);

51case XmlNodeType.Element: 56case XmlNodeType.EndElement: 62case XmlNodeType.Comment: 63case XmlNodeType.ProcessingInstruction: 64case XmlNodeType.Text: 65case XmlNodeType.CDATA: 66case XmlNodeType.Whitespace: 67case XmlNodeType.SignificantWhitespace: 91if (_coreReader.NodeType != XmlNodeType.Element || _readAhead) 116case XmlNodeType.Element: 117if (_coreReader.NodeType != XmlNodeType.EndElement && !_readAhead) 128case XmlNodeType.Attribute: 130goto case XmlNodeType.Element;

224public override XmlNodeType NodeType 234XmlNodeType nodeType = _coreReader.NodeType; 236if (nodeType == XmlNodeType.Whitespace && (_validator.CurrentContentType == XmlSchemaContentType.TextOnly || _validator.CurrentContentType == XmlSchemaContentType.Mixed)) 238return XmlNodeType.SignificantWhitespace; 414case XmlNodeType.Element: 415case XmlNodeType.EndElement: //TODO Check that context is not popped to parents in the validator 422case XmlNodeType.Attribute: 452XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 485XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 518XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 551XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 584XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 617XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 650XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 683XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 719XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; //TODO special case for xsd:duration and xsd:dateTime 753if (this.NodeType != XmlNodeType.Element) 764if (this.NodeType != XmlNodeType.Element) 799if (this.NodeType != XmlNodeType.Element) 834if (this.NodeType != XmlNodeType.Element) 869if (this.NodeType != XmlNodeType.Element) 904if (this.NodeType != XmlNodeType.Element) 939if (this.NodeType != XmlNodeType.Element) 974if (this.NodeType != XmlNodeType.Element) 1009if (this.NodeType != XmlNodeType.Element) 1044if (this.NodeType != XmlNodeType.Element) 1451case XmlNodeType.Element: 1471case XmlNodeType.Attribute: 1473goto case XmlNodeType.Element; 1509if (NodeType == XmlNodeType.Attribute) 1643case XmlNodeType.Element: 1650case XmlNodeType.EndElement: 1653case XmlNodeType.Attribute: 1673case XmlNodeType.Element: 1674case XmlNodeType.EndElement: 1690case XmlNodeType.Element: 1701case XmlNodeType.EndElement: 1704case XmlNodeType.Attribute: 1721case XmlNodeType.Element: 1728case XmlNodeType.EndElement: 1731case XmlNodeType.Attribute: 1750case XmlNodeType.Element: 1751case XmlNodeType.EndElement: 1754case XmlNodeType.Attribute: 1770if (NodeType == XmlNodeType.Element || NodeType == XmlNodeType.EndElement) 1782if (NodeType == XmlNodeType.Attribute) 1911case XmlNodeType.Element: 1916case XmlNodeType.Whitespace: 1917case XmlNodeType.SignificantWhitespace: 1921case XmlNodeType.Text: // text inside a node 1922case XmlNodeType.CDATA: // <![CDATA[...]]> 1926case XmlNodeType.EndElement: 1931case XmlNodeType.EntityReference: 1934case XmlNodeType.DocumentType: 2218if (_coreReader.NodeType == XmlNodeType.Element) 2250XmlNodeType nodeType = this.NodeType; 2251if (nodeType == XmlNodeType.Attribute) 2269else if (nodeType == XmlNodeType.EndElement) 2323Debug.Assert(this.NodeType == XmlNodeType.Element); 2346if (this.NodeType == XmlNodeType.EndElement) 2366else if (this.NodeType == XmlNodeType.Element) 2375if (this.NodeType != XmlNodeType.EndElement) 2400case XmlNodeType.Element: 2404case XmlNodeType.Text: 2405case XmlNodeType.CDATA: 2409case XmlNodeType.Whitespace: 2410case XmlNodeType.SignificantWhitespace: 2414case XmlNodeType.Comment: 2415case XmlNodeType.ProcessingInstruction: 2418case XmlNodeType.EndElement: 2450Debug.Assert(_coreReader.NodeType == XmlNodeType.EndElement); 2460case XmlNodeType.Element: 2464case XmlNodeType.Text: 2465case XmlNodeType.CDATA: 2469case XmlNodeType.Whitespace: 2470case XmlNodeType.SignificantWhitespace: 2474case XmlNodeType.Comment: 2475case XmlNodeType.ProcessingInstruction: 2478case XmlNodeType.EndElement: 2513case XmlNodeType.Element: 2517case XmlNodeType.Text: 2518case XmlNodeType.CDATA: 2522case XmlNodeType.Whitespace: 2523case XmlNodeType.SignificantWhitespace: 2527case XmlNodeType.Comment: 2528case XmlNodeType.ProcessingInstruction: 2531case XmlNodeType.EndElement: 2586Debug.Assert(NodeType != XmlNodeType.Attribute); 2610_textNode = new ValidatingReaderNodeData(XmlNodeType.Text);

52XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 91XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; //TODO special case for xsd:duration and xsd:dateTime 125if (this.NodeType != XmlNodeType.Element) 137if (this.NodeType != XmlNodeType.Element) 175if (this.NodeType != XmlNodeType.Element) 344case XmlNodeType.Element: 364case XmlNodeType.Attribute: 366goto case XmlNodeType.Element; 487case XmlNodeType.Element: 491case XmlNodeType.Whitespace: 492case XmlNodeType.SignificantWhitespace: 496case XmlNodeType.Text: // text inside a node 497case XmlNodeType.CDATA: // <![CDATA[...]]> 501case XmlNodeType.EndElement: 505case XmlNodeType.EntityReference: 508case XmlNodeType.DocumentType: 630if (_coreReader.NodeType == XmlNodeType.Element) 666XmlNodeType nodeType = this.NodeType; 667if (nodeType == XmlNodeType.Attribute) 687else if (nodeType == XmlNodeType.EndElement) 750Debug.Assert(this.NodeType == XmlNodeType.Element); 774if (this.NodeType == XmlNodeType.EndElement) 794else if (this.NodeType == XmlNodeType.Element) 806if (this.NodeType != XmlNodeType.EndElement) 832case XmlNodeType.Element: 836case XmlNodeType.Text: 837case XmlNodeType.CDATA: 841case XmlNodeType.Whitespace: 842case XmlNodeType.SignificantWhitespace: 846case XmlNodeType.Comment: 847case XmlNodeType.ProcessingInstruction: 850case XmlNodeType.EndElement:

100case XmlNodeType.Document: 104case XmlNodeType.DocumentFragment: 107case XmlNodeType.Element: //Validate children of this element 129if (nodeToValidate.ParentNode.NodeType == XmlNodeType.Document) 146case XmlNodeType.Attribute: 187case XmlNodeType.Element: 218case XmlNodeType.Attribute: 285case XmlNodeType.Document: 294case XmlNodeType.DocumentFragment: 295case XmlNodeType.EntityReference: 302case XmlNodeType.Element: 306case XmlNodeType.Attribute: //Top-level attribute 315case XmlNodeType.Text: 319case XmlNodeType.CDATA: 323case XmlNodeType.Whitespace: 324case XmlNodeType.SignificantWhitespace: 328case XmlNodeType.Comment: 329case XmlNodeType.ProcessingInstruction: 510Debug.Assert(elementToValidate.ParentNode.NodeType != XmlNodeType.Document); //Handle if it is the documentElement seperately 757case XmlNodeType.EntityReference: 761case XmlNodeType.Element: //Flat validation, do not drill down into children 765case XmlNodeType.Text: 766case XmlNodeType.CDATA: 770case XmlNodeType.Whitespace: 771case XmlNodeType.SignificantWhitespace: 775case XmlNodeType.Comment: 776case XmlNodeType.ProcessingInstruction:

527XmlNodeType nodeType = XmlNodeType.None; 538if (nodeType == XmlNodeType.Document) 542else if (nodeType == XmlNodeType.DocumentFragment) 550if (nodeType == XmlNodeType.Document) 554else if (nodeType == XmlNodeType.DocumentFragment)

55case XmlNodeType.Attribute: 62case XmlNodeType.Text: 63case XmlNodeType.CDATA: 64case XmlNodeType.Whitespace: 65case XmlNodeType.SignificantWhitespace: 78goto case XmlNodeType.Element; 79case XmlNodeType.Element: 80case XmlNodeType.ProcessingInstruction: 81case XmlNodeType.Comment: 135case XmlNodeType.Element: 136case XmlNodeType.ProcessingInstruction: 138case XmlNodeType.Attribute: 175case XmlNodeType.Element: 176case XmlNodeType.DocumentFragment: 178case XmlNodeType.Document: 180case XmlNodeType.Text: 181case XmlNodeType.CDATA: 182case XmlNodeType.Whitespace: 183case XmlNodeType.SignificantWhitespace: 376&& node.NodeType != XmlNodeType.Element) 789if (_source.NodeType == XmlNodeType.Attribute) 817case XmlNodeType.Element: 824case XmlNodeType.DocumentFragment: 825case XmlNodeType.Document: 920if (_source.NodeType == XmlNodeType.Attribute) 930if (child.NodeType == XmlNodeType.Element 946if (_source.NodeType == XmlNodeType.Attribute) 985case XmlNodeType.Attribute: 997if (following.NodeType == XmlNodeType.Attribute) 1041while (following.NodeType != XmlNodeType.Element 1061case XmlNodeType.Attribute: 1080case XmlNodeType.Attribute: 1087case XmlNodeType.Text: 1088case XmlNodeType.CDATA: 1089case XmlNodeType.SignificantWhitespace: 1090case XmlNodeType.Whitespace: 1145if (sibling.NodeType == XmlNodeType.Element 1200case XmlNodeType.Element: 1207case XmlNodeType.DocumentFragment: 1208case XmlNodeType.Document: 1265if (_source.NodeType == XmlNodeType.Document) 1468if (nsAtom == null || _source.NodeType == XmlNodeType.Attribute) 1493XmlNodeType curNT = _source.NodeType; 1494if (curNT != XmlNodeType.Document && curNT != XmlNodeType.Element) 1519case XmlNodeType.Element: 1520case XmlNodeType.Document: 1521case XmlNodeType.DocumentFragment: 1536case XmlNodeType.Element: 1537case XmlNodeType.Document: 1538case XmlNodeType.DocumentFragment: 1555case XmlNodeType.Attribute: 1556case XmlNodeType.Document: 1557case XmlNodeType.DocumentFragment: 1559case XmlNodeType.Text: 1560case XmlNodeType.CDATA: 1561case XmlNodeType.SignificantWhitespace: 1562case XmlNodeType.Whitespace: 1578case XmlNodeType.Attribute: 1579case XmlNodeType.Document: 1580case XmlNodeType.DocumentFragment: 1582case XmlNodeType.Text: 1583case XmlNodeType.CDATA: 1584case XmlNodeType.SignificantWhitespace: 1585case XmlNodeType.Whitespace: 1600if (_source.NodeType != XmlNodeType.Element) 1635case XmlNodeType.Attribute: 1636case XmlNodeType.Document: 1637case XmlNodeType.DocumentFragment: 1639case XmlNodeType.Text: 1640case XmlNodeType.CDATA: 1641case XmlNodeType.SignificantWhitespace: 1642case XmlNodeType.Whitespace: 1693case XmlNodeType.Attribute: 1706case XmlNodeType.Text: 1707case XmlNodeType.CDATA: 1708case XmlNodeType.SignificantWhitespace: 1709case XmlNodeType.Whitespace: 1711goto case XmlNodeType.Element; 1712case XmlNodeType.Element: 1713case XmlNodeType.ProcessingInstruction: 1714case XmlNodeType.Comment: 1752case XmlNodeType.Attribute: 1765case XmlNodeType.Text: 1766case XmlNodeType.CDATA: 1767case XmlNodeType.SignificantWhitespace: 1768case XmlNodeType.Whitespace: 1773goto case XmlNodeType.Element; 1774case XmlNodeType.Element: 1775case XmlNodeType.ProcessingInstruction: 1776case XmlNodeType.Comment: 1940&& parent.NodeType == XmlNodeType.EntityReference) 1961&& child.NodeType == XmlNodeType.EntityReference) 1985|| node.NodeType != XmlNodeType.EntityReference) 1992&& sibling.NodeType == XmlNodeType.EntityReference) 2016|| node.NodeType != XmlNodeType.EntityReference) 2023&& sibling.NodeType == XmlNodeType.EntityReference) 2056|| node.NodeType != XmlNodeType.EntityReference) 2066case XmlNodeType.EntityReference: 2069case XmlNodeType.Text: 2070case XmlNodeType.CDATA: 2071case XmlNodeType.Whitespace: 2072case XmlNodeType.SignificantWhitespace: 2129case XmlNodeType.Element: 2131case XmlNodeType.DocumentFragment: 2134case XmlNodeType.Element: 2135case XmlNodeType.Text: 2136case XmlNodeType.CDATA: 2137case XmlNodeType.ProcessingInstruction: 2138case XmlNodeType.Comment: 2139case XmlNodeType.Whitespace: 2140case XmlNodeType.SignificantWhitespace: 2144case XmlNodeType.Document: 2147case XmlNodeType.Element: 2148case XmlNodeType.ProcessingInstruction: 2149case XmlNodeType.Comment: 2267if (node.NodeType == XmlNodeType.Element && Match(node)) 2281Debug.Assert(((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute); 2295return (node.NodeType == XmlNodeType.Element); 2319if (node.NodeType == XmlNodeType.Element && Match(node)) 2335Debug.Assert(((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute); 2351Debug.Assert(node.NodeType == XmlNodeType.Element); 2376if (node.NodeType == XmlNodeType.Element && Match(node)) 2393Debug.Assert(((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute); 2416Debug.Assert(node.NodeType == XmlNodeType.Element); 2443if (node.NodeType == XmlNodeType.Element && Match(node))

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

39public override XmlNodeType NodeType 43return XmlNodeType.CDATA; 53case XmlNodeType.Document: 55case XmlNodeType.Text: 56case XmlNodeType.CDATA: 57case XmlNodeType.Whitespace: 58case XmlNodeType.SignificantWhitespace:

202Debug.Assert(XmlDocument.IsTextNode(node.NodeType) || (node.ParentNode != null && node.ParentNode.NodeType == XmlNodeType.EntityReference)); 207case XmlNodeType.Whitespace: 209case XmlNodeType.SignificantWhitespace: 212case XmlNodeType.Text: 213case XmlNodeType.CDATA: 216case XmlNodeType.EntityReference:

32public override XmlNodeType NodeType 34get { return XmlNodeType.Comment; }

144public override XmlNodeType NodeType 146get { return XmlNodeType.XmlDeclaration; }

278public override XmlNodeType NodeType 280get { return XmlNodeType.Document; } 291get { return (XmlDocumentType)FindChild(XmlNodeType.DocumentType); } 328get { return (XmlElement)FindChild(XmlNodeType.Element); } 395internal override bool IsValidChildType(XmlNodeType type) 399case XmlNodeType.ProcessingInstruction: 400case XmlNodeType.Comment: 401case XmlNodeType.Whitespace: 402case XmlNodeType.SignificantWhitespace: 405case XmlNodeType.DocumentType: 410case XmlNodeType.Element: 415case XmlNodeType.XmlDeclaration: 426private bool HasNodeTypeInPrevSiblings(XmlNodeType nt, XmlNode refNode) 447private bool HasNodeTypeInNextSiblings(XmlNodeType nt, XmlNode refNode) 469case XmlNodeType.XmlDeclaration: 472case XmlNodeType.ProcessingInstruction: 473case XmlNodeType.Comment: 474return refChild.NodeType != XmlNodeType.XmlDeclaration; 476case XmlNodeType.DocumentType: 478if (refChild.NodeType != XmlNodeType.XmlDeclaration) 482return !HasNodeTypeInPrevSiblings(XmlNodeType.Element, refChild.PreviousSibling); 487case XmlNodeType.Element: 489if (refChild.NodeType != XmlNodeType.XmlDeclaration) 493return !HasNodeTypeInNextSiblings(XmlNodeType.DocumentType, refChild); 512case XmlNodeType.ProcessingInstruction: 513case XmlNodeType.Comment: 514case XmlNodeType.Whitespace: 515case XmlNodeType.SignificantWhitespace: 518case XmlNodeType.DocumentType: 522return !HasNodeTypeInPrevSiblings(XmlNodeType.Element, refChild); 525case XmlNodeType.Element: 527return !HasNodeTypeInNextSiblings(XmlNodeType.DocumentType, refChild.NextSibling); 698XmlNodeType nodeType = node.NodeType; 700XmlNodeType parentType; 704case XmlNodeType.EntityReference: 705case XmlNodeType.Entity: 706case XmlNodeType.DocumentType: 707case XmlNodeType.Notation: 708case XmlNodeType.XmlDeclaration: 710case XmlNodeType.Text: 711case XmlNodeType.CDATA: 712case XmlNodeType.SignificantWhitespace: 719if (parentType == XmlNodeType.Attribute) 723else if (parentType == XmlNodeType.EntityReference) 736case XmlNodeType.Whitespace: 743if (parentType == XmlNodeType.Document 744|| parentType == XmlNodeType.Attribute) 748else if (parentType == XmlNodeType.EntityReference) 767internal static bool IsTextNode(XmlNodeType nt) 771case XmlNodeType.Text: 772case XmlNodeType.CDATA: 773case XmlNodeType.Whitespace: 774case XmlNodeType.SignificantWhitespace: 794if (intnode.ParentNode != null && intnode.ParentNode.NodeType == XmlNodeType.EntityReference) 815while (n.NodeType == XmlNodeType.EntityReference) 904case XmlNodeType.Element: 911case XmlNodeType.Attribute: 917case XmlNodeType.Text: 920case XmlNodeType.Comment: 923case XmlNodeType.ProcessingInstruction: 926case XmlNodeType.XmlDeclaration: 930case XmlNodeType.CDATA: 933case XmlNodeType.DocumentType: 937case XmlNodeType.DocumentFragment: 943case XmlNodeType.EntityReference: 949case XmlNodeType.Whitespace: 953case XmlNodeType.SignificantWhitespace: 977Debug.Assert(toNode.NodeType != XmlNodeType.EntityReference); 1051public virtual XmlNode CreateNode(XmlNodeType type, string prefix, string name, string namespaceURI) 1055case XmlNodeType.Element: 1061case XmlNodeType.Attribute: 1067case XmlNodeType.Text: 1070case XmlNodeType.CDATA: 1073case XmlNodeType.EntityReference: 1076case XmlNodeType.ProcessingInstruction: 1079case XmlNodeType.XmlDeclaration: 1082case XmlNodeType.Comment: 1085case XmlNodeType.DocumentFragment: 1088case XmlNodeType.DocumentType: 1091case XmlNodeType.Document: 1094case XmlNodeType.SignificantWhitespace: 1097case XmlNodeType.Whitespace: 1114public virtual XmlNode CreateNode(XmlNodeType type, string name, string namespaceURI) 1138internal XmlNodeType ConvertToNodeType(string nodeTypeString) 1142return XmlNodeType.Element; 1146return XmlNodeType.Attribute; 1150return XmlNodeType.Text; 1154return XmlNodeType.CDATA; 1158return XmlNodeType.EntityReference; 1162return XmlNodeType.Entity; 1166return XmlNodeType.ProcessingInstruction; 1170return XmlNodeType.Comment; 1174return XmlNodeType.Document; 1178return XmlNodeType.DocumentType; 1182return XmlNodeType.DocumentFragment; 1186return XmlNodeType.Notation; 1190return XmlNodeType.SignificantWhitespace; 1194return XmlNodeType.Whitespace;

73public override XmlNodeType NodeType 75get { return XmlNodeType.DocumentFragment; } 106loader.ParsePartialContent(this, value, XmlNodeType.Element); 132internal override bool IsValidChildType(XmlNodeType type) 136case XmlNodeType.Element: 137case XmlNodeType.Text: 138case XmlNodeType.EntityReference: 139case XmlNodeType.Comment: 140case XmlNodeType.Whitespace: 141case XmlNodeType.SignificantWhitespace: 142case XmlNodeType.ProcessingInstruction: 143case XmlNodeType.CDATA: 146case XmlNodeType.XmlDeclaration: 149if (firstNode == null || firstNode.NodeType != XmlNodeType.XmlDeclaration) 160if (newChild.NodeType == XmlNodeType.XmlDeclaration) 176if (newChild.NodeType == XmlNodeType.XmlDeclaration)

57public override XmlNodeType NodeType 59get { return XmlNodeType.DocumentType; }

106public override XmlNodeType NodeType 108get { return XmlNodeType.Element; } 214internal override bool IsValidChildType(XmlNodeType type) 218case XmlNodeType.Element: 219case XmlNodeType.Text: 220case XmlNodeType.EntityReference: 221case XmlNodeType.Comment: 222case XmlNodeType.Whitespace: 223case XmlNodeType.SignificantWhitespace: 224case XmlNodeType.ProcessingInstruction: 225case XmlNodeType.CDATA: 594linkedNode.NodeType == XmlNodeType.Text && //which is text node

32Debug.Assert(parent.NodeType == XmlNodeType.Element || parent.NodeType == XmlNodeType.Document); 156if (curNode.NodeType == XmlNodeType.Element)

97internal override bool IsValidChildType(XmlNodeType type) 99return (type == XmlNodeType.Text || 100type == XmlNodeType.Element || 101type == XmlNodeType.ProcessingInstruction || 102type == XmlNodeType.Comment || 103type == XmlNodeType.CDATA || 104type == XmlNodeType.Whitespace || 105type == XmlNodeType.SignificantWhitespace || 106type == XmlNodeType.EntityReference); 110public override XmlNodeType NodeType 112get { return XmlNodeType.Entity; }

79public override XmlNodeType NodeType 81get { return XmlNodeType.EntityReference; } 135internal override bool IsValidChildType(XmlNodeType type) 139case XmlNodeType.Element: 140case XmlNodeType.Text: 141case XmlNodeType.EntityReference: 142case XmlNodeType.Comment: 143case XmlNodeType.Whitespace: 144case XmlNodeType.SignificantWhitespace: 145case XmlNodeType.ProcessingInstruction: 146case XmlNodeType.CDATA:

92if (n.NodeType != XmlNodeType.Attribute) 111case XmlNodeType.Element: 149case XmlNodeType.EndElement: 154Debug.Assert(parent.NodeType == XmlNodeType.Element); 171case XmlNodeType.EntityReference: 175case XmlNodeType.EndEntity: 179case XmlNodeType.Attribute: 183case XmlNodeType.Text: 187case XmlNodeType.SignificantWhitespace: 191case XmlNodeType.Whitespace: 206case XmlNodeType.CDATA: 211case XmlNodeType.XmlDeclaration: 215case XmlNodeType.ProcessingInstruction: 219case XmlNodeType.Comment: 223case XmlNodeType.DocumentType: 256Debug.Assert(_reader.NodeType == XmlNodeType.Attribute); 275case XmlNodeType.Text: 278case XmlNodeType.EntityReference: 332case XmlNodeType.Text: 335case XmlNodeType.EndEntity: 337case XmlNodeType.EntityReference: 362Debug.Assert(_reader.NodeType == XmlNodeType.EntityReference); 367while (_reader.Read() && _reader.NodeType != XmlNodeType.EndEntity) 385Debug.Assert(_reader.NodeType == XmlNodeType.XmlDeclaration); 423Debug.Assert(_reader.NodeType == XmlNodeType.DocumentType); 469case XmlNodeType.Element: 497case XmlNodeType.EndElement: 498Debug.Assert(parent.NodeType == XmlNodeType.Element); 506case XmlNodeType.EntityReference: 510case XmlNodeType.EndEntity: 513case XmlNodeType.Attribute: 517case XmlNodeType.SignificantWhitespace: 521case XmlNodeType.Whitespace: 532case XmlNodeType.Text: 536case XmlNodeType.CDATA: 540case XmlNodeType.ProcessingInstruction: 544case XmlNodeType.Comment: 600XmlTextReaderImpl tr = new XmlTextReaderImpl("", XmlNodeType.Element, pc); 753internal XmlNamespaceManager ParsePartialContent(XmlNode parentNode, string innerxmltext, XmlNodeType nt) 756Debug.Assert(parentNode.NodeType != XmlNodeType.Document); 767if (nt == XmlNodeType.Entity) 795XmlNamespaceManager mgr = ParsePartialContent(node, innerxmltext, XmlNodeType.Element); 803ParsePartialContent(node, innerxmltext, XmlNodeType.Attribute); 874ParsePartialContent(ent, EntitizeName(ent.Name), XmlNodeType.Entity); 913ParsePartialContent(eref, EntitizeName(eref.Name), XmlNodeType.EntityReference); 932private XmlReader CreateInnerXmlReader(String xmlFragment, XmlNodeType nt, XmlParserContext context, XmlDocument doc) 934XmlNodeType contentNT = nt; 935if (contentNT == XmlNodeType.Entity || contentNT == XmlNodeType.EntityReference) 936contentNT = XmlNodeType.Element; 971if (nt == XmlNodeType.Entity || nt == XmlNodeType.EntityReference) 1005static internal Exception UnexpectedNodeType(XmlNodeType nodetype)

144if (node.NodeType == XmlNodeType.Attribute) 208if (node.NodeType == XmlNodeType.Attribute)

105public abstract XmlNodeType NodeType 117if (parentNode.NodeType != XmlNodeType.Document) 173if (parentNode.NodeType == XmlNodeType.Document) 227while (parent != null && !(parent.NodeType == XmlNodeType.Document)) 262if (newChild.NodeType == XmlNodeType.DocumentFragment) 376if (newChild.NodeType == XmlNodeType.DocumentFragment) 587if (newChild.NodeType == XmlNodeType.DocumentFragment) 684internal virtual bool IsValidChildType(XmlNodeType type) 732case XmlNodeType.Text: 733case XmlNodeType.Whitespace: 734case XmlNodeType.SignificantWhitespace: 750case XmlNodeType.Element: 777Debug.Assert(firstNode.NodeType == XmlNodeType.Text 778|| firstNode.NodeType == XmlNodeType.SignificantWhitespace 779|| firstNode.NodeType == XmlNodeType.Whitespace 780|| secondNode.NodeType == XmlNodeType.Text 781|| secondNode.NodeType == XmlNodeType.SignificantWhitespace 782|| secondNode.NodeType == XmlNodeType.Whitespace); 783if (firstNode.NodeType == XmlNodeType.Text) 785if (secondNode.NodeType == XmlNodeType.Text) 787if (firstNode.NodeType == XmlNodeType.SignificantWhitespace) 789if (secondNode.NodeType == XmlNodeType.SignificantWhitespace) 791if (firstNode.NodeType == XmlNodeType.Whitespace) 793if (secondNode.NodeType == XmlNodeType.Whitespace) 847case XmlNodeType.EntityReference: 848case XmlNodeType.Entity: 851case XmlNodeType.Attribute: 892if (child.NodeType == XmlNodeType.Text || child.NodeType == XmlNodeType.CDATA 893|| child.NodeType == XmlNodeType.Whitespace || child.NodeType == XmlNodeType.SignificantWhitespace) 916XmlNodeType nodeType = fc.NodeType; 919case XmlNodeType.Text: 920case XmlNodeType.CDATA: 921case XmlNodeType.Whitespace: 922case XmlNodeType.SignificantWhitespace: 936&& firstChild.NodeType == XmlNodeType.Text)//which is a text node 1007XmlNodeType nt = curNode.NodeType; 1010if (nt == XmlNodeType.EntityReference) 1012if (nt == XmlNodeType.Document 1013|| nt == XmlNodeType.Entity 1014|| nt == XmlNodeType.Attribute) 1047if (NodeType == XmlNodeType.Document) 1074if (node.NodeType == XmlNodeType.Element) 1119else if (node.NodeType == XmlNodeType.Attribute) 1159if (node.NodeType == XmlNodeType.Element) 1198else if (node.NodeType == XmlNodeType.Attribute) 1226if (n.NodeType == XmlNodeType.Element && n.Name == name) 1241if (n.NodeType == XmlNodeType.Element && n.LocalName == localname && n.NamespaceURI == ns) 1280internal virtual XmlNode FindChild(XmlNodeType type) 1435XmlNodeType nodeType = _node.NodeType; 1439case XmlNodeType.Element: 1440case XmlNodeType.EntityReference: 1443case XmlNodeType.Attribute: 1444case XmlNodeType.ProcessingInstruction: 1447case XmlNodeType.Text: 1448case XmlNodeType.CDATA: 1449case XmlNodeType.Comment: 1450case XmlNodeType.Whitespace: 1451case XmlNodeType.SignificantWhitespace: 1452case XmlNodeType.XmlDeclaration: 1455case XmlNodeType.DocumentType:

76XmlNodeType nt = _curNode.NodeType; 77if (nt == XmlNodeType.Attribute) 90if (nt == XmlNodeType.Document) 103public XmlNodeType NodeType 107XmlNodeType nt = _curNode.NodeType; 110Debug.Assert(nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType); 112return XmlNodeType.Text; 114return XmlNodeType.Attribute; 131Debug.Assert(_curNode.NodeType == XmlNodeType.XmlDeclaration || _curNode.NodeType == XmlNodeType.DocumentType); 137if (_curNode.NodeType == XmlNodeType.XmlDeclaration) 188private bool IsLocalNameEmpty(XmlNodeType nt) 192case XmlNodeType.None: 193case XmlNodeType.Text: 194case XmlNodeType.CDATA: 195case XmlNodeType.Comment: 196case XmlNodeType.Document: 197case XmlNodeType.DocumentFragment: 198case XmlNodeType.Whitespace: 199case XmlNodeType.SignificantWhitespace: 200case XmlNodeType.EndElement: 201case XmlNodeType.EndEntity: 203case XmlNodeType.Element: 204case XmlNodeType.Attribute: 205case XmlNodeType.EntityReference: 206case XmlNodeType.Entity: 207case XmlNodeType.ProcessingInstruction: 208case XmlNodeType.DocumentType: 209case XmlNodeType.Notation: 210case XmlNodeType.XmlDeclaration: 232Debug.Assert(_curNode.NodeType == XmlNodeType.XmlDeclaration || _curNode.NodeType == XmlNodeType.DocumentType); 236if (_curNode.Value != null || _curNode.NodeType == XmlNodeType.DocumentType) 248XmlNodeType nt = _curNode.NodeType; 252Debug.Assert(nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType); 254if (_curNode.NodeType == XmlNodeType.XmlDeclaration) 259if (nt == XmlNodeType.DocumentType) 261else if (nt == XmlNodeType.XmlDeclaration) 299if (_curNode.NodeType == XmlNodeType.Element) 311if (_curNode.NodeType == XmlNodeType.Attribute) 338XmlNodeType nt = _curNode.NodeType; 339if (nt == XmlNodeType.Element) 341else if (nt == XmlNodeType.Attribute 342|| (_bOnAttrVal && nt != XmlNodeType.XmlDeclaration && nt != XmlNodeType.DocumentType)) 344else if (nt == XmlNodeType.XmlDeclaration) 351else if (nt == XmlNodeType.DocumentType) 498case XmlNodeType.Element: 500case XmlNodeType.Attribute: 502case XmlNodeType.XmlDeclaration: 504case XmlNodeType.DocumentType: 523case XmlNodeType.Element: 525case XmlNodeType.Attribute: 527case XmlNodeType.XmlDeclaration: 529case XmlNodeType.DocumentType: 541case XmlNodeType.Element: 544case XmlNodeType.Attribute: 547case XmlNodeType.XmlDeclaration: 552case XmlNodeType.DocumentType: 585XmlNodeType nt = _curNode.NodeType; 586return (nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType); 604while (_curNode.NodeType != XmlNodeType.Attribute && ((_curNode = _curNode.ParentNode) != null)) 611public void ResetMove(ref int level, ref XmlNodeType nt) 630if (_bOnAttrVal && _curNode.NodeType != XmlNodeType.Attribute) 632if (_curNode.NodeType == XmlNodeType.Attribute) 637nt = XmlNodeType.Element; 639if (_curNode.NodeType == XmlNodeType.Element) 672XmlNodeType nt = _curNode.NodeType; 673if (nt == XmlNodeType.Element) 675else if (nt == XmlNodeType.Attribute) 677else if (nt == XmlNodeType.XmlDeclaration && namespaceURI.Length == 0) 685else if (nt == XmlNodeType.DocumentType && namespaceURI.Length == 0) 703case XmlNodeType.Element: 713case XmlNodeType.Attribute: 722case XmlNodeType.XmlDeclaration: 723case XmlNodeType.DocumentType: 734XmlNodeType nt = _curNode.NodeType; 735if (nt == XmlNodeType.Attribute) 745else if (nt == XmlNodeType.Element) 756else if (nt == XmlNodeType.XmlDeclaration) 769else if (nt == XmlNodeType.DocumentType) 826if (_curNode.NodeType != XmlNodeType.Attribute) 838case XmlNodeType.Attribute: 846case XmlNodeType.XmlDeclaration: 847case XmlNodeType.DocumentType: 886if (node.NodeType == XmlNodeType.Element) 898else if (node.NodeType == XmlNodeType.Attribute) 954if (node.NodeType == XmlNodeType.Element) 984else if (node.NodeType == XmlNodeType.Attribute) 1004if (node.NodeType == XmlNodeType.Element) 1035else if (node.NodeType == XmlNodeType.Attribute) 1057public bool ReadAttributeValue(ref int level, ref bool bResolveEntity, ref XmlNodeType nt) 1061Debug.Assert(_curNode.NodeType == XmlNodeType.XmlDeclaration || _curNode.NodeType == XmlNodeType.DocumentType); 1066nt = XmlNodeType.Text; 1071if (_curNode.NodeType == XmlNodeType.Attribute) 1086if (_curNode.NodeType == XmlNodeType.EntityReference && bResolveEntity) 1102if (parentNode != null && parentNode.NodeType == XmlNodeType.EntityReference) 1106nt = XmlNodeType.EndEntity; 1138private XmlNodeType _nodeType; // nodeType of the node that the reader is currently positioned on 1162_nodeType = XmlNodeType.None; 1178public override XmlNodeType NodeType 1180get { return (IsInReadingStates()) ? _nodeType : XmlNodeType.None; } 1339if (!IsInReadingStates() || _nodeType == XmlNodeType.EndElement) 1467if (!IsInReadingStates() || _nodeType == XmlNodeType.EndElement) 1523if ((_readerNav.NodeType == XmlNodeType.Document) || (_readerNav.NodeType == XmlNodeType.DocumentFragment)) 1559_nodeType = XmlNodeType.None; 1568_nodeType = XmlNodeType.None; 1573XmlNodeType nt = _readerNav.NodeType; 1577&& (_nodeType != XmlNodeType.EndElement) 1578&& (_nodeType != XmlNodeType.EndEntity) 1579&& (nt == XmlNodeType.Element || (nt == XmlNodeType.EntityReference && _bResolveEntity) || 1580(((_readerNav.NodeType == XmlNodeType.Document) || (_readerNav.NodeType == XmlNodeType.DocumentFragment)) && _readState == ReadState.Initial)); 1592else if (_readerNav.NodeType == XmlNodeType.Element 1595_nodeType = XmlNodeType.EndElement; 1598else if (_readerNav.NodeType == XmlNodeType.EntityReference && _bResolveEntity) 1601_nodeType = XmlNodeType.EndEntity; 1609if (_readerNav.NodeType == XmlNodeType.EntityReference && _bResolveEntity) 1621_nodeType = XmlNodeType.EndEntity; 1634_nodeType = XmlNodeType.None; 1641&& _nodeType != XmlNodeType.EndElement 1642&& _readerNav.NodeType == XmlNodeType.Element 1645_nodeType = XmlNodeType.EndElement; 1679if (_readerNav.NodeType == XmlNodeType.Element) 1682_nodeType = XmlNodeType.EndElement; 1685else if (_readerNav.NodeType == XmlNodeType.EntityReference) 1689_nodeType = XmlNodeType.EndEntity; 1736if ((this.NodeType == XmlNodeType.EntityReference) && _bResolveEntity) 1786if (!IsInReadingStates() || (_nodeType != XmlNodeType.EntityReference))

37public override XmlNodeType NodeType 39get { return XmlNodeType.Notation; }

82public override XmlNodeType NodeType 84get { return XmlNodeType.ProcessingInstruction; }

40public override XmlNodeType NodeType 44return XmlNodeType.SignificantWhitespace; 54case XmlNodeType.Document: 56case XmlNodeType.Text: 57case XmlNodeType.CDATA: 58case XmlNodeType.Whitespace: 59case XmlNodeType.SignificantWhitespace:

42public override XmlNodeType NodeType 46return XmlNodeType.Text; 56case XmlNodeType.Document: 58case XmlNodeType.Text: 59case XmlNodeType.CDATA: 60case XmlNodeType.Whitespace: 61case XmlNodeType.SignificantWhitespace: 92if (parent != null && parent.NodeType == XmlNodeType.Attribute)

40public override XmlNodeType NodeType 44return XmlNodeType.Whitespace; 54case XmlNodeType.Document: 56case XmlNodeType.Text: 57case XmlNodeType.CDATA: 58case XmlNodeType.Whitespace: 59case XmlNodeType.SignificantWhitespace:

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

59case XmlNodeType.Element: 63goto case XmlNodeType.EndElement; 66case XmlNodeType.Whitespace: 67case XmlNodeType.SignificantWhitespace: 73case XmlNodeType.ProcessingInstruction: 74case XmlNodeType.Comment: 78case XmlNodeType.Text: // text inside a node 79case XmlNodeType.CDATA: // <![CDATA[...]]> 82case XmlNodeType.EntityReference: 88case XmlNodeType.EndElement: 96reader.NodeType == XmlNodeType.Element) 146Debug.Assert(reader.NodeType == XmlNodeType.Element);

209while (_xtr.NodeType != XmlNodeType.Element && _xtr.Read()) ; 212if (_xtr.NodeType == XmlNodeType.Element) 711if (_xtr.NodeType == XmlNodeType.Whitespace) 715if (_xtr.NodeType == XmlNodeType.EntityReference) 719} while ((!_xtr.EOF) && (_xtr.NodeType != XmlNodeType.EndElement) && (_xtr.NodeType != XmlNodeType.CDATA) && (_xtr.NodeType != XmlNodeType.Element) && (_xtr.NodeType != XmlNodeType.Text)); 721if (_xtr.NodeType == XmlNodeType.EndElement) 786while (!_xtr.EOF && (_xtr.NodeType != XmlNodeType.EndElement)) 790if ((_xtr.NodeType == XmlNodeType.Text) || (_xtr.NodeType == XmlNodeType.CDATA)) //node can be simple type, complex with simple content or complex with mixed content 800do { _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))); 802if (_xtr.NodeType == XmlNodeType.EndElement) 809if ((_xtr.NodeType == XmlNodeType.Text) && (iChildNumber == 1)) 840if (_xtr.NodeType == XmlNodeType.Text) 871if (_xtr.NodeType == XmlNodeType.Text) 881else if (_xtr.NodeType == XmlNodeType.Text) 907else if (_xtr.NodeType == XmlNodeType.Element) 963else if (_xtr.NodeType == XmlNodeType.Text) 971if (_xtr.NodeType == XmlNodeType.EntityReference) 983} while ((!_xtr.EOF) && (_xtr.NodeType != XmlNodeType.EndElement) && (_xtr.NodeType != XmlNodeType.CDATA) && (_xtr.NodeType != XmlNodeType.Element) && (_xtr.NodeType != XmlNodeType.Text)); 1225Debug.Assert(_xtr.NodeType == XmlNodeType.Attribute);

74while (reader.NodeType != XmlNodeType.Element && reader.Read()) { } 181else if (_reader.NodeType == XmlNodeType.Element) 227else if (_reader.NodeType == XmlNodeType.Text) 234else if (_reader.NodeType == XmlNodeType.EntityReference || 235_reader.NodeType == XmlNodeType.SignificantWhitespace || 236_reader.NodeType == XmlNodeType.CDATA) 240else if (_reader.NodeType == XmlNodeType.EndElement) 279case XmlNodeType.Element: 291case XmlNodeType.Text: 295case XmlNodeType.SignificantWhitespace: 299case XmlNodeType.CDATA: 303case XmlNodeType.EntityReference: 307case XmlNodeType.Comment: 311case XmlNodeType.ProcessingInstruction: 315case XmlNodeType.EndEntity: 318case XmlNodeType.Whitespace: 321case XmlNodeType.EndElement: 336Debug.Assert(_reader.NodeType == XmlNodeType.Element); 421Debug.Assert(_reader.NodeType == XmlNodeType.Attribute); 431case XmlNodeType.Text: 434case XmlNodeType.EntityReference: 447Debug.Assert(_reader.NodeType == XmlNodeType.EntityReference); 460case XmlNodeType.Text: 463case XmlNodeType.EndEntity: 469case XmlNodeType.EntityReference:

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

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

1085attrData.NodeType = XmlNodeType.Attribute;

97case XmlNodeType.Element: 101goto case XmlNodeType.EndElement; 104case XmlNodeType.Whitespace: 107case XmlNodeType.Text: // text inside a node 108case XmlNodeType.CDATA: // <![CDATA[...]]> 109case XmlNodeType.SignificantWhitespace: 112case XmlNodeType.EndElement:

190public XmlNodeType NodeType

223if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 252if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 276if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 300if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 324if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 348if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 372if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 396if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 420if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 444if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 468if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 492if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 516if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 540if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 564if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 593if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 617if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 641if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element)

38public override XmlNodeType NodeType { get { return _innerReader.NodeType; } } 85public override XmlNodeType MoveToContent() { return _innerReader.MoveToContent(); } 102if (_innerReader.NodeType != XmlNodeType.Attribute) 108if (_innerReader.NodeType != XmlNodeType.Attribute)

845while (_r.NodeType != XmlNodeType.EndElement) 932if (_r.NodeType != XmlNodeType.EndElement) 936while (_r.NodeType != XmlNodeType.EndElement) 1271if (_r.NodeType == XmlNodeType.None || _r.NodeType == XmlNodeType.Whitespace) 1276if (_r.NodeType == XmlNodeType.EndElement) 1282else if (_r.NodeType == XmlNodeType.Attribute && _events.OnUnknownAttribute == null) 1286else if (_r.NodeType == XmlNodeType.Element && _events.OnUnknownElement == null) 1301if (unknownNode.NodeType != XmlNodeType.None && unknownNode.NodeType != XmlNodeType.Whitespace && _events.OnUnknownNode != null) 1308if (unknownNode.NodeType == XmlNodeType.Attribute) 1312else if (unknownNode.NodeType == XmlNodeType.Element) 1345case XmlNodeType.Element: 1347case XmlNodeType.EndElement: 1349case XmlNodeType.Text: 1351case XmlNodeType.CDATA: 1353case XmlNodeType.Comment: 1355case XmlNodeType.ProcessingInstruction: 1498while (_r.NodeType == XmlNodeType.Whitespace) _r.Skip(); 1499if (_r.NodeType == XmlNodeType.None) _r.Skip(); 1500if (_r.NodeType == XmlNodeType.EndElement && _r.LocalName == name && _r.NamespaceURI == ns) 1772while (_r.NodeType != XmlNodeType.EndElement) 1791while (_r.NodeType != XmlNodeType.EndElement) 1869while (_r.NodeType != XmlNodeType.EndElement && _r.NodeType != XmlNodeType.None) 1965while (_r.NodeType == XmlNodeType.Whitespace) _r.Skip(); 1966if (_r.NodeType == XmlNodeType.None) _r.Skip(); 1981if (Reader.NodeType == XmlNodeType.Attribute) 2044while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement)

205case XmlNodeType.Element: 243case XmlNodeType.EndElement: 247case XmlNodeType.Text: 248case XmlNodeType.CDATA: 252case XmlNodeType.SignificantWhitespace: 257goto case XmlNodeType.Whitespace; 260case XmlNodeType.Whitespace: 272case XmlNodeType.Comment: 276case XmlNodeType.ProcessingInstruction: 280case XmlNodeType.EntityReference: 284case XmlNodeType.DocumentType: 291case XmlNodeType.EndEntity: 292case XmlNodeType.None: 293case XmlNodeType.XmlDeclaration:

2115XmlTextReader reader = new XmlTextReader(xml, XmlNodeType.Element, context); 2143case XmlNodeType.Element: 2182case XmlNodeType.EndElement: 2187case XmlNodeType.Text: 2188case XmlNodeType.CDATA: 2191case XmlNodeType.SignificantWhitespace: 2192case XmlNodeType.Whitespace: 2196case XmlNodeType.Comment: 2199case XmlNodeType.ProcessingInstruction: 2202case XmlNodeType.EntityReference: 2205case XmlNodeType.EndEntity: 2206case XmlNodeType.None: 2207case XmlNodeType.DocumentType: 2208case XmlNodeType.XmlDeclaration: 2210case XmlNodeType.Attribute:

40private XmlNodeType _nodeType; 52internal static XmlNodeType[] convertFromXPathNodeType = { 53XmlNodeType.Document, // XPathNodeType.Root 54XmlNodeType.Element, // XPathNodeType.Element 55XmlNodeType.Attribute, // XPathNodeType.Attribute 56XmlNodeType.Attribute, // XPathNodeType.Namespace 57XmlNodeType.Text, // XPathNodeType.Text 58XmlNodeType.SignificantWhitespace, // XPathNodeType.SignificantWhitespace 59XmlNodeType.Whitespace, // XPathNodeType.Whitespace 60XmlNodeType.ProcessingInstruction, // XPathNodeType.ProcessingInstruction 61XmlNodeType.Comment, // XPathNodeType.Comment 62XmlNodeType.None // XPathNodeType.All 69internal static XmlNodeType ToXmlNodeType(XPathNodeType typ) 187if (_nodeType == XmlNodeType.Text) 198public override XmlNodeType NodeType 211if (this.NodeType == XmlNodeType.Text) 225if (this.NodeType == XmlNodeType.Text) 239if (this.NodeType == XmlNodeType.Text) 302if ((_nodeType != XmlNodeType.Element) 303&& (_nodeType != XmlNodeType.Document) 304&& (_nodeType != XmlNodeType.EndElement) 305&& (_nodeType != XmlNodeType.None)) 315if ((_nodeType != XmlNodeType.Element) 316&& (_nodeType != XmlNodeType.Document) 317&& (_nodeType != XmlNodeType.EndElement) 318&& (_nodeType != XmlNodeType.None)) 352if (_nodeType == XmlNodeType.Element) 382_nodeType = XmlNodeType.Attribute; 691_nodeType = XmlNodeType.Attribute; 776_nodeType = XmlNodeType.Element; 838_nodeType = XmlNodeType.Text; 1010else if (_nodeType == XmlNodeType.Element 1013_nodeType = XmlNodeType.EndElement; 1034_nodeType = XmlNodeType.EndElement; 1072_nodeType = XmlNodeType.None; 1083_nodeType = XmlNodeType.None;

427throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(string.Format(SRSerialization.ExpectingElementAtDeserialize, XmlNodeType.Element), xmlReader));

763while (_reader.NodeType == XmlNodeType.Element) 808while (_reader.NodeType == XmlNodeType.Element) 813if (_reader.NodeType == XmlNodeType.Text) 848if (_reader.NodeType == XmlNodeType.Text) 856while (_reader.NodeType != XmlNodeType.EndElement)

32private XmlNodeType _nodeType; 112public override XmlNodeType NodeType { get { return IsXmlDataNode ? _xmlNodeReader.NodeType : _nodeType; } } 161_nodeType = XmlNodeType.Attribute; 209if (_nodeType != XmlNodeType.Attribute) 218_nodeType = XmlNodeType.Element; 292if (_nodeType == XmlNodeType.Attribute && MoveToNextAttribute()) 307_nodeType = XmlNodeType.Text; 316_nodeType = XmlNodeType.EndElement; 329_nodeType = XmlNodeType.None;

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

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

806ThrowUnexpectedStateException(XmlNodeType.Element); 824_ilg.Load(XmlNodeType.EndElement); 828private void ThrowUnexpectedStateException(XmlNodeType expectedState)

211return (xmlReader.MoveToContent() != XmlNodeType.EndElement); 307if (xmlReader.NodeType != XmlNodeType.Element) 308throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 506if (xmlReader.NodeType == XmlNodeType.EndElement) 514if (xmlReader.NodeType != XmlNodeType.EndElement) 515throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.EndElement, xmlReader)); 542throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 570internal static Exception CreateUnexpectedStateException(XmlNodeType expectedState, XmlReaderDelegator xmlReader)

174internal XmlNodeType NodeType 177get { return isEndOfEmptyElement ? XmlNodeType.EndElement : reader.NodeType; } 196internal XmlNodeType MoveToContent() 199return XmlNodeType.EndElement;

28if (xmlReader.NodeType != XmlNodeType.Element) 29throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializerReadContext.CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 47throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializerReadContext.CreateUnexpectedStateException(XmlNodeType.EndElement, _xmlReader)); 57if (reader.NodeType == XmlNodeType.EndElement || 58(reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement)) 72public override XmlNodeType NodeType { get { return InnerReader.NodeType; } } 113public override XmlNodeType MoveToContent() { return InnerReader.MoveToContent(); }

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

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

247_whitespaceTextNode.NodeType = XmlNodeType.SignificantWhitespace; 249_whitespaceTextNode.NodeType = XmlNodeType.Whitespace; 841public override XmlNodeType MoveToContent() 847if (_node.NodeType != XmlNodeType.Text && _node.NodeType != XmlNodeType.CDATA) 868if (_node.NodeType == XmlNodeType.Attribute) 942public sealed override XmlNodeType NodeType 1007XmlNodeType nodeType = _node.NodeType; 1008if (nodeType == XmlNodeType.Element) 1010if (nodeType == XmlNodeType.EndElement) 1012if (nodeType == XmlNodeType.None) 1015if (_node.NodeType == XmlNodeType.Element) 1018return (MoveToContent() == XmlNodeType.Element); 1038return (_node.NodeType == XmlNodeType.Element || IsStartElement()) && _node.Prefix == prefix && _node.LocalName == localName; 1047return (_node.NodeType == XmlNodeType.Element || IsStartElement()) && _node.LocalName == localName && _node.IsNamespaceUri(namespaceUri); 1056return (_node.NodeType == XmlNodeType.Element || IsStartElement()) && _node.LocalName == localName && _node.IsNamespaceUri(namespaceUri); 1204if (_node.NodeType != XmlNodeType.Element) 1222if (_node.NodeType != XmlNodeType.Element) 1241if (_node.NodeType != XmlNodeType.EndElement && MoveToContent() != XmlNodeType.EndElement) 1243int nodeDepth = _node.NodeType == XmlNodeType.Element ? _depth - 1 : _depth; 1352while (_node.NodeType != XmlNodeType.Comment && _node.Value.TryReadBase64(buffer, offset, count, out actual)) 1360XmlNodeType nodeType = _node.NodeType; 1361if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement) 1378XmlNodeType nodeType = _node.NodeType; 1379if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement) 1681if ((_node.NodeType == XmlNodeType.Element || MoveToElement()) && !IsEmptyElement) 1689if (_node.NodeType == XmlNodeType.EndElement) 1881private XmlNodeType _nodeType; 1911protected XmlNode(XmlNodeType nodeType, 1933_exitScope = (nodeType == XmlNodeType.EndElement); 1960public XmlNodeType NodeType 2205: base(XmlNodeType.Element, 2249: base(XmlNodeType.Attribute, 2264: base(XmlNodeType.EndElement, 2278protected XmlTextNode(XmlNodeType nodeType, 2295: base(XmlNodeType.Text, 2310: base(XmlNodeType.Text, 2325: base(XmlNodeType.Whitespace, 2340: base(XmlNodeType.CDATA, 2355: base(XmlNodeType.Text, 2370: base(XmlNodeType.None, 2385: base(XmlNodeType.XmlDeclaration, 2400: base(XmlNodeType.Comment, 2414: base(XmlNodeType.None, 2429: base(XmlNodeType.None,

79if (this.Node.NodeType != XmlNodeType.Element) 107if (this.Node.NodeType != XmlNodeType.Element) 138if (this.Node.NodeType != XmlNodeType.Element) 184if (this.Node.NodeType != XmlNodeType.Element) 198if (this.Node.NodeType != XmlNodeType.Element) 212if (this.Node.NodeType != XmlNodeType.Element) 226if (this.Node.NodeType != XmlNodeType.Element) 240if (this.Node.NodeType != XmlNodeType.Element) 254if (this.Node.NodeType != XmlNodeType.Element) 268if (this.Node.NodeType != XmlNodeType.Element) 1103if (this.Node.NodeType != XmlNodeType.Element) 1108if (this.Node.NodeType != XmlNodeType.EndElement)

337case XmlNodeType.Attribute: 340case XmlNodeType.Text: 341case XmlNodeType.Whitespace: 342case XmlNodeType.SignificantWhitespace: 343case XmlNodeType.CDATA: 357case XmlNodeType.ProcessingInstruction: 358case XmlNodeType.Comment: 359case XmlNodeType.EndEntity: 362case XmlNodeType.EntityReference: 369case XmlNodeType.Element: 370case XmlNodeType.EndElement: 438protected bool IsTextNode(XmlNodeType nodeType) 440return nodeType == XmlNodeType.Text || 441nodeType == XmlNodeType.Whitespace || 442nodeType == XmlNodeType.SignificantWhitespace || 443nodeType == XmlNodeType.CDATA || 444nodeType == XmlNodeType.Attribute; 452XmlNodeType nodeType = this.NodeType; 454if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement) 464if (nodeType == XmlNodeType.Attribute /* || inAttributeText */) 1375public override XmlNodeType NodeType

235if (reader.NodeType == XmlNodeType.EntityReference) 354int d = (reader.NodeType == XmlNodeType.None ? -1 : reader.Depth); 357XmlNodeType nodeType = reader.NodeType; 359if (nodeType == XmlNodeType.Text || nodeType == XmlNodeType.Whitespace || nodeType == XmlNodeType.SignificantWhitespace) 373case XmlNodeType.Element: 376case XmlNodeType.CDATA: 379case XmlNodeType.EntityReference: 382case XmlNodeType.XmlDeclaration: 383case XmlNodeType.ProcessingInstruction: 386case XmlNodeType.DocumentType: 389case XmlNodeType.Comment: 392case XmlNodeType.EndElement: 400while (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement));

66case XmlNodeType.Element: 68case XmlNodeType.EndElement: 70case XmlNodeType.Text: 71case XmlNodeType.Whitespace: 72case XmlNodeType.SignificantWhitespace: 74case XmlNodeType.Comment: 76case XmlNodeType.CDATA:

313Fx.Assert(reader.NodeType == XmlNodeType.Element, ""); 359while (reader.NodeType != XmlNodeType.EndElement)

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

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

569if (reader.NodeType != XmlNodeType.Element) 571if (reader.NodeType == XmlNodeType.Element) 576else if (reader.NodeType == XmlNodeType.EndElement) 890if (reader.MoveToContent() != XmlNodeType.Element) 913XmlNodeType type = _reader.MoveToContent(); 914while (!_reader.EOF && type != XmlNodeType.EndElement) 916if (type != XmlNodeType.Element) 1180while (bodyReader.NodeType != XmlNodeType.EndElement && !bodyReader.EOF) 1234if (reader.NodeType != XmlNodeType.Element) 1268if (reader.NodeType != XmlNodeType.Element) 1554if (reader.NodeType != XmlNodeType.Element) 1565if (reader.NodeType != XmlNodeType.Element) 1572if (reader.NodeType != XmlNodeType.Element) 1596while (reader.NodeType != XmlNodeType.EndElement)

175if (reader.NodeType != XmlNodeType.EndElement && !reader.EOF) 545hasDetail = (reader.MoveToContent() != XmlNodeType.EndElement); 571while (r.NodeType != XmlNodeType.EndElement) 602while (r.NodeType != XmlNodeType.EndElement)

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

418if (reader.NodeType != XmlNodeType.Element) 420if (reader.MoveToContent() != XmlNodeType.Element) 774if (reader.NodeType == XmlNodeType.Element) 778if (reader.NodeType == XmlNodeType.Element) 797if (reader.NodeType != XmlNodeType.Element) 810if (reader.MoveToContent() == XmlNodeType.Element && !reader.IsEmptyElement) 820if (reader.NodeType == XmlNodeType.EndElement) 1659while (reader.NodeType != XmlNodeType.EndElement)

41&& currentNode.NodeType == XmlNodeType.Element

107&& (node.NodeType == XmlNodeType.Element) 313private static bool ShouldSkipNodeType(XmlNodeType type) 315return (type == XmlNodeType.Comment || type == XmlNodeType.SignificantWhitespace || type == XmlNodeType.Whitespace || type == XmlNodeType.Notation);

436if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 492while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 494if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 563while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 565if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 575if (this.Reader.NodeType == XmlNodeType.EndElement) 646while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 649if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 653else if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Text || 654Reader.NodeType == Microsoft.Xml.XmlNodeType.CDATA || 655Reader.NodeType == Microsoft.Xml.XmlNodeType.Whitespace || 656Reader.NodeType == Microsoft.Xml.XmlNodeType.SignificantWhitespace)

143if (child.NodeType == XmlNodeType.Element) 166if (child.NodeType == XmlNodeType.Element)

31XmlNodeType type = reader.MoveToContent(); 34case XmlNodeType.Element: 100case XmlNodeType.EndElement: 107case XmlNodeType.CDATA: 116case XmlNodeType.SignificantWhitespace: 117case XmlNodeType.Text:

142if (detailReader.NodeType != XmlNodeType.EndElement && !detailReader.EOF)

264if (_reader.NodeType == XmlNodeType.EndElement) 271if (_reader.MoveToContent() != XmlNodeType.Text)

368if (reader.NodeType == XmlNodeType.EndElement)

559else if (reader.NodeType != XmlNodeType.Element) 597else if (reader.NodeType != XmlNodeType.Element) 932while (reader.NodeType != XmlNodeType.EndElement && !reader.EOF) 987return (reader.NodeType == XmlNodeType.EndElement || reader.EOF);

148else if (reader.NodeType == XmlNodeType.Element)

319if (node.NodeType == XmlNodeType.Whitespace || node.NodeType == XmlNodeType.Comment) 2334while (metadataReader.MoveToContent() == XmlNodeType.Element)

58if (child.NodeType == XmlNodeType.Whitespace || child.NodeType == XmlNodeType.Comment) 62else if (child.NodeType == XmlNodeType.Element && result == null) 74OnChildNodeTypeMissing(parent, XmlNodeType.Element); 91if (child.NodeType == XmlNodeType.Whitespace || child.NodeType == XmlNodeType.Comment) 95else if (child.NodeType == XmlNodeType.Element) 128while (reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.SignificantWhitespace) 154if (reader.NodeType == XmlNodeType.Comment) 158else if (reader.NodeType == XmlNodeType.Whitespace) 168internal static void OnChildNodeTypeMissing(string parentName, XmlNodeType expectedNodeType) 173internal static void OnChildNodeTypeMissing(XmlElement parent, XmlNodeType expectedNodeType)

5187if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 5266while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 5268if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 5369while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 5371if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 5455while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 5457if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 5537while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 5539if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 5598while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 5600if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 5659while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 5661if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 5733while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 5735if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 5827while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 5829if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 5930while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 5932if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6023while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6025if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6109while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6111if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6187while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6189if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6309while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6311if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6398while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6400if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6474while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6476if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6555while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6557if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6644while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6646if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6720while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6722if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6777while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6779if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6871while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6873if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6935while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 6937if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 6999while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7001if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7083while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7085if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7149while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7151if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7217while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7219if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7322while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7324if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7378while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7380if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7449while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7451if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7525while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7527if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7596while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7598if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7662while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7664if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7728while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7730if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7789while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7791if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7858while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7860if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 7946while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 7948if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8040while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8042if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8122while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8124if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8204while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8206if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8282while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8284if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8373while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8375if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8446while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8448if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8559while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8561if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8681while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8683if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8781while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8783if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8859while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8861if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8936while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 8938if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 8942else if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Text || 8943Reader.NodeType == Microsoft.Xml.XmlNodeType.CDATA || 8944Reader.NodeType == Microsoft.Xml.XmlNodeType.Whitespace || 8945Reader.NodeType == Microsoft.Xml.XmlNodeType.SignificantWhitespace) 9014while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9016if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 9020else if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Text || 9021Reader.NodeType == Microsoft.Xml.XmlNodeType.CDATA || 9022Reader.NodeType == Microsoft.Xml.XmlNodeType.Whitespace || 9023Reader.NodeType == Microsoft.Xml.XmlNodeType.SignificantWhitespace) 9106while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9108if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 9218while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9220if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 9310while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9312if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 9416while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9418if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 9504while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9506if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 9644while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9646if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 9731while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9733if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 9818while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9820if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 9905while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9907if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 9992while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 9994if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 10079while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 10081if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 10166while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 10168if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 10253while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 10255if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 10340while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 10342if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 10427while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 10429if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 10514while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 10516if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 10601while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 10603if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 10683while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 10685if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 10879while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 10881if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 10989while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 10991if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 11080while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 11082if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 11163while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 11165if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 11255while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 11257if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 11367while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 11369if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 11498while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 11500if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 11590while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 11592if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 11702while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 11704if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 11790while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 11792if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 11907while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 11909if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 11984while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 11986if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 12077while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 12079if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 12174while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 12176if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 12322while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 12324if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 12415while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 12417if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 12531while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 12533if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 12646while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 12648if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 12753while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 12755if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 12836while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 12838if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 12938while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 12940if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 13020while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 13022if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 13102while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 13104if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element)

357while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 359if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 388while (Reader.NodeType != Microsoft.Xml.XmlNodeType.EndElement && Reader.NodeType != Microsoft.Xml.XmlNodeType.None) 390if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element) 462if (Reader.NodeType == Microsoft.Xml.XmlNodeType.Element)