Code:
/ Net / Net / 3.5.50727.3053 / DEVDIV / depot / DevDiv / releases / whidbey / netfxsp / ndp / fx / src / Xml / System / Xml / Dom / XmlNodeReader.cs / 1 / XmlNodeReader.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml
{
using System;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Collections;
using System.Collections.Generic;
using System.Xml.Schema;
using System.Globalization;
internal class XmlNodeReaderNavigator {
XmlNode curNode;
XmlNode elemNode;
XmlNode logNode;
int attrIndex;
int logAttrIndex;
//presave these 2 variables since they shouldn't change.
XmlNameTable nameTable;
XmlDocument doc;
int nAttrInd; //used to identify virtual attributes of DocumentType node and XmlDeclaration node
const String strPublicID = "PUBLIC";
const String strSystemID = "SYSTEM";
const String strVersion = "version";
const String strStandalone = "standalone";
const String strEncoding = "encoding";
//caching variables for perf reasons
int nDeclarationAttrCount;
int nDocTypeAttrCount;
//variables for roll back the moves
int nLogLevel;
int nLogAttrInd;
bool bLogOnAttrVal;
bool bCreatedOnAttribute;
internal struct VirtualAttribute {
internal String name;
internal String value;
internal VirtualAttribute(String name, String value) {
this.name = name;
this.value = value;
}
};
internal VirtualAttribute [] decNodeAttributes = {
new VirtualAttribute( null, null ),
new VirtualAttribute( null, null ),
new VirtualAttribute( null, null )
};
internal VirtualAttribute [] docTypeNodeAttributes = {
new VirtualAttribute( null, null ),
new VirtualAttribute( null, null )
};
bool bOnAttrVal;
public XmlNodeReaderNavigator( XmlNode node ) {
curNode = node;
logNode = node;
XmlNodeType nt = curNode.NodeType;
if ( nt == XmlNodeType.Attribute ) {
elemNode = null;
attrIndex = -1;
bCreatedOnAttribute = true;
}
else {
elemNode = node;
attrIndex = -1;
bCreatedOnAttribute = false;
}
//presave this for pref reason since it shouldn't change.
if ( nt == XmlNodeType.Document )
this.doc = (XmlDocument)curNode;
else
this.doc = node.OwnerDocument;
this.nameTable = doc.NameTable;
this.nAttrInd = -1;
//initialize the caching variables
this.nDeclarationAttrCount = -1;
this.nDocTypeAttrCount = -1;
this.bOnAttrVal = false;
this.bLogOnAttrVal = false;
}
public XmlNodeType NodeType {
get {
XmlNodeType nt = curNode.NodeType;
if ( nAttrInd != -1 ) {
Debug.Assert( nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType );
if ( this.bOnAttrVal )
return XmlNodeType.Text;
else
return XmlNodeType.Attribute;
}
return nt;
}
}
public String NamespaceURI {
get { return curNode.NamespaceURI; }
}
public String Name {
get {
if ( nAttrInd != -1 ) {
Debug.Assert( curNode.NodeType == XmlNodeType.XmlDeclaration || curNode.NodeType == XmlNodeType.DocumentType );
if ( this.bOnAttrVal )
return String.Empty; //Text node's name is String.Empty
else {
Debug.Assert( nAttrInd >= 0 && nAttrInd < AttributeCount );
if ( curNode.NodeType == XmlNodeType.XmlDeclaration )
return decNodeAttributes[nAttrInd].name;
else
return docTypeNodeAttributes[nAttrInd].name;
}
}
if ( IsLocalNameEmpty ( curNode.NodeType ) )
return String.Empty;
return curNode.Name;
}
}
public String LocalName {
get {
if ( nAttrInd != -1 )
//for the nodes in this case, their LocalName should be the same as their name
return Name;
if ( IsLocalNameEmpty( curNode.NodeType ))
return String.Empty;
return curNode.LocalName;
}
}
internal bool IsOnAttrVal {
get {
return this.bOnAttrVal;
}
}
internal XmlNode OwnerElementNode {
get {
if( this.bCreatedOnAttribute )
return null;
return this.elemNode;
}
}
internal bool CreatedOnAttribute {
get {
return this.bCreatedOnAttribute;
}
}
private bool IsLocalNameEmpty ( XmlNodeType nt) {
switch ( nt ) {
case XmlNodeType.None :
case XmlNodeType.Text :
case XmlNodeType.CDATA :
case XmlNodeType.Comment :
case XmlNodeType.Document :
case XmlNodeType.DocumentFragment :
case XmlNodeType.Whitespace :
case XmlNodeType.SignificantWhitespace :
case XmlNodeType.EndElement :
case XmlNodeType.EndEntity :
return true;
case XmlNodeType.Element :
case XmlNodeType.Attribute :
case XmlNodeType.EntityReference :
case XmlNodeType.Entity :
case XmlNodeType.ProcessingInstruction :
case XmlNodeType.DocumentType :
case XmlNodeType.Notation :
case XmlNodeType.XmlDeclaration :
return false;
default :
return true;
}
}
public String Prefix {
get { return curNode.Prefix; }
}
public bool HasValue {
//In DOM, DocumentType node and XmlDeclaration node doesn't value
//In XPathNavigator, XmlDeclaration node's value is its InnerText; DocumentType doesn't have value
//In XmlReader, DocumentType node's value is its InternalSubset which is never null ( at least String.Empty )
get {
if ( nAttrInd != -1 ) {
//Pointing at the one of virtual attributes of Declaration or DocumentType nodes
Debug.Assert( curNode.NodeType == XmlNodeType.XmlDeclaration || curNode.NodeType == XmlNodeType.DocumentType );
Debug.Assert( nAttrInd >= 0 && nAttrInd < AttributeCount );
return true;
}
if ( curNode.Value != null || curNode.NodeType == XmlNodeType.DocumentType )
return true;
return false;
}
}
public String Value {
//See comments in HasValue
get {
String retValue = null;
XmlNodeType nt = curNode.NodeType;
if ( nAttrInd != -1 ) {
//Pointing at the one of virtual attributes of Declaration or DocumentType nodes
Debug.Assert( nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType );
Debug.Assert( nAttrInd >= 0 && nAttrInd < AttributeCount );
if ( curNode.NodeType == XmlNodeType.XmlDeclaration )
return decNodeAttributes[nAttrInd].value;
else
return docTypeNodeAttributes[nAttrInd].value;
}
if ( nt == XmlNodeType.DocumentType )
retValue = ((XmlDocumentType)curNode).InternalSubset; //in this case nav.Value will be null
else if ( nt == XmlNodeType.XmlDeclaration ) {
StringBuilder strb = new StringBuilder(String.Empty);
if ( nDeclarationAttrCount == -1 )
InitDecAttr();
for ( int i = 0; i < nDeclarationAttrCount; i++ ) {
strb.Append(decNodeAttributes[i].name + "=\"" +decNodeAttributes[i].value + "\"");
if( i != ( nDeclarationAttrCount-1 ) )
strb.Append( " " );
}
retValue = strb.ToString();
} else
retValue = curNode.Value;
return ( retValue == null )? String.Empty : retValue;
}
}
public String BaseURI {
get { return curNode.BaseURI; }
}
public XmlSpace XmlSpace {
get { return curNode.XmlSpace; }
}
public String XmlLang {
get { return curNode.XmlLang; }
}
public bool IsEmptyElement {
get {
if (curNode.NodeType == XmlNodeType.Element) {
return((XmlElement)curNode).IsEmpty;
}
return false;
}
}
public bool IsDefault {
get {
if (curNode.NodeType == XmlNodeType.Attribute) {
return !((XmlAttribute)curNode).Specified;
}
return false;
}
}
public IXmlSchemaInfo SchemaInfo {
get {
return curNode.SchemaInfo;
}
}
public XmlNameTable NameTable {
get { return nameTable; }
}
public int AttributeCount {
get {
if( this.bCreatedOnAttribute )
return 0;
XmlNodeType nt = curNode.NodeType;
if ( nt == XmlNodeType.Element )
return ((XmlElement)curNode).Attributes.Count;
else if ( nt == XmlNodeType.Attribute
|| ( this.bOnAttrVal && nt != XmlNodeType.XmlDeclaration && nt != XmlNodeType.DocumentType ) )
return elemNode.Attributes.Count;
else if ( nt == XmlNodeType.XmlDeclaration ) {
if ( nDeclarationAttrCount != -1 )
return nDeclarationAttrCount;
InitDecAttr();
return nDeclarationAttrCount;
} else if ( nt == XmlNodeType.DocumentType ) {
if ( nDocTypeAttrCount != -1 )
return nDocTypeAttrCount;
InitDocTypeAttr();
return nDocTypeAttrCount;
}
return 0;
}
}
private void CheckIndexCondition(int attributeIndex) {
if (attributeIndex < 0 || attributeIndex >= AttributeCount) {
throw new ArgumentOutOfRangeException( "attributeIndex" );
}
}
//8 functions below are the helper functions to deal with virtual attributes of XmlDeclaration nodes and DocumentType nodes.
private void InitDecAttr() {
int i = 0;
String strTemp = doc.Version;
if ( strTemp != null && strTemp.Length != 0 ) {
decNodeAttributes[i].name = strVersion;
decNodeAttributes[i].value = strTemp;
i++;
}
strTemp = doc.Encoding;
if ( strTemp != null && strTemp.Length != 0 ) {
decNodeAttributes[i].name = strEncoding;
decNodeAttributes[i].value = strTemp;
i++;
}
strTemp = doc.Standalone;
if ( strTemp != null && strTemp.Length != 0 ) {
decNodeAttributes[i].name = strStandalone;
decNodeAttributes[i].value = strTemp;
i++;
}
nDeclarationAttrCount = i;
}
public String GetDeclarationAttr( XmlDeclaration decl, String name ) {
//PreCondition: curNode is pointing at Declaration node or one of its virtual attributes
if ( name == strVersion )
return decl.Version;
if ( name == strEncoding )
return decl.Encoding;
if ( name == strStandalone )
return decl.Standalone;
return null;
}
public String GetDeclarationAttr( int i ) {
if ( nDeclarationAttrCount == -1 )
InitDecAttr();
return decNodeAttributes[i].value;
}
public int GetDecAttrInd( String name ) {
if ( nDeclarationAttrCount == -1 )
InitDecAttr();
for ( int i = 0 ; i < nDeclarationAttrCount; i++ ) {
if ( decNodeAttributes[i].name == name )
return i;
}
return -1;
}
private void InitDocTypeAttr() {
int i = 0;
XmlDocumentType docType = doc.DocumentType;
if ( docType == null ) {
nDocTypeAttrCount = 0;
return;
}
String strTemp = docType.PublicId;
if ( strTemp != null ) {
docTypeNodeAttributes[i].name = strPublicID;
docTypeNodeAttributes[i].value = strTemp;
i++;
}
strTemp = docType.SystemId;
if ( strTemp != null ) {
docTypeNodeAttributes[i].name = strSystemID;
docTypeNodeAttributes[i].value = strTemp;
i++;
}
nDocTypeAttrCount = i;
}
public String GetDocumentTypeAttr ( XmlDocumentType docType, String name ) {
//PreCondition: nav is pointing at DocumentType node or one of its virtual attributes
if ( name == strPublicID )
return docType.PublicId;
if ( name == strSystemID )
return docType.SystemId;
return null;
}
public String GetDocumentTypeAttr( int i ) {
if ( nDocTypeAttrCount == -1 )
InitDocTypeAttr();
return docTypeNodeAttributes[i].value;
}
public int GetDocTypeAttrInd( String name ) {
if ( nDocTypeAttrCount == -1 )
InitDocTypeAttr();
for ( int i = 0 ; i < nDocTypeAttrCount; i++ ) {
if ( docTypeNodeAttributes[i].name == name )
return i;
}
return -1;
}
private String GetAttributeFromElement( XmlElement elem, String name ) {
XmlAttribute attr = elem.GetAttributeNode( name );
if ( attr != null )
return attr.Value;
return null;
}
public String GetAttribute( String name ) {
if( this.bCreatedOnAttribute )
return null;
switch ( curNode.NodeType ) {
case XmlNodeType.Element:
return GetAttributeFromElement((XmlElement)curNode, name);
case XmlNodeType.Attribute :
return GetAttributeFromElement((XmlElement)elemNode, name);
case XmlNodeType.XmlDeclaration:
return GetDeclarationAttr( (XmlDeclaration)curNode, name );
case XmlNodeType.DocumentType:
return GetDocumentTypeAttr( (XmlDocumentType)curNode, name );
}
return null;
}
private String GetAttributeFromElement( XmlElement elem, String name, String ns ) {
XmlAttribute attr = elem.GetAttributeNode( name, ns );
if ( attr != null )
return attr.Value;
return null;
}
public String GetAttribute( String name, String ns ) {
if( this.bCreatedOnAttribute )
return null;
switch ( curNode.NodeType ) {
case XmlNodeType.Element:
return GetAttributeFromElement((XmlElement)curNode, name, ns);
case XmlNodeType.Attribute :
return GetAttributeFromElement((XmlElement)elemNode, name, ns);
case XmlNodeType.XmlDeclaration:
return (ns.Length == 0) ? GetDeclarationAttr( (XmlDeclaration)curNode, name ) : null;
case XmlNodeType.DocumentType:
return (ns.Length == 0) ? GetDocumentTypeAttr( (XmlDocumentType)curNode, name ) : null;
}
return null;
}
public String GetAttribute( int attributeIndex ) {
if( this.bCreatedOnAttribute )
return null;
switch ( curNode.NodeType ) {
case XmlNodeType.Element:
CheckIndexCondition( attributeIndex );
return ((XmlElement)curNode).Attributes[attributeIndex].Value;
case XmlNodeType.Attribute :
CheckIndexCondition( attributeIndex );
return ((XmlElement)elemNode).Attributes[attributeIndex].Value;
case XmlNodeType.XmlDeclaration: {
CheckIndexCondition( attributeIndex );
return GetDeclarationAttr( attributeIndex );
}
case XmlNodeType.DocumentType: {
CheckIndexCondition( attributeIndex );
return GetDocumentTypeAttr( attributeIndex );
}
}
throw new ArgumentOutOfRangeException( "attributeIndex" ); //for other senario, AttributeCount is 0, i has to be out of range
}
public void LogMove( int level ) {
logNode = curNode;
nLogLevel = level;
nLogAttrInd = nAttrInd;
logAttrIndex = attrIndex;
this.bLogOnAttrVal = this.bOnAttrVal;
}
//The function has to be used in pair with ResetMove when the operation fails after LogMove() is
// called because it relies on the values of nOrigLevel, logNav and nOrigAttrInd to be acurate.
public void RollBackMove( ref int level ) {
curNode = logNode;
level = nLogLevel;
nAttrInd = nLogAttrInd;
attrIndex = logAttrIndex;
this.bOnAttrVal = this.bLogOnAttrVal;
}
private bool IsOnDeclOrDocType {
get {
XmlNodeType nt = curNode.NodeType;
return ( nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType );
}
}
public void ResetToAttribute( ref int level ) {
//the current cursor is pointing at one of the attribute children -- this could be caused by
// the calls to ReadAttributeValue(..)
if( this.bCreatedOnAttribute )
return;
if ( this.bOnAttrVal ) {
if ( IsOnDeclOrDocType ) {
level-=2;
} else {
while ( curNode.NodeType != XmlNodeType.Attribute && ( ( curNode = curNode.ParentNode ) != null ) )
level-- ;
}
this.bOnAttrVal = false;
}
}
public void ResetMove( ref int level, ref XmlNodeType nt ) {
LogMove( level );
if( this.bCreatedOnAttribute )
return;
if ( nAttrInd != -1 ) {
Debug.Assert( IsOnDeclOrDocType );
if ( this.bOnAttrVal ) {
level--;
this.bOnAttrVal = false;
}
nLogAttrInd = nAttrInd;
level--;
nAttrInd = -1;
nt = curNode.NodeType;
return;
}
if ( this.bOnAttrVal && curNode.NodeType != XmlNodeType.Attribute )
ResetToAttribute( ref level );
if ( curNode.NodeType == XmlNodeType.Attribute ) {
curNode = ((XmlAttribute)curNode).OwnerElement;
attrIndex = -1;
level--;
nt = XmlNodeType.Element;
}
if ( curNode.NodeType == XmlNodeType.Element )
elemNode = curNode;
}
public bool MoveToAttribute( string name ) {
return MoveToAttribute( name, string.Empty );
}
private bool MoveToAttributeFromElement( XmlElement elem, String name, String ns ) {
XmlAttribute attr = null;
if( ns.Length == 0 )
attr = elem.GetAttributeNode( name );
else
attr = elem.GetAttributeNode( name, ns );
if ( attr != null ) {
this.bOnAttrVal = false;
elemNode = elem;
curNode = attr;
attrIndex = elem.Attributes.FindNodeOffsetNS(attr);
if (attrIndex != -1) {
return true;
}
}
return false;
}
public bool MoveToAttribute( string name, string namespaceURI ) {
if( this.bCreatedOnAttribute )
return false;
XmlNodeType nt = curNode.NodeType;
if ( nt == XmlNodeType.Element )
return MoveToAttributeFromElement((XmlElement)curNode, name, namespaceURI );
else if ( nt == XmlNodeType.Attribute )
return MoveToAttributeFromElement((XmlElement)elemNode, name, namespaceURI );
else if ( nt == XmlNodeType.XmlDeclaration && namespaceURI.Length == 0 ) {
if ( ( nAttrInd = GetDecAttrInd( name ) ) != -1 ) {
this.bOnAttrVal = false;
return true;
}
} else if ( nt == XmlNodeType.DocumentType && namespaceURI.Length == 0 ) {
if ( ( nAttrInd = GetDocTypeAttrInd( name ) ) != -1 ) {
this.bOnAttrVal = false;
return true;
}
}
return false;
}
public void MoveToAttribute( int attributeIndex ) {
if( this.bCreatedOnAttribute )
return;
XmlAttribute attr = null;
switch ( curNode.NodeType ) {
case XmlNodeType.Element:
CheckIndexCondition( attributeIndex );
attr = ((XmlElement)curNode).Attributes[attributeIndex];
if ( attr != null ) {
elemNode = curNode;
curNode = (XmlNode) attr;
attrIndex = attributeIndex;
}
break;
case XmlNodeType.Attribute:
CheckIndexCondition( attributeIndex );
attr = ((XmlElement)elemNode).Attributes[attributeIndex];
if ( attr != null ) {
curNode = (XmlNode) attr;
attrIndex = attributeIndex;
}
break;
case XmlNodeType.XmlDeclaration :
case XmlNodeType.DocumentType :
CheckIndexCondition( attributeIndex );
nAttrInd = attributeIndex;
break;
}
}
public bool MoveToNextAttribute( ref int level ) {
if( this.bCreatedOnAttribute )
return false;
XmlNodeType nt = curNode.NodeType;
if ( nt == XmlNodeType.Attribute ) {
if( attrIndex >= ( elemNode.Attributes.Count-1 ) )
return false;
else {
curNode = elemNode.Attributes[++attrIndex];
return true;
}
} else if ( nt == XmlNodeType.Element ) {
if ( curNode.Attributes.Count > 0 ) {
level++;
elemNode = curNode;
curNode = curNode.Attributes[0];
attrIndex = 0;
return true;
}
} else if ( nt == XmlNodeType.XmlDeclaration ) {
if ( nDeclarationAttrCount == -1 )
InitDecAttr();
nAttrInd++;
if ( nAttrInd < nDeclarationAttrCount ) {
if ( nAttrInd == 0 ) level++;
this.bOnAttrVal = false;
return true;
}
nAttrInd--;
} else if ( nt == XmlNodeType.DocumentType ) {
if ( nDocTypeAttrCount == -1 )
InitDocTypeAttr();
nAttrInd++;
if ( nAttrInd < nDocTypeAttrCount ) {
if ( nAttrInd == 0 ) level++;
this.bOnAttrVal = false;
return true;
}
nAttrInd--;
}
return false;
}
public bool MoveToParent() {
XmlNode parent = curNode.ParentNode;
if ( parent != null ) {
curNode = parent;
if( !bOnAttrVal )
attrIndex = 0;
return true;
}
return false;
}
public bool MoveToFirstChild() {
XmlNode firstChild = curNode.FirstChild;
if ( firstChild != null ) {
curNode = firstChild;
if( !bOnAttrVal )
attrIndex = -1;
return true;
}
return false;
}
private bool MoveToNextSibling( XmlNode node ) {
XmlNode nextSibling = node.NextSibling;
if ( nextSibling != null ) {
curNode = nextSibling;
if( !bOnAttrVal )
attrIndex = -1;
return true;
}
return false;
}
public bool MoveToNext() {
if ( curNode.NodeType != XmlNodeType.Attribute )
return MoveToNextSibling( curNode );
else
return MoveToNextSibling( elemNode );
}
public bool MoveToElement() {
if( this.bCreatedOnAttribute )
return false;
switch ( curNode.NodeType ) {
case XmlNodeType.Attribute :
if ( elemNode != null ) {
curNode = elemNode;
attrIndex = -1;
return true;
}
break;
case XmlNodeType.XmlDeclaration :
case XmlNodeType.DocumentType : {
if ( nAttrInd != -1 ) {
nAttrInd = -1;
return true;
}
break;
}
}
return false;
}
public String LookupNamespace(string prefix) {
if( this.bCreatedOnAttribute )
return null;
if ( prefix == "xmlns" ) {
return nameTable.Add( XmlReservedNs.NsXmlNs );
}
if ( prefix == "xml" ) {
return nameTable.Add( XmlReservedNs.NsXml );
}
// construct the name of the xmlns attribute
string attrName;
if ( prefix == null )
prefix = string.Empty;
if ( prefix.Length == 0 )
attrName = "xmlns";
else
attrName = "xmlns:" + prefix;
// walk up the XmlNode parent chain, looking for the xmlns attribute
XmlNode node = curNode;
while ( node != null ) {
if ( node.NodeType == XmlNodeType.Element ) {
XmlElement elem = (XmlElement)node;
if ( elem.HasAttributes ) {
XmlAttribute attr = elem.GetAttributeNode( attrName );
if ( attr != null ) {
return attr.Value;
}
}
}
else if ( node.NodeType == XmlNodeType.Attribute ) {
node = ((XmlAttribute)node).OwnerElement;
continue;
}
node = node.ParentNode;
}
if ( prefix.Length == 0 ) {
return string.Empty;
}
return null;
}
internal string DefaultLookupNamespace( string prefix ) {
if( !this.bCreatedOnAttribute ) {
if ( prefix == "xmlns" ) {
return nameTable.Add( XmlReservedNs.NsXmlNs );
}
if ( prefix == "xml" ) {
return nameTable.Add( XmlReservedNs.NsXml );
}
if ( prefix == string.Empty ) {
return nameTable.Add( string.Empty );
}
}
return null;
}
internal String LookupPrefix(string namespaceName) {
if( this.bCreatedOnAttribute || namespaceName == null ) {
return null;
}
if ( namespaceName == XmlReservedNs.NsXmlNs ) {
return nameTable.Add( "xmlns" );
}
if ( namespaceName == XmlReservedNs.NsXml ) {
return nameTable.Add( "xml" );
}
if ( namespaceName == string.Empty ) {
return string.Empty;
}
// walk up the XmlNode parent chain, looking for the xmlns attribute with namespaceName value
XmlNode node = curNode;
while ( node != null ) {
if ( node.NodeType == XmlNodeType.Element ) {
XmlElement elem = (XmlElement)node;
if ( elem.HasAttributes ) {
XmlAttributeCollection attrs = elem.Attributes;
for ( int i = 0; i < attrs.Count; i++ ) {
XmlAttribute a = attrs[i];
if ( a.Value == namespaceName ) {
if ( a.Prefix.Length == 0 && a.LocalName == "xmlns" ) {
if ( LookupNamespace( string.Empty ) == namespaceName ) {
return string.Empty;
}
}
else if ( a.Prefix == "xmlns" ) {
string pref = a.LocalName;
if ( LookupNamespace( pref ) == namespaceName ) {
return nameTable.Add( pref );
}
}
}
}
}
}
else if ( node.NodeType == XmlNodeType.Attribute ) {
node = ((XmlAttribute)node).OwnerElement;
continue;
}
node = node.ParentNode;
}
return null;
}
internal IDictionary GetNamespacesInScope( XmlNamespaceScope scope ) {
Dictionary dict = new Dictionary();
if( this.bCreatedOnAttribute )
return dict;
// walk up the XmlNode parent chain and add all namespace declarations to the dictionary
XmlNode node = curNode;
while ( node != null ) {
if ( node.NodeType == XmlNodeType.Element ) {
XmlElement elem = (XmlElement)node;
if ( elem.HasAttributes ) {
XmlAttributeCollection attrs = elem.Attributes;
for ( int i = 0; i < attrs.Count; i++ ) {
XmlAttribute a = attrs[i];
if ( a.LocalName == "xmlns" && a.Prefix.Length == 0 ) {
if ( !dict.ContainsKey( string.Empty ) ) {
dict.Add( nameTable.Add( string.Empty ), nameTable.Add( a.Value ) );
}
}
else if ( a.Prefix == "xmlns" ) {
string localName = a.LocalName;
if ( !dict.ContainsKey( localName ) ) {
dict.Add( nameTable.Add( localName ), nameTable.Add( a.Value ) );
}
}
}
}
if ( scope == XmlNamespaceScope.Local ) {
break;
}
}
else if ( node.NodeType == XmlNodeType.Attribute ) {
node = ((XmlAttribute)node).OwnerElement;
continue;
}
node = node.ParentNode;
};
if ( scope != XmlNamespaceScope.Local ) {
if ( dict.ContainsKey( string.Empty ) && dict[string.Empty] == string.Empty ) {
dict.Remove( string.Empty );
}
if ( scope == XmlNamespaceScope.All ) {
dict.Add( nameTable.Add( "xml" ), nameTable.Add( XmlReservedNs.NsXml ) );
}
}
return dict;
}
public bool ReadAttributeValue( ref int level, ref bool bResolveEntity, ref XmlNodeType nt ) {
if ( nAttrInd != -1 ) {
Debug.Assert( curNode.NodeType == XmlNodeType.XmlDeclaration || curNode.NodeType == XmlNodeType.DocumentType );
if ( !this.bOnAttrVal ) {
this.bOnAttrVal = true;
level++;
nt = XmlNodeType.Text;
return true;
}
return false;
}
if( curNode.NodeType == XmlNodeType.Attribute ) {
XmlNode firstChild = curNode.FirstChild;
if ( firstChild != null ) {
curNode = firstChild;
nt = curNode.NodeType;
level++;
this.bOnAttrVal = true;
return true;
}
}
else if ( this.bOnAttrVal ) {
XmlNode nextSibling = null;
if ( curNode.NodeType == XmlNodeType.EntityReference && bResolveEntity ) {
//going down to ent ref node
curNode = curNode.FirstChild;
nt = curNode.NodeType;
Debug.Assert( curNode != null );
level++;
bResolveEntity = false;
return true;
}
else
nextSibling = curNode.NextSibling;
if ( nextSibling == null ) {
XmlNode parentNode = curNode.ParentNode;
//Check if its parent is entity ref node is sufficient, because in this senario, ent ref node can't have more than 1 level of children that are not other ent ref nodes
if ( parentNode != null && parentNode.NodeType == XmlNodeType.EntityReference ) {
//come back from ent ref node
curNode = parentNode;
nt = XmlNodeType.EndEntity;
level--;
return true;
}
}
if ( nextSibling != null ) {
curNode = nextSibling;
nt = curNode.NodeType;
return true;
}
else
return false;
}
return false;
}
}
// Represents a reader that provides fast, non-cached forward only stream access
// to XML data in an XmlDocument or a specific XmlNode within an XmlDocument.
public class XmlNodeReader: XmlReader, IXmlNamespaceResolver
{
XmlNodeReaderNavigator readerNav;
XmlNodeType nodeType; // nodeType of the node that the reader is currently positioned on
int curDepth; // depth of attrNav ( also functions as reader's depth )
ReadState readState; // current reader's state
bool fEOF; // flag to show if reaches the end of file
//mark to the state that EntityReference node is supposed to be resolved
bool bResolveEntity;
bool bStartFromDocument;
bool bInReadBinary;
ReadContentAsBinaryHelper readBinaryHelper;
// Creates an instance of the XmlNodeReader class using the specified XmlNode.
public XmlNodeReader ( XmlNode node ) {
Init( node );
}
private void Init( XmlNode node ) {
readerNav = new XmlNodeReaderNavigator( node );
this.curDepth = 0;
readState = ReadState.Initial;
fEOF = false;
nodeType = XmlNodeType.None;
bResolveEntity = false;
bStartFromDocument = false;
}
//function returns if the reader currently in valid reading states
internal bool IsInReadingStates() {
return ( readState == ReadState.Interactive ); // || readState == ReadState.EndOfFile
}
//
// Node Properties
//
// Gets the type of the current node.
public override XmlNodeType NodeType {
get { return ( IsInReadingStates() )? nodeType : XmlNodeType.None; }
}
// Gets the name of
// the current node, including the namespace prefix.
public override string Name {
get {
if ( !IsInReadingStates() )
return String.Empty;
return readerNav.Name;
}
}
// Gets the name of the current node without the namespace prefix.
public override string LocalName {
get {
if ( !IsInReadingStates() )
return String.Empty;
return readerNav.LocalName;
}
}
// Gets the namespace URN (as defined in the W3C Namespace Specification)
// of the current namespace scope.
public override string NamespaceURI {
get {
if ( !IsInReadingStates() )
return String.Empty;
return readerNav.NamespaceURI;
}
}
// Gets the namespace prefix associated with the current node.
public override string Prefix {
get {
if ( !IsInReadingStates() )
return String.Empty;
return readerNav.Prefix;
}
}
// Gets a value indicating whether
// XmlNodeReader.Value has a value to return.
public override bool HasValue {
get {
if ( !IsInReadingStates() )
return false;
return readerNav.HasValue;
}
}
// Gets the text value of the current node.
public override string Value {
get {
if ( !IsInReadingStates() )
return String.Empty;
return readerNav.Value;
}
}
// Gets the depth of the
// current node in the XML element stack.
public override int Depth {
get { return curDepth; }
}
// Gets the base URI of the current node.
public override String BaseURI {
get { return readerNav.BaseURI; }
}
public override bool CanResolveEntity {
get { return true; }
}
// Gets a value indicating whether the current
// node is an empty element (for example, IXmlNamespaceResolver.GetNamespacesInScope( XmlNamespaceScope scope ) {
return readerNav.GetNamespacesInScope( scope );
}
string IXmlNamespaceResolver.LookupPrefix( string namespaceName ) {
return readerNav.LookupPrefix( namespaceName );
}
String IXmlNamespaceResolver.LookupNamespace( string prefix ) {
if ( !IsInReadingStates() ) {
return readerNav.DefaultLookupNamespace( prefix );
}
string ns = readerNav.LookupNamespace( prefix );
if ( ns != null ) {
ns = readerNav.NameTable.Add( ns );
}
return ns;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
// [....]
//-----------------------------------------------------------------------------
namespace System.Xml
{
using System;
using System.Text;
using System.IO;
using System.Diagnostics;
using System.Collections;
using System.Collections.Generic;
using System.Xml.Schema;
using System.Globalization;
internal class XmlNodeReaderNavigator {
XmlNode curNode;
XmlNode elemNode;
XmlNode logNode;
int attrIndex;
int logAttrIndex;
//presave these 2 variables since they shouldn't change.
XmlNameTable nameTable;
XmlDocument doc;
int nAttrInd; //used to identify virtual attributes of DocumentType node and XmlDeclaration node
const String strPublicID = "PUBLIC";
const String strSystemID = "SYSTEM";
const String strVersion = "version";
const String strStandalone = "standalone";
const String strEncoding = "encoding";
//caching variables for perf reasons
int nDeclarationAttrCount;
int nDocTypeAttrCount;
//variables for roll back the moves
int nLogLevel;
int nLogAttrInd;
bool bLogOnAttrVal;
bool bCreatedOnAttribute;
internal struct VirtualAttribute {
internal String name;
internal String value;
internal VirtualAttribute(String name, String value) {
this.name = name;
this.value = value;
}
};
internal VirtualAttribute [] decNodeAttributes = {
new VirtualAttribute( null, null ),
new VirtualAttribute( null, null ),
new VirtualAttribute( null, null )
};
internal VirtualAttribute [] docTypeNodeAttributes = {
new VirtualAttribute( null, null ),
new VirtualAttribute( null, null )
};
bool bOnAttrVal;
public XmlNodeReaderNavigator( XmlNode node ) {
curNode = node;
logNode = node;
XmlNodeType nt = curNode.NodeType;
if ( nt == XmlNodeType.Attribute ) {
elemNode = null;
attrIndex = -1;
bCreatedOnAttribute = true;
}
else {
elemNode = node;
attrIndex = -1;
bCreatedOnAttribute = false;
}
//presave this for pref reason since it shouldn't change.
if ( nt == XmlNodeType.Document )
this.doc = (XmlDocument)curNode;
else
this.doc = node.OwnerDocument;
this.nameTable = doc.NameTable;
this.nAttrInd = -1;
//initialize the caching variables
this.nDeclarationAttrCount = -1;
this.nDocTypeAttrCount = -1;
this.bOnAttrVal = false;
this.bLogOnAttrVal = false;
}
public XmlNodeType NodeType {
get {
XmlNodeType nt = curNode.NodeType;
if ( nAttrInd != -1 ) {
Debug.Assert( nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType );
if ( this.bOnAttrVal )
return XmlNodeType.Text;
else
return XmlNodeType.Attribute;
}
return nt;
}
}
public String NamespaceURI {
get { return curNode.NamespaceURI; }
}
public String Name {
get {
if ( nAttrInd != -1 ) {
Debug.Assert( curNode.NodeType == XmlNodeType.XmlDeclaration || curNode.NodeType == XmlNodeType.DocumentType );
if ( this.bOnAttrVal )
return String.Empty; //Text node's name is String.Empty
else {
Debug.Assert( nAttrInd >= 0 && nAttrInd < AttributeCount );
if ( curNode.NodeType == XmlNodeType.XmlDeclaration )
return decNodeAttributes[nAttrInd].name;
else
return docTypeNodeAttributes[nAttrInd].name;
}
}
if ( IsLocalNameEmpty ( curNode.NodeType ) )
return String.Empty;
return curNode.Name;
}
}
public String LocalName {
get {
if ( nAttrInd != -1 )
//for the nodes in this case, their LocalName should be the same as their name
return Name;
if ( IsLocalNameEmpty( curNode.NodeType ))
return String.Empty;
return curNode.LocalName;
}
}
internal bool IsOnAttrVal {
get {
return this.bOnAttrVal;
}
}
internal XmlNode OwnerElementNode {
get {
if( this.bCreatedOnAttribute )
return null;
return this.elemNode;
}
}
internal bool CreatedOnAttribute {
get {
return this.bCreatedOnAttribute;
}
}
private bool IsLocalNameEmpty ( XmlNodeType nt) {
switch ( nt ) {
case XmlNodeType.None :
case XmlNodeType.Text :
case XmlNodeType.CDATA :
case XmlNodeType.Comment :
case XmlNodeType.Document :
case XmlNodeType.DocumentFragment :
case XmlNodeType.Whitespace :
case XmlNodeType.SignificantWhitespace :
case XmlNodeType.EndElement :
case XmlNodeType.EndEntity :
return true;
case XmlNodeType.Element :
case XmlNodeType.Attribute :
case XmlNodeType.EntityReference :
case XmlNodeType.Entity :
case XmlNodeType.ProcessingInstruction :
case XmlNodeType.DocumentType :
case XmlNodeType.Notation :
case XmlNodeType.XmlDeclaration :
return false;
default :
return true;
}
}
public String Prefix {
get { return curNode.Prefix; }
}
public bool HasValue {
//In DOM, DocumentType node and XmlDeclaration node doesn't value
//In XPathNavigator, XmlDeclaration node's value is its InnerText; DocumentType doesn't have value
//In XmlReader, DocumentType node's value is its InternalSubset which is never null ( at least String.Empty )
get {
if ( nAttrInd != -1 ) {
//Pointing at the one of virtual attributes of Declaration or DocumentType nodes
Debug.Assert( curNode.NodeType == XmlNodeType.XmlDeclaration || curNode.NodeType == XmlNodeType.DocumentType );
Debug.Assert( nAttrInd >= 0 && nAttrInd < AttributeCount );
return true;
}
if ( curNode.Value != null || curNode.NodeType == XmlNodeType.DocumentType )
return true;
return false;
}
}
public String Value {
//See comments in HasValue
get {
String retValue = null;
XmlNodeType nt = curNode.NodeType;
if ( nAttrInd != -1 ) {
//Pointing at the one of virtual attributes of Declaration or DocumentType nodes
Debug.Assert( nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType );
Debug.Assert( nAttrInd >= 0 && nAttrInd < AttributeCount );
if ( curNode.NodeType == XmlNodeType.XmlDeclaration )
return decNodeAttributes[nAttrInd].value;
else
return docTypeNodeAttributes[nAttrInd].value;
}
if ( nt == XmlNodeType.DocumentType )
retValue = ((XmlDocumentType)curNode).InternalSubset; //in this case nav.Value will be null
else if ( nt == XmlNodeType.XmlDeclaration ) {
StringBuilder strb = new StringBuilder(String.Empty);
if ( nDeclarationAttrCount == -1 )
InitDecAttr();
for ( int i = 0; i < nDeclarationAttrCount; i++ ) {
strb.Append(decNodeAttributes[i].name + "=\"" +decNodeAttributes[i].value + "\"");
if( i != ( nDeclarationAttrCount-1 ) )
strb.Append( " " );
}
retValue = strb.ToString();
} else
retValue = curNode.Value;
return ( retValue == null )? String.Empty : retValue;
}
}
public String BaseURI {
get { return curNode.BaseURI; }
}
public XmlSpace XmlSpace {
get { return curNode.XmlSpace; }
}
public String XmlLang {
get { return curNode.XmlLang; }
}
public bool IsEmptyElement {
get {
if (curNode.NodeType == XmlNodeType.Element) {
return((XmlElement)curNode).IsEmpty;
}
return false;
}
}
public bool IsDefault {
get {
if (curNode.NodeType == XmlNodeType.Attribute) {
return !((XmlAttribute)curNode).Specified;
}
return false;
}
}
public IXmlSchemaInfo SchemaInfo {
get {
return curNode.SchemaInfo;
}
}
public XmlNameTable NameTable {
get { return nameTable; }
}
public int AttributeCount {
get {
if( this.bCreatedOnAttribute )
return 0;
XmlNodeType nt = curNode.NodeType;
if ( nt == XmlNodeType.Element )
return ((XmlElement)curNode).Attributes.Count;
else if ( nt == XmlNodeType.Attribute
|| ( this.bOnAttrVal && nt != XmlNodeType.XmlDeclaration && nt != XmlNodeType.DocumentType ) )
return elemNode.Attributes.Count;
else if ( nt == XmlNodeType.XmlDeclaration ) {
if ( nDeclarationAttrCount != -1 )
return nDeclarationAttrCount;
InitDecAttr();
return nDeclarationAttrCount;
} else if ( nt == XmlNodeType.DocumentType ) {
if ( nDocTypeAttrCount != -1 )
return nDocTypeAttrCount;
InitDocTypeAttr();
return nDocTypeAttrCount;
}
return 0;
}
}
private void CheckIndexCondition(int attributeIndex) {
if (attributeIndex < 0 || attributeIndex >= AttributeCount) {
throw new ArgumentOutOfRangeException( "attributeIndex" );
}
}
//8 functions below are the helper functions to deal with virtual attributes of XmlDeclaration nodes and DocumentType nodes.
private void InitDecAttr() {
int i = 0;
String strTemp = doc.Version;
if ( strTemp != null && strTemp.Length != 0 ) {
decNodeAttributes[i].name = strVersion;
decNodeAttributes[i].value = strTemp;
i++;
}
strTemp = doc.Encoding;
if ( strTemp != null && strTemp.Length != 0 ) {
decNodeAttributes[i].name = strEncoding;
decNodeAttributes[i].value = strTemp;
i++;
}
strTemp = doc.Standalone;
if ( strTemp != null && strTemp.Length != 0 ) {
decNodeAttributes[i].name = strStandalone;
decNodeAttributes[i].value = strTemp;
i++;
}
nDeclarationAttrCount = i;
}
public String GetDeclarationAttr( XmlDeclaration decl, String name ) {
//PreCondition: curNode is pointing at Declaration node or one of its virtual attributes
if ( name == strVersion )
return decl.Version;
if ( name == strEncoding )
return decl.Encoding;
if ( name == strStandalone )
return decl.Standalone;
return null;
}
public String GetDeclarationAttr( int i ) {
if ( nDeclarationAttrCount == -1 )
InitDecAttr();
return decNodeAttributes[i].value;
}
public int GetDecAttrInd( String name ) {
if ( nDeclarationAttrCount == -1 )
InitDecAttr();
for ( int i = 0 ; i < nDeclarationAttrCount; i++ ) {
if ( decNodeAttributes[i].name == name )
return i;
}
return -1;
}
private void InitDocTypeAttr() {
int i = 0;
XmlDocumentType docType = doc.DocumentType;
if ( docType == null ) {
nDocTypeAttrCount = 0;
return;
}
String strTemp = docType.PublicId;
if ( strTemp != null ) {
docTypeNodeAttributes[i].name = strPublicID;
docTypeNodeAttributes[i].value = strTemp;
i++;
}
strTemp = docType.SystemId;
if ( strTemp != null ) {
docTypeNodeAttributes[i].name = strSystemID;
docTypeNodeAttributes[i].value = strTemp;
i++;
}
nDocTypeAttrCount = i;
}
public String GetDocumentTypeAttr ( XmlDocumentType docType, String name ) {
//PreCondition: nav is pointing at DocumentType node or one of its virtual attributes
if ( name == strPublicID )
return docType.PublicId;
if ( name == strSystemID )
return docType.SystemId;
return null;
}
public String GetDocumentTypeAttr( int i ) {
if ( nDocTypeAttrCount == -1 )
InitDocTypeAttr();
return docTypeNodeAttributes[i].value;
}
public int GetDocTypeAttrInd( String name ) {
if ( nDocTypeAttrCount == -1 )
InitDocTypeAttr();
for ( int i = 0 ; i < nDocTypeAttrCount; i++ ) {
if ( docTypeNodeAttributes[i].name == name )
return i;
}
return -1;
}
private String GetAttributeFromElement( XmlElement elem, String name ) {
XmlAttribute attr = elem.GetAttributeNode( name );
if ( attr != null )
return attr.Value;
return null;
}
public String GetAttribute( String name ) {
if( this.bCreatedOnAttribute )
return null;
switch ( curNode.NodeType ) {
case XmlNodeType.Element:
return GetAttributeFromElement((XmlElement)curNode, name);
case XmlNodeType.Attribute :
return GetAttributeFromElement((XmlElement)elemNode, name);
case XmlNodeType.XmlDeclaration:
return GetDeclarationAttr( (XmlDeclaration)curNode, name );
case XmlNodeType.DocumentType:
return GetDocumentTypeAttr( (XmlDocumentType)curNode, name );
}
return null;
}
private String GetAttributeFromElement( XmlElement elem, String name, String ns ) {
XmlAttribute attr = elem.GetAttributeNode( name, ns );
if ( attr != null )
return attr.Value;
return null;
}
public String GetAttribute( String name, String ns ) {
if( this.bCreatedOnAttribute )
return null;
switch ( curNode.NodeType ) {
case XmlNodeType.Element:
return GetAttributeFromElement((XmlElement)curNode, name, ns);
case XmlNodeType.Attribute :
return GetAttributeFromElement((XmlElement)elemNode, name, ns);
case XmlNodeType.XmlDeclaration:
return (ns.Length == 0) ? GetDeclarationAttr( (XmlDeclaration)curNode, name ) : null;
case XmlNodeType.DocumentType:
return (ns.Length == 0) ? GetDocumentTypeAttr( (XmlDocumentType)curNode, name ) : null;
}
return null;
}
public String GetAttribute( int attributeIndex ) {
if( this.bCreatedOnAttribute )
return null;
switch ( curNode.NodeType ) {
case XmlNodeType.Element:
CheckIndexCondition( attributeIndex );
return ((XmlElement)curNode).Attributes[attributeIndex].Value;
case XmlNodeType.Attribute :
CheckIndexCondition( attributeIndex );
return ((XmlElement)elemNode).Attributes[attributeIndex].Value;
case XmlNodeType.XmlDeclaration: {
CheckIndexCondition( attributeIndex );
return GetDeclarationAttr( attributeIndex );
}
case XmlNodeType.DocumentType: {
CheckIndexCondition( attributeIndex );
return GetDocumentTypeAttr( attributeIndex );
}
}
throw new ArgumentOutOfRangeException( "attributeIndex" ); //for other senario, AttributeCount is 0, i has to be out of range
}
public void LogMove( int level ) {
logNode = curNode;
nLogLevel = level;
nLogAttrInd = nAttrInd;
logAttrIndex = attrIndex;
this.bLogOnAttrVal = this.bOnAttrVal;
}
//The function has to be used in pair with ResetMove when the operation fails after LogMove() is
// called because it relies on the values of nOrigLevel, logNav and nOrigAttrInd to be acurate.
public void RollBackMove( ref int level ) {
curNode = logNode;
level = nLogLevel;
nAttrInd = nLogAttrInd;
attrIndex = logAttrIndex;
this.bOnAttrVal = this.bLogOnAttrVal;
}
private bool IsOnDeclOrDocType {
get {
XmlNodeType nt = curNode.NodeType;
return ( nt == XmlNodeType.XmlDeclaration || nt == XmlNodeType.DocumentType );
}
}
public void ResetToAttribute( ref int level ) {
//the current cursor is pointing at one of the attribute children -- this could be caused by
// the calls to ReadAttributeValue(..)
if( this.bCreatedOnAttribute )
return;
if ( this.bOnAttrVal ) {
if ( IsOnDeclOrDocType ) {
level-=2;
} else {
while ( curNode.NodeType != XmlNodeType.Attribute && ( ( curNode = curNode.ParentNode ) != null ) )
level-- ;
}
this.bOnAttrVal = false;
}
}
public void ResetMove( ref int level, ref XmlNodeType nt ) {
LogMove( level );
if( this.bCreatedOnAttribute )
return;
if ( nAttrInd != -1 ) {
Debug.Assert( IsOnDeclOrDocType );
if ( this.bOnAttrVal ) {
level--;
this.bOnAttrVal = false;
}
nLogAttrInd = nAttrInd;
level--;
nAttrInd = -1;
nt = curNode.NodeType;
return;
}
if ( this.bOnAttrVal && curNode.NodeType != XmlNodeType.Attribute )
ResetToAttribute( ref level );
if ( curNode.NodeType == XmlNodeType.Attribute ) {
curNode = ((XmlAttribute)curNode).OwnerElement;
attrIndex = -1;
level--;
nt = XmlNodeType.Element;
}
if ( curNode.NodeType == XmlNodeType.Element )
elemNode = curNode;
}
public bool MoveToAttribute( string name ) {
return MoveToAttribute( name, string.Empty );
}
private bool MoveToAttributeFromElement( XmlElement elem, String name, String ns ) {
XmlAttribute attr = null;
if( ns.Length == 0 )
attr = elem.GetAttributeNode( name );
else
attr = elem.GetAttributeNode( name, ns );
if ( attr != null ) {
this.bOnAttrVal = false;
elemNode = elem;
curNode = attr;
attrIndex = elem.Attributes.FindNodeOffsetNS(attr);
if (attrIndex != -1) {
return true;
}
}
return false;
}
public bool MoveToAttribute( string name, string namespaceURI ) {
if( this.bCreatedOnAttribute )
return false;
XmlNodeType nt = curNode.NodeType;
if ( nt == XmlNodeType.Element )
return MoveToAttributeFromElement((XmlElement)curNode, name, namespaceURI );
else if ( nt == XmlNodeType.Attribute )
return MoveToAttributeFromElement((XmlElement)elemNode, name, namespaceURI );
else if ( nt == XmlNodeType.XmlDeclaration && namespaceURI.Length == 0 ) {
if ( ( nAttrInd = GetDecAttrInd( name ) ) != -1 ) {
this.bOnAttrVal = false;
return true;
}
} else if ( nt == XmlNodeType.DocumentType && namespaceURI.Length == 0 ) {
if ( ( nAttrInd = GetDocTypeAttrInd( name ) ) != -1 ) {
this.bOnAttrVal = false;
return true;
}
}
return false;
}
public void MoveToAttribute( int attributeIndex ) {
if( this.bCreatedOnAttribute )
return;
XmlAttribute attr = null;
switch ( curNode.NodeType ) {
case XmlNodeType.Element:
CheckIndexCondition( attributeIndex );
attr = ((XmlElement)curNode).Attributes[attributeIndex];
if ( attr != null ) {
elemNode = curNode;
curNode = (XmlNode) attr;
attrIndex = attributeIndex;
}
break;
case XmlNodeType.Attribute:
CheckIndexCondition( attributeIndex );
attr = ((XmlElement)elemNode).Attributes[attributeIndex];
if ( attr != null ) {
curNode = (XmlNode) attr;
attrIndex = attributeIndex;
}
break;
case XmlNodeType.XmlDeclaration :
case XmlNodeType.DocumentType :
CheckIndexCondition( attributeIndex );
nAttrInd = attributeIndex;
break;
}
}
public bool MoveToNextAttribute( ref int level ) {
if( this.bCreatedOnAttribute )
return false;
XmlNodeType nt = curNode.NodeType;
if ( nt == XmlNodeType.Attribute ) {
if( attrIndex >= ( elemNode.Attributes.Count-1 ) )
return false;
else {
curNode = elemNode.Attributes[++attrIndex];
return true;
}
} else if ( nt == XmlNodeType.Element ) {
if ( curNode.Attributes.Count > 0 ) {
level++;
elemNode = curNode;
curNode = curNode.Attributes[0];
attrIndex = 0;
return true;
}
} else if ( nt == XmlNodeType.XmlDeclaration ) {
if ( nDeclarationAttrCount == -1 )
InitDecAttr();
nAttrInd++;
if ( nAttrInd < nDeclarationAttrCount ) {
if ( nAttrInd == 0 ) level++;
this.bOnAttrVal = false;
return true;
}
nAttrInd--;
} else if ( nt == XmlNodeType.DocumentType ) {
if ( nDocTypeAttrCount == -1 )
InitDocTypeAttr();
nAttrInd++;
if ( nAttrInd < nDocTypeAttrCount ) {
if ( nAttrInd == 0 ) level++;
this.bOnAttrVal = false;
return true;
}
nAttrInd--;
}
return false;
}
public bool MoveToParent() {
XmlNode parent = curNode.ParentNode;
if ( parent != null ) {
curNode = parent;
if( !bOnAttrVal )
attrIndex = 0;
return true;
}
return false;
}
public bool MoveToFirstChild() {
XmlNode firstChild = curNode.FirstChild;
if ( firstChild != null ) {
curNode = firstChild;
if( !bOnAttrVal )
attrIndex = -1;
return true;
}
return false;
}
private bool MoveToNextSibling( XmlNode node ) {
XmlNode nextSibling = node.NextSibling;
if ( nextSibling != null ) {
curNode = nextSibling;
if( !bOnAttrVal )
attrIndex = -1;
return true;
}
return false;
}
public bool MoveToNext() {
if ( curNode.NodeType != XmlNodeType.Attribute )
return MoveToNextSibling( curNode );
else
return MoveToNextSibling( elemNode );
}
public bool MoveToElement() {
if( this.bCreatedOnAttribute )
return false;
switch ( curNode.NodeType ) {
case XmlNodeType.Attribute :
if ( elemNode != null ) {
curNode = elemNode;
attrIndex = -1;
return true;
}
break;
case XmlNodeType.XmlDeclaration :
case XmlNodeType.DocumentType : {
if ( nAttrInd != -1 ) {
nAttrInd = -1;
return true;
}
break;
}
}
return false;
}
public String LookupNamespace(string prefix) {
if( this.bCreatedOnAttribute )
return null;
if ( prefix == "xmlns" ) {
return nameTable.Add( XmlReservedNs.NsXmlNs );
}
if ( prefix == "xml" ) {
return nameTable.Add( XmlReservedNs.NsXml );
}
// construct the name of the xmlns attribute
string attrName;
if ( prefix == null )
prefix = string.Empty;
if ( prefix.Length == 0 )
attrName = "xmlns";
else
attrName = "xmlns:" + prefix;
// walk up the XmlNode parent chain, looking for the xmlns attribute
XmlNode node = curNode;
while ( node != null ) {
if ( node.NodeType == XmlNodeType.Element ) {
XmlElement elem = (XmlElement)node;
if ( elem.HasAttributes ) {
XmlAttribute attr = elem.GetAttributeNode( attrName );
if ( attr != null ) {
return attr.Value;
}
}
}
else if ( node.NodeType == XmlNodeType.Attribute ) {
node = ((XmlAttribute)node).OwnerElement;
continue;
}
node = node.ParentNode;
}
if ( prefix.Length == 0 ) {
return string.Empty;
}
return null;
}
internal string DefaultLookupNamespace( string prefix ) {
if( !this.bCreatedOnAttribute ) {
if ( prefix == "xmlns" ) {
return nameTable.Add( XmlReservedNs.NsXmlNs );
}
if ( prefix == "xml" ) {
return nameTable.Add( XmlReservedNs.NsXml );
}
if ( prefix == string.Empty ) {
return nameTable.Add( string.Empty );
}
}
return null;
}
internal String LookupPrefix(string namespaceName) {
if( this.bCreatedOnAttribute || namespaceName == null ) {
return null;
}
if ( namespaceName == XmlReservedNs.NsXmlNs ) {
return nameTable.Add( "xmlns" );
}
if ( namespaceName == XmlReservedNs.NsXml ) {
return nameTable.Add( "xml" );
}
if ( namespaceName == string.Empty ) {
return string.Empty;
}
// walk up the XmlNode parent chain, looking for the xmlns attribute with namespaceName value
XmlNode node = curNode;
while ( node != null ) {
if ( node.NodeType == XmlNodeType.Element ) {
XmlElement elem = (XmlElement)node;
if ( elem.HasAttributes ) {
XmlAttributeCollection attrs = elem.Attributes;
for ( int i = 0; i < attrs.Count; i++ ) {
XmlAttribute a = attrs[i];
if ( a.Value == namespaceName ) {
if ( a.Prefix.Length == 0 && a.LocalName == "xmlns" ) {
if ( LookupNamespace( string.Empty ) == namespaceName ) {
return string.Empty;
}
}
else if ( a.Prefix == "xmlns" ) {
string pref = a.LocalName;
if ( LookupNamespace( pref ) == namespaceName ) {
return nameTable.Add( pref );
}
}
}
}
}
}
else if ( node.NodeType == XmlNodeType.Attribute ) {
node = ((XmlAttribute)node).OwnerElement;
continue;
}
node = node.ParentNode;
}
return null;
}
internal IDictionary GetNamespacesInScope( XmlNamespaceScope scope ) {
Dictionary dict = new Dictionary();
if( this.bCreatedOnAttribute )
return dict;
// walk up the XmlNode parent chain and add all namespace declarations to the dictionary
XmlNode node = curNode;
while ( node != null ) {
if ( node.NodeType == XmlNodeType.Element ) {
XmlElement elem = (XmlElement)node;
if ( elem.HasAttributes ) {
XmlAttributeCollection attrs = elem.Attributes;
for ( int i = 0; i < attrs.Count; i++ ) {
XmlAttribute a = attrs[i];
if ( a.LocalName == "xmlns" && a.Prefix.Length == 0 ) {
if ( !dict.ContainsKey( string.Empty ) ) {
dict.Add( nameTable.Add( string.Empty ), nameTable.Add( a.Value ) );
}
}
else if ( a.Prefix == "xmlns" ) {
string localName = a.LocalName;
if ( !dict.ContainsKey( localName ) ) {
dict.Add( nameTable.Add( localName ), nameTable.Add( a.Value ) );
}
}
}
}
if ( scope == XmlNamespaceScope.Local ) {
break;
}
}
else if ( node.NodeType == XmlNodeType.Attribute ) {
node = ((XmlAttribute)node).OwnerElement;
continue;
}
node = node.ParentNode;
};
if ( scope != XmlNamespaceScope.Local ) {
if ( dict.ContainsKey( string.Empty ) && dict[string.Empty] == string.Empty ) {
dict.Remove( string.Empty );
}
if ( scope == XmlNamespaceScope.All ) {
dict.Add( nameTable.Add( "xml" ), nameTable.Add( XmlReservedNs.NsXml ) );
}
}
return dict;
}
public bool ReadAttributeValue( ref int level, ref bool bResolveEntity, ref XmlNodeType nt ) {
if ( nAttrInd != -1 ) {
Debug.Assert( curNode.NodeType == XmlNodeType.XmlDeclaration || curNode.NodeType == XmlNodeType.DocumentType );
if ( !this.bOnAttrVal ) {
this.bOnAttrVal = true;
level++;
nt = XmlNodeType.Text;
return true;
}
return false;
}
if( curNode.NodeType == XmlNodeType.Attribute ) {
XmlNode firstChild = curNode.FirstChild;
if ( firstChild != null ) {
curNode = firstChild;
nt = curNode.NodeType;
level++;
this.bOnAttrVal = true;
return true;
}
}
else if ( this.bOnAttrVal ) {
XmlNode nextSibling = null;
if ( curNode.NodeType == XmlNodeType.EntityReference && bResolveEntity ) {
//going down to ent ref node
curNode = curNode.FirstChild;
nt = curNode.NodeType;
Debug.Assert( curNode != null );
level++;
bResolveEntity = false;
return true;
}
else
nextSibling = curNode.NextSibling;
if ( nextSibling == null ) {
XmlNode parentNode = curNode.ParentNode;
//Check if its parent is entity ref node is sufficient, because in this senario, ent ref node can't have more than 1 level of children that are not other ent ref nodes
if ( parentNode != null && parentNode.NodeType == XmlNodeType.EntityReference ) {
//come back from ent ref node
curNode = parentNode;
nt = XmlNodeType.EndEntity;
level--;
return true;
}
}
if ( nextSibling != null ) {
curNode = nextSibling;
nt = curNode.NodeType;
return true;
}
else
return false;
}
return false;
}
}
// Represents a reader that provides fast, non-cached forward only stream access
// to XML data in an XmlDocument or a specific XmlNode within an XmlDocument.
public class XmlNodeReader: XmlReader, IXmlNamespaceResolver
{
XmlNodeReaderNavigator readerNav;
XmlNodeType nodeType; // nodeType of the node that the reader is currently positioned on
int curDepth; // depth of attrNav ( also functions as reader's depth )
ReadState readState; // current reader's state
bool fEOF; // flag to show if reaches the end of file
//mark to the state that EntityReference node is supposed to be resolved
bool bResolveEntity;
bool bStartFromDocument;
bool bInReadBinary;
ReadContentAsBinaryHelper readBinaryHelper;
// Creates an instance of the XmlNodeReader class using the specified XmlNode.
public XmlNodeReader ( XmlNode node ) {
Init( node );
}
private void Init( XmlNode node ) {
readerNav = new XmlNodeReaderNavigator( node );
this.curDepth = 0;
readState = ReadState.Initial;
fEOF = false;
nodeType = XmlNodeType.None;
bResolveEntity = false;
bStartFromDocument = false;
}
//function returns if the reader currently in valid reading states
internal bool IsInReadingStates() {
return ( readState == ReadState.Interactive ); // || readState == ReadState.EndOfFile
}
//
// Node Properties
//
// Gets the type of the current node.
public override XmlNodeType NodeType {
get { return ( IsInReadingStates() )? nodeType : XmlNodeType.None; }
}
// Gets the name of
// the current node, including the namespace prefix.
public override string Name {
get {
if ( !IsInReadingStates() )
return String.Empty;
return readerNav.Name;
}
}
// Gets the name of the current node without the namespace prefix.
public override string LocalName {
get {
if ( !IsInReadingStates() )
return String.Empty;
return readerNav.LocalName;
}
}
// Gets the namespace URN (as defined in the W3C Namespace Specification)
// of the current namespace scope.
public override string NamespaceURI {
get {
if ( !IsInReadingStates() )
return String.Empty;
return readerNav.NamespaceURI;
}
}
// Gets the namespace prefix associated with the current node.
public override string Prefix {
get {
if ( !IsInReadingStates() )
return String.Empty;
return readerNav.Prefix;
}
}
// Gets a value indicating whether
// XmlNodeReader.Value has a value to return.
public override bool HasValue {
get {
if ( !IsInReadingStates() )
return false;
return readerNav.HasValue;
}
}
// Gets the text value of the current node.
public override string Value {
get {
if ( !IsInReadingStates() )
return String.Empty;
return readerNav.Value;
}
}
// Gets the depth of the
// current node in the XML element stack.
public override int Depth {
get { return curDepth; }
}
// Gets the base URI of the current node.
public override String BaseURI {
get { return readerNav.BaseURI; }
}
public override bool CanResolveEntity {
get { return true; }
}
// Gets a value indicating whether the current
// node is an empty element (for example, IXmlNamespaceResolver.GetNamespacesInScope( XmlNamespaceScope scope ) {
return readerNav.GetNamespacesInScope( scope );
}
string IXmlNamespaceResolver.LookupPrefix( string namespaceName ) {
return readerNav.LookupPrefix( namespaceName );
}
String IXmlNamespaceResolver.LookupNamespace( string prefix ) {
if ( !IsInReadingStates() ) {
return readerNav.DefaultLookupNamespace( prefix );
}
string ns = readerNav.LookupNamespace( prefix );
if ( ns != null ) {
ns = readerNav.NameTable.Add( ns );
}
return ns;
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- LocalizeDesigner.cs
- SqlBulkCopyColumnMappingCollection.cs
- TreeView.cs
- NumberAction.cs
- CommandLibraryHelper.cs
- DbDataSourceEnumerator.cs
- MultitargetUtil.cs
- PathSegmentCollection.cs
- ViewEvent.cs
- Soap.cs
- XmlWriterTraceListener.cs
- ElapsedEventArgs.cs
- SafeHandles.cs
- DeviceSpecificChoice.cs
- CacheVirtualItemsEvent.cs
- VisualStyleInformation.cs
- ColorDialog.cs
- WebPartAddingEventArgs.cs
- PageFunction.cs
- TextTreeNode.cs
- EventLogPermissionAttribute.cs
- PerspectiveCamera.cs
- namescope.cs
- DiscriminatorMap.cs
- BindingContext.cs
- CountAggregationOperator.cs
- RuntimeArgumentHandle.cs
- DrawingBrush.cs
- ObjectDataSourceFilteringEventArgs.cs
- RuntimeEnvironment.cs
- HtmlShimManager.cs
- ProvidersHelper.cs
- GeneralTransformGroup.cs
- NameValueSectionHandler.cs
- UIAgentCrashedException.cs
- Atom10FormatterFactory.cs
- DoubleKeyFrameCollection.cs
- OleStrCAMarshaler.cs
- ActivationServices.cs
- ListViewSortEventArgs.cs
- XmlNullResolver.cs
- WinFormsSecurity.cs
- DirectoryObjectSecurity.cs
- FlatButtonAppearance.cs
- EnumMemberAttribute.cs
- XmlAttributes.cs
- HeaderCollection.cs
- WsdlInspector.cs
- CaseInsensitiveOrdinalStringComparer.cs
- DataSourceConverter.cs
- QueryStringParameter.cs
- CacheDependency.cs
- AlternateViewCollection.cs
- HtmlElement.cs
- COSERVERINFO.cs
- IndentedWriter.cs
- DrawingGroup.cs
- MasterPageBuildProvider.cs
- TypeSystem.cs
- DiscoveryDocumentSerializer.cs
- ScrollProviderWrapper.cs
- ProxyManager.cs
- LinqDataSourceStatusEventArgs.cs
- IInstanceContextProvider.cs
- GrammarBuilderDictation.cs
- BitmapScalingModeValidation.cs
- XmlSchemaSimpleTypeList.cs
- HostingPreferredMapPath.cs
- Emitter.cs
- RepeaterItemCollection.cs
- StorageAssociationSetMapping.cs
- StylusPointPropertyUnit.cs
- ContextProperty.cs
- Triangle.cs
- UserControlDocumentDesigner.cs
- RawStylusInput.cs
- EditorZoneAutoFormat.cs
- DataTableCollection.cs
- Calendar.cs
- Pointer.cs
- SessionStateContainer.cs
- DropDownButton.cs
- ParseNumbers.cs
- Calendar.cs
- AtlasWeb.Designer.cs
- Point3DKeyFrameCollection.cs
- ListParagraph.cs
- NonPrimarySelectionGlyph.cs
- PrefixQName.cs
- ComponentSerializationService.cs
- XmlIlGenerator.cs
- DateTimeOffset.cs
- Visual.cs
- SafeSecurityHandles.cs
- SortedList.cs
- ExecutionEngineException.cs
- MimeWriter.cs
- PasswordTextNavigator.cs
- DoubleKeyFrameCollection.cs
- RegexWriter.cs