private int GetAttributeIndexWithoutPrefix(string name) { name = this.coreReaderNameTable.Get(name); if (name != null) { for (int i = 0; i < this.attributeCount; i++) { ValidatingReaderNodeData data = this.attributeEvents[i]; if (Ref.Equal(data.LocalName, name) && (data.Prefix.Length == 0)) { return(i); } } } return(-1); }
private int GetAttributeIndexWithPrefix(string name) { name = this.coreReaderNameTable.Get(name); if (name != null) { for (int i = 0; i < this.attributeCount; i++) { ValidatingReaderNodeData data = this.attributeEvents[i]; if (Ref.Equal(data.GetAtomizedNameWPrefix(this.coreReaderNameTable), name)) { return(i); } } } return(-1); }
/// <include file='doc\XmlNamespaceManager.uex' path='docs/doc[@for="XmlNamespaceManager.HasNamespace"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public virtual bool HasNamespace(string prefix) { if (prefix == null) { return(false); } for (int declIndex = decls.Length - 1; declIndex >= decls.Length - count; declIndex--) { NsDecl decl = (NsDecl)decls[declIndex]; if (Ref.Equal(decl.Prefix, prefix) && decl.Uri != null) { return(true); } } return(false); }
// Gets the value of the attribute with the specified LocalName and NamespaceURI. public override string GetAttribute(string name, string namespaceURI) { namespaceURI = (namespaceURI == null) ? string.Empty : coreReaderNameTable.Get(namespaceURI); name = coreReaderNameTable.Get(name); ValidatingReaderNodeData attribute; for (int i = 0; i < attributeCount; i++) { attribute = attributeEvents[i]; if (Ref.Equal(attribute.LocalName, name) && Ref.Equal(attribute.Namespace, namespaceURI)) { return(attribute.RawValue); } } return(null); }
public override bool MoveToAttribute(string name, string ns) { ns = (ns == null) ? string.Empty : this.coreReaderNameTable.Get(ns); name = this.coreReaderNameTable.Get(name); for (int i = 0; i < this.attributeCount; i++) { ValidatingReaderNodeData data = this.attributeEvents[i]; if (Ref.Equal(data.LocalName, name) && Ref.Equal(data.Namespace, ns)) { this.currentAttrIndex = i; this.cachedNode = this.attributeEvents[i]; return(true); } } return(false); }
private void RemoveNamespace(string prefix, string localName) { for (int i = 0; i < this.nsAttrCount; i++) { if (Ref.Equal(prefix, this.nsAttributes[i].prefix) && Ref.Equal(localName, this.nsAttributes[i].localName)) { if (i < (this.nsAttrCount - 1)) { NodeData data = this.nsAttributes[i]; this.nsAttributes[i] = this.nsAttributes[this.nsAttrCount - 1]; this.nsAttributes[this.nsAttrCount - 1] = data; } this.nsAttrCount--; return; } } }
private void ValidateSingleElement(XmlElement elementNode, bool skipToEnd, XmlSchemaInfo newSchemaInfo) { _nsManager.PushScope(); Debug.Assert(elementNode != null); XmlAttributeCollection attributes = elementNode.Attributes; XmlAttribute attr = null; //Find Xsi attributes that need to be processed before validating the element string xsiNil = null; string xsiType = null; for (int i = 0; i < attributes.Count; i++) { attr = attributes[i]; string objectNs = attr.NamespaceURI; string objectName = attr.LocalName; Debug.Assert(_nameTable.Get(attr.NamespaceURI) != null); Debug.Assert(_nameTable.Get(attr.LocalName) != null); if (Ref.Equal(objectNs, _nsXsi)) { if (Ref.Equal(objectName, _xsiType)) { xsiType = attr.Value; } else if (Ref.Equal(objectName, _xsiNil)) { xsiNil = attr.Value; } } else if (Ref.Equal(objectNs, _nsXmlNs)) { _nsManager.AddNamespace(attr.Prefix.Length == 0 ? string.Empty : attr.LocalName, attr.Value); } } _validator.ValidateElement(elementNode.LocalName, elementNode.NamespaceURI, newSchemaInfo, xsiType, xsiNil, null, null); //Validate end of element if (skipToEnd) { _validator.ValidateEndOfAttributes(newSchemaInfo); _validator.SkipToEndElement(newSchemaInfo); _nsManager.PopScope(); //Pop current namespace scope } }
private bool IsMatch(XmlNode curNode) { if (curNode.NodeType == XmlNodeType.Element) { if (this.name != null) { if (Ref.Equal(this.name, this.asterisk) || Ref.Equal(curNode.Name, this.name)) { return(true); } } else if ((Ref.Equal(this.localName, this.asterisk) || Ref.Equal(curNode.LocalName, this.localName)) && (Ref.Equal(this.namespaceURI, this.asterisk) || (curNode.NamespaceURI == this.namespaceURI))) { return(true); } } return(false); }
/// <include file='doc\XmlNamespaceManager.uex' path='docs/doc[@for="XmlNamespaceManager.AddNamespace"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public virtual void AddNamespace(string prefix, string uri) { if (uri == null) { throw new ArgumentNullException("uri"); } if (prefix == null) { throw new ArgumentNullException("prefix"); } prefix = nameTable.Add(prefix); uri = nameTable.Add(uri); if (Ref.Equal(xml, prefix) || Ref.Equal(xmlNs, prefix)) { throw new ArgumentException(Res.GetString(Res.Xml_InvalidPrefix)); } for (int declIndex = decls.Length - 1; declIndex >= decls.Length - count; declIndex--) { NsDecl decl = (NsDecl)decls[declIndex]; if (Ref.Equal(decl.Prefix, prefix)) { decl.Uri = uri; return; // redefine } } /* else */ { NsDecl decl = (NsDecl)decls.Push(); if (decl == null) { decl = new NsDecl(); decls.AddToTop(decl); } decl.Prefix = prefix; decl.Uri = uri; count++; if (prefix == string.Empty) { defaultNs = decl; } } }
private void RemoveNamespace(string prefix, string localName) { for (int i = 0; i < nsAttrCount; i++) { if (Ref.Equal(prefix, nsAttributes[i].prefix) && Ref.Equal(localName, nsAttributes[i].localName)) { if (i < nsAttrCount - 1) { // swap NodeData tmpNodeData = nsAttributes[i]; nsAttributes[i] = nsAttributes[nsAttrCount - 1]; nsAttributes[nsAttrCount - 1] = tmpNodeData; } nsAttrCount--; break; } } }
// Moves to the attribute with the specified LocalName and NamespaceURI public override bool MoveToAttribute(string name, string ns) { ns = (ns == null) ? string.Empty : _coreReaderNameTable.Get(ns); name = _coreReaderNameTable.Get(name); ValidatingReaderNodeData attribute; for (int i = 0; i < _attributeCount; i++) { attribute = _attributeEvents[i]; if (Ref.Equal(attribute.LocalName, name) && Ref.Equal(attribute.Namespace, ns)) { _currentAttrIndex = i; _cachedNode = _attributeEvents[i]; return(true); } } return(false); }
private int GetAttributeIndexWithoutPrefix(string name) { name = _coreReaderNameTable.Get(name); if (name == null) { return(-1); } ValidatingReaderNodeData attribute; for (int i = 0; i < _attributeCount; i++) { attribute = _attributeEvents[i]; if (Ref.Equal(attribute.LocalName, name) && attribute.Prefix.Length == 0) { return(i); } } return(-1); }
// Reads to the first descendant of the current element with the given Name. public virtual bool ReadToDescendant(string name) { if (name == null || name.Length == 0) { throw new ArgumentException(name, "name"); } // save the element or root depth int parentDepth = Depth; if (NodeType != XmlNodeType.Element) { // adjust the depth if we are on root node if (ReadState == ReadState.Initial) { Debug.Assert(parentDepth == 0); parentDepth--; } else { return(false); } } else if (IsEmptyElement) { return(false); } // atomize name name = NameTable.Add(name); // find the descendant while (Read() && Depth > parentDepth) { if (NodeType == XmlNodeType.Element && Ref.Equal(name, Name)) { return(true); } } Debug.Assert(NodeType == XmlNodeType.EndElement || (parentDepth == -1 && ReadState == ReadState.EndOfFile)); return(false); }
private int GetAttributeIndexWithPrefix(string name) { name = _coreReaderNameTable.Get(name); if (name == null) { return(-1); } ValidatingReaderNodeData attribute; for (int i = 0; i < _attributeCount; i++) { attribute = _attributeEvents[i]; if (Ref.Equal(attribute.GetAtomizedNameWPrefix(_coreReaderNameTable), name)) { return(i); } } return(-1); }
public virtual bool ReadToNextSibling(string name) { if (name == null || name.Length == 0) { throw XmlExceptionHelper.CreateInvalidNameArgumentException(name, nameof(name)); } name = this.NameTable.Add(name); XmlNodeType nodeType; do { this.SkipSubtree(); nodeType = this.NodeType; if (nodeType == XmlNodeType.Element && Ref.Equal(name, this.Name)) { return(true); } }while (nodeType != XmlNodeType.EndElement && !this.EOF); return(false); }
// Reads to the following element with the given Name. public virtual bool ReadToFollowing(string name) { if (name == null || name.Length == 0) { throw XmlExceptionHelper.CreateInvalidNameArgumentException(name, "name"); } // atomize name name = NameTable.Add(name); // find following element with that name while (Read()) { if (NodeType == XmlNodeType.Element && Ref.Equal(name, Name)) { return(true); } } return(false); }
public virtual bool ReadToFollowing(string localName, string namespaceURI) { if (localName == null || localName.Length == 0) { throw XmlExceptionHelper.CreateInvalidNameArgumentException(localName, nameof(localName)); } if (namespaceURI == null) { throw new ArgumentNullException(nameof(namespaceURI)); } localName = this.NameTable.Add(localName); namespaceURI = this.NameTable.Add(namespaceURI); while (this.Read()) { if (this.NodeType == XmlNodeType.Element && Ref.Equal(localName, this.LocalName) && Ref.Equal(namespaceURI, this.NamespaceURI)) { return(true); } } return(false); }
private void ValidateSingleElement(XmlElement elementNode, bool skipToEnd, XmlSchemaInfo newSchemaInfo) { this.nsManager.PushScope(); XmlAttributeCollection attributes = elementNode.Attributes; XmlAttribute attribute = null; string xsiNil = null; string xsiType = null; for (int i = 0; i < attributes.Count; i++) { attribute = attributes[i]; string namespaceURI = attribute.NamespaceURI; string localName = attribute.LocalName; if (Ref.Equal(namespaceURI, this.NsXsi)) { if (Ref.Equal(localName, this.XsiType)) { xsiType = attribute.Value; } else if (Ref.Equal(localName, this.XsiNil)) { xsiNil = attribute.Value; } } else if (Ref.Equal(namespaceURI, this.NsXmlNs)) { this.nsManager.AddNamespace((attribute.Prefix.Length == 0) ? string.Empty : attribute.LocalName, attribute.Value); } } this.validator.ValidateElement(elementNode.LocalName, elementNode.NamespaceURI, newSchemaInfo, xsiType, xsiNil, null, null); if (skipToEnd) { this.validator.ValidateEndOfAttributes(newSchemaInfo); this.validator.SkipToEndElement(newSchemaInfo); this.nsManager.PopScope(); } }
/// <include file='doc\XmlNamespaceManager.uex' path='docs/doc[@for="XmlNamespaceManager.RemoveNamespace"]/*' /> /// <devdoc> /// <para>[To be supplied.]</para> /// </devdoc> public virtual void RemoveNamespace(string prefix, string uri) { if (uri == null) { throw new ArgumentNullException("uri"); } if (prefix == null) { throw new ArgumentNullException("prefix"); } prefix = nameTable.Get(prefix); uri = nameTable.Get(uri); if (prefix != null && uri != null) { for (int declIndex = decls.Length - 1; declIndex >= decls.Length - count; declIndex--) { NsDecl decl = (NsDecl)decls[declIndex]; if (Ref.Equal(decl.Prefix, prefix) && Ref.Equal(decl.Uri, uri)) { decl.Uri = null; } } } }
// if the current node a matching element node private bool IsMatch(XmlNode curNode) { if (curNode.NodeType == XmlNodeType.Element) { if (_name != null) { if (Ref.Equal(_name, _asterisk) || Ref.Equal(curNode.Name, _name)) { return(true); } } else { if ( (Ref.Equal(_localName, _asterisk) || Ref.Equal(curNode.LocalName, _localName)) && (Ref.Equal(_namespaceURI, _asterisk) || curNode.NamespaceURI == _namespaceURI) ) { return(true); } } } return(false); }
// Reads to the next sibling of the current element with the given Name. public virtual bool ReadToNextSibling(string name) { if (name == null || name.Length == 0) { throw XmlExceptionHelper.CreateInvalidNameArgumentException(name, "name"); } // atomize name name = NameTable.Add(name); // find the next sibling XmlNodeType nt; do { SkipSubtree(); nt = NodeType; if (nt == XmlNodeType.Element && Ref.Equal(name, Name)) { return(true); } } while (nt != XmlNodeType.EndElement && !EOF); return(false); }
public virtual void AddNamespace(string prefix, string uri) { if (uri == null) { throw new ArgumentNullException(nameof(uri)); } if (prefix == null) { throw new ArgumentNullException(nameof(prefix)); } prefix = _nameTable.Add(prefix); uri = _nameTable.Add(uri); if ((Ref.Equal(_xml, prefix) && !uri.Equals(XmlReservedNs.NsXml))) { throw new ArgumentException(SR.Xml_XmlPrefix); } if (Ref.Equal(_xmlNs, prefix)) { throw new ArgumentException(SR.Xml_XmlnsPrefix); } int declIndex = LookupNamespaceDecl(prefix); int previousDeclIndex = -1; if (declIndex != -1) { if (_nsdecls[declIndex].scopeId == _scopeId) { // redefine if in the same scope _nsdecls[declIndex].uri = uri; return; } else { // othewise link previousDeclIndex = declIndex; } } // set new namespace declaration if (_lastDecl == _nsdecls.Length - 1) { NamespaceDeclaration[] newNsdecls = new NamespaceDeclaration[_nsdecls.Length * 2]; Array.Copy(_nsdecls, 0, newNsdecls, 0, _nsdecls.Length); _nsdecls = newNsdecls; } _nsdecls[++_lastDecl].Set(prefix, uri, _scopeId, previousDeclIndex); // add to hashTable if (_useHashtable) { _hashTable[prefix] = _lastDecl; } // or create a new hashTable if the threashold has been reached else if (_lastDecl >= MinDeclsCountForHashtable) { // add all to hash table Debug.Assert(_hashTable == null); _hashTable = new Dictionary <string, int>(_lastDecl); for (int i = 0; i <= _lastDecl; i++) { _hashTable[_nsdecls[i].prefix] = i; } _useHashtable = true; } }
private async Task ProcessElementEventAsync() { if (_processInlineSchema && IsXSDRoot(_coreReader.LocalName, _coreReader.NamespaceURI) && _coreReader.Depth > 0) { _xmlSchemaInfo.Clear(); _attributeCount = _coreReaderAttributeCount = _coreReader.AttributeCount; if (!_coreReader.IsEmptyElement) { // If its not empty schema, then parse else ignore _inlineSchemaParser = new Parser(SchemaType.XSD, _coreReaderNameTable, _validator.SchemaSet.GetSchemaNames(_coreReaderNameTable), _validationEvent); await _inlineSchemaParser.StartParsingAsync(_coreReader, null).ConfigureAwait(false); _inlineSchemaParser.ParseReaderNode(); _validationState = ValidatingReaderState.ParseInlineSchema; } else { _validationState = ValidatingReaderState.ClearAttributes; } } else { // Validate element // Clear previous data _atomicValue = null; _originalAtomicValueString = null; _xmlSchemaInfo.Clear(); if (_manageNamespaces) { Debug.Assert(_nsManager != null); _nsManager.PushScope(); } // Find Xsi attributes that need to be processed before validating the element string?xsiSchemaLocation = null; string?xsiNoNamespaceSL = null; string?xsiNil = null; string?xsiType = null; if (_coreReader.MoveToFirstAttribute()) { do { string objectNs = _coreReader.NamespaceURI; string objectName = _coreReader.LocalName; if (Ref.Equal(objectNs, _nsXsi)) { if (Ref.Equal(objectName, _xsiSchemaLocation)) { xsiSchemaLocation = _coreReader.Value; } else if (Ref.Equal(objectName, _xsiNoNamespaceSchemaLocation)) { xsiNoNamespaceSL = _coreReader.Value; } else if (Ref.Equal(objectName, _xsiType)) { xsiType = _coreReader.Value; } else if (Ref.Equal(objectName, _xsiNil)) { xsiNil = _coreReader.Value; } } if (_manageNamespaces && Ref.Equal(_coreReader.NamespaceURI, _nsXmlNs)) { Debug.Assert(_nsManager != null); _nsManager.AddNamespace(_coreReader.Prefix.Length == 0 ? string.Empty : _coreReader.LocalName, _coreReader.Value); } } while (_coreReader.MoveToNextAttribute()); _coreReader.MoveToElement(); } _validator.ValidateElement(_coreReader.LocalName, _coreReader.NamespaceURI, _xmlSchemaInfo, xsiType, xsiNil, xsiSchemaLocation, xsiNoNamespaceSL); ValidateAttributes(); _validator.ValidateEndOfAttributes(_xmlSchemaInfo); if (_coreReader.IsEmptyElement) { await ProcessEndElementEventAsync().ConfigureAwait(false); } _validationState = ValidatingReaderState.ClearAttributes; } }
internal string GetPrefixOfNamespaceStrict(string namespaceURI) { XmlDocument doc = Document; if (doc != null) { namespaceURI = doc.NameTable.Add(namespaceURI); XmlNode node = this; while (node != null) { if (node.NodeType == XmlNodeType.Element) { XmlElement elem = (XmlElement)node; if (elem.HasAttributes) { XmlAttributeCollection attrs = elem.Attributes; for (int iAttr = 0; iAttr < attrs.Count; iAttr++) { XmlAttribute attr = attrs[iAttr]; if (attr.Prefix.Length == 0) { if (Ref.Equal(attr.LocalName, doc.strXmlns)) { if (attr.Value == namespaceURI) { return(string.Empty); // found xmlns="namespaceURI" } } } else if (Ref.Equal(attr.Prefix, doc.strXmlns)) { if (attr.Value == namespaceURI) { return(attr.LocalName); // found xmlns:prefix="namespaceURI" } } else if (Ref.Equal(attr.NamespaceURI, namespaceURI)) { return(attr.Prefix); // found prefix:attr // with prefix bound to namespaceURI } } } if (Ref.Equal(node.NamespaceURI, namespaceURI)) { return(node.Prefix); } node = node.ParentNode; } else if (node.NodeType == XmlNodeType.Attribute) { node = ((XmlAttribute)node).OwnerElement; } else { node = node.ParentNode; } } if (Ref.Equal(doc.strReservedXml, namespaceURI)) { // xmlns:xml return(doc.strXml); } else if (Ref.Equal(doc.strReservedXmlns, namespaceURI)) { // xmlns:xmlns return(doc.strXmlns); } } return(null); }
internal string GetNamespaceOfPrefixStrict(string prefix) { XmlDocument doc = Document; if (doc != null) { prefix = doc.NameTable.Get(prefix); if (prefix == null) { return(null); } XmlNode node = this; while (node != null) { if (node.NodeType == XmlNodeType.Element) { XmlElement elem = (XmlElement)node; if (elem.HasAttributes) { XmlAttributeCollection attrs = elem.Attributes; if (prefix.Length == 0) { for (int iAttr = 0; iAttr < attrs.Count; iAttr++) { XmlAttribute attr = attrs[iAttr]; if (attr.Prefix.Length == 0) { if (Ref.Equal(attr.LocalName, doc.strXmlns)) { return(attr.Value); // found xmlns } } } } else { for (int iAttr = 0; iAttr < attrs.Count; iAttr++) { XmlAttribute attr = attrs[iAttr]; if (Ref.Equal(attr.Prefix, doc.strXmlns)) { if (Ref.Equal(attr.LocalName, prefix)) { return(attr.Value); // found xmlns:prefix } } else if (Ref.Equal(attr.Prefix, prefix)) { return(attr.NamespaceURI); // found prefix:attr } } } } if (Ref.Equal(node.Prefix, prefix)) { return(node.NamespaceURI); } node = node.ParentNode; } else if (node.NodeType == XmlNodeType.Attribute) { node = ((XmlAttribute)node).OwnerElement; } else { node = node.ParentNode; } } if (Ref.Equal(doc.strXml, prefix)) { // xmlns:xml return(doc.strReservedXml); } else if (Ref.Equal(doc.strXmlns, prefix)) { // xmlns:xmlns return(doc.strReservedXmlns); } } return(null); }
public IDictionary <string, string> GetNamespacesInScope(XmlNamespaceScope scope) { IDictionary <string, string> namespacesInScope = this.nsManager.GetNamespacesInScope(scope); if (scope != XmlNamespaceScope.Local) { XmlNode startNode = this.startNode; while (startNode != null) { XmlAttributeCollection attributes; int num; XmlAttribute attribute; switch (startNode.NodeType) { case XmlNodeType.Element: { XmlElement element = (XmlElement)startNode; if (!element.HasAttributes) { goto Label_00E4; } attributes = element.Attributes; num = 0; goto Label_00D7; } case XmlNodeType.Attribute: { startNode = ((XmlAttribute)startNode).OwnerElement; continue; } default: goto Label_00FB; } Label_005C: attribute = attributes[num]; if (Ref.Equal(attribute.NamespaceURI, this.document.strReservedXmlns)) { if (attribute.Prefix.Length == 0) { if (!namespacesInScope.ContainsKey(string.Empty)) { namespacesInScope.Add(string.Empty, attribute.Value); } } else if (!namespacesInScope.ContainsKey(attribute.LocalName)) { namespacesInScope.Add(attribute.LocalName, attribute.Value); } } num++; Label_00D7: if (num < attributes.Count) { goto Label_005C; } Label_00E4: startNode = startNode.ParentNode; continue; Label_00FB: startNode = startNode.ParentNode; } } return(namespacesInScope); }
internal string GetPrefixOfNamespaceStrict(string namespaceURI) { XmlDocument document = this.Document; if (document != null) { namespaceURI = document.NameTable.Add(namespaceURI); XmlNode parentNode = this; while (parentNode != null) { if (parentNode.NodeType == XmlNodeType.Element) { XmlElement element = (XmlElement)parentNode; if (element.HasAttributes) { XmlAttributeCollection attributes = element.Attributes; for (int i = 0; i < attributes.Count; i++) { XmlAttribute attribute = attributes[i]; if (attribute.Prefix.Length == 0) { if (Ref.Equal(attribute.LocalName, document.strXmlns) && (attribute.Value == namespaceURI)) { return(string.Empty); } } else if (Ref.Equal(attribute.Prefix, document.strXmlns)) { if (attribute.Value == namespaceURI) { return(attribute.LocalName); } } else if (Ref.Equal(attribute.NamespaceURI, namespaceURI)) { return(attribute.Prefix); } } } if (Ref.Equal(parentNode.NamespaceURI, namespaceURI)) { return(parentNode.Prefix); } parentNode = parentNode.ParentNode; } else if (parentNode.NodeType == XmlNodeType.Attribute) { parentNode = ((XmlAttribute)parentNode).OwnerElement; } else { parentNode = parentNode.ParentNode; } } if (Ref.Equal(document.strReservedXml, namespaceURI)) { return(document.strXml); } if (Ref.Equal(document.strReservedXmlns, namespaceURI)) { return(document.strXmlns); } } return(null); }
internal string GetNamespaceOfPrefixStrict(string prefix) { XmlDocument document = this.Document; if (document != null) { prefix = document.NameTable.Get(prefix); if (prefix == null) { return(null); } XmlNode parentNode = this; while (parentNode != null) { if (parentNode.NodeType == XmlNodeType.Element) { XmlElement element = (XmlElement)parentNode; if (element.HasAttributes) { XmlAttributeCollection attributes = element.Attributes; if (prefix.Length == 0) { for (int i = 0; i < attributes.Count; i++) { XmlAttribute attribute = attributes[i]; if ((attribute.Prefix.Length == 0) && Ref.Equal(attribute.LocalName, document.strXmlns)) { return(attribute.Value); } } } else { for (int j = 0; j < attributes.Count; j++) { XmlAttribute attribute2 = attributes[j]; if (Ref.Equal(attribute2.Prefix, document.strXmlns)) { if (Ref.Equal(attribute2.LocalName, prefix)) { return(attribute2.Value); } } else if (Ref.Equal(attribute2.Prefix, prefix)) { return(attribute2.NamespaceURI); } } } } if (Ref.Equal(parentNode.Prefix, prefix)) { return(parentNode.NamespaceURI); } parentNode = parentNode.ParentNode; } else if (parentNode.NodeType == XmlNodeType.Attribute) { parentNode = ((XmlAttribute)parentNode).OwnerElement; } else { parentNode = parentNode.ParentNode; } } if (Ref.Equal(document.strXml, prefix)) { return(document.strReservedXml); } if (Ref.Equal(document.strXmlns, prefix)) { return(document.strReservedXmlns); } } return(null); }
protected override bool Match(XmlNode node) { return(Ref.Equal(node.LocalName, this.localNameAtom) && Ref.Equal(node.NamespaceURI, this.nsAtom)); }
private void ValidateElement() { _nsManager.PushScope(); XmlElement elementNode = _currentNode as XmlElement; Debug.Assert(elementNode != null); XmlAttributeCollection attributes = elementNode.Attributes; XmlAttribute attr = null; //Find Xsi attributes that need to be processed before validating the element string xsiNil = null; string xsiType = null; for (int i = 0; i < attributes.Count; i++) { attr = attributes[i]; string objectNs = attr.NamespaceURI; string objectName = attr.LocalName; Debug.Assert(_nameTable.Get(attr.NamespaceURI) != null); Debug.Assert(_nameTable.Get(attr.LocalName) != null); if (Ref.Equal(objectNs, _nsXsi)) { if (Ref.Equal(objectName, _xsiType)) { xsiType = attr.Value; } else if (Ref.Equal(objectName, _xsiNil)) { xsiNil = attr.Value; } } else if (Ref.Equal(objectNs, _nsXmlNs)) { _nsManager.AddNamespace(attr.Prefix.Length == 0 ? string.Empty : attr.LocalName, attr.Value); } } _validator.ValidateElement(elementNode.LocalName, elementNode.NamespaceURI, _schemaInfo, xsiType, xsiNil, null, null); ValidateAttributes(elementNode); _validator.ValidateEndOfAttributes(_schemaInfo); //If element has children, drill down for (XmlNode child = elementNode.FirstChild; child != null; child = child.NextSibling) { ValidateNode(child); } //Validate end of element _currentNode = elementNode; //Reset current Node for validation call back _validator.ValidateEndElement(_schemaInfo); //Get XmlName, as memberType / validity might be set now if (_psviAugmentation) { elementNode.XmlName = _document.AddXmlName(elementNode.Prefix, elementNode.LocalName, elementNode.NamespaceURI, _schemaInfo); if (_schemaInfo.IsDefault) { //the element has a default value XmlText textNode = _document.CreateTextNode(_schemaInfo.SchemaElement.ElementDecl.DefaultValueRaw); elementNode.AppendChild(textNode); } } _nsManager.PopScope(); //Pop current namespace scope }