1076 references to XPathNodeType
SMDiagnostics (43)
System\ServiceModel\Diagnostics\TraceXPathNavigator.cs (43)
25XPathNodeType state = XPathNodeType.Element; 42protected TraceNode(XPathNodeType nodeType, ElementNode parent) 48internal XPathNodeType NodeType 53XPathNodeType nodeType; 60: base(XPathNodeType.Comment, parent) 90: base(XPathNodeType.Element, parent) 131if (child.NodeType == XPathNodeType.Element) 191if (node.NodeType == XPathNodeType.Element) 269base(XPathNodeType.ProcessingInstruction, parent) 520this.state = XPathNodeType.Attribute; 543this.state = XPathNodeType.Text; 570if (this.state != XPathNodeType.Text) 578this.state = XPathNodeType.Text; 606this.state = XPathNodeType.Attribute; 628case XPathNodeType.Comment: 629case XPathNodeType.Element: 630case XPathNodeType.ProcessingInstruction: 638case XPathNodeType.Attribute: 639this.state = XPathNodeType.Element; 642case XPathNodeType.Text: 643this.state = XPathNodeType.Element; 646case XPathNodeType.Namespace: 647this.state = XPathNodeType.Element; 662this.state = XPathNodeType.Element; 682case XPathNodeType.Attribute: 685case XPathNodeType.Element: 688case XPathNodeType.ProcessingInstruction: 718case XPathNodeType.Element: 721case XPathNodeType.Attribute: 724case XPathNodeType.Namespace: 734public override XPathNodeType NodeType 755case XPathNodeType.Element: 758case XPathNodeType.Attribute: 761case XPathNodeType.Namespace: 801case XPathNodeType.Text: 804case XPathNodeType.Attribute: 807case XPathNodeType.Comment: 810case XPathNodeType.ProcessingInstruction: 836case XPathNodeType.Attribute: 839case XPathNodeType.Element: 842case XPathNodeType.Text: 845case XPathNodeType.Comment:
System.Data (67)
fx\src\data\System\NewXml\DataDocumentXPathNavigator.cs (14)
37public override XPathNodeType NodeType { get { return _curNode.NodeType; } } 49XPathNodeType xnt = _curNode.NodeType; 50if ( xnt == XPathNodeType.Element || xnt == XPathNodeType.Root ) 68if ( _curNode.NodeType != XPathNodeType.Element ) 83if ( _curNode.NodeType != XPathNodeType.Element ) 89if ( _curNode.NodeType != XPathNodeType.Element ) 95if ( _curNode.NodeType != XPathNodeType.Namespace ) 102if ( _curNode.NodeType != XPathNodeType.Element ) 108if ( _curNode.NodeType != XPathNodeType.Element ) 114if ( _curNode.NodeType != XPathNodeType.Attribute ) 122if ( _curNode.NodeType == XPathNodeType.Attribute ) 128if ( _curNode.NodeType == XPathNodeType.Attribute ) 134if ( _curNode.NodeType == XPathNodeType.Attribute )
fx\src\data\System\NewXml\XPathNodePointer.cs (53)
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; 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; 51xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.DocumentFragment)] = (int)XPathNodeType.Root; 53xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.Whitespace)] = (int)XPathNodeType.Whitespace; 54xmlNodeType_To_XpathNodeType_Map[(int)(XmlNodeType.SignificantWhitespace)] = (int)XPathNodeType.SignificantWhitespace; 61private XPathNodeType DecideXPNodeTypeForTextNodes( XmlNode node ) { 64XPathNodeType xnt = XPathNodeType.Whitespace; 70xnt = XPathNodeType.SignificantWhitespace; 74return XPathNodeType.Text; 83private XPathNodeType ConvertNodeType( XmlNode node ) { 88if ( xnt == (int) XPathNodeType.Attribute ) { 90return XPathNodeType.Namespace; 92return XPathNodeType.Attribute; 95return (XPathNodeType)xnt; 147internal XPathNodeType NodeType { 153return XPathNodeType.All; 159return XPathNodeType.Text; 163return XPathNodeType.Namespace; 165return XPathNodeType.Attribute; 168return XPathNodeType.Element; 239XPathNodeType xnt = ConvertNodeType( this._node ); 240if ( xnt == XPathNodeType.Element || xnt == XPathNodeType.Root || xnt == XPathNodeType.Attribute ) 638case (int)XPathNodeType.Root: 639return ( xntChildInt == (int)XPathNodeType.Element || 640xntChildInt == (int)XPathNodeType.Comment || 641xntChildInt == (int)XPathNodeType.ProcessingInstruction ); 642case (int)XPathNodeType.Element: 643return ( xntChildInt == (int)XPathNodeType.Element || 644xntChildInt == (int)XPathNodeType.Text || 645xntChildInt == (int)XPathNodeType.Comment || 646xntChildInt == (int)XPathNodeType.Whitespace || 647xntChildInt == (int)XPathNodeType.SignificantWhitespace || 648xntChildInt == (int)XPathNodeType.ProcessingInstruction ); 659case (int)XPathNodeType.Root: 661case (int)XPathNodeType.Element: 885if ( NodeType == XPathNodeType.Namespace ) { 915XPathNodeType xnt = ConvertNodeType( node ); 916if ( xnt == XPathNodeType.Namespace ) { 920if ( xnt == XPathNodeType.Attribute ) 987if ( this.NodeType == XPathNodeType.Namespace && other.NodeType == XPathNodeType.Namespace ) { 994else if ( this.NodeType == XPathNodeType.Namespace ) { 995Debug.Assert( other.NodeType != XPathNodeType.Namespace ); 1007else if ( other.NodeType == XPathNodeType.Namespace ) { 1008Debug.Assert( this.NodeType != XPathNodeType.Namespace );
System.Data.Entity (36)
System\Data\Mapping\StorageMappingItemLoader.cs (36)
231if (!MoveToRootElement(nav) || (nav.NodeType != XPathNodeType.Element)) 298hasContainerMapping = nav.MoveToNext(XPathNodeType.Element); 303hasContainerMapping = nav.MoveToChild(XPathNodeType.Element); 404if (nav.MoveToChild(XPathNodeType.Element)) 433} while (nav.MoveToNext(XPathNodeType.Element)); 836if (nav.MoveToChild(XPathNodeType.Element)) 873} while (nav.MoveToNext(XPathNodeType.Element)); 1065if (!nav.MoveToChild(XPathNodeType.Element)) 1098} while (nav.MoveToNext(XPathNodeType.Element)); 1178if (nav.MoveToChild(XPathNodeType.Element)) 1194} while (nav.MoveToNext(XPathNodeType.Element)); 1458if (!nav.MoveToChild(XPathNodeType.Element)) 1484if (!nav.MoveToNext(XPathNodeType.Element)) 1561if (nav.MoveToChild(XPathNodeType.Element)) 1573} while (nav.MoveToNext(XPathNodeType.Element)); 1842if (nav.MoveToChild(XPathNodeType.Element)) 1904while (nav.MoveToNext(XPathNodeType.Element)); 2009if (nav.MoveToChild(XPathNodeType.Element)) 2022while (nav.MoveToNext(XPathNodeType.Element)); 2607if (nav.MoveToChild(XPathNodeType.Element)) 2620} while (nav.MoveToNext(XPathNodeType.Element)); 2667if (nav.MoveToChild(XPathNodeType.Element)) 2718} while (nav.MoveToNext(XPathNodeType.Element)); 2721nav.MoveToChild(XPathNodeType.Element); 2820} while (nav.MoveToNext(XPathNodeType.Element)); 2975if (cloneNav.MoveToChild(XPathNodeType.Element)) 2991nav.MoveToChild(XPathNodeType.Element); 2996while (nav.MoveToNext(XPathNodeType.Element)); 3073if (nav.MoveToChild(XPathNodeType.Element)) 3115} while (nav.MoveToNext(XPathNodeType.Element)); 3136nav.MoveToChild(XPathNodeType.Element); 3168} while (nav.MoveToNext(XPathNodeType.Element)); 3820if (nav.MoveToChild(XPathNodeType.Element)) 3850} while (nav.MoveToNext(XPathNodeType.Element)); 3910if (nav.MoveToChild(XPathNodeType.Element)) 3986} while (nav.MoveToNext(XPathNodeType.Element));
System.Data.SqlXml (428)
System\Xml\Xsl\IlGen\GenerateHelper.cs (2)
1052public void CallGetTypeFilter(XPathNodeType nodeType) { 1110public void CallStartTree(XPathNodeType rootType) {
System\Xml\Xsl\IlGen\XmlILConstructAnalyzer.cs (4)
947XPathNodeType nodeType; 956nodeType = (nd.NodeType == QilNodeType.ElementCtor) ? XPathNodeType.Element : XPathNodeType.Attribute; 967nodeType = XPathNodeType.Namespace;
System\Xml\Xsl\IlGen\XmlIlVisitor.cs (40)
2598nameType = LoadNameAndType(XPathNodeType.Element, ndElem.Left, true, callChk); 2609nameType = LoadNameAndType(XPathNodeType.Element, ndElem.Left, false, callChk); 2639nameType = LoadNameAndType(XPathNodeType.Attribute, ndAttr.Left, true, callChk); 3008XPathNodeType kindsRuntime; 3045case XmlNodeKindFlags.Element: kindsRuntime = XPathNodeType.Element; break; 3046case XmlNodeKindFlags.Attribute: kindsRuntime = XPathNodeType.Attribute; break; 3047case XmlNodeKindFlags.Namespace: kindsRuntime = XPathNodeType.Namespace; break; 3048case XmlNodeKindFlags.PI: kindsRuntime = XPathNodeType.ProcessingInstruction; break; 3049case XmlNodeKindFlags.Comment: kindsRuntime = XPathNodeType.Comment; break; 3050case XmlNodeKindFlags.Document: kindsRuntime = XPathNodeType.Root; break; 3057kindsRuntime = XPathNodeType.All; 3065if (kindsRuntime == XPathNodeType.All) { 3070if ((kinds & XmlNodeKindFlags.Document) != 0) kindsUnion |= (1 << (int) XPathNodeType.Root); 3071if ((kinds & XmlNodeKindFlags.Element) != 0) kindsUnion |= (1 << (int) XPathNodeType.Element); 3072if ((kinds & XmlNodeKindFlags.Attribute) != 0) kindsUnion |= (1 << (int) XPathNodeType.Attribute); 3073if ((kinds & XmlNodeKindFlags.Text) != 0) kindsUnion |= (1 << (int) (int) XPathNodeType.Text) | 3074(1 << (int) (int) XPathNodeType.SignificantWhitespace) | 3075(1 << (int) (int) XPathNodeType.Whitespace); 3076if ((kinds & XmlNodeKindFlags.Comment) != 0) kindsUnion |= (1 << (int) XPathNodeType.Comment); 3077if ((kinds & XmlNodeKindFlags.PI) != 0) kindsUnion |= (1 << (int) XPathNodeType.ProcessingInstruction); 3078if ((kinds & XmlNodeKindFlags.Namespace) != 0) kindsUnion |= (1 << (int) XPathNodeType.Namespace); 3807private GenerateNameType LoadNameAndType(XPathNodeType nodeType, QilNode ndName, bool isStart, bool callChk) { 4235private XPathNodeType QilXmlToXPathNodeType(XmlNodeKindFlags xmlTypes) { 4237case XmlNodeKindFlags.Element: return XPathNodeType.Element; 4238case XmlNodeKindFlags.Attribute: return XPathNodeType.Attribute; 4239case XmlNodeKindFlags.Text: return XPathNodeType.Text; 4240case XmlNodeKindFlags.Comment: return XPathNodeType.Comment; 4243return XPathNodeType.ProcessingInstruction; 4249private XPathNodeType QilConstructorToNodeType(QilNodeType typ) { 4251case QilNodeType.DocumentCtor: return XPathNodeType.Root; 4252case QilNodeType.ElementCtor: return XPathNodeType.Element; 4253case QilNodeType.TextCtor: return XPathNodeType.Text; 4254case QilNodeType.RawTextCtor: return XPathNodeType.Text; 4255case QilNodeType.PICtor: return XPathNodeType.ProcessingInstruction; 4256case QilNodeType.CommentCtor: return XPathNodeType.Comment; 4257case QilNodeType.AttributeCtor: return XPathNodeType.Attribute; 4258case QilNodeType.NamespaceDecl: return XPathNodeType.Namespace; 4262return XPathNodeType.All; 4282this.helper.CallGetTypeFilter(XPathNodeType.All); 4286this.helper.CallGetTypeFilter(XPathNodeType.Attribute);
System\Xml\Xsl\Runtime\ContentIterators.cs (4)
99private XPathNodeType nodeType; 106public void Create(XPathNavigator context, XPathNodeType nodeType) { 107Debug.Assert(nodeType != XPathNodeType.Attribute && nodeType != XPathNodeType.Namespace);
System\Xml\Xsl\Runtime\RtfNavigator.cs (2)
51public override XPathNodeType NodeType { 52get { return XPathNodeType.Root; }
System\Xml\Xsl\Runtime\TreeIterators.cs (3)
32if (input.NodeType == XPathNodeType.Root) { 321if (nav.NodeType == XPathNodeType.Attribute || nav.NodeType == XPathNodeType.Namespace) {
System\Xml\Xsl\Runtime\XmlNavigatorFilter.cs (18)
130private XPathNodeType nodeType; 137TypeFilters = new XmlNavigatorFilter[(int) XPathNodeType.Comment + 1]; 138TypeFilters[(int) XPathNodeType.Element] = new XmlNavTypeFilter(XPathNodeType.Element); 139TypeFilters[(int) XPathNodeType.Text] = new XmlNavTypeFilter(XPathNodeType.Text); 140TypeFilters[(int) XPathNodeType.ProcessingInstruction] = new XmlNavTypeFilter(XPathNodeType.ProcessingInstruction); 141TypeFilters[(int) XPathNodeType.Comment] = new XmlNavTypeFilter(XPathNodeType.Comment); 147public static XmlNavigatorFilter Create(XPathNodeType nodeType) { 155private XmlNavTypeFilter(XPathNodeType nodeType) { 156Debug.Assert(nodeType != XPathNodeType.Attribute && nodeType != XPathNodeType.Namespace); 256return navigator.MoveToFollowing(XPathNodeType.All, navEnd); 263return navigator.NodeType == XPathNodeType.Attribute; 319return navigator.MoveToFollowing(XPathNodeType.All, navEnd); 346if (navigator.NodeType == XPathNodeType.Attribute) {
System\Xml\Xsl\Runtime\XmlQueryOutput.cs (78)
55private XPathNodeType rootType; // NodeType of the root of the tree 78this.rootType = XPathNodeType.Root; 154Debug.Assert(ValidateNames.ValidateName(prefix, localName, ns, XPathNodeType.Element, ValidateNames.Flags.All), "Name validation failed"); 157ConstructWithinContent(XPathNodeType.Element); 217Debug.Assert(ValidateNames.ValidateName(prefix, localName, ns, XPathNodeType.Attribute, ValidateNames.Flags.All)); 220ConstructInEnumAttrs(XPathNodeType.Attribute); 382public void StartTree(XPathNodeType rootType) { 386this.xstate = (rootType == XPathNodeType.Attribute || rootType == XPathNodeType.Namespace) ? XmlState.EnumAttrs : XmlState.WithinContent; 546ThrowInvalidStateError(XPathNodeType.Root); 548StartTree(XPathNodeType.Root); 579WriteStartComputed(XPathNodeType.Element, tagName, prefixMappingsIndex); 586WriteStartComputed(XPathNodeType.Element, tagName, ns); 593WriteStartComputed(XPathNodeType.Element, navigator); 600WriteStartComputed(XPathNodeType.Element, name); 607WriteStartComputed(XPathNodeType.Attribute, tagName, prefixMappingsIndex); 614WriteStartComputed(XPathNodeType.Attribute, tagName, ns); 621WriteStartComputed(XPathNodeType.Attribute, navigator); 628WriteStartComputed(XPathNodeType.Attribute, name); 638ConstructInEnumAttrs(XPathNodeType.Namespace); 680ConstructInEnumAttrs(XPathNodeType.Namespace); 717ConstructWithinContent(XPathNodeType.Comment); 752ConstructWithinContent(XPathNodeType.ProcessingInstruction); 755ValidateNames.ValidateNameThrow("", target, "", XPathNodeType.ProcessingInstruction, ValidateNames.Flags.AllExceptPrefixMapping); 822else if (navigator.NodeType == XPathNodeType.Root) { 846if (navigator.NodeType == XPathNodeType.Root) 850Debug.Assert(navigator.NodeType == XPathNodeType.Element, "StartCopy should return true only for Element nodes."); 865if (navigator.NodeType == XPathNodeType.Element) 868Debug.Assert(navigator.NodeType == XPathNodeType.Root, "EndCopy should only be called for Element and Document nodes."); 895StartTree(XPathNodeType.Text); 942XPathNodeType nodeType; 949Debug.Assert(nodeType == XPathNodeType.Element, "StartCopy should return true only for Element nodes."); 1000case XPathNodeType.Element: 1012case XPathNodeType.Attribute: 1033case XPathNodeType.Namespace: 1048case XPathNodeType.Text: 1049case XPathNodeType.SignificantWhitespace: 1050case XPathNodeType.Whitespace: 1061case XPathNodeType.Root: 1064ThrowInvalidStateError(XPathNodeType.Root); 1067case XPathNodeType.Comment: 1073case XPathNodeType.ProcessingInstruction: 1092Debug.Assert(navigator.NodeType == XPathNodeType.Element); 1105Debug.Assert(navigator.NodeType == XPathNodeType.Element, "Only elements have namespaces to copy"); 1138private void ConstructWithinContent(XPathNodeType rootType) { 1139Debug.Assert(rootType == XPathNodeType.Element || rootType == XPathNodeType.Comment || rootType == XPathNodeType.ProcessingInstruction); 1167private void ConstructInEnumAttrs(XPathNodeType rootType) { 1168Debug.Assert(rootType == XPathNodeType.Attribute || rootType == XPathNodeType.Namespace); 1206private XPathNodeType XmlStateToNodeType(XmlState xstate) { 1208case XmlState.EnumAttrs: return XPathNodeType.Element; 1209case XmlState.WithinContent: return XPathNodeType.Element; 1210case XmlState.WithinAttr: return XPathNodeType.Attribute; 1211case XmlState.WithinComment: return XPathNodeType.Comment; 1212case XmlState.WithinPI: return XPathNodeType.ProcessingInstruction; 1216return XPathNodeType.Element; 1308private void WriteStartComputed(XPathNodeType nodeType, string tagName, int prefixMappingsIndex) { 1317if (nodeType == XPathNodeType.Element) 1326private void WriteStartComputed(XPathNodeType nodeType, string tagName, string ns) { 1335if (nodeType == XPathNodeType.Element) 1344private void WriteStartComputed(XPathNodeType nodeType, XPathNavigator navigator) { 1356if (nodeType == XPathNodeType.Element) 1365private void WriteStartComputed(XPathNodeType nodeType, XmlQualifiedName name) { 1370prefix = (name.Namespace.Length != 0) ? RemapPrefix(string.Empty, name.Namespace, nodeType == XPathNodeType.Element) : string.Empty; 1373if (nodeType == XPathNodeType.Element) 1384private string EnsureValidName(string prefix, string localName, string ns, XPathNodeType nodeType) { 1387prefix = (ns.Length != 0) ? RemapPrefix(string.Empty, ns, nodeType == XPathNodeType.Element) : string.Empty; 1423private void ThrowInvalidStateError(XPathNodeType constructorType) { 1425case XPathNodeType.Element: 1426case XPathNodeType.Root: 1427case XPathNodeType.Text: 1428case XPathNodeType.Comment: 1429case XPathNodeType.ProcessingInstruction: 1432case XPathNodeType.Attribute: 1433case XPathNodeType.Namespace: 1440goto case XPathNodeType.Element;
System\Xml\Xsl\Runtime\XmlQueryRuntime.cs (17)
340public XmlNavigatorFilter GetTypeFilter(XPathNodeType nodeType) { 341if (nodeType == XPathNodeType.All) 344if (nodeType == XPathNodeType.Attribute) 721case XPathNodeType.Root: return code == XmlTypeCode.Document; 722case XPathNodeType.Element: return code == XmlTypeCode.Element; 723case XPathNodeType.Attribute: return code == XmlTypeCode.Attribute; 724case XPathNodeType.Namespace: return code == XmlTypeCode.Namespace; 725case XPathNodeType.Text: return code == XmlTypeCode.Text; 726case XPathNodeType.SignificantWhitespace: return code == XmlTypeCode.Text; 727case XPathNodeType.Whitespace: return code == XmlTypeCode.Text; 728case XPathNodeType.ProcessingInstruction: return code == XmlTypeCode.ProcessingInstruction; 729case XPathNodeType.Comment: return code == XmlTypeCode.Comment; 751case XPathNodeType.Root: 752case XPathNodeType.Element: 758case XPathNodeType.Attribute: 1006if (lineInfo != null && ! (currentNode.NodeType == XPathNodeType.Namespace && IsInheritedNamespace(currentNode))) { 1014Debug.Assert(node.NodeType == XPathNodeType.Namespace);
System\Xml\Xsl\Runtime\XmlSequenceWriter.cs (21)
43public abstract XmlRawWriter StartTree(XPathNodeType rootType, IXmlNamespaceResolver nsResolver, XmlNameTable nameTable); 83public override XmlRawWriter StartTree(XPathNodeType rootType, IXmlNamespaceResolver nsResolver, XmlNameTable nameTable) { 87this.writer = doc.LoadFromWriter(XPathDocument.LoadFlags.AtomizeNames | (rootType == XPathNodeType.Root ? XPathDocument.LoadFlags.None : XPathDocument.LoadFlags.Fragment), string.Empty); 135public override XmlRawWriter StartTree(XPathNodeType rootType, IXmlNamespaceResolver nsResolver, XmlNameTable nameTable) { 136if (rootType == XPathNodeType.Attribute || rootType == XPathNodeType.Namespace) 159if (nav.NodeType == XPathNodeType.Attribute || nav.NodeType == XPathNodeType.Namespace) 189XPathNodeType nodeType; 195if (nodeType == XPathNodeType.Element) { 222if (nav.NodeType == XPathNodeType.Element) 244if (nav.NodeType == XPathNodeType.Element) 257case XPathNodeType.Element: 262case XPathNodeType.Attribute: 268case XPathNodeType.Text: 272case XPathNodeType.SignificantWhitespace: 273case XPathNodeType.Whitespace: 277case XPathNodeType.Root: 281case XPathNodeType.Comment: 285case XPathNodeType.ProcessingInstruction: 289case XPathNodeType.Namespace:
System\Xml\Xsl\Runtime\XsltLibrary.cs (10)
403Debug.Assert(XPathNodeType.SignificantWhitespace == XPathNodeType.Text + 1); 404Debug.Assert(XPathNodeType.Whitespace == XPathNodeType.Text + 2); 406XPathNodeType nt1 = nav1.NodeType; 407XPathNodeType nt2 = nav2.NodeType; 410if (XPathNodeType.Text <= nt1 && nt1 <= XPathNodeType.Whitespace) { 411return XPathNodeType.Text <= nt2 && nt2 <= XPathNodeType.Whitespace;
System\Xml\Xsl\XmlQueryTypeFactory.cs (1)
1097public static XmlQueryType Type(XPathNodeType kind, XmlQualifiedNameTest nameTest, XmlSchemaType contentType, bool isNillable) {
System\Xml\Xsl\XPath\IXpathBuilder.cs (1)
26Node Axis(XPathAxis xpathAxis, XPathNodeType nodeType, string prefix, string name);
System\Xml\Xsl\XPath\XPathBuilder.cs (4)
269public static XmlNodeKindFlags AxisTypeMask(XmlNodeKindFlags inputTypeMask, XPathNodeType nodeType, XPathAxis xpathAxis) { 276QilNode BuildAxisFilter(QilNode qilAxis, XPathAxis xpathAxis, XPathNodeType nodeType, string name, string nsUri) { 332QilNode BuildAxis(XPathAxis xpathAxis, XPathNodeType nodeType, string nsUri, string name) { 371public virtual QilNode Axis(XPathAxis xpathAxis, XPathNodeType nodeType, string prefix, string name) {
System\Xml\Xsl\XPath\XPathParser.cs (19)
13using XPathNodeType = System.Xml.XPath.XPathNodeType; 82Node opnd = builder.Axis(XPathAxis.Root, XPathNodeType.All, null, null); 91builder.Axis(XPathAxis.Root, XPathNodeType.All, null, null), 93builder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null), 122builder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null), 138opnd = builder.Axis(XPathAxis.Self, XPathNodeType.All, null, null); 144opnd = builder.Axis(XPathAxis.Parent, XPathNodeType.All, null, null); 190XPathNodeType nodeType; 210private static XPathNodeType PrincipalNodeType(XPathAxis axis) { 212axis == XPathAxis.Attribute ? XPathNodeType.Attribute : 213axis == XPathAxis.Namespace ? XPathNodeType.Namespace : 214/*else*/ XPathNodeType.Element 218internal static void InternalParseNodeTest(XPathScanner scanner, XPathAxis axis, out XPathNodeType nodeType, out string nodePrefix, out string nodeName) { 225case "comment": nodeType = XPathNodeType.Comment; break; 226case "text" : nodeType = XPathNodeType.Text; break; 227case "node" : nodeType = XPathNodeType.All; break; 230nodeType = XPathNodeType.ProcessingInstruction; 237if (nodeType == XPathNodeType.ProcessingInstruction) { 404builder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null),
System\Xml\Xsl\Xslt\Compiler.cs (1)
222XPathNodeType.ProcessingInstruction, ValidateNames.Flags.AllExceptPrefixMapping
System\Xml\Xsl\Xslt\XPathPatternBuilder.cs (6)
91private static QilLoop BuildAxisFilter(QilPatternFactory f, QilIterator itr, XPathAxis xpathAxis, XPathNodeType nodeType, string name, string nsUri) { 113public QilNode Axis(XPathAxis xpathAxis, XPathNodeType nodeType, string prefix, string name) { 124Debug.Assert(nodeType == XPathNodeType.All && prefix == null && name == null, " // is the only d-o-s axes that we can have in pattern"); 135case XPathNodeType.Element : 136case XPathNodeType.Attribute : 147case XPathNodeType.ProcessingInstruction :
System\Xml\Xsl\Xslt\XPathPatternParser.cs (7)
16using XPathNodeType = System.Xml.XPath.XPathNodeType; 70opnd = ptrnBuilder.Axis(XPathAxis.Root, XPathNodeType.All, null, null); 79ptrnBuilder.Axis(XPathAxis.Root, XPathNodeType.All, null, null), 81ptrnBuilder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null), 97ptrnBuilder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null), 163ptrnBuilder.Axis(XPathAxis.DescendantOrSelf, XPathNodeType.All, null, null), 205XPathNodeType nodeType;
System\Xml\Xsl\Xslt\XslAstAnalyzer.cs (2)
921public virtual XslFlags Axis(XPathAxis xpathAxis, XPathNodeType nodeType, string prefix, string name) { 923if (xpathAxis == XPathAxis.Self && nodeType == XPathNodeType.All && prefix == null && name == null) {
System\Xml\Xsl\XsltOld\ActionFrame.cs (6)
237XPathNodeType type = this.nodeSet.Current.NodeType; 238if (type == XPathNodeType.Whitespace) { 247while (flag && (type == XPathNodeType.Whitespace )); 256XPathNodeType type = this.newNodeSet.Current.NodeType; 257if (type == XPathNodeType.Whitespace) { 266while(flag && (type == XPathNodeType.Whitespace ));
System\Xml\Xsl\XsltOld\ApplyTemplatesAction.cs (6)
82case XPathNodeType.Element: 106case XPathNodeType.Comment: 107case XPathNodeType.ProcessingInstruction: 108case XPathNodeType.Whitespace: 109case XPathNodeType.SignificantWhitespace: 141frame.InitNewNodeSet(frame.Node.SelectChildren(XPathNodeType.All));
System\Xml\Xsl\XsltOld\AttributeAction.cs (2)
125if (processor.BeginEvent(XPathNodeType.Attribute, qname.Prefix, qname.Name, qname.Namespace, false) == false) { 136if (processor.EndEvent(XPathNodeType.Attribute) == false) {
System\Xml\Xsl\XsltOld\AttributeSetAction.cs (5)
54case XPathNodeType.Element: 70case XPathNodeType.Comment: 71case XPathNodeType.ProcessingInstruction: 72case XPathNodeType.Whitespace: 73case XPathNodeType.SignificantWhitespace:
System\Xml\Xsl\XsltOld\BeginEvent.cs (5)
16private XPathNodeType nodeType; 29Debug.Assert(input.NodeType != XPathNodeType.Namespace); 35if (nodeType == XPathNodeType.Element) { 38else if (nodeType == XPathNodeType.Attribute) { 48if (this.nodeType == XPathNodeType.Attribute && this.namespaceUri.Length == 0) {
System\Xml\Xsl\XsltOld\CallTemplateAction.cs (5)
46case XPathNodeType.Element: 61case XPathNodeType.Comment: 62case XPathNodeType.ProcessingInstruction: 63case XPathNodeType.Whitespace: 64case XPathNodeType.SignificantWhitespace:
System\Xml\Xsl\XsltOld\ChooseAction.cs (5)
32case XPathNodeType.Element: 64case XPathNodeType.Comment: 65case XPathNodeType.ProcessingInstruction: 66case XPathNodeType.Whitespace: 67case XPathNodeType.SignificantWhitespace:
System\Xml\Xsl\XsltOld\CommentAction.cs (2)
30if (processor.BeginEvent(XPathNodeType.Comment, string.Empty, string.Empty, string.Empty, false) == false) { 40if (processor.EndEvent(XPathNodeType.Comment) == false) {
System\Xml\Xsl\XsltOld\CompiledAction.cs (4)
66XPathNodeType nodeType = compiler.Input.NodeType; 68nodeType != XPathNodeType.Whitespace && 69nodeType != XPathNodeType.Comment && 70nodeType != XPathNodeType.ProcessingInstruction
System\Xml\Xsl\XsltOld\ContainerAction.cs (17)
139while (input.NodeType != XPathNodeType.Element) { 145Debug.Assert(compiler.Input.NodeType == XPathNodeType.Element); 427case XPathNodeType.Element: 508case XPathNodeType.ProcessingInstruction: 509case XPathNodeType.Comment: 510case XPathNodeType.Whitespace: 511case XPathNodeType.SignificantWhitespace: 533if (input.NodeType == XPathNodeType.Element) { 636case XPathNodeType.Element: 645this.AddEvent(new EndEvent(XPathNodeType.Element)); 648case XPathNodeType.Text: 649case XPathNodeType.SignificantWhitespace: 652case XPathNodeType.Whitespace: 653case XPathNodeType.ProcessingInstruction: 654case XPathNodeType.Comment: 703this.AddEvent (new EndEvent(XPathNodeType.Attribute)); 786if (!input.Recurse() || input.NodeType != XPathNodeType.Text) {
System\Xml\Xsl\XsltOld\CopyAction.cs (2)
74if ( frame.Node.NodeType == XPathNodeType.Element ) { 80if (frame.Node.NodeType == XPathNodeType.Element && !this.empty) {
System\Xml\Xsl\XsltOld\CopyAttributesAction.cs (9)
44Debug.Assert(frame.Node.NodeType == XPathNodeType.Attribute); 55Debug.Assert(frame.Node.NodeType == XPathNodeType.Attribute); 66Debug.Assert(frame.Node.NodeType == XPathNodeType.Attribute); 77Debug.Assert(frame.Node.NodeType == XPathNodeType.Attribute); 94Debug.Assert(node.NodeType == XPathNodeType.Attribute); 95return processor.BeginEvent(XPathNodeType.Attribute, node.Prefix, node.LocalName, node.NamespaceURI, false); 99Debug.Assert(node.NodeType == XPathNodeType.Attribute); 104Debug.Assert(node.NodeType == XPathNodeType.Attribute); 105return processor.EndEvent(XPathNodeType.Attribute);
System\Xml\Xsl\XsltOld\CopyNamespacesAction.cs (5)
44Debug.Assert(frame.Node.NodeType == XPathNodeType.Namespace); 46if (processor.BeginEvent(XPathNodeType.Namespace, null, frame.Node.LocalName, frame.Node.Value, false) == false) { 55Debug.Assert(frame.Node.NodeType == XPathNodeType.Namespace); 57if (processor.EndEvent(XPathNodeType.Namespace) == false) { 66Debug.Assert(frame.Node.NodeType == XPathNodeType.Namespace);
System\Xml\Xsl\XsltOld\CopyNodesetAction.cs (4)
55XPathNodeType nodeType = frame.Node.NodeType; 57if (nodeType == XPathNodeType.Element || nodeType == XPathNodeType.Root) { 77processor.PushActionFrame(GetAction(), frame.Node.SelectChildren(XPathNodeType.All));
System\Xml\Xsl\XsltOld\ElementAction.cs (2)
110if (processor.BeginEvent(XPathNodeType.Element, qname.Prefix, qname.Name, qname.Namespace, this.empty) == false) { 126if (processor.EndEvent(XPathNodeType.Element) == false) {
System\Xml\Xsl\XsltOld\EndEvent.cs (3)
16private XPathNodeType nodeType; 18internal EndEvent(XPathNodeType nodeType) { 19Debug.Assert(nodeType != XPathNodeType.Namespace);
System\Xml\Xsl\XsltOld\ForeachAction.cs (3)
99case XPathNodeType.Element: 109case XPathNodeType.Text: 111case XPathNodeType.SignificantWhitespace:
System\Xml\Xsl\XsltOld\NamespaceEvent.cs (3)
21Debug.Assert(input.NodeType == XPathNodeType.Namespace); 40res = processor.BeginEvent(XPathNodeType.Namespace, /*prefix:*/null, this.name, this.namespaceUri, /*empty:*/false); 42res = processor.EndEvent(XPathNodeType.Namespace);
System\Xml\Xsl\XsltOld\NavigatorInput.cs (2)
95internal XPathNodeType NodeType { 189if (NodeType == XPathNodeType.Root) {
System\Xml\Xsl\XsltOld\NumberAction.cs (14)
218if(endNode.NodeType == XPathNodeType.Attribute || endNode.NodeType == XPathNodeType.Namespace) { 236startNode.NodeType == XPathNodeType.Root // we are at root 241XPathNodeIterator sel = startNode.SelectDescendants(XPathNodeType.All, /*matchSelf:*/ true); 261XPathNodeIterator sel = startNode.SelectDescendants(XPathNodeType.All, /*matchSelf:*/ true); 302Debug.Assert(nav.NodeType != XPathNodeType.Attribute && nav.NodeType != XPathNodeType.Namespace); 364if (countNode.NodeType == XPathNodeType.Attribute || countNode.NodeType == XPathNodeType.Namespace) { 411private XPathNodeType BasicNodeType(XPathNodeType type) { 412if(type == XPathNodeType.SignificantWhitespace || type == XPathNodeType.Whitespace) { 413return XPathNodeType.Text;
System\Xml\Xsl\XsltOld\ProcessingInstructionAction.cs (2)
88if (processor.BeginEvent(XPathNodeType.ProcessingInstruction, string.Empty, frame.StoredOutput, string.Empty, false) == false) { 98if (processor.EndEvent(XPathNodeType.ProcessingInstruction) == false) {
System\Xml\Xsl\XsltOld\Processor.cs (45)
540if (this.stylesheet.Whitespace && n.NodeType == XPathNodeType.Element) { 550Debug.Assert(nav.NodeType == XPathNodeType.Element); 555case XPathNodeType.Text : 556case XPathNodeType.SignificantWhitespace : 559case XPathNodeType.Whitespace : 564case XPathNodeType.Element : 654internal bool BeginEvent(XPathNodeType nodeType, string prefix, string name, string nspace, bool empty) { 658internal bool BeginEvent(XPathNodeType nodeType, string prefix, string name, string nspace, bool empty, Object htmlProps, bool search) { 704int stateOutlook = this.xsm.BeginOutlook(XPathNodeType.Text); 708this.xsm.Begin(XPathNodeType.Text); 713this.xsm.Begin(XPathNodeType.Text); 729internal bool EndEvent(XPathNodeType nodeType) { 763case XPathNodeType.Element: 764case XPathNodeType.Attribute: 765case XPathNodeType.ProcessingInstruction: 766case XPathNodeType.Comment: 768case XPathNodeType.Namespace: 770return BeginEvent(XPathNodeType.Namespace, null, node.LocalName, node.Value, false); 771case XPathNodeType.Text: 775case XPathNodeType.Root: 776case XPathNodeType.Whitespace: 777case XPathNodeType.SignificantWhitespace: 778case XPathNodeType.All: 791case XPathNodeType.Element: 792case XPathNodeType.Namespace: 795case XPathNodeType.Attribute: 796case XPathNodeType.ProcessingInstruction: 797case XPathNodeType.Comment: 798case XPathNodeType.Text: 799case XPathNodeType.Whitespace: 800case XPathNodeType.SignificantWhitespace: 804case XPathNodeType.Root: 805case XPathNodeType.All: 818case XPathNodeType.Element: 819case XPathNodeType.Attribute: 820case XPathNodeType.ProcessingInstruction: 821case XPathNodeType.Comment: 822case XPathNodeType.Namespace: 825case XPathNodeType.Text: 830case XPathNodeType.Root: 831case XPathNodeType.Whitespace: 832case XPathNodeType.SignificantWhitespace: 833case XPathNodeType.All: 847if (navigator.NodeType == XPathNodeType.Root) { 850else if (navigator.NodeType == XPathNodeType.Element) {
System\Xml\Xsl\XsltOld\RecordBuilder.cs (13)
120internal Processor.OutputResult BeginEvent(int state, XPathNodeType nodeType, string prefix, string name, string nspace, bool empty, Object htmlProps, bool search) { 136case XPathNodeType.Element: 141case XPathNodeType.Attribute: 144case XPathNodeType.Namespace: 147case XPathNodeType.Text: 149case XPathNodeType.ProcessingInstruction: 154case XPathNodeType.Comment: 157case XPathNodeType.Root: 159case XPathNodeType.Whitespace: 160case XPathNodeType.SignificantWhitespace: 161case XPathNodeType.All: 189internal Processor.OutputResult EndEvent(int state, XPathNodeType nodeType) { 205if(nodeType == XPathNodeType.Element) {
System\Xml\Xsl\XsltOld\StateMachine.cs (4)
94internal int BeginOutlook(XPathNodeType nodeType) { 100internal int Begin(XPathNodeType nodeType) { 110internal int EndOutlook(XPathNodeType nodeType) { 116internal int End(XPathNodeType nodeType) {
System\Xml\Xsl\XsltOld\TemplateAction.cs (3)
153case XPathNodeType.Element: 164case XPathNodeType.Text: 166case XPathNodeType.SignificantWhitespace:
System\Xml\Xsl\XsltOld\TemplateLookupAction.cs (9)
63case XPathNodeType.Element: 64case XPathNodeType.Root: 70case XPathNodeType.Attribute: 71case XPathNodeType.Whitespace: 72case XPathNodeType.SignificantWhitespace: 73case XPathNodeType.Text: 77case XPathNodeType.ProcessingInstruction: 78case XPathNodeType.Comment: 81case XPathNodeType.All:
System\Xml\Xsl\XsltOld\TextAction.cs (5)
47case XPathNodeType.Text: 48case XPathNodeType.Whitespace: 49case XPathNodeType.SignificantWhitespace: 52case XPathNodeType.Comment: 53case XPathNodeType.ProcessingInstruction:
System\Xml\Xsl\XsltOld\TextEvent.cs (2)
27Debug.Assert(input.NodeType == XPathNodeType.Text || input.NodeType == XPathNodeType.SignificantWhitespace);
System\Xml\Xsl\XsltOld\XsltCompileContext.cs (1)
257XPathNodeIterator sel = root.SelectDescendants(XPathNodeType.All, /*matchSelf:*/ false);
System.ServiceModel (81)
System\ServiceModel\Dispatcher\QuerySafeNavigator.cs (4)
270public override XPathNodeType NodeType 353public override XPathNodeType GetNodeType(long nodePosition) 641public override XPathNodeType NodeType 756public override XPathNodeType GetNodeType(long nodePosition)
System\ServiceModel\Dispatcher\QuerySelectOp.cs (10)
93case XPathNodeType.Root: 97case XPathNodeType.Attribute: 101case XPathNodeType.Element: 105case XPathNodeType.Comment: 109case XPathNodeType.Text: 110case XPathNodeType.Whitespace: 111case XPathNodeType.SignificantWhitespace: 115case XPathNodeType.ProcessingInstruction: 297if (XPathNodeType.Element == contextNode.NodeType && this.MatchQName(contextNode)) 378if (XPathNodeType.Element == contextNode.NodeType && this.MatchQName(contextNode))
System\ServiceModel\Dispatcher\QuerySubExprEliminator.cs (1)
348if (nav.NodeType == XPathNodeType.Element)
System\ServiceModel\Dispatcher\SeekableMessageNavigator.cs (65)
79BlankDom[RootIndex].type = XPathNodeType.Root; 86BlankDom[EnvelopeIndex].type = XPathNodeType.Element; 95BlankDom[SoapNSIndex].type = XPathNodeType.Namespace; 102BlankDom[XmlNSIndex].type = XPathNodeType.Namespace; 109BlankDom[HeaderIndex].type = XPathNodeType.Element; 288public override XPathNodeType NodeType 442if (this.NodeType != XPathNodeType.Element) 498if (this.NodeType != XPathNodeType.Element) 526public override XPathNodeType GetNodeType(long pos) 569XPathNodeType type = this.dom.nodes[nav.location].type; 570if (type == XPathNodeType.Namespace || type == XPathNodeType.Attribute) 577if (type == XPathNodeType.Namespace || type == XPathNodeType.Attribute) 700if (this.dom.nodes[this.location].type != XPathNodeType.Element) 733XPathNodeType t = this.dom.nodes[this.location].type; 734if (t != XPathNodeType.Attribute && t != XPathNodeType.Namespace) 759if (this.dom.nodes[this.location].type != XPathNodeType.Element) 784if (this.location == RootIndex || this.dom.nodes[this.location].type == XPathNodeType.Element) 805if (this.dom.nodes[this.location].type != XPathNodeType.Element) 852if (this.dom.nodes[this.location].type != XPathNodeType.Element) 911XPathNodeType type = this.dom.nodes[this.location].type; 912if (type == XPathNodeType.Attribute || type == XPathNodeType.Namespace) 933if (this.dom.nodes[this.location].type != XPathNodeType.Attribute) 954if (this.dom.nodes[this.location].type != XPathNodeType.Namespace) 1001XPathNodeType t = this.dom.nodes[this.location].type; 1002if (t != XPathNodeType.Attribute && t != XPathNodeType.Namespace) 1048public override XPathNodeIterator SelectAncestors(XPathNodeType type, bool matchSelf) 1070public override XPathNodeIterator SelectChildren(XPathNodeType type) 1092public override XPathNodeIterator SelectDescendants(XPathNodeType type, bool matchSelf) 1187this.nodes[i].type = XPathNodeType.Element; 1203this.nodes[bodyIndex].type = XPathNodeType.Element; 1352if (this.nodes[loc1].type == XPathNodeType.Attribute) 1370if (this.nodes[loc2].type == XPathNodeType.Attribute) 1387XPathNodeType type1 = this.nodes[loc1].type; 1388XPathNodeType type2 = this.nodes[loc2].type; 1392if (type1 == XPathNodeType.Namespace) 1394if (type2 == XPathNodeType.Attribute) 1406if (type2 == XPathNodeType.Namespace) 1408if (type1 == XPathNodeType.Attribute) 1462if (p.parent > NullIndex && p.parent < this.nextFreeIndex && this.nodes[p.parent].type == XPathNodeType.Element && this.nodes[p.elem].type == XPathNodeType.Namespace) 1617case XPathNodeType.Element: 1618case XPathNodeType.Root: 1895this.nodes[a].type = XPathNodeType.Attribute; 1915this.nodes[n].type = XPathNodeType.Namespace; 1940this.nodes[n].type = XPathNodeType.Element; 1966this.nodes[n].type = XPathNodeType.Comment; 1975this.nodes[n].type = XPathNodeType.ProcessingInstruction; 1989if (n != NullIndex && (this.nodes[n].type == XPathNodeType.Text || 1990this.nodes[n].type == XPathNodeType.Whitespace || 1991this.nodes[n].type == XPathNodeType.SignificantWhitespace)) 1998this.nodes[n].type = XPathNodeType.SignificantWhitespace; 2017if (n != NullIndex && (this.nodes[n].type == XPathNodeType.Text || 2018this.nodes[n].type == XPathNodeType.Whitespace || 2019this.nodes[n].type == XPathNodeType.SignificantWhitespace)) 2026this.nodes[n].type = XPathNodeType.Whitespace; 2039if (n == NullIndex || (this.nodes[n].type != XPathNodeType.Text && 2040this.nodes[n].type != XPathNodeType.Whitespace && 2041this.nodes[n].type != XPathNodeType.SignificantWhitespace)) 2052this.nodes[n].type = XPathNodeType.Text; 2153internal XPathNodeType type;
System\ServiceModel\Dispatcher\SeekableXPathNavigator.cs (1)
53public abstract XPathNodeType GetNodeType(long nodePosition);
System.Transactions (27)
System\Transactions\Trace\TraceXPathNavigator.cs (27)
26XPathNodeType state = XPathNodeType.Element; 241this.state = XPathNodeType.Attribute; 256this.state = XPathNodeType.Element; 261this.state = XPathNodeType.Text; 285if (this.state != XPathNodeType.Text) 293this.state = XPathNodeType.Text; 299this.state = XPathNodeType.Element; 317this.state = XPathNodeType.Attribute; 336case XPathNodeType.Element: 340this.state = XPathNodeType.Element; 344case XPathNodeType.Attribute: 345this.state = XPathNodeType.Element; 348case XPathNodeType.Text: 349this.state = XPathNodeType.Element; 352case XPathNodeType.Namespace: 353this.state = XPathNodeType.Element; 368this.state = XPathNodeType.Element; 383case XPathNodeType.Element: 386case XPathNodeType.Attribute: 404public override XPathNodeType NodeType 420case XPathNodeType.Element: 423case XPathNodeType.Attribute: 426case XPathNodeType.Namespace: 445case XPathNodeType.Text: 448case XPathNodeType.Attribute: 451case XPathNodeType.Namespace:
System.Xml (382)
System\Xml\Cache\XPathDocumentBuilder.cs (29)
27Text = XPathNodeType.Text, 28SignificantWhitespace = XPathNodeType.SignificantWhitespace, 29Whitespace = XPathNodeType.Whitespace, 100idx = NewNode(out page, XPathNodeType.Text, string.Empty, string.Empty, string.Empty, string.Empty); 109this.idxParent = NewNode(out this.pageParent, XPathNodeType.Root, string.Empty, string.Empty, string.Empty, baseUri); 149AddSibling(XPathNodeType.Element, localName, ns, prefix, baseUri); 196Debug.Assert(this.pageParent[this.idxParent].NodeType == XPathNodeType.Element); 264Debug.Assert(this.idxParent == 0 || this.pageParent[this.idxParent].NodeType == XPathNodeType.Element); 265Debug.Assert(this.idxSibling == 0 || this.pageSibling[this.idxSibling].NodeType == XPathNodeType.Attribute); 273AddSibling(XPathNodeType.Attribute, localName, namespaceName, prefix, string.Empty); 280Debug.Assert(this.pageSibling[this.idxSibling].NodeType == XPathNodeType.Attribute); 307AddSibling(XPathNodeType.Comment, string.Empty, string.Empty, string.Empty, string.Empty); 325AddSibling(XPathNodeType.ProcessingInstruction, name, string.Empty, string.Empty, baseUri); 402AddSibling(XPathNodeType.Text, string.Empty, string.Empty, string.Empty, string.Empty); 433Debug.Assert(this.pageParent[this.idxParent].NodeType == XPathNodeType.Element); 443Debug.Assert(this.idxSibling == 0 || this.pageSibling[this.idxSibling].NodeType == XPathNodeType.Attribute); 446Debug.Assert(this.idxParent == 0 || this.pageParent[this.idxParent].NodeType == XPathNodeType.Element); 566Debug.Assert(pageElem == null || pageElem[idxElem].NodeType == XPathNodeType.Element); 580pageNode[idxNode].Create(info, XPathNodeType.Namespace, idxElem); 591private int NewNode(out XPathNode[] page, XPathNodeType xptyp, string localName, string namespaceUri, string prefix, string baseUri) { 595Debug.Assert(xptyp != XPathNodeType.Namespace); 656private void AddSibling(XPathNodeType xptyp, string localName, string namespaceUri, string prefix, string baseUri) { 659Debug.Assert(xptyp != XPathNodeType.Root && xptyp != XPathNodeType.Namespace); 697AddSibling((XPathNodeType) textType, string.Empty, string.Empty, string.Empty, string.Empty); 807Debug.Assert((int) XPathNodeType.Text < (int) XPathNodeType.SignificantWhitespace); 808Debug.Assert((int) XPathNodeType.SignificantWhitespace < (int) XPathNodeType.Whitespace);
System\Xml\Cache\XPathDocumentIterator.cs (6)
106private XPathNodeType typ; 111public XPathDocumentKindChildIterator(XPathDocumentNavigator parent, XPathNodeType typ) : base(parent) { 167if (root.NodeType != XPathNodeType.Root) { 217private XPathNodeType typ; 223public XPathDocumentKindDescendantIterator(XPathDocumentNavigator root, XPathNodeType typ, bool matchSelf) : base(root) { 228if (root.NodeType != XPathNodeType.Root) {
System\Xml\Cache\XPathDocumentNavigator.cs (25)
95Debug.Assert(this.pageCurrent[this.idxCurrent].NodeType == XPathNodeType.Text); 112Debug.Assert(page[idx].NodeType == XPathNodeType.Element || page[idx].IsText); 145public override XPathNodeType NodeType { 197case XPathNodeType.Element: 198case XPathNodeType.Root: 199case XPathNodeType.ProcessingInstruction: 326if (page[idx].NodeType != XPathNodeType.Namespace) 446Debug.Assert(page[idx].NodeType == XPathNodeType.Element); 515public override bool MoveToChild(XPathNodeType type) { 518if (type != XPathNodeType.Text && type != XPathNodeType.All) 535public override bool MoveToNext(XPathNodeType type) { 578public override bool MoveToFollowing(XPathNodeType type, XPathNavigator end) { 584if (type == XPathNodeType.Text || type == XPathNodeType.All) { 598if (type == XPathNodeType.Text) { 620if (page[idx].NodeType == XPathNodeType.Element) { 660public override XPathNodeIterator SelectChildren(XPathNodeType type) { 679public override XPathNodeIterator SelectDescendants(XPathNodeType type, bool matchSelf) { 785case XPathNodeType.Namespace: 789case XPathNodeType.Attribute: 860if (this.idxParent != 0 && NodeType == XPathNodeType.Text) 873if (this.idxParent != 0 && NodeType == XPathNodeType.Text) 910public bool IsContentKindMatch(XPathNodeType typ) { 918public bool IsKindMatch(XPathNodeType typ) {
System\Xml\Cache\XPathNode.cs (13)
68public XPathNodeType NodeType { 69get { return (XPathNodeType) (this.props & NodeTypeMask); } 207return NodeType == XPathNodeType.Element && 218return NodeType == XPathNodeType.Namespace && localName.Length == 3 && localName == "xml"; 263XPathNodeType xptyp = NodeType; 264return xptyp == XPathNodeType.Attribute || xptyp == XPathNodeType.Namespace; 325public void Create(XPathNodeInfoAtom info, XPathNodeType xptyp, int idxParent) { 361Debug.Assert(NodeType == XPathNodeType.Element); 371Debug.Assert(NodeType == XPathNodeType.Element); 380public void SetParentProperties(XPathNodeType xptyp) { 381if (xptyp == XPathNodeType.Attribute) { 386if (xptyp == XPathNodeType.Element)
System\Xml\Cache\XPathNodeHelper.cs (23)
30Debug.Assert(pageElem[idxElem].NodeType == XPathNodeType.Element); 46if (pageElem[idxElem].NodeType == XPathNodeType.Element) { 73Debug.Assert(pageNode[idxNode].NodeType == XPathNodeType.Attribute); 89if (idx != 0 && page[idx].NodeType == XPathNodeType.Attribute) { 110while (page[idx].NodeType == XPathNodeType.Attribute) { 212if (page[idx].NodeType != XPathNodeType.Attribute) { 234public static bool GetContentChild(ref XPathNode[] pageNode, ref int idxNode, XPathNodeType typ) { 248if (typ == XPathNodeType.Attribute) 268public static bool GetContentSibling(ref XPathNode[] pageNode, ref int idxNode, XPathNodeType typ) { 274if (page[idx].NodeType != XPathNodeType.Attribute) { 282Debug.Assert(typ != XPathNodeType.Attribute && typ != XPathNodeType.Namespace); 301Debug.Assert(pageNode[idxNode].NodeType != XPathNodeType.Attribute); 338if (pagePrec[idxPrec].NodeType != XPathNodeType.Attribute) { 359if (page[idx].NodeType != XPathNodeType.Attribute) { 379public static bool GetPreviousContentSibling(ref XPathNode[] pageNode, ref int idxNode, XPathNodeType typ) { 420while (idx != 0 && page[idx].NodeType == XPathNodeType.Attribute); 465if (page[idx].NodeType == XPathNodeType.Element && (object) page[idx].LocalName == (object) localName) { 545public static bool GetContentFollowing(ref XPathNode[] pageCurrent, ref int idxCurrent, XPathNode[] pageEnd, int idxEnd, XPathNodeType typ) { 550Debug.Assert(typ != XPathNodeType.Text, "Text should be handled by GetTextFollowing in order to take into account collapsed text."); 551Debug.Assert(page[idx].NodeType != XPathNodeType.Attribute, "Current node should never be an attribute or namespace--caller should handle this case."); 611if (page[idx].IsText || (page[idx].NodeType == XPathNodeType.Element && page[idx].HasCollapsedText)) 620if (page[idx].IsText || (page[idx].NodeType == XPathNodeType.Element && page[idx].HasCollapsedText))
System\Xml\Core\XmlWriter.cs (12)
443XPathNodeType nodeType = navigator.NodeType; 446case XPathNodeType.Element: 470case XPathNodeType.Attribute: 473case XPathNodeType.Text: 476case XPathNodeType.SignificantWhitespace: 477case XPathNodeType.Whitespace: 480case XPathNodeType.Root: 483case XPathNodeType.Comment: 486case XPathNodeType.ProcessingInstruction: 489case XPathNodeType.Namespace: 505if (navigator.NodeType == XPathNodeType.Element) { 533if (navigator.NodeType == XPathNodeType.Element)
System\Xml\Core\XmlWriterAsync.cs (12)
395XPathNodeType nodeType = navigator.NodeType; 398case XPathNodeType.Element: 422case XPathNodeType.Attribute: 425case XPathNodeType.Text: 428case XPathNodeType.SignificantWhitespace: 429case XPathNodeType.Whitespace: 432case XPathNodeType.Root: 435case XPathNodeType.Comment: 438case XPathNodeType.ProcessingInstruction: 441case XPathNodeType.Namespace: 457if (navigator.NodeType == XPathNodeType.Element) { 485if (navigator.NodeType == XPathNodeType.Element)
System\Xml\Dom\DocumentSchemaValidator.cs (1)
134if (nodeToValidate.XPNodeType == XPathNodeType.Namespace) goto default;
System\Xml\Dom\DocumentXPathNavigator.cs (13)
85public override XPathNodeType NodeType { 89return (XPathNodeType)source.XPNodeType; 773public override bool MoveToChild(XPathNodeType type) { 856public override bool MoveToFollowing(XPathNodeType type, XPathNavigator end) { 944public override bool MoveToNext(XPathNodeType type) { 1083if (node1.XPNodeType == XPathNodeType.Attribute) { 1084if (node2.XPNodeType == XPathNodeType.Attribute) { 1104if (node2.XPNodeType == XPathNodeType.Attribute) { 1201Debug.Assert( this.NodeType != XPathNodeType.Attribute && this.NodeType != XPathNodeType.Namespace && this.NodeType != XPathNodeType.All ); 1218public override XPathNodeIterator SelectDescendants( XPathNodeType nt, bool includeSelf ) { 1219if ( nt == XPathNodeType.Element ) {
System\Xml\Dom\XmlAttribute.cs (3)
326internal override XPathNodeType XPNodeType { 329return XPathNodeType.Namespace; 331return XPathNodeType.Attribute;
System\Xml\Dom\XmlCDataSection.cs (2)
77internal override XPathNodeType XPNodeType { 79return XPathNodeType.Text;
System\Xml\Dom\XmlCharacterData.cs (3)
170internal bool DecideXPNodeTypeForTextNodes(XmlNode node, ref XPathNodeType xnt) { 182xnt = XPathNodeType.SignificantWhitespace; 186xnt = XPathNodeType.Text;
System\Xml\Dom\XmlComment.cs (2)
48internal override XPathNodeType XPNodeType { get { return XPathNodeType.Comment; } }
System\Xml\Dom\XmlDocument.cs (2)
1514internal override XPathNodeType XPNodeType { get { return XPathNodeType.Root; } }
System\Xml\Dom\XmlDocumentFragment.cs (2)
174internal override XPathNodeType XPNodeType { get { return XPathNodeType.Root; } }
System\Xml\Dom\XmlElement.cs (2)
526internal override XPathNodeType XPNodeType { get { return XPathNodeType.Element; } }
System\Xml\Dom\XmlNode.cs (2)
1156internal virtual XPathNodeType XPNodeType { 1158return (XPathNodeType)(-1);
System\Xml\Dom\XmlProcessingInstruction.cs (2)
95internal override XPathNodeType XPNodeType { get { return XPathNodeType.ProcessingInstruction; } }
System\Xml\Dom\XmlSignificantWhiteSpace.cs (3)
92internal override XPathNodeType XPNodeType { 94XPathNodeType xnt = XPathNodeType.SignificantWhitespace;
System\Xml\Dom\XmlText.cs (2)
116internal override XPathNodeType XPNodeType { 118return XPathNodeType.Text;
System\Xml\Dom\XmlWhitespace.cs (3)
92internal override XPathNodeType XPNodeType { 94XPathNodeType xnt = XPathNodeType.Whitespace;
System\Xml\Schema\Asttree.cs (4)
465return ((ast.TypeOfAxis == Axis.AxisType.Child) && (ast.NodeType == XPathNodeType.Element)); 469return ((ast.TypeOfAxis == Axis.AxisType.Attribute) && (ast.NodeType == XPathNodeType.Attribute)); 473return ((ast.TypeOfAxis == Axis.AxisType.DescendantOrSelf) && (ast.NodeType == XPathNodeType.All) && (ast.AbbrAxis)); 477return ((ast.TypeOfAxis == Axis.AxisType.Self) && (ast.NodeType == XPathNodeType.All) && (ast.AbbrAxis));
System\Xml\ValidateNames.cs (12)
452internal static void ValidateNameThrow(string prefix, string localName, string ns, XPathNodeType nodeKind, Flags flags) { 462internal static bool ValidateName(string prefix, string localName, string ns, XPathNodeType nodeKind, Flags flags) { 472private static bool ValidateNameInternal(string prefix, string localName, string ns, XPathNodeType nodeKind, Flags flags, bool throwOnError) { 493case XPathNodeType.Element: 501case XPathNodeType.Attribute: 507goto case XPathNodeType.Element; 509case XPathNodeType.ProcessingInstruction: 531case XPathNodeType.Element: 532case XPathNodeType.Attribute: 533case XPathNodeType.Namespace: 543if (prefix.Length == 0 && nodeKind == XPathNodeType.Attribute) { 568case XPathNodeType.ProcessingInstruction:
System\Xml\XPath\Internal\AbsoluteQuery.cs (1)
27if (context != null && context.NodeType == XPathNodeType.Root) {
System\Xml\XPath\Internal\AttributeQuery.cs (2)
18public AttributeQuery(Query qyParent, string Name, string Prefix, XPathNodeType Type) : base(qyParent, Name, Prefix, Type) {} 53if (context.NodeType == XPathNodeType.Attribute && matches(context)) {
System\Xml\XPath\Internal\Axis.cs (4)
20private XPathNodeType nodeType; 41public Axis(AxisType axisType, AstNode input, string prefix, string name, XPathNodeType nodetype) { 53: this(axisType, input, string.Empty, string.Empty, XPathNodeType.All) 69public XPathNodeType NodeType { get { return nodeType; } }
System\Xml\XPath\Internal\BaseAxisQuery.cs (8)
23XPathNodeType typeTest; 36protected BaseAxisQuery(Query qyInput, string name, string prefix, XPathNodeType typeTest) { 73protected XPathNodeType TypeTest { get { return typeTest; } } 81TypeTest == XPathNodeType.All || 82TypeTest == XPathNodeType.Text && (e.NodeType == XPathNodeType.Whitespace || e.NodeType == XPathNodeType.SignificantWhitespace) 126if (TypeTest != XPathNodeType.Element) {
System\Xml\XPath\Internal\CacheAxisQuery.cs (1)
19public CacheAxisQuery(Query qyInput, string name, string prefix, XPathNodeType typeTest) : base(qyInput, name, prefix, typeTest) {
System\Xml\XPath\Internal\CacheChildrenQuery.cs (1)
32public CacheChildrenQuery(Query qyInput, string name, string prefix, XPathNodeType type) : base(qyInput, name, prefix, type) {
System\Xml\XPath\Internal\ChildrenQuery.cs (3)
20public ChildrenQuery(Query qyInput, string name, string prefix, XPathNodeType type) : base (qyInput, name, prefix, type) {} 37if (TypeTest == XPathNodeType.ProcessingInstruction) { 56if (temp.NodeType != XPathNodeType.Attribute && temp.MoveToParent()) {
System\Xml\XPath\Internal\DescendantBaseQuery.cs (2)
18public DescendantBaseQuery(Query qyParent, string Name, string Prefix, XPathNodeType Type, bool matchSelf, bool abbrAxis) : base(qyParent, Name, Prefix, Type) { 59if (TypeTest != XPathNodeType.Element) {
System\Xml\XPath\Internal\DescendantoverDescendantQuery.cs (1)
21public DescendantOverDescendantQuery(Query qyParent, bool matchSelf, string name, string prefix, XPathNodeType typeTest, bool abbrAxis) :
System\Xml\XPath\Internal\DescendantQuery.cs (2)
17internal DescendantQuery(Query qyParent, string Name, string Prefix, XPathNodeType Type, bool matchSelf, bool abbrAxis) 38if (TypeTest == XPathNodeType.ProcessingInstruction) {
System\Xml\XPath\Internal\FollowingQuery.cs (3)
18public FollowingQuery(Query qyInput, string name, string prefix, XPathNodeType typeTest) : base(qyInput, name, prefix, typeTest) {} 48if (input.NodeType == XPathNodeType.Attribute || input.NodeType == XPathNodeType.Namespace) {
System\Xml\XPath\Internal\FollowingSibling.cs (1)
21public FollSiblingQuery(Query qyInput, string name, string prefix, XPathNodeType type) : base (qyInput, name, prefix, type) {
System\Xml\XPath\Internal\NamespaceQuery.cs (2)
18public NamespaceQuery(Query qyParent, string Name, string Prefix, XPathNodeType Type) : base(qyParent, Name, Prefix, Type) {} 52Debug.Assert(e.NodeType == XPathNodeType.Namespace);
System\Xml\XPath\Internal\NodeFunctions.cs (1)
74if (nav.NodeType != XPathNodeType.Whitespace || xsltContext.PreserveWhitespace(nav)) {
System\Xml\XPath\Internal\ParentQuery.cs (1)
18public ParentQuery(Query qyInput, string Name, string Prefix, XPathNodeType Type) : base(qyInput, Name, Prefix, Type) {}
System\Xml\XPath\Internal\PrecedingQuery.cs (4)
31public PrecedingQuery(Query qyInput, string name, string prefix, XPathNodeType typeTest) : base(qyInput, name, prefix, typeTest) { 57if (last.NodeType == XPathNodeType.Attribute || last.NodeType == XPathNodeType.Namespace) { 67workIterator = last.SelectDescendants(XPathNodeType.All, true);
System\Xml\XPath\Internal\PrecedingSibling.cs (3)
30public PreSiblingQuery(Query qyInput, string name, string prefix, XPathNodeType typeTest) : base (qyInput, name, prefix, typeTest) {} 56if (input.NodeType == XPathNodeType.Attribute || input.NodeType == XPathNodeType.Namespace) {
System\Xml\XPath\Internal\Query.cs (2)
195if (last.NodeType == XPathNodeType.Namespace && curr.NodeType == XPathNodeType.Namespace) {
System\Xml\XPath\Internal\QueryBuilder.cs (4)
70input.TypeOfAxis == Axis.AxisType.DescendantOrSelf && input.NodeType == XPathNodeType.All 164if ((root.NodeType == XPathNodeType.All || root.NodeType == XPathNodeType.Element || root.NodeType == XPathNodeType.Attribute) && root.Prefix.Length == 0) {
System\Xml\XPath\Internal\XPathAncestorIterator.cs (1)
16public XPathAncestorIterator(XPathNavigator nav, XPathNodeType type, bool matchSelf) : base(nav, type, matchSelf) {}
System\Xml\XPath\Internal\XPathAncestorQuery.cs (2)
18public XPathAncestorQuery(Query qyInput, string name, string prefix, XPathNodeType typeTest, bool matchSelf) : base(qyInput, name, prefix, typeTest) { 66if (TypeTest != XPathNodeType.Element) {
System\Xml\XPath\Internal\XPathAxisIterator.cs (7)
17internal XPathNodeType type; 29public XPathAxisIterator(XPathNavigator nav, XPathNodeType type, bool matchSelf) : this(nav, matchSelf) { 67type == XPathNodeType.All || 68type == XPathNodeType.Text && ( 69nav.NodeType == XPathNodeType.Whitespace || 70nav.NodeType == XPathNodeType.SignificantWhitespace 75nav.NodeType == XPathNodeType.Element &&
System\Xml\XPath\Internal\XPathChildIterator.cs (1)
16public XPathChildIterator(XPathNavigator nav, XPathNodeType type) : base(nav, type, /*matchSelf:*/false) {}
System\Xml\XPath\Internal\XPathDescendantIterator.cs (1)
14public XPathDescendantIterator(XPathNavigator nav, XPathNodeType type, bool matchSelf) : base(nav, type, matchSelf) {}
System\Xml\XPath\Internal\XPathParser.cs (14)
333XPathNodeType nodeType = ( 334axisType == Axis.AxisType.Attribute ? XPathNodeType.Attribute : 336/* default: */ XPathNodeType.Element 349private AstNode ParseNodeTest(AstNode qyInput, Axis.AxisType axisType, XPathNodeType nodeType) { 358this.scanner.Name == "comment" ? XPathNodeType.Comment : 359this.scanner.Name == "text" ? XPathNodeType.Text : 360this.scanner.Name == "node" ? XPathNodeType.All : 361this.scanner.Name == "processing-instruction" ? XPathNodeType.ProcessingInstruction : 362/* default: */ XPathNodeType.Root 364Debug.Assert(nodeType != XPathNodeType.Root); 369if (nodeType == XPathNodeType.ProcessingInstruction) { 635XPathNodeType nodeType = ( 636axisType == Axis.AxisType.Attribute ? XPathNodeType.Attribute : 637/* default: */ XPathNodeType.Element
System\Xml\XPath\Internal\XPathSelfQuery.cs (1)
15public XPathSelfQuery(Query qyInput, string Name, string Prefix, XPathNodeType Type) : base(qyInput, Name, Prefix, Type) {}
System\Xml\XPath\XPathDocument.cs (3)
357Debug.Assert(pageElem[idxElem].NodeType == XPathNodeType.Element && pageNmsp[idxNmsp].NodeType == XPathNodeType.Namespace); 370Debug.Assert(pageElem[idxElem].NodeType == XPathNodeType.Element);
System\Xml\XPath\XPathNavigator.cs (113)
106case XPathNodeType.Element: 107case XPathNodeType.Attribute: 363if (NodeType != XPathNodeType.Element) { 393if (NodeType != XPathNodeType.Element) { 424XPathNodeType nt = NodeType; 425if ((nt != XPathNodeType.Element && scope != XmlNamespaceScope.Local) || nt == XPathNodeType.Attribute || nt == XPathNodeType.Namespace) { 470public abstract XPathNodeType NodeType { get; } 499case XPathNodeType.Root: 500case XPathNodeType.Element: 604case XPathNodeType.Attribute: 605case XPathNodeType.Namespace: 632if (NodeType == XPathNodeType.Element && localName == LocalName && namespaceURI == NamespaceURI) 642public virtual bool MoveToChild(XPathNodeType type) { 666case XPathNodeType.Attribute: 667case XPathNodeType.Namespace: 676case XPathNodeType.Attribute: 677case XPathNodeType.Namespace: 707while (NodeType != XPathNodeType.Element 714public virtual bool MoveToFollowing(XPathNodeType type) { 718public virtual bool MoveToFollowing(XPathNodeType type, XPathNavigator end) { 724case XPathNodeType.Attribute: 725case XPathNodeType.Namespace: 734case XPathNodeType.Attribute: 735case XPathNodeType.Namespace: 774if (NodeType == XPathNodeType.Element && localName == LocalName && namespaceURI == NamespaceURI) 781public virtual bool MoveToNext(XPathNodeType type) { 878case XPathNodeType.Root: 884case XPathNodeType.Element: 898case XPathNodeType.Attribute: 917Debug.Assert( schemaType != null || this.NodeType == XPathNodeType.Root, "schemaType != null || this.NodeType == XPathNodeType.Root" ); 1080public virtual XPathNodeIterator SelectChildren( XPathNodeType type ) { 1088public virtual XPathNodeIterator SelectAncestors( XPathNodeType type, bool matchSelf ) { 1096public virtual XPathNodeIterator SelectDescendants( XPathNodeType type, bool matchSelf ) { 1143XPathNodeType type = NodeType; 1144if (type == XPathNodeType.Root 1145|| type == XPathNodeType.Attribute 1146|| type == XPathNodeType.Namespace) { 1170if (NodeType == XPathNodeType.Attribute) { 1173else if (NodeType == XPathNodeType.Namespace) { 1207case XPathNodeType.Root: 1208case XPathNodeType.Element: 1236case XPathNodeType.Attribute: 1237case XPathNodeType.Namespace: 1250case XPathNodeType.Root: 1251case XPathNodeType.Element: 1260case XPathNodeType.Attribute: 1436if (NodeType == XPathNodeType.Element && (object) localName == (object) LocalName && namespaceURI == NamespaceURI) 1444internal bool MoveToPrevious(XPathNodeType type) { 1459if (NodeType == XPathNodeType.Root) 1473case XPathNodeType.Attribute: 1474case XPathNodeType.Namespace: 1503case XPathNodeType.Attribute: 1508case XPathNodeType.Namespace: 1610case XPathNodeType.Namespace: 1612case XPathNodeType.Attribute: 1620case XPathNodeType.Namespace: 1629case XPathNodeType.Attribute: 1666internal const int NoAttrNmspMask = AllMask & ~(1 << (int) XPathNodeType.Attribute) & ~(1 << (int) XPathNodeType.Namespace); 1667internal const int TextMask = (1 << (int) XPathNodeType.Text) | (1 << (int) XPathNodeType.SignificantWhitespace) | (1 << (int) XPathNodeType.Whitespace); 1669(1 << (int) XPathNodeType.Root), // Root 1670(1 << (int) XPathNodeType.Element), // Element 1674(1 << (int) XPathNodeType.SignificantWhitespace), // SignificantWhitespace 1675(1 << (int) XPathNodeType.Whitespace), // Whitespace 1676(1 << (int) XPathNodeType.ProcessingInstruction), // ProcessingInstruction 1677(1 << (int) XPathNodeType.Comment), // Comment 1681internal static int GetContentKindMask(XPathNodeType type) { 1685internal static int GetKindMask(XPathNodeType type) { 1686if (type == XPathNodeType.All) 1688else if (type == XPathNodeType.Text) 1694internal static bool IsText(XPathNodeType type) { 1696return (uint)(type - XPathNodeType.Text) <= (XPathNodeType.Whitespace - XPathNodeType.Text); 1700private bool IsValidChildType(XPathNodeType type) { 1702case XPathNodeType.Root: 1704case XPathNodeType.Element: 1705case XPathNodeType.SignificantWhitespace: 1706case XPathNodeType.Whitespace: 1707case XPathNodeType.ProcessingInstruction: 1708case XPathNodeType.Comment: 1712case XPathNodeType.Element: 1714case XPathNodeType.Element: 1715case XPathNodeType.Text: 1716case XPathNodeType.SignificantWhitespace: 1717case XPathNodeType.Whitespace: 1718case XPathNodeType.ProcessingInstruction: 1719case XPathNodeType.Comment: 1728private bool IsValidSiblingType(XPathNodeType type) { 1730case XPathNodeType.Element: 1731case XPathNodeType.Text: 1732case XPathNodeType.SignificantWhitespace: 1733case XPathNodeType.Whitespace: 1734case XPathNodeType.ProcessingInstruction: 1735case XPathNodeType.Comment: 1737case XPathNodeType.Element: 1738case XPathNodeType.Text: 1739case XPathNodeType.SignificantWhitespace: 1740case XPathNodeType.Whitespace: 1741case XPathNodeType.ProcessingInstruction: 1742case XPathNodeType.Comment: 1891case XPathNodeType.Element : 1894case XPathNodeType.Attribute: 1895case XPathNodeType.Namespace : 1896case XPathNodeType.ProcessingInstruction: 1900case XPathNodeType.Text : 1901case XPathNodeType.Whitespace : 1902case XPathNodeType.SignificantWhitespace: 1903case XPathNodeType.Comment :
System\Xml\XPath\XPathNavigatorReader.cs (15)
66internal static XmlNodeType ToXmlNodeType( XPathNodeType typ ) { 183if (this.nav.NodeType == XPathNodeType.Namespace) 195if (this.nav.NodeType == XPathNodeType.Namespace && this.nav.LocalName.Length == 0) 207if (this.nav.NodeType == XPathNodeType.Namespace && this.nav.LocalName.Length != 0) 366case XPathNodeType.Element: 368case XPathNodeType.Attribute: 407case XPathNodeType.Element: 409case XPathNodeType.Attribute: 550if (XPathNodeType.Attribute == this.nav.NodeType) 554Debug.Assert( XPathNodeType.Namespace == this.nav.NodeType ); 849if ( XPathNodeType.Root == this.nav.NodeType ) { 856else if ( XPathNodeType.Attribute == this.nav.NodeType ) { 887Debug.Assert( this.nav.NodeType == XPathNodeType.Element, this.nav.NodeType.ToString() + " == XPathNodeType.Element" ); 1014public override XPathNodeType NodeType { 1015get { return XPathNodeType.All; }
System.Xml.Linq (12)
System\Xml\Linq\XNodeNavigator.cs (12)
175public override XPathNodeType NodeType { 181return XPathNodeType.Element; 184return XPathNodeType.Namespace; 186return XPathNodeType.Attribute; 188return XPathNodeType.Root; 190return XPathNodeType.Comment; 192return XPathNodeType.ProcessingInstruction; 194return XPathNodeType.Text; 197return XPathNodeType.Text; 330public override bool MoveToChild(XPathNodeType type) { 504public override bool MoveToNext(XPathNodeType type) { 700static int GetElementContentMask(XPathNodeType type) {