189case XmlNodeType.Element: 198case XmlNodeType.EndElement: 761_inAttribute = (Reader.NodeType == XmlNodeType.Attribute);

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

511XmlNodeType.Document, // parsing document 519case XmlNodeType.Element :

796XmlNodeType currNodeType = xmlReader.NodeType; 799case XmlNodeType.Element: 852case XmlNodeType.EndElement: 859case XmlNodeType.CDATA: 860case XmlNodeType.Text: 876ThrowCompilerException(SRID.IllegalCDataTextScoping, DefinitionNSPrefix, LocalName, (currNodeType == XmlNodeType.CDATA ? "a CDATA section" : "text content"));

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

90multipleRoots ? XmlNodeType.Element : XmlNodeType.Document,

396case XmlNodeType.Element: 399case XmlNodeType.EndElement: 1251case XmlNodeType.SignificantWhitespace: 1252case XmlNodeType.Text: 1253case XmlNodeType.CDATA: 1254case XmlNodeType.Whitespace: 1271case XmlNodeType.Element: 1290case XmlNodeType.EndElement: 1318case XmlNodeType.Attribute: // review this. 1323case XmlNodeType.Comment: 1326case XmlNodeType.ProcessingInstruction: 2001CompileBamlTag(XmlNodeType.Element, ref endTagHasBeenRead); 2014CompileBamlTag(XmlNodeType.EndElement, ref endTagHasBeenRead); 2053CompileBamlTag(XmlNodeType.EndElement, 2103case XmlNodeType.Text: 2104case XmlNodeType.CDATA: 2105case XmlNodeType.SignificantWhitespace: 2106case XmlNodeType.Whitespace: 2111case XmlNodeType.ProcessingInstruction: 2117case XmlNodeType.EntityReference: 2140XmlNodeType xmlNodeType, 2148case XmlNodeType.Element: 2160case XmlNodeType.EndElement: 2163case XmlNodeType.Text: 2164case XmlNodeType.CDATA: 2165case XmlNodeType.SignificantWhitespace: 2166case XmlNodeType.Whitespace: 3574XmlNodeType xmlNodeType, // Type of xml node we are processing. 3595case XmlNodeType.Element: 3752case XmlNodeType.EndElement: 3801case XmlNodeType.CDATA: 3802case XmlNodeType.Text: 3803case XmlNodeType.SignificantWhitespace: 3804case XmlNodeType.Whitespace: 3814case XmlNodeType.ProcessingInstruction: 3821case XmlNodeType.Comment: 3828case XmlNodeType.EntityReference: 4119CompileText(XmlNodeType.None, textValue); 5006private void CompileText(XmlNodeType xmlNodeType, string textValue) 5010Debug.Assert( xmlNodeType == XmlNodeType.Text || 5011xmlNodeType == XmlNodeType.Whitespace || 5012xmlNodeType == XmlNodeType.SignificantWhitespace || 5013xmlNodeType == XmlNodeType.CDATA || 5014xmlNodeType == XmlNodeType.None, 5018case XmlNodeType.Text: 5022case XmlNodeType.Whitespace: 5023case XmlNodeType.SignificantWhitespace: 5027case XmlNodeType.CDATA: 5028case XmlNodeType.None: 51760 == XmlReader.Depth && XmlReader.NodeType == XmlNodeType.None))

213if (_reader.NodeType == XmlNodeType.Attribute) 220if (_reader.NodeType == XmlNodeType.Attribute) 297private XmlNodeType MoveToContent() 305case XmlNodeType.CDATA: 306case XmlNodeType.Element: 307case XmlNodeType.EndElement: 308case XmlNodeType.EntityReference: 309case XmlNodeType.EndEntity: 418while (MoveToContent() != XmlNodeType.EndElement) 420if (_reader.NodeType == XmlNodeType.Element && _reader.NamespaceURI == CompositeFontNamespace) 433while (MoveToContent() == XmlNodeType.Element) 586while (MoveToContent() != XmlNodeType.EndElement) 588if (_reader.NodeType == XmlNodeType.Element && _reader.NamespaceURI == CompositeFontNamespace) 603while (MoveToContent() == XmlNodeType.Element) 836while (MoveToContent() != XmlNodeType.EndElement) 838if (_reader.NodeType == XmlNodeType.Element && _reader.NamespaceURI == CompositeFontNamespace)

465while(rdr.NodeType != XmlNodeType.EndElement)

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

485if (node.NodeType == XmlNodeType.Text) 495else if (node.NodeType == XmlNodeType.Element)

423case XmlNodeType.Text: 424case XmlNodeType.SignificantWhitespace: 425case XmlNodeType.CDATA: 432case XmlNodeType.Element: 437case XmlNodeType.EndElement:

315while (!(XmlNodeType.EndElement == reader.NodeType && AnnotationXmlConstants.Elements.Annotation == reader.LocalName)) 324while (!(AnnotationXmlConstants.Elements.AnchorCollection == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) 339while (!(AnnotationXmlConstants.Elements.CargoCollection == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) 354while (!(AnnotationXmlConstants.Elements.AuthorCollection == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) 356if (!(AnnotationXmlConstants.Elements.StringAuthor == reader.LocalName && XmlNodeType.Element == reader.NodeType)) 548if (reader.NodeType == XmlNodeType.Attribute)

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

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

242while (!(AnnotationXmlConstants.Elements.ContentLocator == reader.LocalName && XmlNodeType.EndElement == reader.NodeType)) 244if (XmlNodeType.Element != reader.NodeType) 260while (!(XmlNodeType.EndElement == reader.NodeType && part.PartType.Name == reader.LocalName)) 303if (!(XmlNodeType.EndElement == reader.NodeType && AnnotationXmlConstants.Elements.Item == reader.LocalName))

398case XmlNodeType.Element:

40if (base.NodeType == XmlNodeType.XmlDeclaration) 213if ( (Reader.NodeType == XmlNodeType.Element) && !_rootXMLNSChecked )

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

2064XmlNodeType.Element,

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

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

114if (this.NodeType == Xml.XmlNodeType.Element) 150else if (this.NodeType == Xml.XmlNodeType.EndElement) 165else if (this.NodeType == Xml.XmlNodeType.Text)

24public override XmlNodeType NodeType

140XmlNodeType t = xmlUtil.Reader.NodeType; 141if (t != XmlNodeType.Comment) {

1959XmlNodeType t = xmlUtil.Reader.NodeType; 1960if (t != XmlNodeType.Comment) { 2268if (xmlUtil.Reader.NodeType != XmlNodeType.Element || xmlUtil.Reader.Name != KEYWORD_CONFIGURATION) { 3136XmlNodeType t = xmlUtil.Reader.NodeType; 3137if (t == XmlNodeType.EndElement) 3140if (t != XmlNodeType.Comment) { 3146if (t == XmlNodeType.Element) { 3185if (xmlUtil.Reader.NodeType != XmlNodeType.Element) { 4228XmlNodeType nodeType; 4249if (nodeType == XmlNodeType.Element && clone.Name == "EncryptedData") { // Found it! 4253if (nodeType == XmlNodeType.EndElement) { 4256else if (nodeType != XmlNodeType.Comment && nodeType != XmlNodeType.Whitespace) { 4279if (nodeType == XmlNodeType.EndElement) { 4282else if (nodeType != XmlNodeType.Comment && nodeType != XmlNodeType.Whitespace) {

1515if (reader.NodeType == XmlNodeType.Element) { 1546else if (reader.NodeType == XmlNodeType.EndElement) { 1549else if ((reader.NodeType == XmlNodeType.CDATA) || (reader.NodeType == XmlNodeType.Text)) {

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

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

26if (encryptedNode.NodeType != XmlNodeType.Element || 220if (child.NodeType != XmlNodeType.Element)

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

698reader = new XmlTextReader(xmlElement, XmlNodeType.Element, context); 702if (reader.NodeType != XmlNodeType.Element) { 725case XmlNodeType.XmlDeclaration: 726case XmlNodeType.DocumentType: 735if (reader.Depth <= 0 && reader.NodeType != XmlNodeType.EndElement) { 2305if (xmlUtil.Reader.NodeType == XmlNodeType.Element && utilWriter.IsLastLineBlank) { 2329Debug.Assert(reader.NodeType == XmlNodeType.Element && reader.Name == KEYWORD_CONFIGURATION, 2361if (reader.NodeType == XmlNodeType.Element && reader.Name == KEYWORD_CONFIGSECTIONS) { 2384Debug.Assert(reader.NodeType == XmlNodeType.EndElement && reader.Name == KEYWORD_CONFIGSECTIONS, 2427bool skipFirstIndent = reader.Depth > 0 && reader.NodeType == XmlNodeType.Element; 2510if (reader.NodeType == XmlNodeType.Element) { 2514else if (reader.NodeType == XmlNodeType.EndElement) { 2555if (reader.NodeType == XmlNodeType.Element) { 2736if (reader.NodeType == XmlNodeType.Element) { 2740else if (reader.NodeType == XmlNodeType.EndElement) { 2785if (reader.NodeType == XmlNodeType.Element) { 3028if (reader.NodeType == XmlNodeType.EndElement) { 3199if (reader.NodeType == XmlNodeType.Element) { 3226if (reader.IsEmptyElement || reader.NodeType == XmlNodeType.EndElement) {

89if (node2.NodeType == XmlNodeType.Element) 91if (node3.NodeType == XmlNodeType.Element)

210if (xmlNode.NodeType == XmlNodeType.Element) {

62private static int GetPositionOffset(XmlNodeType nodeType) { 101case XmlNodeType.XmlDeclaration: 102case XmlNodeType.Comment: 103case XmlNodeType.DocumentType: 106case XmlNodeType.Element: 178if (_reader.MoveToContent() == XmlNodeType.Element) { 195while (!_reader.EOF && _reader.NodeType != XmlNodeType.Element) { 207if (_reader.NodeType == XmlNodeType.Element) { 223while (!_reader.EOF && _reader.NodeType != XmlNodeType.Element) { 243while (!_reader.EOF && _reader.NodeType != XmlNodeType.EndElement) { 253XmlNodeType nodeType = _reader.NodeType; 255if (nodeType != XmlNodeType.Comment && nodeType != XmlNodeType.EndElement) { 388Debug.Assert(_reader.NodeType == XmlNodeType.Element, "_reader.NodeType == XmlNodeType.Element"); 394while (_reader.NodeType != XmlNodeType.EndElement) { 397if (_reader.NodeType == XmlNodeType.Element) { 405if (_reader.NodeType == XmlNodeType.Whitespace) { 443if (_reader.NodeType == XmlNodeType.EndElement) 454if (_reader.NodeType == XmlNodeType.Element) 482Debug.Assert(_reader.NodeType == XmlNodeType.Element, "_reader.NodeType == XmlNodeType.Element"); 507if (_reader.NodeType != XmlNodeType.Whitespace) { 526if (_reader.NodeType == XmlNodeType.Element) 543Debug.Assert(_reader.NodeType== XmlNodeType.Element, "_reader.NodeType== XmlNodeType.Element"); 603XmlNodeType nodeType = _reader.NodeType; 604if (nodeType == XmlNodeType.Whitespace) { 607else if (nodeType == XmlNodeType.Element) { 655else if (nodeType == XmlNodeType.EndElement) { 669else if (nodeType == XmlNodeType.Comment) { 672else if (nodeType == XmlNodeType.Text) { 675else if (nodeType == XmlNodeType.XmlDeclaration) { 725else if (nodeType == XmlNodeType.SignificantWhitespace) { 728else if (nodeType == XmlNodeType.ProcessingInstruction) { 743else if (nodeType == XmlNodeType.EntityReference) { 746else if (nodeType == XmlNodeType.CDATA) { 749else if (nodeType == XmlNodeType.DocumentType) { 863Debug.Assert(_reader.NodeType == XmlNodeType.Element, 898Debug.Assert(_reader.NodeType == XmlNodeType.Element, "_reader.NodeType == NodeType.Element"); 988(Reader.NodeType == XmlNodeType.Whitespace)) { 1010XmlTextReader reader = new XmlTextReader(xmlElement, XmlNodeType.Element, context); 1028XmlNodeType nodeType = reader.NodeType; 1039case XmlNodeType.CDATA: 1040case XmlNodeType.Element: 1041case XmlNodeType.EndElement: 1042case XmlNodeType.Comment: 1061case XmlNodeType.Whitespace: 1064case XmlNodeType.SignificantWhitespace: 1068case XmlNodeType.CDATA: 1072case XmlNodeType.ProcessingInstruction: 1076case XmlNodeType.Comment: 1080case XmlNodeType.Text: 1085case XmlNodeType.Element: 1137case XmlNodeType.EndElement: 1143case XmlNodeType.EntityReference: 1148case XmlNodeType.XmlDeclaration: 1149case XmlNodeType.DocumentType:

293if (reader.NodeType == XmlNodeType.Text) {

26if (XmlNodeType.Element != node.NodeType) { 38if ((XmlNodeType.Comment == node.NodeType) || (XmlNodeType.Whitespace == node.NodeType)) {

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

92XmlTextReader reader = new XmlTextReader(s, XmlNodeType.Element, null) ;

186if (reader.NodeType == XmlNodeType.Element) { 1488if (reader.NodeType == XmlNodeType.Element) { 1566if (reader.NodeType == XmlNodeType.Element) 1571if (reader.NodeType == XmlNodeType.Element) { 1646while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Element && reader.Depth > depth) { 1649return (reader.NodeType == XmlNodeType.Element); 1653while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Element) { 1658while (reader.NodeType == XmlNodeType.Whitespace) { 1661if (reader.NodeType == XmlNodeType.None) { 1664else if (reader.NodeType == XmlNodeType.EndElement) { 1692while (reader.NodeType == XmlNodeType.Whitespace) { 1927if (reader.NodeType == XmlNodeType.Element) 1930if (reader.NodeType == XmlNodeType.Element) { 2014while (!reader.EOF && reader.NodeType == XmlNodeType.Whitespace) 2016if (reader.NodeType != XmlNodeType.Element) 2234if (reader.NodeType == XmlNodeType.Whitespace) 2245if (reader.NodeType == XmlNodeType.Whitespace) { 2254if (reader.NodeType == XmlNodeType.Whitespace) { 2258Debug.Assert(reader.NodeType != XmlNodeType.Whitespace, "Should not be on Whitespace node"); 2351if ((mode != XmlReadMode.Fragment) && (reader.NodeType == XmlNodeType.Element)) 2357if (reader.NodeType == XmlNodeType.Element) { 2535XmlTextReader reader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(stream, XmlNodeType.Element, null) : new XmlTextReader(stream); 2548XmlTextReader xmlreader = (mode == XmlReadMode.Fragment) ? new XmlTextReader(reader.ReadToEnd(), XmlNodeType.Element, null) : new XmlTextReader(reader); 2563xr = new XmlTextReader(stream, XmlNodeType.Element, null);

5162if (reader.NodeType == XmlNodeType.Element) { 5354if ((mode != XmlReadMode.Fragment) && (reader.NodeType == XmlNodeType.Element)) 5367if (reader.NodeType == XmlNodeType.Element) { 5560while (reader.NodeType == XmlNodeType.Whitespace) { 5563if (reader.NodeType == XmlNodeType.None) { 5566else if (reader.NodeType == XmlNodeType.EndElement) { 5577while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Element && reader.Depth > depth) { 5580return (reader.NodeType == XmlNodeType.Element); 5606if (reader.NodeType == XmlNodeType.Whitespace) {

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

974if ( (XmlNodeType.Element == xmlReader.NodeType) && 1064if ((XmlNodeType.Element != xmlReader.NodeType) || (0 != String.Compare(xmlReader.LocalName, MessageNode, StringComparison.OrdinalIgnoreCase))) { 1076if (xmlReader.NodeType != XmlNodeType.Text) { 1082using (XmlTextReader xmlMessageReader = new XmlTextReader(xmlReader.Value, XmlNodeType.Element, null)) { 1089if (xmlMessageReader.NodeType == XmlNodeType.Text) {

572case XmlNodeType.Element: 580case XmlNodeType.Text: 594case XmlNodeType.Whitespace: 595case XmlNodeType.SignificantWhitespace: 598case XmlNodeType.CDATA: 601case XmlNodeType.EntityReference: 604case XmlNodeType.XmlDeclaration: 605case XmlNodeType.ProcessingInstruction: 608case XmlNodeType.DocumentType: 611case XmlNodeType.Comment: 614case XmlNodeType.EndElement:

10384if (feed._source.NodeType == XmlNodeType.XmlDeclaration) {

98if (n.NodeType == XmlNodeType.Element) { 132while (n != null && (n.NodeType == XmlNodeType.Whitespace || !IsTextLikeNode(n.NodeType))) { 163while (n.NodeType == XmlNodeType.Whitespace) 247internal bool IsTextLikeNode( XmlNodeType n ) { 249case XmlNodeType.EntityReference: 252case XmlNodeType.Text: 253case XmlNodeType.Whitespace: 254case XmlNodeType.SignificantWhitespace: 255case XmlNodeType.CDATA: 366if (n.NodeType == XmlNodeType.Element) { 602if ( reader.NodeType != XmlNodeType.Element ) { // Read till Element is found 708case XmlNodeType.Element: // It's an element 751case XmlNodeType.EntityReference: // Oops. No support for Entity Reference 753case XmlNodeType.Text: // It looks like a text. 754case XmlNodeType.Whitespace: // This actually could be 755case XmlNodeType.CDATA: // if we have XmlText in our table 756case XmlNodeType.SignificantWhitespace: 925case XmlNodeType.Element: // It's an element 972case XmlNodeType.EntityReference: // Oops. No support for Entity Reference 974case XmlNodeType.Text: // It looks like a text. 975case XmlNodeType.Whitespace: // This actually could be 976case XmlNodeType.CDATA: // if we have XmlText in our table 977case XmlNodeType.SignificantWhitespace: 1163case XmlNodeType.Text: // It looks like a text. And we need it. 1164case XmlNodeType.Whitespace: 1165case XmlNodeType.CDATA: 1166case XmlNodeType.SignificantWhitespace: 1191case XmlNodeType.Element: 1243case XmlNodeType.EntityReference: // Oops. No support for Entity Reference

192if (XmlNodeType.Element == ssync.NodeType) { 202while ((ssync.NodeType == XmlNodeType.EndElement) && (iSsyncDepth < ssync.Depth) ) 240if (XmlNodeType.Element == ssync.NodeType) { 249while ((ssync.NodeType == XmlNodeType.EndElement) && (iSsyncDepth < ssync.Depth) ) 328if (currentDepth == iRowDepth && row.NodeType == XmlNodeType.EndElement) { 348while((row.NodeType != XmlNodeType.EndElement) && (row.LocalName!=ln) && (row.NamespaceURI!=ns)) 393if (row.NodeType == XmlNodeType.Text || row.NodeType == XmlNodeType.Whitespace || row.NodeType == XmlNodeType.SignificantWhitespace) { 414while (reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.SignificantWhitespace) {

2866public override XmlNodeType NodeType {

407XmlNode nodeRegion = (node.NodeType == XmlNodeType.Attribute) ? ((XmlAttribute)node).OwnerElement : node.ParentNode; 410if(nodeRegion == null || nodeRegion.NodeType != XmlNodeType.Element) { 441if (node.NodeType == XmlNodeType.Element) { // If element

253else if (node.NodeType == XmlNodeType.Attribute) { 271if (column == null && node.NodeType == XmlNodeType.Element) { 289if ((column == null || column.ColumnMapping == MappingType.Attribute) && node.NodeType == XmlNodeType.Element) { 309internal XmlNodeType NodeType { 314return XmlNodeType.None; 320return XmlNodeType.Text; 323return XmlNodeType.Attribute; 326return XmlNodeType.Element; 406private bool IsLocalNameEmpty ( XmlNodeType nt) { 408case XmlNodeType.None : 409case XmlNodeType.Text : 410case XmlNodeType.CDATA : 411case XmlNodeType.Comment : 412case XmlNodeType.Document : 413case XmlNodeType.DocumentFragment : 414case XmlNodeType.Whitespace : 415case XmlNodeType.SignificantWhitespace : 416case XmlNodeType.EndElement : 417case XmlNodeType.EndEntity : 419case XmlNodeType.Element : 420case XmlNodeType.Attribute : 421case XmlNodeType.EntityReference : 422case XmlNodeType.Entity : 423case XmlNodeType.ProcessingInstruction : 424case XmlNodeType.DocumentType : 425case XmlNodeType.Notation : 426case XmlNodeType.XmlDeclaration : 494if (node.NodeType == XmlNodeType.Element) { 506if (node != null && column == null && node.NodeType == XmlNodeType.Attribute) { 563XmlNodeType nt = NodeType; 565case XmlNodeType.DocumentType : { 569case XmlNodeType.Entity : { 573case XmlNodeType.Notation : { 584XmlNodeType nt = NodeType; 586case XmlNodeType.DocumentType : { 590case XmlNodeType.Entity : { 594case XmlNodeType.Notation : { 605if ( NodeType == XmlNodeType.DocumentType ) { 616if ( child != null && child.NodeType == XmlNodeType.XmlDeclaration ) 624if ( NodeType == XmlNodeType.XmlDeclaration ) { 627} else if ( NodeType == XmlNodeType.Document ) { 638if ( NodeType == XmlNodeType.XmlDeclaration ) { 641} else if ( NodeType == XmlNodeType.Document ) { 652if ( NodeType == XmlNodeType.XmlDeclaration ) { 655} else if ( NodeType == XmlNodeType.Document ) {

120if ( n.NodeType == XmlNodeType.Element ) { 146if ( node.NodeType == XmlNodeType.Attribute && mt == MappingType.Attribute ) 148if ( node.NodeType == XmlNodeType.Element && mt == MappingType.Element ) 205if ( node.NodeType == XmlNodeType.Attribute ) 251if ( fc == null || fc.NodeType != XmlNodeType.Text || fc.NextSibling != null ) { 262if ( n.NodeType != XmlNodeType.Element ) { 291if ( fc == null || fc.NodeType != XmlNodeType.Text || fc.NextSibling != null ) { 300if ( n.NodeType != XmlNodeType.Element ) {

113Debug.Assert( this.CurrentNode.NodeType == XmlNodeType.Element ); 149while ( n.NodeType == XmlNodeType.Whitespace ) { 164if ( n.NodeType != XmlNodeType.Whitespace )

226Debug.Assert( dp.NodeType == XmlNodeType.Element ); 255Debug.Assert( dp.NodeType == XmlNodeType.Element ); 288case XmlNodeType.Attribute: 305case XmlNodeType.Element: 309case XmlNodeType.Text:

686if ( node.NodeType != XmlNodeType.Element ) 901if (newNode.NodeType == XmlNodeType.Element) { 939if ( dp.NodeType == XmlNodeType.Element ) 957case XmlNodeType.DocumentFragment: 959case XmlNodeType.DocumentType: 962case XmlNodeType.XmlDeclaration: 968case XmlNodeType.Text: 970case XmlNodeType.CDATA: 972case XmlNodeType.ProcessingInstruction: 974case XmlNodeType.Comment: 976case XmlNodeType.Whitespace: 978case XmlNodeType.SignificantWhitespace: 981case XmlNodeType.Element: 983case XmlNodeType.Attribute: 985case XmlNodeType.EntityReference: 993case XmlNodeType.Text: 994case XmlNodeType.CDATA: 995case XmlNodeType.Whitespace: 996case XmlNodeType.SignificantWhitespace: 999case XmlNodeType.EntityReference: 1356if ( iter.CurrentNode.NodeType == XmlNodeType.Element ) { 2049Debug.Assert( parent.NodeType != XmlNodeType.Attribute ); // We need to get get the grand-parent region 2097while ( n != null && n.NodeType == XmlNodeType.Whitespace ) 2101if ( n.NodeType == XmlNodeType.Text ) 2619internal static bool IsTextNode( XmlNodeType nt ) { 2621case XmlNodeType.Text: 2622case XmlNodeType.CDATA: 2623case XmlNodeType.Whitespace: 2624case XmlNodeType.SignificantWhitespace: 2664if ( parent != null && parent.NodeType == XmlNodeType.Attribute )

40xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.None)] = -1; 41xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.Element)] = (int)XPathNodeType.Element; 42xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.Attribute)] = (int)XPathNodeType.Attribute; 43xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.Text)] = (int)XPathNodeType.Text; 44xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.CDATA)] = (int)XPathNodeType.Text; 45xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.EntityReference)] = -1; 46xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.Entity)] = -1; 47xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.ProcessingInstruction)] = (int)XPathNodeType.ProcessingInstruction; 48xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.Comment)] = (int)XPathNodeType.Comment; 49xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.Document)] = (int)XPathNodeType.Root; 50xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.DocumentType)] = -1; 51xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.DocumentFragment)] = (int)XPathNodeType.Root; 52xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.Notation)] = -1; 53xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.Whitespace)] = (int)XPathNodeType.Whitespace; 54xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.SignificantWhitespace)] = (int)XPathNodeType.SignificantWhitespace; 55xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.EndElement)] = -1; 56xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.EndEntity)] = -1; 57xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.XmlDeclaration)] = -1; 67case XmlNodeType.Whitespace : 69case XmlNodeType.SignificantWhitespace : 72case XmlNodeType.Text : 73case XmlNodeType.CDATA : 98private bool IsNamespaceNode( XmlNodeType nt, string ns ) { 99if ( nt == XmlNodeType.Attribute && ns == s_strReservedXmlns ) 139if (_node.NodeType == XmlNodeType.Element) { 184XmlNodeType nt = this._node.NodeType; 187if ( nt == XmlNodeType.Element || nt == XmlNodeType.Attribute || nt == XmlNodeType.ProcessingInstruction ) 209XmlNodeType nt = this._node.NodeType; 216if ( nt == XmlNodeType.Element || nt == XmlNodeType.Attribute || nt == XmlNodeType.ProcessingInstruction ) 320if ( this._node.NodeType == XmlNodeType.Document ) { 382if ( curNode.NodeType == XmlNodeType.Attribute ) 490if (_column == null && _node.NodeType == XmlNodeType.Element) { 556if ((_column == null || _column.ColumnMapping == MappingType.Attribute) && _node.NodeType == XmlNodeType.Element) { 585if ( bFirst && ( _column != null || _node.NodeType != XmlNodeType.Element ) ) 590if ( _column == null && _node.NodeType != XmlNodeType.Attribute ) 900if ( _node.NodeType == XmlNodeType.Attribute ) 970XmlNode parent = ( ( curNode.NodeType == XmlNodeType.Attribute ) ? ( ((XmlAttribute)curNode).OwnerElement ) : ( curNode.ParentNode ) ); 1064curNode1 = ( ( curNode1.NodeType == XmlNodeType.Attribute ) ? ( ((XmlAttribute)curNode1).OwnerElement ) : ( curNode1.ParentNode ) ); 1072curNode2 = ( ( curNode2.NodeType == XmlNodeType.Attribute ) ? ( ((XmlAttribute)curNode2).OwnerElement ) : ( curNode2.ParentNode ) ); 1233XmlNodeType nt = node.NodeType; 1237while ( node != null && ( ( nt = node.NodeType ) != XmlNodeType.Element ) ) { 1238if ( nt == XmlNodeType.Attribute ) 1270XmlNodeType nt = node.NodeType; 1302} while ( node != null && node.NodeType != XmlNodeType.Element ); 1375} while ( node != null && node.NodeType != XmlNodeType.Element ); 1400} while ( node != null && node.NodeType != XmlNodeType.Element ); 1435} while ( node != null && node.NodeType != XmlNodeType.Element ); 1437else if ( this._node.NodeType == XmlNodeType.Attribute ) { 1452} while ( node != null && node.NodeType != XmlNodeType.Element ); 1463} while ( node != null && node.NodeType == XmlNodeType.Element );

143if (sourceReader.NodeType != XmlNodeType.Element) 145while (sourceReader.Read() && sourceReader.NodeType != XmlNodeType.Element) 304if (reader != null && !IsValidateableXmlNamespace(reader.NamespaceURI, reader.NodeType == XmlNodeType.Attribute)) 318if ( (reader.NodeType == XmlNodeType.Attribute) || (e.Severity == System.Xml.Schema.XmlSeverityType.Warning)) 326if ((this.SchemaVersion >= XmlConstants.EdmVersionForV2) && (reader.NodeType == XmlNodeType.Attribute)

241Debug.Assert(reader.NodeType == XmlNodeType.Element); 266case XmlNodeType.Element: 270case XmlNodeType.EndElement: 276case XmlNodeType.CDATA: 277case XmlNodeType.Text: 278case XmlNodeType.SignificantWhitespace: 283case XmlNodeType.Whitespace: 284case XmlNodeType.XmlDeclaration: 285case XmlNodeType.Comment: 286case XmlNodeType.Notation: 287case XmlNodeType.ProcessingInstruction: 293case XmlNodeType.DocumentType: 294case XmlNodeType.EntityReference: 657if (reader.NodeType == XmlNodeType.Element) 706Debug.Assert(reader.NodeType == XmlNodeType.Attribute, "called an attribute function when not on an attribute");

205if (!reader.EOF && reader.NodeType != XmlNodeType.Element) 207while (reader.Read() && reader.NodeType != XmlNodeType.Element)

198if (!reader.EOF && reader.NodeType != XmlNodeType.Element) 200while (reader.Read() && reader.NodeType != XmlNodeType.Element)

242if (reader.NodeType != XmlNodeType.EndElement) { 251System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element); 269while (reader.NodeType != XmlNodeType.EndElement) { 270if (reader.NodeType == XmlNodeType.Whitespace || !IsInNamespace(reader)) { 325System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element); 344while (reader.NodeType != XmlNodeType.EndElement) { 345if (reader.NodeType == XmlNodeType.Whitespace || !IsInNamespace(reader)) { 376System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element); 394System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element); 418System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element); 435while (reader.NodeType != XmlNodeType.EndElement) { 436if (reader.NodeType == XmlNodeType.Whitespace || !IsInNamespace(reader)) { 469System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element); 478System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element); 502while (reader.NodeType != XmlNodeType.EndElement) { 503if (reader.NodeType == XmlNodeType.Whitespace || !IsInNamespace(reader)) { 533System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element); 567System.Diagnostics.Debug.Assert(reader.NodeType == XmlNodeType.Element);

63case XmlNodeType.Element: 101case XmlNodeType.CDATA: 102case XmlNodeType.Text: 103case XmlNodeType.SignificantWhitespace: 115case XmlNodeType.EndElement: 128case XmlNodeType.Comment: 129case XmlNodeType.Whitespace: 132case XmlNodeType.None: 133case XmlNodeType.XmlDeclaration: 134case XmlNodeType.Attribute: 135case XmlNodeType.EndEntity: 136case XmlNodeType.EntityReference: 137case XmlNodeType.Entity: 138case XmlNodeType.Document: 139case XmlNodeType.DocumentType: 140case XmlNodeType.DocumentFragment: 141case XmlNodeType.Notation: 142case XmlNodeType.ProcessingInstruction:

213case XmlNodeType.Element: 243this.xmlReader.NodeType != XmlNodeType.Element, 262Debug.Assert(reader.NodeType == XmlNodeType.Element, "reader.NodeType == XmlNodeType.Element"); 274if (reader.NodeType != XmlNodeType.EndElement) 296Debug.Assert(XmlNodeType.Element == reader.NodeType, "not positioned on Element"); 314case XmlNodeType.EndElement: 317case XmlNodeType.CDATA: 318case XmlNodeType.Text: 319case XmlNodeType.SignificantWhitespace: 337case XmlNodeType.Comment: 338case XmlNodeType.Whitespace: 342case XmlNodeType.None: 343case XmlNodeType.XmlDeclaration: 344case XmlNodeType.Attribute: 345case XmlNodeType.EndEntity: 346case XmlNodeType.EntityReference: 347case XmlNodeType.Entity: 348case XmlNodeType.Document: 349case XmlNodeType.DocumentType: 350case XmlNodeType.DocumentFragment: 351case XmlNodeType.Notation: 352case XmlNodeType.ProcessingInstruction: 396case XmlNodeType.Element: 415reader.NodeType != XmlNodeType.Element, 569reader.NodeType == XmlNodeType.EndElement,

258reader.NodeType == XmlNodeType.Element, 608if (linkReader.NodeType == XmlNodeType.Element)

1178case XmlNodeType.Element: 1180case XmlNodeType.Comment: 1181case XmlNodeType.None: 1182case XmlNodeType.ProcessingInstruction: 1183case XmlNodeType.XmlDeclaration: 1184case XmlNodeType.Whitespace: 1186case XmlNodeType.Text: 1399return ((XmlNodeType.Element == reader.NodeType) || (XmlNodeType.EndElement == reader.NodeType)) && 1420case XmlNodeType.Element: 1430case XmlNodeType.EndElement:

1479var node = element.Nodes().Where(n => n.NodeType == XmlNodeType.Text || n.NodeType == XmlNodeType.SignificantWhitespace).FirstOrDefault();

207this.reader.NodeType == XmlNodeType.Element || this.reader.NodeType == XmlNodeType.EndElement, 212if (this.reader.NodeType == XmlNodeType.EndElement) 341reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.EndElement, 390Debug.Assert(reader.NodeType != XmlNodeType.EndElement, "reader.NodeType != XmlNodeType.EndElement"); 414(reader.NodeType == XmlNodeType.EndElement || 415(reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement)))) 449reader.NodeType == XmlNodeType.EndElement, 454if (reader.NodeType == XmlNodeType.SignificantWhitespace || 455reader.NodeType == XmlNodeType.Text) 480case XmlNodeType.CDATA: 481case XmlNodeType.EntityReference: 482case XmlNodeType.EndEntity: 485case XmlNodeType.Text: 486case XmlNodeType.SignificantWhitespace: 490case XmlNodeType.Element: 491case XmlNodeType.EndElement: 532Debug.Assert(this.reader.NodeType == XmlNodeType.Element, "this.reader.NodeType == XmlNodeType.Element"); 572else if (this.reader.NodeType != XmlNodeType.EndElement) 587this.reader.NodeType == XmlNodeType.Element, 750case XmlNodeType.CDATA: 751case XmlNodeType.SignificantWhitespace: 752case XmlNodeType.Text: 761case XmlNodeType.Comment: 762case XmlNodeType.Whitespace: 763case XmlNodeType.ProcessingInstruction: 764case XmlNodeType.EndElement: 769case XmlNodeType.Element: 799this.reader.NodeType == XmlNodeType.Element, 839Debug.Assert(this.reader.NodeType == XmlNodeType.Element, "this.reader.NodeType == XmlNodeType.Element"); 848if (this.reader.NodeType == XmlNodeType.EndElement) 853if (this.reader.NodeType == XmlNodeType.Element) 875Debug.Assert(this.reader.NodeType == XmlNodeType.Element, "this.reader.NodeType == XmlNodeType.Element"); 899if (this.reader.NodeType == XmlNodeType.Element)

380Debug.Assert(reader.NodeType == XmlNodeType.Element, "reader.NodeType == XmlNodeType.Element"); 390if (reader.NodeType == XmlNodeType.EndElement && reader.Depth == readerDepth) 486while (this.reader.NodeType != XmlNodeType.Element && this.reader.Read()) 558reader.NodeType == XmlNodeType.Element, 573case XmlNodeType.EndElement: 575case XmlNodeType.CDATA: 576case XmlNodeType.Text: 577case XmlNodeType.SignificantWhitespace: 585case XmlNodeType.Comment: 586case XmlNodeType.Whitespace: 590case XmlNodeType.Element:

415return ((XmlNodeType.Element == reader.NodeType) || (XmlNodeType.EndElement == reader.NodeType)) && 563Debug.Assert(XmlNodeType.Element == reader.NodeType, "not positioned on Element");

41if (this.NodeType == XmlNodeType.Element && 64Debug.Assert(XmlNodeType.Element == reader.NodeType, "not positioned on Element"); 78case XmlNodeType.EndElement: 80case XmlNodeType.CDATA: 81case XmlNodeType.Text: 82case XmlNodeType.SignificantWhitespace: 90case XmlNodeType.Comment: 91case XmlNodeType.Whitespace: 93case XmlNodeType.Element: 109Debug.Assert(reader.NodeType == XmlNodeType.Element, "reader.NodeType == XmlNodeType.Element"); 115if (reader.NodeType == XmlNodeType.Element) 128else if (reader.NodeType == XmlNodeType.EndElement)

211public override XmlNodeType NodeType 439if (this.reader.NodeType == XmlNodeType.EndElement) 457if (this.reader.NodeType == XmlNodeType.Element &&

75case XmlNodeType.Element: 83case XmlNodeType.EndElement: 87case XmlNodeType.Whitespace: 88case XmlNodeType.SignificantWhitespace: 89case XmlNodeType.XmlDeclaration: 90case XmlNodeType.Comment: 91case XmlNodeType.ProcessingInstruction: 391case XmlNodeType.Text: 392case XmlNodeType.SignificantWhitespace: 393case XmlNodeType.Whitespace:

79case XmlNodeType.Element: 89case XmlNodeType.EndElement: 94case XmlNodeType.Text: 95case XmlNodeType.CDATA: 103goto case XmlNodeType.Whitespace; 115case XmlNodeType.Whitespace: 116case XmlNodeType.SignificantWhitespace: 132case XmlNodeType.EndEntity:

37private XmlNodeType nodeType; 59this.nodeType = XmlNodeType.Document; 63public XmlNodeType NodeType { get { return nodeType == XmlNodeType.Element && 0 < currentRecord ? XmlNodeType.Attribute : nodeType; } } 116while (MoveToNextSibling() && nodeType == XmlNodeType.Whitespace) ; 119if (nodeType == XmlNodeType.Element) { 182reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.SignificantWhitespace || 183reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.CDATA 192bool isCDATA = (reader.NodeType == XmlNodeType.CDATA); 219Debug.Assert(reader.NodeType == XmlNodeType.EntityReference); 232Debug.Assert(reader.NodeType == XmlNodeType.Text || reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.SignificantWhitespace); 235Debug.Assert(reader.NodeType == XmlNodeType.EndEntity); 247Debug.Assert(reader.NodeType == XmlNodeType.Attribute, "reader.NodeType == XmlNodeType.Attribute"); 270int correction = (reader.NodeType == XmlNodeType.EntityReference) ? -2 : -1; 281case XmlNodeType.EntityReference: 284case XmlNodeType.EndEntity: 287Debug.Assert(reader.NodeType == XmlNodeType.Text, "Unexpected node type inside attribute value"); 295Debug.Assert(reader.NodeType != XmlNodeType.EntityReference); 296int correction = ((reader.NodeType == XmlNodeType.EndEntity) ? 1 : lastText.Length) + 1; 309Debug.Assert(nodeType == XmlNodeType.Element, "To call MoveToFirstChild() XsltI---- should be positioned on an Element."); 317Debug.Assert(nodeType != XmlNodeType.Element || IsEmptyElement, "On non-empty elements we should call MoveToFirstChild()"); 318if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement) { 325if (nodeType == XmlNodeType.Element && MoveToFirstChild()) { 338case XmlNodeType.Text: 340case XmlNodeType.CDATA: 344goto case XmlNodeType.SignificantWhitespace; 345case XmlNodeType.Whitespace: 346case XmlNodeType.SignificantWhitespace: 352case XmlNodeType.EntityReference: 370case XmlNodeType.EndEntity: 375! textIsWhite ? XmlNodeType.Text : 376textPreserveWS ? XmlNodeType.SignificantWhitespace : 377/*default: */ XmlNodeType.Whitespace 386Debug.Assert(nodeType == XmlNodeType.Text || nodeType == XmlNodeType.Whitespace || nodeType == XmlNodeType.SignificantWhitespace); 396case XmlNodeType.Text: 397case XmlNodeType.CDATA: 398case XmlNodeType.Whitespace: 399case XmlNodeType.SignificantWhitespace: 400case XmlNodeType.EntityReference: 408case XmlNodeType.Element: 412case XmlNodeType.EndElement: 413nodeType = XmlNodeType.EndElement; 428Debug.Assert(reader.NodeType == XmlNodeType.Element); 432nodeType = XmlNodeType.Element; 454Debug.Assert(nodeType == XmlNodeType.Element, "For MoveToElement() we should be positioned on Element or Attribute"); 459Debug.Assert(nodeType == XmlNodeType.Element, "For MoveToLiteralAttribute() we should be positioned on Element or Attribute"); 470Debug.Assert(nodeType == XmlNodeType.Element, "For MoveToLiteralAttribute() we should be positioned on Element or Attribute"); 509Debug.Assert(nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement, "Input is positioned on element or attribute"); 539Debug.Assert(nodeType != XmlNodeType.Element || attributesRead, "Should first read attributes"); 545Debug.Assert(nodeType != XmlNodeType.Element || attributesRead, "Should first read attributes"); 552Debug.Assert(nodeType != XmlNodeType.Element || attributesRead, "Should first read attributes"); 618Debug.Assert(NodeType == XmlNodeType.Element); 722Debug.Assert(NodeType == XmlNodeType.Element); 785Debug.Assert(NodeType == XmlNodeType.Element && IsXsltNamespace()); 874private static int PositionAdjustment(XmlNodeType nt) { 876case XmlNodeType.Element: 878case XmlNodeType.CDATA: 880case XmlNodeType.ProcessingInstruction: 882case XmlNodeType.Comment: 884case XmlNodeType.EndElement: 886case XmlNodeType.EntityReference: 1001Debug.Assert(input.NodeType == XmlNodeType.EndElement); 1004Debug.Assert(input.NodeType == XmlNodeType.Element || input.NodeType == XmlNodeType.Attribute);

258Debug.Assert(input.NodeType == XmlNodeType.Element); 317case XmlNodeType.Element: 376case XmlNodeType.Whitespace: 377case XmlNodeType.SignificantWhitespace: 380Debug.Assert(input.NodeType == XmlNodeType.Text); 900case XmlNodeType.Element: 909case XmlNodeType.Whitespace: 910case XmlNodeType.SignificantWhitespace: 913Debug.Assert(input.NodeType == XmlNodeType.Text); 1123case XmlNodeType.Text: 1139case XmlNodeType.Element: 1156input.NodeType == XmlNodeType.SignificantWhitespace || 1157input.NodeType == XmlNodeType.Whitespace 1161goto case XmlNodeType.Text; 1273case XmlNodeType.Element: 1335case XmlNodeType.SignificantWhitespace: 1338case XmlNodeType.Whitespace: 1341Debug.Assert(input.NodeType == XmlNodeType.Text); 1343goto case XmlNodeType.SignificantWhitespace; 1360case XmlNodeType.Element: 1374case XmlNodeType.Whitespace: 1375case XmlNodeType.SignificantWhitespace: 1378Debug.Assert(input.NodeType == XmlNodeType.Text); 1529case XmlNodeType.Element: 1559case XmlNodeType.Whitespace: 1560case XmlNodeType.SignificantWhitespace: 1563Debug.Assert(input.NodeType == XmlNodeType.Text); 1858case XmlNodeType.Text: 1859case XmlNodeType.Whitespace: 1860case XmlNodeType.SignificantWhitespace: 1865Debug.Assert(input.NodeType == XmlNodeType.Element); 2310Debug.Assert(input.NodeType == XmlNodeType.Element); 2764if (input.NodeType != XmlNodeType.Whitespace) {

23private XmlNodeType nodeType; 75Debug.Assert(info.NodeType != XmlNodeType.Text || XmlCharType.Instance.IsOnlyWhitespace(info.Value)); 155internal XmlNodeType NodeType {

38case XmlNodeType.Element: { 62case XmlNodeType.Text: 65case XmlNodeType.Whitespace: 67case XmlNodeType.SignificantWhitespace: 71case XmlNodeType.ProcessingInstruction: 74case XmlNodeType.Comment: 78case XmlNodeType.Document: 81case XmlNodeType.EndElement:

58public override XmlNodeType NodeType { 255if (NodeType == XmlNodeType.Attribute || this.currentInfo == this.attributeValue) { 288case XmlNodeType.Text : 290this.currentInfo.NodeType = XmlNodeType.Whitespace; 291goto case XmlNodeType.Whitespace; 295case XmlNodeType.Whitespace : 300this.currentInfo.NodeType = XmlNodeType.SignificantWhitespace; 333if (NodeType == XmlNodeType.Element || NodeType == XmlNodeType.Attribute || this.currentInfo == this.attributeValue) { 347case XmlNodeType.Text: 348case XmlNodeType.Whitespace: 349case XmlNodeType.SignificantWhitespace: 371if (NodeType == XmlNodeType.Element && ! IsEmptyElement) { 382Debug.Assert(NodeType == XmlNodeType.EndElement); 388else if(NodeType == XmlNodeType.Attribute) { 400if (NodeType == XmlNodeType.Element) { 423else if(NodeType == XmlNodeType.Attribute) { 454Debug.Assert(NodeType != XmlNodeType.EntityReference); 456if (NodeType != XmlNodeType.EntityReference) { 462if (ReadState != ReadState.Interactive || NodeType != XmlNodeType.Attribute) { 468this.attributeValue.NodeType = XmlNodeType.Text;

181this.currentInfo.NodeType = XmlNodeType.Text; 258this.currentInfo.NodeType = XmlNodeType.Element; 272this.currentInfo.NodeType = XmlNodeType.EndElement; 299attribute.NodeType = XmlNodeType.Attribute; 334currentInfo.NodeType = XmlNodeType.Attribute; 338this.currentInfo.NodeType = XmlNodeType.ProcessingInstruction; 347this.currentInfo.NodeType = XmlNodeType.Comment; 373this.currentInfo.NodeType = XmlNodeType.None; 427Debug.Assert(this.mainNode.NodeType == XmlNodeType.Element); 447Debug.Assert(this.mainNode.NodeType == XmlNodeType.Element); 525Debug.Assert(this.mainNode.NodeType == XmlNodeType.Comment); 568Debug.Assert(this.mainNode.NodeType == XmlNodeType.ProcessingInstruction || this.mainNode.NodeType == XmlNodeType.XmlDeclaration); 610case XmlNodeType.Element: 619case XmlNodeType.Comment: 622case XmlNodeType.ProcessingInstruction: 649ns.NodeType = XmlNodeType.Attribute;

111Debug.Assert(record.MainNode.NodeType == XmlNodeType.Element); 325case XmlNodeType.Element: 330case XmlNodeType.Text: 331case XmlNodeType.Whitespace: 332case XmlNodeType.SignificantWhitespace: 378case XmlNodeType.Element: 381case XmlNodeType.Text: 382case XmlNodeType.Whitespace: 383case XmlNodeType.SignificantWhitespace: 386case XmlNodeType.CDATA: 389case XmlNodeType.EntityReference: 394case XmlNodeType.ProcessingInstruction: 397case XmlNodeType.Comment: 403case XmlNodeType.Document: 405case XmlNodeType.DocumentType: 408case XmlNodeType.EndElement: 424case XmlNodeType.Element: 427case XmlNodeType.Text: 428case XmlNodeType.Whitespace: 429case XmlNodeType.SignificantWhitespace: 432case XmlNodeType.CDATA: 435case XmlNodeType.EntityReference: 440case XmlNodeType.ProcessingInstruction: 443case XmlNodeType.Comment: 448case XmlNodeType.Document: 450case XmlNodeType.DocumentType: 453case XmlNodeType.EndElement:

59case XmlNodeType.Text: 60case XmlNodeType.Whitespace: 61case XmlNodeType.SignificantWhitespace:

35case XmlNodeType.Element: 44case XmlNodeType.Text: 45case XmlNodeType.Whitespace: 46case XmlNodeType.SignificantWhitespace: 49case XmlNodeType.CDATA: 53case XmlNodeType.EntityReference: 56case XmlNodeType.ProcessingInstruction: 59case XmlNodeType.Comment: 62case XmlNodeType.Document: 64case XmlNodeType.DocumentType: 67case XmlNodeType.EndElement: 71case XmlNodeType.None: 72case XmlNodeType.Attribute: 73case XmlNodeType.Entity: 74case XmlNodeType.Notation: 75case XmlNodeType.DocumentFragment: 76case XmlNodeType.EndEntity:

43if (node.NodeType != XmlNodeType.Element)

173public override XmlNodeType NodeType

143if ((base.NodeType == XmlNodeType.Element) && (!base.IsEmptyElement)) 148if (base.NodeType == XmlNodeType.EndElement)

202public override XmlNodeType NodeType

3156while (reader.NodeType == XmlNodeType.Whitespace) 3163if (reader.NodeType == XmlNodeType.Element) 3165while (reader.NodeType == XmlNodeType.Element) 5330if (!requireKeyInfo && XmlNodeType.EndElement != reader.NodeType)

2732while (reader.NodeType == XmlNodeType.Whitespace) 2739if (reader.NodeType == XmlNodeType.Element) 2741while (reader.NodeType == XmlNodeType.Element)

156if (NodeType == XmlNodeType.Attribute) 163while (NodeType != XmlNodeType.Element && NodeType != XmlNodeType.EndElement) 168case XmlNodeType.Text: 173case XmlNodeType.Whitespace: 254case XmlNodeType.Element: 277case XmlNodeType.CDATA: 278case XmlNodeType.Comment: 279case XmlNodeType.Text: 280case XmlNodeType.EntityReference: 281case XmlNodeType.EndEntity: 282case XmlNodeType.SignificantWhitespace: 283case XmlNodeType.Whitespace: 288case XmlNodeType.EndElement: 297case XmlNodeType.DocumentType: 298case XmlNodeType.XmlDeclaration: 374public void Add(XmlNodeType type, string value) 479public XmlNodeType NodeType 536DiagnosticUtility.DebugAssert(this.NodeType == XmlNodeType.Element, ""); 537if (this.position < this.Count - 1 && this.entries[this.position + 1].nodeType == XmlNodeType.Attribute) 560DiagnosticUtility.DebugAssert(this.NodeType == XmlNodeType.Attribute, ""); 561if (this.position < this.count - 1 && this.entries[this.position + 1].nodeType == XmlNodeType.Attribute) 589case XmlNodeType.Element: 617goto case XmlNodeType.EndElement; 620case XmlNodeType.EndElement: 632case XmlNodeType.CDATA: 638case XmlNodeType.Comment: 644case XmlNodeType.Text: 650case XmlNodeType.SignificantWhitespace: 651case XmlNodeType.Whitespace: 657case XmlNodeType.DocumentType: 658case XmlNodeType.XmlDeclaration: 669internal XmlNodeType nodeType; 686public void Set(XmlNodeType nodeType, string value) 694this.nodeType = XmlNodeType.Attribute; 703this.nodeType = XmlNodeType.Element;

139public override XmlNodeType NodeType

18while (reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.SignificantWhitespace)

113XmlNodeType nodeType = _XMLReader.MoveToContent(); 114while (nodeType == XmlNodeType.EndElement) 118if (nodeType == XmlNodeType.None) 122return(nodeType != XmlNodeType.None); 130XmlNodeType nodeType = _XMLReader.MoveToContent(); 131while (nodeType == XmlNodeType.EndElement) 135if (nodeType == XmlNodeType.None) 140return(nodeType != XmlNodeType.None);

476throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.GetString(SR.ExpectingElementAtDeserialize, XmlNodeType.Element), xmlReader));

39XmlNodeType nodeType; 121public override XmlNodeType NodeType { get { return IsXmlDataNode ? xmlNodeReader.NodeType : nodeType; } } 170this.nodeType = XmlNodeType.Attribute; 218if (this.nodeType != XmlNodeType.Attribute) 227this.nodeType = XmlNodeType.Element; 301if (nodeType == XmlNodeType.Attribute && MoveToNextAttribute()) 316this.nodeType = XmlNodeType.Text; 325this.nodeType = XmlNodeType.EndElement; 338this.nodeType = XmlNodeType.None;

423throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(System.Runtime.Serialization.SR.GetString(System.Runtime.Serialization.SR.ExpectingElementAtDeserialize, XmlNodeType.Element), xmlReader));

807LocalBuilder nodeType = ilg.DeclareLocal(typeof(XmlNodeType), "nodeType"); 813ilg.Load(XmlNodeType.EndElement); 817ilg.Load(XmlNodeType.Element); 819ThrowUnexpectedStateException(XmlNodeType.Element); 1058ThrowUnexpectedStateException(XmlNodeType.Element); 1076ilg.Load(XmlNodeType.EndElement); 1080void ThrowUnexpectedStateException(XmlNodeType expectedState)

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

427throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializer.CreateSerializationExceptionWithReaderDetails(SR.GetString(SR.ExpectingElementAtDeserialize, XmlNodeType.Element), xmlReader));

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

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

904ThrowUnexpectedStateException(XmlNodeType.Element); 922ilg.Load(XmlNodeType.EndElement); 926void ThrowUnexpectedStateException(XmlNodeType expectedState)

252return (xmlReader.MoveToContent() != XmlNodeType.EndElement); 298if (xmlReader.NodeType != XmlNodeType.Element) 299throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 509if (xmlReader.NodeType == XmlNodeType.EndElement) 517if (xmlReader.NodeType != XmlNodeType.EndElement) 518throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.EndElement, xmlReader)); 545throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 566XmlNodeType nodeType; 567while ((nodeType = xmlReader.MoveToContent()) != XmlNodeType.EndElement) 569if (nodeType != XmlNodeType.Element) 570throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 734case XmlNodeType.Text: 736case XmlNodeType.Element: 742case XmlNodeType.EndElement: 751throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 798XmlNodeType nodeType; 799while ((nodeType = xmlReader.MoveToContent()) != XmlNodeType.EndElement) 801if (nodeType != XmlNodeType.Element) 802throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 818XmlNodeType nodeType; 819while ((nodeType = xmlReader.MoveToContent()) != XmlNodeType.EndElement) 821if (nodeType != XmlNodeType.Element) 822throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 874XmlNodeType nodeType; 875while ((nodeType = xmlReader.MoveToContent()) != XmlNodeType.EndElement) 877if (nodeType != XmlNodeType.Element) 878throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 903if (xmlReader.NodeType == XmlNodeType.EndElement) 909XmlNodeType nodeType = xmlReader.MoveToContent(); 910if (nodeType != XmlNodeType.Text) 925while ((nodeType = xmlReader.MoveToContent()) != XmlNodeType.EndElement) 963XmlNodeType nodeType; 964while ((nodeType = xmlReader.NodeType) != XmlNodeType.EndElement) 966if (nodeType == XmlNodeType.Element) 1022bool IsContentNode(XmlNodeType nodeType) 1026case XmlNodeType.Whitespace: 1027case XmlNodeType.SignificantWhitespace: 1028case XmlNodeType.Comment: 1029case XmlNodeType.ProcessingInstruction: 1030case XmlNodeType.DocumentType: 1073public static Exception CreateUnexpectedStateException(XmlNodeType expectedState, XmlReaderDelegator xmlReader)

172public XmlNodeType NodeType 174get { return isEndOfEmptyElement ? XmlNodeType.EndElement : reader.NodeType; } 196internal XmlNodeType MoveToContent() 200return XmlNodeType.EndElement;

26if (xmlReader.NodeType != XmlNodeType.Element) 27throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializerReadContext.CreateUnexpectedStateException(XmlNodeType.Element, xmlReader)); 45throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(XmlObjectSerializerReadContext.CreateUnexpectedStateException(XmlNodeType.EndElement, xmlReader)); 55if (reader.NodeType == XmlNodeType.EndElement || 56(reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement)) 70public override XmlNodeType NodeType { get { return InnerReader.NodeType; } } 113public override XmlNodeType MoveToContent() { return InnerReader.MoveToContent(); }

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

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

258whitespaceTextNode.NodeType = XmlNodeType.SignificantWhitespace; 260whitespaceTextNode.NodeType = XmlNodeType.Whitespace; 849public override XmlNodeType MoveToContent() 855if (node.NodeType != XmlNodeType.Text && node.NodeType != XmlNodeType.CDATA) 876if (node.NodeType == XmlNodeType.Attribute) 941public sealed override XmlNodeType NodeType 1092XmlNodeType nodeType = node.NodeType; 1093if (nodeType == XmlNodeType.Element) 1095if (nodeType == XmlNodeType.EndElement) 1097if (nodeType == XmlNodeType.None) 1100if (node.NodeType == XmlNodeType.Element) 1103return (MoveToContent() == XmlNodeType.Element); 1123return (node.NodeType == XmlNodeType.Element || IsStartElement()) && node.Prefix == prefix && node.LocalName == localName; 1132return (node.NodeType == XmlNodeType.Element || IsStartElement()) && node.LocalName == localName && node.IsNamespaceUri(namespaceUri); 1141return (node.NodeType == XmlNodeType.Element || IsStartElement()) && node.LocalName == localName && node.IsNamespaceUri(namespaceUri); 1289if (node.NodeType != XmlNodeType.Element) 1337if (node.NodeType != XmlNodeType.Element) 1356if (node.NodeType != XmlNodeType.EndElement && MoveToContent() != XmlNodeType.EndElement) 1358int nodeDepth = node.NodeType == XmlNodeType.Element ? this.depth - 1 : this.depth; 1467while (node.NodeType != XmlNodeType.Comment && node.Value.TryReadBase64(buffer, offset, count, out actual)) 1475XmlNodeType nodeType = node.NodeType; 1476if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement) 1539XmlNodeType nodeType = node.NodeType; 1540if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement) 1840if ((node.NodeType == XmlNodeType.Element || MoveToElement()) && !IsEmptyElement) 1848if (node.NodeType == XmlNodeType.EndElement) 2077case XmlNodeType.None: 2079case XmlNodeType.Element: 2085case XmlNodeType.Text: 2086case XmlNodeType.Whitespace: 2087case XmlNodeType.SignificantWhitespace: 2088case XmlNodeType.CDATA: 2091case XmlNodeType.XmlDeclaration: 2094case XmlNodeType.Comment: 2097case XmlNodeType.EndElement: 2162XmlNodeType nodeType; 2192protected XmlNode(XmlNodeType nodeType, 2214this.exitScope = (nodeType == XmlNodeType.EndElement); 2240public XmlNodeType NodeType 2487: base(XmlNodeType.Element, 2531: base(XmlNodeType.Attribute, 2546: base(XmlNodeType.EndElement, 2560protected XmlTextNode(XmlNodeType nodeType, 2577: base(XmlNodeType.Text, 2592: base(XmlNodeType.Text, 2607: base(XmlNodeType.Whitespace, 2622: base(XmlNodeType.CDATA, 2637: base(XmlNodeType.Text, 2652: base(XmlNodeType.None, 2667: base(XmlNodeType.XmlDeclaration, 2682: base(XmlNodeType.Comment, 2697: base(XmlNodeType.None, 2712: base(XmlNodeType.None,

105if (this.Node.NodeType != XmlNodeType.Element) 133if (this.Node.NodeType != XmlNodeType.Element) 164if (this.Node.NodeType != XmlNodeType.Element) 210if (this.Node.NodeType != XmlNodeType.Element) 224if (this.Node.NodeType != XmlNodeType.Element) 238if (this.Node.NodeType != XmlNodeType.Element) 252if (this.Node.NodeType != XmlNodeType.Element) 266if (this.Node.NodeType != XmlNodeType.Element) 280if (this.Node.NodeType != XmlNodeType.Element) 294if (this.Node.NodeType != XmlNodeType.Element) 1133if (this.Node.NodeType != XmlNodeType.Element) 1138if (this.Node.NodeType != XmlNodeType.EndElement)

424case XmlNodeType.Attribute: 427case XmlNodeType.Text: 428case XmlNodeType.Whitespace: 429case XmlNodeType.SignificantWhitespace: 430case XmlNodeType.CDATA: 446case XmlNodeType.ProcessingInstruction: 447case XmlNodeType.Comment: 448case XmlNodeType.EndEntity: 451case XmlNodeType.EntityReference: 458case XmlNodeType.Element: 459case XmlNodeType.EndElement: 487if (this.NodeType != XmlNodeType.Element) 489if (this.NodeType == XmlNodeType.Element) 495if (this.NodeType == XmlNodeType.EndElement) 577protected bool IsTextNode(XmlNodeType nodeType) 579return nodeType == XmlNodeType.Text || 580nodeType == XmlNodeType.Whitespace || 581nodeType == XmlNodeType.SignificantWhitespace || 582nodeType == XmlNodeType.CDATA || 583nodeType == XmlNodeType.Attribute; 591XmlNodeType nodeType = this.NodeType; 593if (nodeType == XmlNodeType.Element || nodeType == XmlNodeType.EndElement) 603if (nodeType == XmlNodeType.Attribute /* || inAttributeText */) 1521public override XmlNodeType NodeType

773if (reader.NodeType == XmlNodeType.EntityReference) 892int d = (reader.NodeType == XmlNodeType.None ? -1 : reader.Depth); 895XmlNodeType nodeType = reader.NodeType; 897if (nodeType == XmlNodeType.Text || nodeType == XmlNodeType.Whitespace || nodeType == XmlNodeType.SignificantWhitespace) 911case XmlNodeType.Element: 914case XmlNodeType.CDATA: 917case XmlNodeType.EntityReference: 920case XmlNodeType.XmlDeclaration: 921case XmlNodeType.ProcessingInstruction: 924case XmlNodeType.DocumentType: 927case XmlNodeType.Comment: 930case XmlNodeType.EndElement: 938while (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement));

70case XmlNodeType.Element: 72case XmlNodeType.EndElement: 74case XmlNodeType.Text: 75case XmlNodeType.Whitespace: 76case XmlNodeType.SignificantWhitespace: 78case XmlNodeType.Comment: 80case XmlNodeType.CDATA:

282if (xmlReader.NodeType == XmlNodeType.Element) 440if (NodeType != XmlNodeType.Attribute) 692public override XmlNodeType NodeType 1083XmlNodeType nodeType; 1100this.nodeType = XmlNodeType.None; 1114public override XmlNodeType NodeType 1129nodeType = XmlNodeType.Text; 1135nodeType = XmlNodeType.EndElement; 1143nodeType = XmlNodeType.None;

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

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

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

125while (reader.MoveToContent() == XmlNodeType.Element) 143if (reader.NodeType != XmlNodeType.EndElement)

610if (reader.NodeType != XmlNodeType.Element) 612if (reader.NodeType == XmlNodeType.Element) 617else if (reader.NodeType == XmlNodeType.EndElement) 931if (reader.MoveToContent() != XmlNodeType.Element) 954XmlNodeType type = reader.MoveToContent(); 955while (!reader.EOF && type != XmlNodeType.EndElement) 957if (type != XmlNodeType.Element) 1245while (bodyReader.NodeType != XmlNodeType.EndElement && !bodyReader.EOF) 1299if (reader.NodeType != XmlNodeType.Element) 1333if (reader.NodeType != XmlNodeType.Element) 1622if (reader.NodeType != XmlNodeType.Element) 1633if (reader.NodeType != XmlNodeType.Element) 1640if (reader.NodeType != XmlNodeType.Element) 1664while (reader.NodeType != XmlNodeType.EndElement)

180if (reader.NodeType != XmlNodeType.EndElement && !reader.EOF) 550hasDetail = (reader.MoveToContent() != XmlNodeType.EndElement); 576while (r.NodeType != XmlNodeType.EndElement) 607while (r.NodeType != XmlNodeType.EndElement)

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

417if (reader.NodeType != XmlNodeType.Element) 419if (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) 1673while (reader.NodeType != XmlNodeType.EndElement)

41&& currentNode.NodeType == XmlNodeType.Element

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

732if ((headerReader.NodeType != XmlNodeType.Element) 757if ((headerReader.NodeType == XmlNodeType.Element)

49if ((reader.MoveToContent() == XmlNodeType.Element) && (reader.Name == "wsdl:definitions")) 840if ((reader.MoveToContent() == XmlNodeType.Element) && (reader.Name == "xs:schema"))

454if (XmlNodeType.Element != reader.NodeType) 464if (XmlNodeType.Element == subTree.NodeType)

437if (Reader.NodeType == System.Xml.XmlNodeType.Element) 493while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) 495if (Reader.NodeType == System.Xml.XmlNodeType.Element) 564while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) 566if (Reader.NodeType == System.Xml.XmlNodeType.Element) 576if (this.Reader.NodeType == XmlNodeType.EndElement) 647while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) 650if (Reader.NodeType == System.Xml.XmlNodeType.Element) 654else if (Reader.NodeType == System.Xml.XmlNodeType.Text || 655Reader.NodeType == System.Xml.XmlNodeType.CDATA || 656Reader.NodeType == System.Xml.XmlNodeType.Whitespace || 657Reader.NodeType == System.Xml.XmlNodeType.SignificantWhitespace)

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

57XmlNodeType type = reader.MoveToContent(); 60case XmlNodeType.Element: 126case XmlNodeType.EndElement: 133case XmlNodeType.CDATA: 142case XmlNodeType.SignificantWhitespace: 143case XmlNodeType.Text:

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

1938case XmlNodeType.Element: 1964case XmlNodeType.Comment: 1973case XmlNodeType.ProcessingInstruction: 1983case XmlNodeType.SignificantWhitespace: 2007goto case XmlNodeType.Whitespace; 2011case XmlNodeType.Whitespace: 2035case XmlNodeType.CDATA: 2036case XmlNodeType.Text: 2056case XmlNodeType.EntityReference: 2066case XmlNodeType.EndEntity: 2067case XmlNodeType.EndElement: 2068case XmlNodeType.None: 2071case XmlNodeType.DocumentType: 2074case XmlNodeType.XmlDeclaration:

262if (reader.NodeType == XmlNodeType.EndElement) 269if (reader.MoveToContent() != XmlNodeType.Text)

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

457if (reader.NodeType == XmlNodeType.Attribute) 524if (reader.NodeType == XmlNodeType.Attribute)

561else if (reader.NodeType != XmlNodeType.Element) 599else if (reader.NodeType != XmlNodeType.Element) 934while (reader.NodeType != XmlNodeType.EndElement && !reader.EOF) 989return (reader.NodeType == XmlNodeType.EndElement || reader.EOF);

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

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

219if (reader.NodeType != XmlNodeType.Element) 228if (reader.NodeType != XmlNodeType.Element) 236if (reader.NodeType != XmlNodeType.Element) 259if (reader.NodeType != XmlNodeType.Element) 424while (reader.NodeType != XmlNodeType.EndElement) 506if (reader.NodeType != XmlNodeType.Element)

429Fx.Assert(reader.NodeType == XmlNodeType.Element, "");

74if (!bodyContentReader.EOF && bodyContentReader.NodeType != XmlNodeType.EndElement) 204if (reader.NodeType != XmlNodeType.Element) 308if (reader.NodeType != XmlNodeType.Element)

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

60if (child.NodeType == XmlNodeType.Whitespace || child.NodeType == XmlNodeType.Comment) 64else if (child.NodeType == XmlNodeType.Element && result == null) 76OnChildNodeTypeMissing(parent, XmlNodeType.Element); 93if (child.NodeType == XmlNodeType.Whitespace || child.NodeType == XmlNodeType.Comment) 97else if (child.NodeType == XmlNodeType.Element) 130while (reader.NodeType == XmlNodeType.Whitespace || reader.NodeType == XmlNodeType.SignificantWhitespace) 156if (reader.NodeType == XmlNodeType.Comment) 160else if (reader.NodeType == XmlNodeType.Whitespace) 170internal static void OnChildNodeTypeMissing(string parentName, XmlNodeType expectedNodeType) 175internal static void OnChildNodeTypeMissing(XmlElement parent, XmlNodeType expectedNodeType)

585case XmlNodeType.Element: 587case XmlNodeType.EndElement: 589case XmlNodeType.Text: 590case XmlNodeType.Whitespace: 591case XmlNodeType.SignificantWhitespace: 593case XmlNodeType.Comment: 595case XmlNodeType.CDATA:

116public override XmlNodeType NodeType 123return XmlNodeType.Element; 125return XmlNodeType.Text; 127return XmlNodeType.EndElement; 130return XmlNodeType.None;

394if ((reader.NodeType == XmlNodeType.EndElement) && (reader.Depth == startDepth))

333if ((reader.NodeType == XmlNodeType.EndElement) && (reader.Depth == startDepth))

116if ((reader.NodeType == XmlNodeType.EndElement) && (reader.Depth == startDepth))

179if (dependenciesNode.NodeType != XmlNodeType.Element) 206if (dependencyNode.NodeType != XmlNodeType.Element)

468if (node.NodeType != XmlNodeType.Element) 579if (node.NodeType != XmlNodeType.Element) {

189if(child.NodeType != XmlNodeType.Element) { 385if(child.NodeType != XmlNodeType.Element) { 469if(child.NodeType != XmlNodeType.Element) { 507if(child.NodeType != XmlNodeType.Element) { 531if(child.NodeType != XmlNodeType.Element) {

226if (childNode.NodeType != XmlNodeType.Comment) {

177case XmlNodeType.Text: 178case XmlNodeType.CDATA: 183case XmlNodeType.Element: 212case XmlNodeType.Comment: 213case XmlNodeType.Whitespace:

80if (node.NodeType == XmlNodeType.Comment || node.NodeType == XmlNodeType.Whitespace) { 84if (node.NodeType != XmlNodeType.Element)

544if (reader.NodeType == XmlNodeType.Element && reader.Name == "Ad" && reader.Depth == 1) { 548while (!(reader.NodeType == XmlNodeType.EndElement)) { 549if (reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) { 609if (prop.NodeType == XmlNodeType.Element) {

74if (node.NodeType == XmlNodeType.Element) { 86if (node.NodeType == XmlNodeType.Element) {

47if (node.NodeType == XmlNodeType.Element) {

61if (nodeList[i].NodeType == XmlNodeType.Element)

254while (!reader.EOF && !(reader.NodeType == XmlNodeType.Element &&

3140((reader.Name == ExportIPersonalizableElement) && (reader.NodeType == XmlNodeType.EndElement))) {

299if (subNode.NodeType == XmlNodeType.Element) { 809if (subNode.NodeType != XmlNodeType.Element)

206if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 257while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 258if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 272while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 273if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 307while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 308if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 342while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 343if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 377while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 378if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 451while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 452if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 501while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 502if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 574while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 575if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 641while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 642if (Reader.NodeType == System.Xml.XmlNodeType.Element) {

393if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 443while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 444if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 464while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 465if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 499while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 500if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 534while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 535if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 608while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 609if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 681while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 682if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 748while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 749if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 796while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 797if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 827while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 828if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 875while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 876if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 905while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 906if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 965while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 966if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 995while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 996if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 1025while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 1026if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 1098while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 1099if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 1144while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 1145if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 1190while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 1191if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 1249while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 1250if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 1308while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 1309if (Reader.NodeType == System.Xml.XmlNodeType.Element) {

188if (child.NodeType == XmlNodeType.Element) {

147return _currentNode.NodeType == XmlNodeType.Comment || 148_currentNode.NodeType == XmlNodeType.Whitespace; 156if(_currentNode.NodeType != XmlNodeType.Element)

4117if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4183while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4184if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4267while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4268if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4338while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4339if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4404while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4405if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4454while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4455if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4504while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4505if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4566while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4567if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4643while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4644if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4727while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4728if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4802while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4803if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4872while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4873if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 4937while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 4938if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5034while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5035if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5106while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5107if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5168while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5169if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5234while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5235if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5306while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5307if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5368while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5369if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5415while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5416if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5491while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5492if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5543while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5544if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5595while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5596if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5662while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5663if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5716while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5717if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5773while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5774if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5856while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5857if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5902while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5903if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 5960while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 5961if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6022while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6023if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6080while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6081if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6134while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6135if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6188while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6189if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6238while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6239if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6296while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6297if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6369while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6370if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6446while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6447if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6514while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6515if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6582while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6583if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6647while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6648if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6722while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6723if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6783while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6784if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6876while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6877if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 6974while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 6975if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7056while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7057if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7121while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7122if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7184while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7185if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7188else if (Reader.NodeType == System.Xml.XmlNodeType.Text || 7189Reader.NodeType == System.Xml.XmlNodeType.CDATA || 7190Reader.NodeType == System.Xml.XmlNodeType.Whitespace || 7191Reader.NodeType == System.Xml.XmlNodeType.SignificantWhitespace) { 7249while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7250if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7253else if (Reader.NodeType == System.Xml.XmlNodeType.Text || 7254Reader.NodeType == System.Xml.XmlNodeType.CDATA || 7255Reader.NodeType == System.Xml.XmlNodeType.Whitespace || 7256Reader.NodeType == System.Xml.XmlNodeType.SignificantWhitespace) { 7326while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7327if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7418while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7419if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7494while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7495if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7582while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7583if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7655while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7656if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7767while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7768if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7839while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7840if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7911while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7912if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 7983while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 7984if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8055while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8056if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8127while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8128if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8199while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8200if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8271while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8272if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8343while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8344if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8415while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8416if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8487while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8488if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8559while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8560if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8627while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8628if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8788while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8789if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8878while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8879if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 8953while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 8954if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9022while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9023if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9098while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9099if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9190while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9191if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9297while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9298if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9373while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9374if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9464while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9465if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9537while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9538if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9632while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9633if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9696while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9697if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9773while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9774if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9853while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9854if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 9971while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 9972if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 10048while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 10049if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 10143while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 10144if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 10237while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 10238if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 10325while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 10326if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 10394while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 10395if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 10477while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 10478if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 10545while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 10546if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 10613while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 10614if (Reader.NodeType == System.Xml.XmlNodeType.Element) {

304while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 305if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 326while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 327if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 385if (Reader.NodeType == System.Xml.XmlNodeType.Element) {

189while (newReader.NodeType != XmlNodeType.Element) { 190if (newReader.NodeType == XmlNodeType.ProcessingInstruction) {

148if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 191while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 192if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 255while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 256if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 305while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 306if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 355while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 356if (Reader.NodeType == System.Xml.XmlNodeType.Element) { 401while (Reader.NodeType != System.Xml.XmlNodeType.EndElement && Reader.NodeType != System.Xml.XmlNodeType.None) { 402if (Reader.NodeType == System.Xml.XmlNodeType.Element) {

696if (reader.NodeType == XmlNodeType.EndElement) { 724while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None) { 743while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None) { 752while (reader.NodeType == XmlNodeType.Whitespace) reader.Skip(); 753if (reader.NodeType == XmlNodeType.None) reader.Skip(); 780if (reader.NodeType == XmlNodeType.EndElement) { 813while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.None) { 835if (reader.NodeType == XmlNodeType.EndElement) {

284if (reader.NodeType == XmlNodeType.EndElement) {

644if (reader.NodeType == XmlNodeType.EndElement) { 894public override XmlNodeType MoveToContent() {

385if (reader.NodeType == XmlNodeType.Element) { 490if (reader.NodeType == XmlNodeType.Element) { 498if (reader.NodeType == XmlNodeType.Element) { 506if (reader.NodeType == XmlNodeType.Element) { 514if (reader.NodeType == XmlNodeType.Element) { 524if (reader.NodeType == XmlNodeType.Element) { 532if (reader.NodeType == XmlNodeType.Element) { 540if (reader.NodeType == XmlNodeType.Element) { 548if (reader.NodeType == XmlNodeType.Element) { 609if(reader.NodeType == XmlNodeType.EndElement && ( reader.LocalName.Equals(ResXResourceWriter.DataStr) || reader.LocalName.Equals(ResXResourceWriter.MetadataStr) )) { 614if (reader.NodeType == XmlNodeType.Element) {

1147if (reader.MoveToContent() == System.Xml.XmlNodeType.Element)

269if (reader != null && reader.NodeType == XmlNodeType.Element)

196XmlTextReader reader = new XmlTextReader(this.serializedXmlString, XmlNodeType.Element, null) { DtdProcessing = DtdProcessing.Prohibit }; 240while (reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.ProcessingInstruction && reader.Read());

132while (xmlReader.Read() && xmlReader.NodeType != XmlNodeType.Element && xmlReader.NodeType != XmlNodeType.ProcessingInstruction); 218if (reader.NodeType != XmlNodeType.Element) 275if (reader.NodeType != XmlNodeType.Element) 446if (reader.NodeType != XmlNodeType.Comment && reader.NodeType != XmlNodeType.Whitespace && !unnecessaryXmlFound) 456if (reader.NodeType == XmlNodeType.Element) 513else if (reader.NodeType == XmlNodeType.Text && contentProperty.Property != null) 524if (reader.NodeType == XmlNodeType.Entity || 525reader.NodeType == XmlNodeType.Text || 526reader.NodeType == XmlNodeType.CDATA) 557using (new SafeXmlNodeWriter(serializationManager, obj, null, XmlNodeType.Element)) 904using (new SafeXmlNodeWriter(serializationManager, obj, propertyObj, XmlNodeType.Attribute)) 999using (new SafeXmlNodeWriter(serializationManager, obj, propertyObj, XmlNodeType.Element)) 1654while (reader.NodeType != XmlNodeType.EndElement && reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.Text && reader.Read()); 1852} while (reader.NodeType != XmlNodeType.Text && reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.ProcessingInstruction && reader.NodeType != XmlNodeType.EndElement); 1854if (reader.NodeType == XmlNodeType.Text) 1861if (reader.NodeType == XmlNodeType.Element) 2333private XmlNodeType xmlNodeType = XmlNodeType.None; 2336public SafeXmlNodeWriter(WorkflowMarkupSerializationManager serializationManager, object owner, object property, XmlNodeType xmlNodeType) 2350if (!dependencyProperty.IsAttached && xmlNodeType == XmlNodeType.Attribute) 2371else if (this.xmlNodeType == XmlNodeType.Element) 2394if (this.xmlNodeType == XmlNodeType.Element) 2399else if (this.xmlNodeType == XmlNodeType.Attribute) 2411if (this.xmlNodeType == XmlNodeType.Element)

111if (reader.NodeType == XmlNodeType.Attribute) 130XmlNodeType currNodeType = reader.NodeType; 133case XmlNodeType.Element: 160case XmlNodeType.EndElement: 168case XmlNodeType.CDATA: 169case XmlNodeType.Text:

161case XmlNodeType.Element: 169case XmlNodeType.EndElement: 200case XmlNodeType.Element: 213case XmlNodeType.EndElement: 245case XmlNodeType.Element: 275case XmlNodeType.EndElement: 316case XmlNodeType.Element: 329case XmlNodeType.EndElement: 364case XmlNodeType.Element: 380case XmlNodeType.EndElement: 472case XmlNodeType.Element: 480case XmlNodeType.EndElement: 512case XmlNodeType.Element: 530case XmlNodeType.EndElement: 559case XmlNodeType.Element: 570case XmlNodeType.EndElement: 599case XmlNodeType.Element: 626case XmlNodeType.EndElement: 655case XmlNodeType.Element: 672case XmlNodeType.EndElement: 698case XmlNodeType.Element: 707case XmlNodeType.EndElement: 736case XmlNodeType.Element: 748case XmlNodeType.EndElement: 776case XmlNodeType.Element: 784case XmlNodeType.EndElement: 812case XmlNodeType.Element: 820case XmlNodeType.EndElement:

264XmlNodeType nodetype; 272XmlNodeType parentNodeType; // use for MoveToElement() 330this.nodetype = XmlNodeType.None; 413public override XmlNodeType NodeType { 453case XmlNodeType.DocumentType: 454case XmlNodeType.ProcessingInstruction: 455case XmlNodeType.Comment: 458case XmlNodeType.CDATA: 461case XmlNodeType.XmlDeclaration: 464case XmlNodeType.Text: 465case XmlNodeType.Whitespace: 466case XmlNodeType.SignificantWhitespace: 490if (this.nodetype == XmlNodeType.Element 491|| this.nodetype == XmlNodeType.EndElement) 500if (this.parentNodeType != XmlNodeType.Element) 505if (this.parentNodeType != XmlNodeType.Element) 715if (XmlNodeType.Element == this.parentNodeType) 717else if (XmlNodeType.XmlDeclaration == this.parentNodeType) 719else if (XmlNodeType.DocumentType == this.parentNodeType) 764this.nodetype = XmlNodeType.Text; 780this.nodetype = XmlNodeType.None; 834this.nodetype = XmlNodeType.None; 875if (this.NodeType == XmlNodeType.EndElement) 877if (this.NodeType == XmlNodeType.ProcessingInstruction || this.NodeType == XmlNodeType.Comment) { 878while (Read() && (this.NodeType == XmlNodeType.ProcessingInstruction || this.NodeType == XmlNodeType.Comment)) 880if (this.NodeType == XmlNodeType.EndElement) 906if (this.NodeType != XmlNodeType.Element && this.NodeType != XmlNodeType.EndElement) { 911case XmlNodeType.ProcessingInstruction: 912case XmlNodeType.Comment: 915case XmlNodeType.Element: 916case XmlNodeType.EndElement: 1533if (this.NodeType == XmlNodeType.Element || this.NodeType == XmlNodeType.EndElement) 1564if (this.NodeType == XmlNodeType.Element || this.NodeType == XmlNodeType.EndElement) { 2117this.nodetype = XmlNodeType.Attribute; 2261this.nodetype = XmlNodeType.XmlDeclaration; 2463case XmlNodeType.CDATA: 2466case XmlNodeType.EndElement: 2469case XmlNodeType.Element: 2479this.nodetype = XmlNodeType.None; 2591if (XmlNodeType.Text == this.nodetype) 2733this.nodetype = XmlNodeType.Element; 2746this.nodetype = XmlNodeType.EndElement; 2780this.nodetype = XmlNodeType.DocumentType; 2788this.nodetype = XmlNodeType.ProcessingInstruction; 2792this.nodetype = XmlNodeType.Comment; 2799this.nodetype = XmlNodeType.CDATA; 2845|| ((this.textXmlReader.NodeType == XmlNodeType.XmlDeclaration) 2950XmlNodeType ScanOverValue(BinXmlToken token, bool attr, bool checkChars) { 2968return XmlNodeType.Text; 2976XmlNodeType ScanOverAnyValue(BinXmlToken token, bool attr, bool checkChars) { 3087return XmlNodeType.Text; 3090unsafe XmlNodeType CheckText(bool attr) { 3106return this.xmlspacePreserve ? XmlNodeType.SignificantWhitespace : XmlNodeType.Whitespace; 3118return XmlNodeType.Text; 3142XmlNodeType CheckTextIsWS() { 3161return XmlNodeType.SignificantWhitespace; 3162return XmlNodeType.Whitespace; 3164return XmlNodeType.Text;

38public override Task<XmlNodeType> MoveToContentAsync() {

173if ( reader.NodeType != XmlNodeType.Element ) { 220if ( reader.NodeType != XmlNodeType.Element ) { 255if ( reader.NodeType != XmlNodeType.EndElement ) { 284Debug.Assert( reader.NodeType == XmlNodeType.Element ); 295if ( reader.NodeType != XmlNodeType.EndElement ) { 386if ( reader.NodeType != XmlNodeType.EndElement ) { 399case XmlNodeType.Attribute: 401case XmlNodeType.Text: 402case XmlNodeType.Whitespace: 403case XmlNodeType.SignificantWhitespace: 404case XmlNodeType.CDATA: 409case XmlNodeType.ProcessingInstruction: 410case XmlNodeType.Comment: 411case XmlNodeType.EndEntity: 414case XmlNodeType.EntityReference:

123if ( reader.NodeType != XmlNodeType.Element ) { 170if ( reader.NodeType != XmlNodeType.Element ) { 205if ( reader.NodeType != XmlNodeType.EndElement ) { 228Debug.Assert( reader.NodeType == XmlNodeType.Element ); 239if ( reader.NodeType != XmlNodeType.EndElement ) { 310if ( reader.NodeType != XmlNodeType.EndElement ) { 323case XmlNodeType.Attribute: 325case XmlNodeType.Text: 326case XmlNodeType.Whitespace: 327case XmlNodeType.SignificantWhitespace: 328case XmlNodeType.CDATA: 333case XmlNodeType.ProcessingInstruction: 334case XmlNodeType.Comment: 335case XmlNodeType.EndEntity: 338case XmlNodeType.EntityReference:

28XmlNodeType nodeType; 34Clear(XmlNodeType.None); 37public ValidatingReaderNodeData(XmlNodeType nodeType) { 107public XmlNodeType NodeType { 137internal void Clear( XmlNodeType nodeType ) {

75public override XmlNodeType NodeType { 523public override XmlNodeType MoveToContent() { 758public override Task<XmlNodeType> MoveToContentAsync() {

46XmlNodeType lastNodeType; 67lastNodeType = XmlNodeType.None; 177XmlNodeType nodeType = base.reader.NodeType; 181case XmlNodeType.Comment: 186case XmlNodeType.Whitespace: 191case XmlNodeType.ProcessingInstruction: 196case XmlNodeType.DocumentType: 209case XmlNodeType.Element: 226case XmlNodeType.Text: 227case XmlNodeType.CDATA: 233case XmlNodeType.EntityReference: 240case XmlNodeType.ProcessingInstruction: 250case XmlNodeType.Comment: 259case XmlNodeType.DocumentType: 286case XmlNodeType.Whitespace: 295case XmlNodeType.SignificantWhitespace: 301case XmlNodeType.EndElement:

45XmlNodeType nodeType = base.reader.NodeType; 49case XmlNodeType.Comment: 54case XmlNodeType.Whitespace: 59case XmlNodeType.ProcessingInstruction: 64case XmlNodeType.DocumentType: 77case XmlNodeType.Element: 94case XmlNodeType.Text: 95case XmlNodeType.CDATA: 101case XmlNodeType.EntityReference: 108case XmlNodeType.ProcessingInstruction: 118case XmlNodeType.Comment: 127case XmlNodeType.DocumentType: 154case XmlNodeType.Whitespace: 163case XmlNodeType.SignificantWhitespace: 169case XmlNodeType.EndElement:

111public abstract XmlNodeType NodeType { get; } 689if (this.NodeType == XmlNodeType.Element) { 696if (this.NodeType == XmlNodeType.EndElement) { 714public virtual XmlNodeType MoveToContent() { 717case XmlNodeType.Attribute: 719goto case XmlNodeType.Element; 720case XmlNodeType.Element: 721case XmlNodeType.EndElement: 722case XmlNodeType.CDATA: 723case XmlNodeType.Text: 724case XmlNodeType.EntityReference: 725case XmlNodeType.EndEntity: 734if (MoveToContent() != XmlNodeType.Element) { 742if (MoveToContent() != XmlNodeType.Element) { 756if (MoveToContent() != XmlNodeType.Element) { 773if (MoveToContent() != XmlNodeType.Element) { 779if (this.NodeType != XmlNodeType.EndElement) { 795if (MoveToContent() != XmlNodeType.Element) { 805if (this.NodeType != XmlNodeType.EndElement) { 821if (MoveToContent() != XmlNodeType.Element) { 831if (this.NodeType != XmlNodeType.EndElement) { 845if (MoveToContent() != XmlNodeType.EndElement) { 853return MoveToContent() == XmlNodeType.Element; 859return (MoveToContent() == XmlNodeType.Element) && 866return (MoveToContent() == XmlNodeType.Element) && 880if (NodeType == XmlNodeType.Element && Ref.Equal(name, Name)) { 902if (NodeType == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI)) { 916if (NodeType != XmlNodeType.Element) { 935if (NodeType == XmlNodeType.Element && Ref.Equal(name, Name)) { 939Debug.Assert(NodeType == XmlNodeType.EndElement || NodeType == XmlNodeType.None || ReadState == ReadState.Error); 953if (NodeType != XmlNodeType.Element) { 973if (NodeType == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI)) { 977Debug.Assert(NodeType == XmlNodeType.EndElement); 991XmlNodeType nt; 997if (nt == XmlNodeType.Element && Ref.Equal(name, Name)) { 1000} while (nt != XmlNodeType.EndElement && !EOF); 1018XmlNodeType nt; 1024if (nt == XmlNodeType.Element && Ref.Equal(localName, LocalName) && Ref.Equal(namespaceURI, NamespaceURI)) { 1027} while (nt != XmlNodeType.EndElement && !EOF); 1052if ((this.NodeType != XmlNodeType.Attribute) && (this.NodeType != XmlNodeType.Element)) { 1061if (this.NodeType == XmlNodeType.Attribute) { 1067if (this.NodeType == XmlNodeType.Element) { 1082int d = this.NodeType == XmlNodeType.None ? -1 : this.Depth; 1085case XmlNodeType.Element: 1095case XmlNodeType.Text: 1098case XmlNodeType.Whitespace: 1099case XmlNodeType.SignificantWhitespace: 1102case XmlNodeType.CDATA: 1105case XmlNodeType.EntityReference: 1108case XmlNodeType.XmlDeclaration: 1109case XmlNodeType.ProcessingInstruction: 1112case XmlNodeType.DocumentType: 1115case XmlNodeType.Comment: 1118case XmlNodeType.EndElement: 1123if (d == this.Depth && this.NodeType == XmlNodeType.EndElement) { 1132if (this.NodeType == XmlNodeType.EntityReference) { 1147if ((this.NodeType != XmlNodeType.Attribute) && (this.NodeType != XmlNodeType.Element)) { 1156if (this.NodeType == XmlNodeType.Attribute) { 1206if (NodeType != XmlNodeType.Element) { 1244static internal bool IsTextualNode(XmlNodeType nodeType) { 1270static internal bool CanReadContentAs(XmlNodeType nodeType) { 1296static internal bool HasValueInternal(XmlNodeType nodeType) { 1328if (NodeType == XmlNodeType.Element && !IsEmptyElement) { 1336if (NodeType == XmlNodeType.EndElement) 1353if (NodeType != XmlNodeType.Element) { 1373static internal Exception CreateReadContentAsException(string methodName, XmlNodeType nodeType, IXmlLineInfo lineInfo) { 1377static internal Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType, IXmlLineInfo lineInfo) { 1396case XmlNodeType.Attribute: 1398case XmlNodeType.Text: 1399case XmlNodeType.Whitespace: 1400case XmlNodeType.SignificantWhitespace: 1401case XmlNodeType.CDATA: 1414case XmlNodeType.ProcessingInstruction: 1415case XmlNodeType.Comment: 1416case XmlNodeType.EndEntity: 1419case XmlNodeType.EntityReference: 1425case XmlNodeType.EndElement: 1436if (this.NodeType != XmlNodeType.Element) { 1449XmlNodeType nodeType = this.NodeType; 1450if (nodeType == XmlNodeType.EndElement) { 1454else if (nodeType == XmlNodeType.Element) { 1461if (this.NodeType != XmlNodeType.EndElement) { 1732XmlNodeType nt = reader.NodeType; 1735case XmlNodeType.Element: 1736case XmlNodeType.EndElement: 1737case XmlNodeType.EntityReference: 1738case XmlNodeType.EndEntity: 1741case XmlNodeType.Attribute: 1742case XmlNodeType.ProcessingInstruction: 1745case XmlNodeType.Text: 1746case XmlNodeType.Whitespace: 1747case XmlNodeType.SignificantWhitespace: 1748case XmlNodeType.Comment: 1749case XmlNodeType.XmlDeclaration: 1750case XmlNodeType.CDATA: 1753case XmlNodeType.DocumentType:

158public virtual async Task< XmlNodeType > MoveToContentAsync() { 161case XmlNodeType.Attribute: 163goto case XmlNodeType.Element; 164case XmlNodeType.Element: 165case XmlNodeType.EndElement: 166case XmlNodeType.CDATA: 167case XmlNodeType.Text: 168case XmlNodeType.EntityReference: 169case XmlNodeType.EndEntity: 181if ((this.NodeType != XmlNodeType.Attribute) && (this.NodeType != XmlNodeType.Element)) { 190if (this.NodeType == XmlNodeType.Attribute) { 196if (this.NodeType == XmlNodeType.Element) { 211int d = this.NodeType == XmlNodeType.None ? -1 : this.Depth; 214case XmlNodeType.Element: 224case XmlNodeType.Text: 227case XmlNodeType.Whitespace: 228case XmlNodeType.SignificantWhitespace: 231case XmlNodeType.CDATA: 234case XmlNodeType.EntityReference: 237case XmlNodeType.XmlDeclaration: 238case XmlNodeType.ProcessingInstruction: 241case XmlNodeType.DocumentType: 244case XmlNodeType.Comment: 247case XmlNodeType.EndElement: 252if (d == this.Depth && this.NodeType == XmlNodeType.EndElement) { 262if ((this.NodeType != XmlNodeType.Attribute) && (this.NodeType != XmlNodeType.Element)) { 271if (this.NodeType == XmlNodeType.Attribute) { 292if (NodeType == XmlNodeType.Element && !IsEmptyElement) { 300if (NodeType == XmlNodeType.EndElement) 315case XmlNodeType.Attribute: 317case XmlNodeType.Text: 318case XmlNodeType.Whitespace: 319case XmlNodeType.SignificantWhitespace: 320case XmlNodeType.CDATA: 333case XmlNodeType.ProcessingInstruction: 334case XmlNodeType.Comment: 335case XmlNodeType.EndEntity: 338case XmlNodeType.EntityReference: 344case XmlNodeType.EndElement: 355if (this.NodeType != XmlNodeType.Element) { 368XmlNodeType nodeType = this.NodeType; 369if (nodeType == XmlNodeType.EndElement) { 373else if (nodeType == XmlNodeType.Element) { 380if (this.NodeType != XmlNodeType.EndElement) {

24internal XmlNodeType type; 34internal void Set( XmlNodeType nodeType, string localName, string prefix, string name, string namespaceUri, string value ) { 102tmpNode.Set( XmlNodeType.None, string.Empty, string.Empty, string.Empty, string.Empty, string.Empty ); 110public override XmlNodeType NodeType { 150if ( curNode.type == XmlNodeType.Text ) { // we are on namespace attribute value 347Debug.Assert(reader.NodeType == XmlNodeType.Element); 362else if ( curNode.type == XmlNodeType.Text ) { // we are on namespace attribute value 366Debug.Assert( curNode.type == XmlNodeType.Attribute ); 367tmpNode.type = XmlNodeType.Text; 388if ( reader.NodeType == XmlNodeType.EndElement || 389( reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement ) ) { 394Debug.Assert( reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement ); 449if (reader.Depth == initialDepth && reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement) { 480if ( reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement ) { 483while ( reader.NodeType != XmlNodeType.EndElement && reader.Depth > initialDepth ) { 488Debug.Assert( reader.NodeType == XmlNodeType.EndElement || 489reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement || 496if ( reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement ) { 688case XmlNodeType.Element: 690case XmlNodeType.EndElement: 692case XmlNodeType.Attribute: 714goto case XmlNodeType.Text; 715case XmlNodeType.Text: 767if ( NodeType != XmlNodeType.EndElement ) { 807case XmlNodeType.Element: 809case XmlNodeType.EndElement: 811case XmlNodeType.Attribute: 832goto case XmlNodeType.Text; 833case XmlNodeType.Text: 884if ( NodeType != XmlNodeType.EndElement ) { 1037case XmlNodeType.Element: 1073case XmlNodeType.EndElement: 1096nsAttributes[index].Set( XmlNodeType.Attribute, xmlns, string.Empty, xmlns, xmlnsUri, ns ); 1099nsAttributes[index].Set( XmlNodeType.Attribute, prefix, xmlns, reader.NameTable.Add( string.Concat( xmlns, ":", prefix ) ), xmlnsUri, ns ); 1133if ( NodeType != XmlNodeType.Element ) { 1145case XmlNodeType.Element: 1147case XmlNodeType.EndElement: 1170if ( NodeType != XmlNodeType.EndElement ) { 1251tmpNode.type = XmlNodeType.None; 1302case XmlNodeType.Element: 1306case XmlNodeType.EndElement: 1310case XmlNodeType.Attribute:

38if ( reader.NodeType == XmlNodeType.EndElement || 39( reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement ) ) { 44Debug.Assert( reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement ); 101if ( reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement ) { 104while ( reader.NodeType != XmlNodeType.EndElement && reader.Depth > initialDepth ) { 109Debug.Assert( reader.NodeType == XmlNodeType.EndElement || 110reader.NodeType == XmlNodeType.Element && reader.IsEmptyElement || 117if ( reader.NodeType == XmlNodeType.Element && !reader.IsEmptyElement ) { 212case XmlNodeType.Element: 214case XmlNodeType.EndElement: 216case XmlNodeType.Attribute: 238goto case XmlNodeType.Text; 239case XmlNodeType.Text: 291if ( NodeType != XmlNodeType.EndElement ) { 331case XmlNodeType.Element: 333case XmlNodeType.EndElement: 335case XmlNodeType.Attribute: 356goto case XmlNodeType.Text; 357case XmlNodeType.Text: 408if ( NodeType != XmlNodeType.EndElement ) { 484if ( NodeType != XmlNodeType.Element ) { 496case XmlNodeType.Element: 498case XmlNodeType.EndElement: 521if ( NodeType != XmlNodeType.EndElement ) {

82public XmlTextReader( Stream xmlFragment, XmlNodeType fragType, XmlParserContext context ) { 87public XmlTextReader( string xmlFragment, XmlNodeType fragType, XmlParserContext context ) { 108public override XmlNodeType NodeType {

242XmlNodeType fragmentType = XmlNodeType.Document; 470fragmentType = XmlNodeType.None; 476fragmentType = XmlNodeType.Element; 482fragmentType = XmlNodeType.Document; 533internal XmlTextReaderImpl( Stream xmlFragment, XmlNodeType fragType, XmlParserContext context ) 553internal XmlTextReaderImpl( string xmlFragment, XmlNodeType fragType, XmlParserContext context ) 580InitFragmentReader( XmlNodeType.XmlDeclaration, context, true ); 843case XmlNodeType.None: settings.ConformanceLevel = ConformanceLevel.Auto; break; 844case XmlNodeType.Element: settings.ConformanceLevel = ConformanceLevel.Fragment; break; 845case XmlNodeType.Document: settings.ConformanceLevel = ConformanceLevel.Document; break; 846default: Debug.Assert(false); goto case XmlNodeType.None; 869public override XmlNodeType NodeType { 951return curNode.type == XmlNodeType.Attribute ? curNode.quoteChar : '"'; 1125else if ( curNode.type != XmlNodeType.Attribute ) { 1206Debug.Assert( curNode.type == XmlNodeType.Element ); 1229curNode.SetValueNode( XmlNodeType.Text, string.Empty ); 1321case XmlNodeType.Element: 1329Debug.Assert( curNode.type == XmlNodeType.EndElement ); 1333case XmlNodeType.Attribute: 1335goto case XmlNodeType.Element; 1354if ( curNode.type != XmlNodeType.Attribute ) { 1379simpleValueNode.SetValueNode( XmlNodeType.Text, curNode.StringValue ); 1430if ( curNode.type != XmlNodeType.EntityReference ) { 1493if ( outerReader.NodeType == XmlNodeType.EntityReference && 1641if ( curNode.type != XmlNodeType.Element ) { 1689if ( curNode.type != XmlNodeType.Element ) { 2012curNode.Clear( XmlNodeType.None ); 2076if ( curNode.type != XmlNodeType.Element) { 2106if ( curNode.type != XmlNodeType.Element) { 2136if ( curNode.type != XmlNodeType.Element) { 2311ParseCDataOrComment( XmlNodeType.Comment ); 2318ParseCDataOrComment( XmlNodeType.Comment ); 2733private void InitFragmentReader( XmlNodeType fragmentType, XmlParserContext parserContext, bool allowXmlDeclFragment ) { 2760case XmlNodeType.Attribute: 2765case XmlNodeType.Element: 2769case XmlNodeType.Document: 2773case XmlNodeType.XmlDeclaration: 3290curNode.SetNamedNode( XmlNodeType.XmlDeclaration, Xml ); 3594if ( fragmentType != XmlNodeType.Document ) { 3602if ( fragmentType == XmlNodeType.None ) { 3603fragmentType = XmlNodeType.Element; 3617if ( fragmentType == XmlNodeType.Document || fragmentType == XmlNodeType.None ) { 3618fragmentType = XmlNodeType.Document; 3641if ( fragmentType == XmlNodeType.Document ) { 3644if ( fragmentType == XmlNodeType.None ) { 3645fragmentType = XmlNodeType.Element; 3655if ( fragmentType == XmlNodeType.Document ) { 3659if ( fragmentType == XmlNodeType.None ) { 3660fragmentType = XmlNodeType.Element; 3692if ( fragmentType == XmlNodeType.Document ) { 3699if ( fragmentType == XmlNodeType.None && curNode.type == XmlNodeType.Text ) { 3700fragmentType = XmlNodeType.Element; 3733if ( !rootElementParsed && fragmentType == XmlNodeType.Document ) { 3737if ( fragmentType == XmlNodeType.None ) { 3738fragmentType = rootElementParsed ? XmlNodeType.Document : XmlNodeType.Element; 3853if ( index == 0 && fragmentType != XmlNodeType.Document ) { 3872if ( index == 0 && curNode.type != XmlNodeType.Element ) { 3880if ( el.type != XmlNodeType.Element ) { 3978curNode.SetNamedNode( XmlNodeType.Element, 3985curNode.SetNamedNode( XmlNodeType.Element, 3991curNode.SetNamedNode( XmlNodeType.Element, 4057Debug.Assert( curNode.type == XmlNodeType.Element ); 4228startTagNode.type = XmlNodeType.EndElement; 4237if ( startTag.type == XmlNodeType.Element ) { 4250Debug.Assert( startTag.type == XmlNodeType.EntityReference ); 4318Debug.Assert( curNode.type == XmlNodeType.Element ); 4325Debug.Assert( curNode.type == XmlNodeType.Element ); 4548Debug.Assert( curNode.type == XmlNodeType.Element ); 4560if ( at.type == XmlNodeType.Attribute && at.prefix.Length > 0 ) { 4758textChunk.SetValueNode( XmlNodeType.Text, stringBuilder.ToString( valueChunkStartPos, valueChunkLen ) ); 4770entityChunk.SetNamedNode( XmlNodeType.EntityReference, entityName ); 4800textChunk.SetValueNode( XmlNodeType.Text, stringBuilder.ToString( valueChunkStartPos, valueChunkLen ) ); 4808entityChunk.SetNamedNode( XmlNodeType.EntityReference, ps.entity.Name ); 4861if ( fragmentType == XmlNodeType.Attribute ) { 4897textChunk.SetValueNode( XmlNodeType.Text, stringBuilder.ToString( valueChunkStartPos, valueChunkLen ) ); 4946XmlNodeType nodeType = GetTextNodeType( orChars ); 4947if ( nodeType == XmlNodeType.None ) { 4970XmlNodeType nodeType = GetTextNodeType( orChars ); 4971if ( nodeType == XmlNodeType.None ) { 4987curNode.SetValueNode( XmlNodeType.Text, ps.chars, startPos, endPos - startPos ); 5005XmlNodeType nodeType = ( stringBuilder.Length < MinWhitespaceLookahedCount ) ? GetTextNodeType( orChars ) : XmlNodeType.Text; 5006if ( nodeType == XmlNodeType.None ) { 5366if ( curNode.type != XmlNodeType.EndElement ) { 5376XmlNodeType nodeType = GetWhitespaceType(); 5378if ( nodeType == XmlNodeType.None ) { 5412curNode.SetNamedNode( XmlNodeType.EntityReference, ParseEntityName() ); 5620curNode.SetNamedNode( XmlNodeType.EndEntity, lastEntity.Name ); 5630Debug.Assert( curNode.type == XmlNodeType.EntityReference ); 5633curNode.type = XmlNodeType.EndEntity; 5661curNode.SetNamedNode( XmlNodeType.ProcessingInstruction, target ); 5860ParseCDataOrComment( XmlNodeType.Comment ); 5865ParseCDataOrComment( XmlNodeType.Comment ); 5871ParseCDataOrComment( XmlNodeType.CDATA ); 5875private void ParseCDataOrComment( XmlNodeType type ) { 5899private bool ParseCDataOrComment( XmlNodeType type, out int outStartPos, out int outEndPos ) { 5903Throw( Res.Xml_UnexpectedEOF, ( type == XmlNodeType.Comment ) ? "Comment" : "CDATA" ); 5911char stopChar = ( type == XmlNodeType.Comment ) ? '-' : ']'; 5949else if ( type == XmlNodeType.Comment ) { 6103curNode.SetNamedNode(XmlNodeType.DocumentType, dtdInfo.Name.ToString(), string.Empty, null); 6913newAttr.SetNamedNode( XmlNodeType.Attribute, nameTable.Add( name ) ); 6947newAttr.SetNamedNode( XmlNodeType.Attribute, localName, prefix, nameWPrefix ); 6961Debug.Assert( attr.type == XmlNodeType.Attribute ); 6992curNode.Clear( XmlNodeType.None ); 7076private XmlNodeType GetWhitespaceType() { 7079return XmlNodeType.SignificantWhitespace; 7082return XmlNodeType.Whitespace; 7085return XmlNodeType.None; 7088private XmlNodeType GetTextNodeType( int orChars ) { 7090return XmlNodeType.Text; 7391if ( ParseCDataOrComment( XmlNodeType.Comment, out startPos, out pos ) ) { 7398if ( ParseCDataOrComment( XmlNodeType.CDATA, out startPos, out pos ) ) { 7406nextParsingFunction = ( index > 0 || fragmentType != XmlNodeType.Document ) ? ParsingFunction.ElementContent 7659Debug.Assert( fragmentType == XmlNodeType.Attribute ); 7662if ( curNode.type == XmlNodeType.None ) { 7663curNode.type = XmlNodeType.Attribute; 7694curNode.SetValueNode( XmlNodeType.Text, string.Empty ); 7751curNode.SetNamedNode( XmlNodeType.EntityReference, ParseEntityName() ); 7816curNode.SetValueNode( XmlNodeType.Text, stringBuilder.ToString() ); 7971Debug.Assert( curNode.type == XmlNodeType.Element ); 7983if ( curNode.type != XmlNodeType.EndElement ) { 7998case XmlNodeType.Attribute: 8000case XmlNodeType.Text: 8001case XmlNodeType.Whitespace: 8002case XmlNodeType.SignificantWhitespace: 8003case XmlNodeType.CDATA: 8008case XmlNodeType.ProcessingInstruction: 8009case XmlNodeType.Comment: 8010case XmlNodeType.EndEntity: 8013case XmlNodeType.EntityReference: 8141internal XmlNodeType FragmentType { 8147internal void ChangeCurrentNodeType( XmlNodeType newNodeType ) { 8148Debug.Assert( curNode.type == XmlNodeType.Whitespace && newNodeType == XmlNodeType.SignificantWhitespace, "Incorrect node type change!" ); 8198return fragmentType == XmlNodeType.Element ? ConformanceLevel.Fragment : ConformanceLevel.Document; 8301Debug.Assert( nodes[index].type == XmlNodeType.Element ); 8315Debug.Assert( nodes[index].type == XmlNodeType.Element ); 8431if ( curNode.type != XmlNodeType.EndElement ) {

190Debug.Assert(curNode.type == XmlNodeType.Element); 212curNode.SetValueNode(XmlNodeType.Text, string.Empty); 325case XmlNodeType.Element: 333Debug.Assert( curNode.type == XmlNodeType.EndElement ); 337case XmlNodeType.Attribute: 339goto case XmlNodeType.Element; 511if ( curNode.type != XmlNodeType.Element ) { 566if ( curNode.type != XmlNodeType.Element ) { 729await ParseCDataOrCommentAsync( XmlNodeType.Comment ).ConfigureAwait(false); 736await ParseCDataOrCommentAsync( XmlNodeType.Comment ).ConfigureAwait(false); 1122curNode.SetNamedNode( XmlNodeType.XmlDeclaration, Xml ); 1412if (fragmentType != XmlNodeType.Document) { 1431if (fragmentType == XmlNodeType.Document || fragmentType == XmlNodeType.None) { 1432fragmentType = XmlNodeType.Document; 1452if (fragmentType == XmlNodeType.Document) { 1455if (fragmentType == XmlNodeType.None) { 1456fragmentType = XmlNodeType.Element; 1473if (fragmentType == XmlNodeType.Document) { 1486if (fragmentType == XmlNodeType.None) { 1487fragmentType = XmlNodeType.Element; 1496if (fragmentType == XmlNodeType.Document) { 1501if (fragmentType == XmlNodeType.None) { 1502fragmentType = XmlNodeType.Element; 1535if (fragmentType == XmlNodeType.None && curNode.type == XmlNodeType.Text) { 1536fragmentType = XmlNodeType.Element; 1551if (fragmentType == XmlNodeType.None && curNode.type == XmlNodeType.Text) { 1552fragmentType = XmlNodeType.Element; 1582if (!rootElementParsed && fragmentType == XmlNodeType.Document) { 1585if (fragmentType == XmlNodeType.None) { 1586fragmentType = rootElementParsed ? XmlNodeType.Document : XmlNodeType.Element; 1684if (index == 0 && fragmentType != XmlNodeType.Document) { 1812curNode.SetNamedNode(XmlNodeType.Element, 1819curNode.SetNamedNode(XmlNodeType.Element, 1825curNode.SetNamedNode(XmlNodeType.Element, 2087startTagNode.type = XmlNodeType.EndElement; 2107if ( startTag.type == XmlNodeType.Element ) { 2124Debug.Assert( startTag.type == XmlNodeType.EntityReference ); 2193Debug.Assert( curNode.type == XmlNodeType.Element ); 2200Debug.Assert( curNode.type == XmlNodeType.Element ); 2545textChunk.SetValueNode( XmlNodeType.Text, stringBuilder.ToString( valueChunkStartPos, valueChunkLen ) ); 2557entityChunk.SetNamedNode( XmlNodeType.EntityReference, entityName ); 2587textChunk.SetValueNode( XmlNodeType.Text, stringBuilder.ToString( valueChunkStartPos, valueChunkLen ) ); 2595entityChunk.SetNamedNode( XmlNodeType.EntityReference, ps.entity.Name ); 2648if ( fragmentType == XmlNodeType.Attribute ) { 2684textChunk.SetValueNode( XmlNodeType.Text, stringBuilder.ToString( valueChunkStartPos, valueChunkLen ) ); 2728XmlNodeType nodeType = GetTextNodeType(orChars); 2729if (nodeType == XmlNodeType.None) { 2786XmlNodeType nodeType = GetTextNodeType( orChars ); 2787if ( nodeType == XmlNodeType.None ) { 2819XmlNodeType nodeType = GetTextNodeType( orChars ); 2820if ( nodeType == XmlNodeType.None ) { 2836curNode.SetValueNode( XmlNodeType.Text, ps.chars, startPos, endPos - startPos ); 2861XmlNodeType nodeType = ( stringBuilder.Length < MinWhitespaceLookahedCount ) ? GetTextNodeType( orChars ) : XmlNodeType.Text; 2862if ( nodeType == XmlNodeType.None ) { 3416if ( curNode.type != XmlNodeType.EndElement ) { 3426XmlNodeType nodeType = GetWhitespaceType(); 3428if ( nodeType == XmlNodeType.None ) { 3462curNode.SetNamedNode( XmlNodeType.EntityReference, await ParseEntityNameAsync().ConfigureAwait(false) ); 3652curNode.SetNamedNode( XmlNodeType.ProcessingInstruction, target ); 3881await ParseCDataOrCommentAsync( XmlNodeType.Comment ).ConfigureAwait(false); 3886await ParseCDataOrCommentAsync( XmlNodeType.Comment ).ConfigureAwait(false); 3892return ParseCDataOrCommentAsync( XmlNodeType.CDATA ); 3896private async Task ParseCDataOrCommentAsync( XmlNodeType type ) { 3944private async Task< Tuple<int, int, bool> > ParseCDataOrCommentTupleAsync(XmlNodeType type) { 3951Throw( Res.Xml_UnexpectedEOF, ( type == XmlNodeType.Comment ) ? "Comment" : "CDATA" ); 3959char stopChar = ( type == XmlNodeType.Comment ) ? '-' : ']'; 3999else if ( type == XmlNodeType.Comment ) { 4155curNode.SetNamedNode(XmlNodeType.DocumentType, dtdInfo.Name.ToString(), string.Empty, null); 4925Debug.Assert( curNode.type == XmlNodeType.Element ); 4937if ( curNode.type != XmlNodeType.EndElement ) { 4952case XmlNodeType.Attribute: 4954case XmlNodeType.Text: 4955case XmlNodeType.Whitespace: 4956case XmlNodeType.SignificantWhitespace: 4957case XmlNodeType.CDATA: 4962case XmlNodeType.ProcessingInstruction: 4963case XmlNodeType.Comment: 4964case XmlNodeType.EndEntity: 4967case XmlNodeType.EntityReference: 5072if ( curNode.type != XmlNodeType.EndElement ) {

335internal XmlNodeType type; 381Clear( XmlNodeType.None ); 399return type == XmlNodeType.Element && isEmptyOrDefault; 402Debug.Assert( type == XmlNodeType.Element ); 409return type == XmlNodeType.Attribute && isEmptyOrDefault; 412Debug.Assert( type == XmlNodeType.Attribute ); 443internal void Clear( XmlNodeType type ) { 468internal void SetValueNode( XmlNodeType type, string value ) { 477internal void SetValueNode( XmlNodeType type, char[] chars, int startPos, int len ) { 487internal void SetNamedNode( XmlNodeType type, string localName ) { 491internal void SetNamedNode( XmlNodeType type, string localName, string prefix, string nameWPrefix ) {

33public XmlValidatingReader( string xmlFragment, XmlNodeType fragType, XmlParserContext context ) { 41public XmlValidatingReader( Stream xmlFragment, XmlNodeType fragType, XmlParserContext context ) { 52public override XmlNodeType NodeType {

156internal XmlValidatingReaderImpl( string xmlFragment, XmlNodeType fragType, XmlParserContext context ) 174internal XmlValidatingReaderImpl( Stream xmlFragment, XmlNodeType fragType, XmlParserContext context ) 258public override XmlNodeType NodeType { 640if ( outerReader.NodeType == XmlNodeType.EntityReference && parsingFunction != ParsingFunction.ResolveEntityInternally ) { 798case XmlNodeType.Attribute: 800case XmlNodeType.Element: 811XmlNodeType type = outerReader.NodeType; 812if ( type != XmlNodeType.CDATA && type != XmlNodeType.Text && 813type != XmlNodeType.Whitespace && type != XmlNodeType.SignificantWhitespace && 814type != XmlNodeType.Comment && type != XmlNodeType.ProcessingInstruction ) { 818if ( outerReader.NodeType != XmlNodeType.EndElement ) { 826case XmlNodeType.EndElement: 879Debug.Assert( coreReader.NodeType == XmlNodeType.EntityReference ); 923case XmlNodeType.Whitespace: 924if ( coreReader.Depth > 0 || coreReaderImpl.FragmentType != XmlNodeType.Document ) { 926coreReaderImpl.ChangeCurrentNodeType( XmlNodeType.SignificantWhitespace ); 930case XmlNodeType.DocumentType: 933case XmlNodeType.EntityReference:

152if ( outerReader.NodeType == XmlNodeType.EntityReference && parsingFunction != ParsingFunction.ResolveEntityInternally ) { 166case XmlNodeType.Attribute: 168case XmlNodeType.Element: 179XmlNodeType type = outerReader.NodeType; 180if ( type != XmlNodeType.CDATA && type != XmlNodeType.Text && 181type != XmlNodeType.Whitespace && type != XmlNodeType.SignificantWhitespace && 182type != XmlNodeType.Comment && type != XmlNodeType.ProcessingInstruction ) { 186if ( outerReader.NodeType != XmlNodeType.EndElement ) { 194case XmlNodeType.EndElement: 229Debug.Assert( coreReader.NodeType == XmlNodeType.EntityReference );

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

336if (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.XmlDeclaration) { 342else if (reader.NodeType != XmlNodeType.Attribute) { 352if (reader.NodeType == XmlNodeType.EntityReference) { 374int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth; 377case XmlNodeType.Element: 385case XmlNodeType.Text: 401case XmlNodeType.Whitespace: 402case XmlNodeType.SignificantWhitespace: 407case XmlNodeType.CDATA: 410case XmlNodeType.EntityReference: 413case XmlNodeType.XmlDeclaration: 414case XmlNodeType.ProcessingInstruction: 417case XmlNodeType.DocumentType: 421case XmlNodeType.Comment: 424case XmlNodeType.EndElement: 428} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));

218if (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.XmlDeclaration) { 224else if (reader.NodeType != XmlNodeType.Attribute) { 234if (reader.NodeType == XmlNodeType.EntityReference) { 270int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth; 273case XmlNodeType.Element: 281case XmlNodeType.Text: 295case XmlNodeType.Whitespace: 296case XmlNodeType.SignificantWhitespace: 299case XmlNodeType.CDATA: 302case XmlNodeType.EntityReference: 305case XmlNodeType.XmlDeclaration: 306case XmlNodeType.ProcessingInstruction: 309case XmlNodeType.DocumentType: 313case XmlNodeType.Comment: 316case XmlNodeType.EndElement: 320} while (reader.Read() && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement))); 329int d = reader.NodeType == XmlNodeType.None ? -1 : reader.Depth; 332case XmlNodeType.Element: 340case XmlNodeType.Text: 355case XmlNodeType.Whitespace: 356case XmlNodeType.SignificantWhitespace: 359case XmlNodeType.CDATA: 362case XmlNodeType.EntityReference: 365case XmlNodeType.XmlDeclaration: 366case XmlNodeType.ProcessingInstruction: 369case XmlNodeType.DocumentType: 373case XmlNodeType.Comment: 376case XmlNodeType.EndElement: 380} while (await reader.ReadAsync().ConfigureAwait(false) && (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)));

82if (coreReader.NodeType == XmlNodeType.Element) { 105public override XmlNodeType NodeType { 334if (cacheState != CachingReaderState.Replay || cachedNode.NodeType != XmlNodeType.Attribute) { 354case XmlNodeType.Element: 359case XmlNodeType.EndElement: 365case XmlNodeType.Comment: 366case XmlNodeType.ProcessingInstruction: 367case XmlNodeType.Text: 368case XmlNodeType.CDATA: 369case XmlNodeType.Whitespace: 370case XmlNodeType.SignificantWhitespace: 392if (coreReader.NodeType != XmlNodeType.Element || readAhead) { //Only when coreReader not positioned on Element node, read ahead, otherwise it is on the next element node already, since this was not cached 410ValidatingReaderNodeData textNode = AddContent(XmlNodeType.Text); 418Debug.Assert(coreReader.NodeType == XmlNodeType.EndElement || (coreReader.NodeType == XmlNodeType.Element && coreReader.IsEmptyElement)); 423Debug.Assert(endElementNode.NodeType == XmlNodeType.EndElement); 429ValidatingReaderNodeData recordedNode = AddContent(XmlNodeType.EndElement); 430Debug.Assert(coreReader.NodeType == XmlNodeType.EndElement || (coreReader.NodeType == XmlNodeType.Element && coreReader.IsEmptyElement)); 469case XmlNodeType.Element: 470if (coreReader.NodeType != XmlNodeType.EndElement && !readAhead) { //will be true for IsDefault cases where we peek only one node ahead 480case XmlNodeType.Attribute: 482goto case XmlNodeType.Element; 511if (cachedNode.NodeType != XmlNodeType.Attribute) { 563attInfo.Clear(XmlNodeType.Attribute); 573attInfo = new ValidatingReaderNodeData(XmlNodeType.Attribute); 579private ValidatingReaderNodeData AddContent(XmlNodeType nodeType) { 602Debug.Assert(coreReader.NodeType == XmlNodeType.Element); 650textNode = new ValidatingReaderNodeData(XmlNodeType.Text);

38case XmlNodeType.Element: 43case XmlNodeType.EndElement: 49case XmlNodeType.Comment: 50case XmlNodeType.ProcessingInstruction: 51case XmlNodeType.Text: 52case XmlNodeType.CDATA: 53case XmlNodeType.Whitespace: 54case XmlNodeType.SignificantWhitespace: 76if (coreReader.NodeType != XmlNodeType.Element || readAhead) { //Only when coreReader not positioned on Element node, read ahead, otherwise it is on the next element node already, since this was not cached 97case XmlNodeType.Element: 98if (coreReader.NodeType != XmlNodeType.EndElement && !readAhead) { //will be true for IsDefault cases where we peek only one node ahead 108case XmlNodeType.Attribute: 110goto case XmlNodeType.Element;

209public override XmlNodeType NodeType { 215XmlNodeType nodeType = coreReader.NodeType; 217if (nodeType == XmlNodeType.Whitespace && (validator.CurrentContentType == XmlSchemaContentType.TextOnly || validator.CurrentContentType == XmlSchemaContentType.Mixed)) { 218return XmlNodeType.SignificantWhitespace; 354case XmlNodeType.Element: 355case XmlNodeType.EndElement: // 361case XmlNodeType.Attribute: 387XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 412XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 437XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 462XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 487XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 512XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 537XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 562XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 590XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; // 616if (this.NodeType != XmlNodeType.Element) { 626if (this.NodeType != XmlNodeType.Element) { 653if (this.NodeType != XmlNodeType.Element) { 680if (this.NodeType != XmlNodeType.Element) { 707if (this.NodeType != XmlNodeType.Element) { 734if (this.NodeType != XmlNodeType.Element) { 761if (this.NodeType != XmlNodeType.Element) { 788if (this.NodeType != XmlNodeType.Element) { 815if (this.NodeType != XmlNodeType.Element) { 842if (this.NodeType != XmlNodeType.Element) { 1179case XmlNodeType.Element: 1196case XmlNodeType.Attribute: 1198goto case XmlNodeType.Element; 1228if (NodeType == XmlNodeType.Attribute) { 1343case XmlNodeType.Element: 1349case XmlNodeType.EndElement: 1352case XmlNodeType.Attribute: 1368case XmlNodeType.Element: 1369case XmlNodeType.EndElement: 1382case XmlNodeType.Element: 1391case XmlNodeType.EndElement: 1394case XmlNodeType.Attribute: 1407case XmlNodeType.Element: 1413case XmlNodeType.EndElement: 1416case XmlNodeType.Attribute: 1431case XmlNodeType.Element: 1432case XmlNodeType.EndElement: 1435case XmlNodeType.Attribute: 1448if (NodeType == XmlNodeType.Element || NodeType == XmlNodeType.EndElement) { 1457if (NodeType == XmlNodeType.Attribute) { 1558case XmlNodeType.Element: 1563case XmlNodeType.Whitespace: 1564case XmlNodeType.SignificantWhitespace: 1568case XmlNodeType.Text: // text inside a node 1569case XmlNodeType.CDATA: // <![CDATA[...]]> 1573case XmlNodeType.EndElement: 1578case XmlNodeType.EntityReference: 1581case XmlNodeType.DocumentType: 1822if (coreReader.NodeType == XmlNodeType.Element) { 1851XmlNodeType nodeType = this.NodeType; 1852if (nodeType == XmlNodeType.Attribute) { 1869else if (nodeType == XmlNodeType.EndElement) { 1921Debug.Assert(this.NodeType == XmlNodeType.Element); 1942if (this.NodeType == XmlNodeType.EndElement) { //If IsDefault is true, the next node will be EndElement 1957else if (this.NodeType == XmlNodeType.Element) { //the first child is again element node 1965if (this.NodeType != XmlNodeType.EndElement) { 1985case XmlNodeType.Element: 1989case XmlNodeType.Text: 1990case XmlNodeType.CDATA: 1994case XmlNodeType.Whitespace: 1995case XmlNodeType.SignificantWhitespace: 1999case XmlNodeType.Comment: 2000case XmlNodeType.ProcessingInstruction: 2003case XmlNodeType.EndElement: 2030Debug.Assert(coreReader.NodeType == XmlNodeType.EndElement); 2037case XmlNodeType.Element: 2041case XmlNodeType.Text: 2042case XmlNodeType.CDATA: 2046case XmlNodeType.Whitespace: 2047case XmlNodeType.SignificantWhitespace: 2051case XmlNodeType.Comment: 2052case XmlNodeType.ProcessingInstruction: 2055case XmlNodeType.EndElement: 2082case XmlNodeType.Element: 2086case XmlNodeType.Text: 2087case XmlNodeType.CDATA: 2091case XmlNodeType.Whitespace: 2092case XmlNodeType.SignificantWhitespace: 2096case XmlNodeType.Comment: 2097case XmlNodeType.ProcessingInstruction: 2100case XmlNodeType.EndElement: 2145Debug.Assert(NodeType != XmlNodeType.Attribute); 2164textNode = new ValidatingReaderNodeData(XmlNodeType.Text);

41XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; 72XmlSchemaType xmlType = NodeType == XmlNodeType.Attribute ? AttributeXmlType : ElementXmlType; // 98if (this.NodeType != XmlNodeType.Element) { 109if (this.NodeType != XmlNodeType.Element) { 139if (this.NodeType != XmlNodeType.Element) { 279case XmlNodeType.Element: 296case XmlNodeType.Attribute: 298goto case XmlNodeType.Element; 405case XmlNodeType.Element: 409case XmlNodeType.Whitespace: 410case XmlNodeType.SignificantWhitespace: 414case XmlNodeType.Text: // text inside a node 415case XmlNodeType.CDATA: // <![CDATA[...]]> 419case XmlNodeType.EndElement: 423case XmlNodeType.EntityReference: 426case XmlNodeType.DocumentType: 531if (coreReader.NodeType == XmlNodeType.Element) { 563XmlNodeType nodeType = this.NodeType; 564if (nodeType == XmlNodeType.Attribute) { 583else if (nodeType == XmlNodeType.EndElement) { 643Debug.Assert(this.NodeType == XmlNodeType.Element); 665if (this.NodeType == XmlNodeType.EndElement) { //If IsDefault is true, the next node will be EndElement 680else if (this.NodeType == XmlNodeType.Element) { //the first child is again element node 691if (this.NodeType != XmlNodeType.EndElement) { 712case XmlNodeType.Element: 716case XmlNodeType.Text: 717case XmlNodeType.CDATA: 721case XmlNodeType.Whitespace: 722case XmlNodeType.SignificantWhitespace: 726case XmlNodeType.Comment: 727case XmlNodeType.ProcessingInstruction: 730case XmlNodeType.EndElement:

95case XmlNodeType.Document: 99case XmlNodeType.DocumentFragment: 102case XmlNodeType.Element: //Validate children of this element 119if (nodeToValidate.ParentNode.NodeType == XmlNodeType.Document) { 133case XmlNodeType.Attribute: 166case XmlNodeType.Element: 190case XmlNodeType.Attribute: 245case XmlNodeType.Document: 253case XmlNodeType.DocumentFragment: 254case XmlNodeType.EntityReference: 260case XmlNodeType.Element: 264case XmlNodeType.Attribute: //Top-level attribute 272case XmlNodeType.Text: 276case XmlNodeType.CDATA: 280case XmlNodeType.Whitespace: 281case XmlNodeType.SignificantWhitespace: 285case XmlNodeType.Comment: 286case XmlNodeType.ProcessingInstruction: 441Debug.Assert(elementToValidate.ParentNode.NodeType != XmlNodeType.Document); //Handle if it is the documentElement seperately 649case XmlNodeType.EntityReference: 653case XmlNodeType.Element: //Flat validation, do not drill down into children 657case XmlNodeType.Text: 658case XmlNodeType.CDATA: 662case XmlNodeType.Whitespace: 663case XmlNodeType.SignificantWhitespace: 667case XmlNodeType.Comment: 668case XmlNodeType.ProcessingInstruction:

438XmlNodeType nodeType = XmlNodeType.None; 447if (nodeType == XmlNodeType.Document) { 450else if (nodeType == XmlNodeType.DocumentFragment) { 457if (nodeType == XmlNodeType.Document) { 460else if (nodeType == XmlNodeType.DocumentFragment) {

48case XmlNodeType.Attribute: 54case XmlNodeType.Text: 55case XmlNodeType.CDATA: 56case XmlNodeType.Whitespace: 57case XmlNodeType.SignificantWhitespace: 68goto case XmlNodeType.Element; 69case XmlNodeType.Element: 70case XmlNodeType.ProcessingInstruction: 71case XmlNodeType.Comment: 113case XmlNodeType.Element: 114case XmlNodeType.ProcessingInstruction: 116case XmlNodeType.Attribute: 145case XmlNodeType.Element: 146case XmlNodeType.DocumentFragment: 148case XmlNodeType.Document: 150case XmlNodeType.Text: 151case XmlNodeType.CDATA: 152case XmlNodeType.Whitespace: 153case XmlNodeType.SignificantWhitespace: 308&& node.NodeType != XmlNodeType.Element) { 645if (source.NodeType == XmlNodeType.Attribute) { 667case XmlNodeType.Element: 673case XmlNodeType.DocumentFragment: 674case XmlNodeType.Document: 753if (source.NodeType == XmlNodeType.Attribute) { 760if (child.NodeType == XmlNodeType.Element 774if (source.NodeType == XmlNodeType.Attribute) { 804case XmlNodeType.Attribute: 815if (following.NodeType == XmlNodeType.Attribute) { 848while (following.NodeType != XmlNodeType.Element 864case XmlNodeType.Attribute: 880case XmlNodeType.Attribute: 886case XmlNodeType.Text: 887case XmlNodeType.CDATA: 888case XmlNodeType.SignificantWhitespace: 889case XmlNodeType.Whitespace: 932if (sibling.NodeType == XmlNodeType.Element 976case XmlNodeType.Element: 982case XmlNodeType.DocumentFragment: 983case XmlNodeType.Document: 1030if (source.NodeType == XmlNodeType.Document) { 1198if ( nsAtom == null || this.source.NodeType == XmlNodeType.Attribute ) 1220XmlNodeType curNT = source.NodeType; 1221if ( curNT != XmlNodeType.Document && curNT != XmlNodeType.Element ) { 1241case XmlNodeType.Element: 1242case XmlNodeType.Document: 1243case XmlNodeType.DocumentFragment: 1256case XmlNodeType.Element: 1257case XmlNodeType.Document: 1258case XmlNodeType.DocumentFragment: 1273case XmlNodeType.Attribute: 1274case XmlNodeType.Document: 1275case XmlNodeType.DocumentFragment: 1277case XmlNodeType.Text: 1278case XmlNodeType.CDATA: 1279case XmlNodeType.SignificantWhitespace: 1280case XmlNodeType.Whitespace: 1294case XmlNodeType.Attribute: 1295case XmlNodeType.Document: 1296case XmlNodeType.DocumentFragment: 1298case XmlNodeType.Text: 1299case XmlNodeType.CDATA: 1300case XmlNodeType.SignificantWhitespace: 1301case XmlNodeType.Whitespace: 1315if (source.NodeType != XmlNodeType.Element) { 1343case XmlNodeType.Attribute: 1344case XmlNodeType.Document: 1345case XmlNodeType.DocumentFragment: 1347case XmlNodeType.Text: 1348case XmlNodeType.CDATA: 1349case XmlNodeType.SignificantWhitespace: 1350case XmlNodeType.Whitespace: 1392case XmlNodeType.Attribute: 1403case XmlNodeType.Text: 1404case XmlNodeType.CDATA: 1405case XmlNodeType.SignificantWhitespace: 1406case XmlNodeType.Whitespace: 1408goto case XmlNodeType.Element; 1409case XmlNodeType.Element: 1410case XmlNodeType.ProcessingInstruction: 1411case XmlNodeType.Comment: 1442case XmlNodeType.Attribute: 1453case XmlNodeType.Text: 1454case XmlNodeType.CDATA: 1455case XmlNodeType.SignificantWhitespace: 1456case XmlNodeType.Whitespace: 1461goto case XmlNodeType.Element; 1462case XmlNodeType.Element: 1463case XmlNodeType.ProcessingInstruction: 1464case XmlNodeType.Comment: 1597&& parent.NodeType == XmlNodeType.EntityReference) { 1614&& child.NodeType == XmlNodeType.EntityReference) { 1633|| node.NodeType != XmlNodeType.EntityReference) { 1639&& sibling.NodeType == XmlNodeType.EntityReference) { 1658|| node.NodeType != XmlNodeType.EntityReference) { 1664&& sibling.NodeType == XmlNodeType.EntityReference) { 1690|| node.NodeType != XmlNodeType.EntityReference) { 1697case XmlNodeType.EntityReference: 1700case XmlNodeType.Text: 1701case XmlNodeType.CDATA: 1702case XmlNodeType.Whitespace: 1703case XmlNodeType.SignificantWhitespace: 1748case XmlNodeType.Element: 1750case XmlNodeType.DocumentFragment: 1752case XmlNodeType.Element: 1753case XmlNodeType.Text: 1754case XmlNodeType.CDATA: 1755case XmlNodeType.ProcessingInstruction: 1756case XmlNodeType.Comment: 1757case XmlNodeType.Whitespace: 1758case XmlNodeType.SignificantWhitespace: 1762case XmlNodeType.Document: 1764case XmlNodeType.Element: 1765case XmlNodeType.ProcessingInstruction: 1766case XmlNodeType.Comment: 1865if (node.NodeType == XmlNodeType.Element && Match(node)) { 1876Debug.Assert( ((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute ); 1887return ( node.NodeType == XmlNodeType.Element ); 1905if ( node.NodeType == XmlNodeType.Element && Match( node ) ) { 1918Debug.Assert( ((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute ); 1931Debug.Assert( node.NodeType == XmlNodeType.Element ); 1951if ( node.NodeType == XmlNodeType.Element && Match( node ) ) { 1965Debug.Assert( ((XmlNode)nav.UnderlyingObject).NodeType != XmlNodeType.Attribute ); 1985Debug.Assert( node.NodeType == XmlNodeType.Element ); 2007if ( node.NodeType == XmlNodeType.Element && Match( node ) ) {