public static XmlNode CreateNode(XmlNodeType type, string name) { XmlDocument document = new XmlDocument(); XmlNode node = document.CreateNode(type, name, null); return node; }
public override void Close() { this.nav = XmlEmptyNavigator.Singleton; this.nodeType = XmlNodeType.None; this.state = State.Closed; this.depth = 0; }
public XmlValidatingReader( Stream xmlFragment, XmlNodeType fragType, XmlParserContext context ) { if (xmlFragment == null) { throw new ArgumentNullException("xmlFragment"); } impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context); impl.OuterReader = this; }
public void AdvanceNode(XmlNodeType xmlNodeType) { AdvanceNode(); if (m_xmlReader.NodeType != xmlNodeType) throw new Exception("The expected node is " + xmlNodeType); }
/// <summary> /// Initializes a new instance of the OpenXmlMiscNode class using the /// supplied XmlNodeType and outer XML values. /// </summary> /// <param name="nodeType">The XmlNodeType value.</param> /// <param name="outerXml">The outer XML of the element.</param> public OpenXmlMiscNode(XmlNodeType nodeType, string outerXml) : this(nodeType) { if ( String.IsNullOrEmpty( outerXml ) ) { throw new ArgumentNullException("outerXml"); } // check the out XML match the nodeType using (StringReader stringReader = new StringReader(outerXml)) { XmlReaderSettings settings = new XmlReaderSettings(); settings.DtdProcessing = DtdProcessing.Prohibit; // set true explicitly for serucity fix using (XmlReader xmlReader = XmlConvertingReaderFactory.Create(stringReader, settings)) { xmlReader.Read(); if (xmlReader.NodeType != nodeType) { throw new ArgumentException(ExceptionMessages.InvalidOuterXmlForMiscNode); } xmlReader.Close(); } } this.RawOuterXml = outerXml; }
public static object LoadXml(string fragment, XmlNodeType xmlNodeType, object target, string filename) { XamlParser parser = new XamlParser(); parser._filename = filename; return parser.Read(fragment, xmlNodeType, target); }
void AssertNode (int depth, string localName, XmlNodeType nodeType, string value, string type, XmlDictionaryReader reader, string label) { Assert.AreEqual (localName, reader.LocalName, label + ".LocalName"); Assert.AreEqual (nodeType, reader.NodeType, label + ".NodeType"); Assert.AreEqual (value, reader.Value, label + ".Value"); Assert.AreEqual (type, reader.GetAttribute ("type"), label + ".GetAttribute('type')"); }
private static void VerifyOwnerOfGivenType(XmlNodeType nodeType) { var xmlDocument = new XmlDocument(); var node = xmlDocument.CreateNode(nodeType, "test", string.Empty); Assert.Equal(xmlDocument, node.OwnerDocument); }
private void AssertNodeValues ( XmlReader xmlReader, XmlNodeType nodeType, int depth, bool isEmptyElement, string name, string prefix, string localName, string namespaceURI, string value, int attributeCount) { Assert.AreEqual (nodeType, xmlReader.NodeType, "NodeType"); Assert.AreEqual (depth, xmlReader.Depth, "Depth"); Assert.AreEqual (isEmptyElement, xmlReader.IsEmptyElement, "IsEmptyElement"); Assert.AreEqual (name, xmlReader.Name, "name"); Assert.AreEqual (prefix, xmlReader.Prefix, "prefix"); Assert.AreEqual (localName, xmlReader.LocalName, "localName"); Assert.AreEqual (namespaceURI, xmlReader.NamespaceURI, "namespaceURI"); Assert.AreEqual ((value != String.Empty), xmlReader.HasValue, "hasValue"); Assert.AreEqual (value, xmlReader.Value, "Value"); Assert.AreEqual (attributeCount > 0, xmlReader.HasAttributes, "hasAttributes"); Assert.AreEqual (attributeCount, xmlReader.AttributeCount, "attributeCount"); }
/// <summary> /// Constructor /// </summary> /// <param name="value">innerText for this node</param> /// <param name="nodeType">type of node</param> internal XmlDiffViewCharData( string value, XmlNodeType nodeType) : base(nodeType) { this.InnerText = value; }
/// <summary> /// Consumes nodes from the reader until the first ocurance of the XmlNodeType identified within types. /// </summary> /// <param name="reader">The reader from which to consume Xml nodes</param> /// <param name="types">The XmlNodeType types of interest which will halt consumption</param> public static void ConsumeUntilFirst(this XmlReader reader, XmlNodeType[] types) { while (Array.IndexOf(types, reader.NodeType) < 0) { reader.Read(); } }
internal override bool IsValidChildType(XmlNodeType type) { switch (type) { case XmlNodeType.Element: case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.EntityReference: case XmlNodeType.ProcessingInstruction: case XmlNodeType.Comment: case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: return true; case XmlNodeType.XmlDeclaration: { XmlNode firstChild = this.FirstChild; if ((firstChild != null) && (firstChild.NodeType == XmlNodeType.XmlDeclaration)) { return false; } return true; } } return false; }
private void AssertNodeValues ( XmlReader xmlReader, XmlNodeType nodeType, int depth, bool isEmptyElement, string name, string prefix, string localName, string namespaceURI, string value, int attributeCount) { AssertEquals ("NodeType", nodeType, xmlReader.NodeType); AssertEquals ("Depth", depth, xmlReader.Depth); AssertEquals ("IsEmptyElement", isEmptyElement, xmlReader.IsEmptyElement); AssertEquals ("name", name, xmlReader.Name); AssertEquals ("prefix", prefix, xmlReader.Prefix); AssertEquals ("localName", localName, xmlReader.LocalName); AssertEquals ("namespaceURI", namespaceURI, xmlReader.NamespaceURI); AssertEquals ("hasValue", (value != String.Empty), xmlReader.HasValue); AssertEquals ("Value", value, xmlReader.Value); AssertEquals ("hasAttributes", attributeCount > 0, xmlReader.HasAttributes); AssertEquals ("attributeCount", attributeCount, xmlReader.AttributeCount); }
public ParserNode(string name, string value, XmlNodeType nodeType) { Name = name; Value = value; NodeType = nodeType; Attributes = new Dictionary<string, string>(); }
private static void TwoTextNodeBase(XmlDocument xmlDocument, InsertType insertType, XmlNodeType nodeType) { XmlNode parent = xmlDocument.DocumentElement; XmlNode refChild = (insertType == InsertType.Prepend) ? parent.FirstChild : parent.LastChild; XmlNode newChild = TestHelper.CreateNode(xmlDocument, nodeType); string original = parent.InnerXml; string expected = (insertType == InsertType.Prepend) ? (newChild.OuterXml + parent.InnerXml) : ((insertType == InsertType.Append) ? (parent.InnerXml + newChild.OuterXml) : (refChild.PreviousSibling.OuterXml + newChild.OuterXml + refChild.OuterXml)); // insert new child var insertDelegate = TestHelper.CreateInsertBeforeOrAfter(insertType); insertDelegate(parent, newChild, refChild); // verify Assert.Equal(3, parent.ChildNodes.Count); Assert.Equal(expected, parent.InnerXml); TestHelper.Verify(parent, refChild, newChild); TestHelper.VerifySiblings(refChild, newChild, insertType); if (insertType == InsertType.Prepend || insertType == InsertType.Append) TestHelper.Verify(refChild, newChild, insertType); // delete new child parent.RemoveChild(newChild); Assert.Equal(2, parent.ChildNodes.Count); TestHelper.VerifySiblings(parent.FirstChild, parent.LastChild, InsertType.Append); Assert.Equal(original, parent.InnerXml); }
public XmlValidatingReader(String xmlFragment, XmlNodeType fragType, XmlParserContext context) { reader = new XmlTextReader(xmlFragment, fragType, context); entityHandling = EntityHandling.ExpandEntities; validationType = ValidationType.Auto; reader.Normalization = true; }
public void AdvanceNamedNode(XmlNodeType xmlNodeType, string nodeName) { AdvanceNode(xmlNodeType); if (m_xmlReader.Name != nodeName) throw new Exception("Node '" + nodeName + "' of type '" + xmlNodeType + "' expected"); }
void AssertNode (XmlNodeType nodeType, string localName, string ns, string value, int depth, XmlReader reader, string label) { Assert.AreEqual (nodeType, reader.NodeType, label + ".Node"); Assert.AreEqual (localName, reader.LocalName, label + ".LocalName"); Assert.AreEqual (ns, reader.NamespaceURI, label + ".NS"); Assert.AreEqual (value, reader.Value, label + ".Value"); Assert.AreEqual (depth, reader.Depth, label + ".Depth"); }
/// <summary> /// Initializes a new instance of the <see cref="NodeHandlerAttribute"/> class. /// </summary> /// <param name="nodeType">The type of the node being handled.</param> /// <param name="nodeName">The name of the node being handled.</param> /// <param name="ns">The namespace of the node being handled.</param> public NodeHandlerAttribute(XmlNodeType nodeType, string nodeName, string ns = null) { Contract.Requires<ArgumentNullException>(!string.IsNullOrWhiteSpace(nodeName)); this.NodeType = nodeType; this.NodeName = nodeName.Substring(nodeName.IndexOf(":", StringComparison.Ordinal) + 1); this.Namespace = ns; }
//******************************************************************************** /// <summary> /// /// </summary> /// <returns></returns> /// <created>UPh,20.03.2013</created> /// <changed>UPh,20.03.2013</changed> //******************************************************************************** public CXmlNode() { m_nDepth = 0; m_nNodeType = XmlNodeType.None; m_bEmptyElement = false; m_pReader = null; m_pWriter = null; }
internal XmlBasicTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type, int depth) { _Scanner = scanner; _NsMgr = nsMgr; _NodeType = type; _Depth = depth; _LineNum = 0; _LinePos = 0; }
internal void Set( XmlNodeType nodeType, string localName, string prefix, string name, string namespaceUri, string value ) { this.type = nodeType; this.localName = localName; this.prefix = prefix; this.name = name; this.namespaceUri = namespaceUri; this.value = value; }
internal override bool IsValidChildType(XmlNodeType type) { if ((((type != XmlNodeType.Text) && (type != XmlNodeType.Element)) && ((type != XmlNodeType.ProcessingInstruction) && (type != XmlNodeType.Comment))) && (((type != XmlNodeType.CDATA) && (type != XmlNodeType.Whitespace)) && (type != XmlNodeType.SignificantWhitespace))) { return (type == XmlNodeType.EntityReference); } return true; }
public static bool FindNode(XmlReader reader, XmlNodeType type) { do { if(reader.NodeType==type) return true; } while(reader.Read()); return false; }
private XmlToken(XmlNodeType kind) { _Name = null; _Kind = kind; _Value = null; _LineNumber = null; _LinePosition = null; }
internal XmlAttributeTokenInfo(XmlScanner scanner, XmlNamespaceManager nsMgr, XmlNodeType type, bool nor) : this() { _NsMgr = nsMgr; _Scanner = scanner; _NodeType = type; _NormalizeText = nor; _HasNormalize = !_NormalizeText; }
private XmlToken(XmlNodeType kind) { _Name = null; _Kind = kind; _IsEmptyElement = kind == XmlNodeType.Element; _Value = null; _LineNumber = null; _LinePosition = null; }
public static bool DefaultNodeTypeMatcher(XmlNodeType controlType, XmlNodeType testType) { return controlType == testType || (controlType == XmlNodeType.CDATA && testType == XmlNodeType.Text) || (controlType == XmlNodeType.Text && testType == XmlNodeType.CDATA); }
internal void SetTokenInfo(XmlNodeType nodeType, String name, int depth) { _NodeType = nodeType; // // this name should already be atomalized _Name = name; Debug.Assert(Ref.Equal(_Name, _Scanner.GetTextAtom(name)), "Name should be atomalized"); _Depth = depth; }
public XmlValidatingReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context) { if (xmlFragment == null) { throw new ArgumentNullException(nameof(xmlFragment)); } _impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context); _impl.OuterReader = this; }
internal XmlTextReader(string baseURI, TextReader xmlFragment, XmlNodeType fragType, XmlParserContext context) { source = new XmlTextReaderImpl(baseURI, xmlFragment, fragType, context); }
internal XmlTextReader(string baseURI, TextReader xmlFragment, XmlNodeType fragType) { source = new XmlTextReaderImpl(baseURI, xmlFragment, fragType); }
// When reading an array (0x03), it requires extraneously // complex procedure for XmlReader. First, it reads element, // type of operation and length of the items. And this XmlReader // has to return Element state. On the next Read(), it proceeds // to the value node of the first item of the array, so it // reads the value stream. On the next Read(), it proceeds to // EndElement, so it should not read anything from stream while // it has to move to the node state to EndElement. public override bool Read() { switch (state) { case ReadState.Closed: case ReadState.EndOfFile: case ReadState.Error: return(false); } // clear. state = ReadState.Interactive; MoveToElement(); attr_count = 0; attr_value_count = 0; ns_slot = 0; if (node.NodeType == XmlNodeType.Element) { // push element scope if (node_stack.Count <= ++depth) { if (depth == quota.MaxDepth) { throw new XmlException(String.Format("Binary XML stream quota exceeded. Depth must be less than {0}", quota.MaxDepth)); } node = new NodeInfo(); node_stack.Add(node); } else { node = node_stack [depth]; // reuse node.Reset(); } } current = node; if (is_next_end_element) { is_next_end_element = false; node.Reset(); ProcessEndElement(); return(true); } // process array node after preparing node stack. switch (array_state) { case XmlNodeType.Element: ReadArrayItem(); return(true); case XmlNodeType.Text: ShiftToArrayItemEndElement(); return(true); case XmlNodeType.EndElement: if (--array_item_remaining == 0) { array_state = XmlNodeType.None; break; } else { ShiftToArrayItemElement(); return(true); } } // array consumer does not expect Reset whlie it's on reading. So call it later than array check. node.Reset(); int ident = next >= 0 ? next : source.ReadByte(); next = -1; // check end of source. if (ident < 0) { state = ReadState.EndOfFile; current.Reset(); return(false); } is_next_end_element = ident > 0x80 && (ident & 1) == 1; ident -= is_next_end_element ? 1 : 0; switch (ident) { case BF.EndElement: ProcessEndElement(); break; case BF.Comment: node.Value = ReadUTF8(); node.ValueType = BF.Comment; node.NodeType = XmlNodeType.Comment; break; case BF.ElemString: case BF.ElemStringPrefix: case BF.ElemIndex: case BF.ElemIndexPrefix: ReadElementBinary((byte)ident); break; case BF.Array: ident = ReadByteOrError(); ReadElementBinary((byte)ident); ident = ReadByteOrError(); if (ident != 0x01) { throw new XmlException(String.Format("EndElement is expected after element in an array. The actual byte was {0:X} in hexadecimal", ident)); } ident = ReadByteOrError() - 1; // -1 becauseit contains EndElement VerifyValidArrayItemType(ident); if (ident < 0) { throw new XmlException("The stream has ended where the array item type is expected"); } array_item_type = (byte)ident; array_item_remaining = ReadVariantSize(); if (array_item_remaining > quota.MaxArrayLength) { throw new Exception(String.Format("Binary xml stream exceeded max array length quota. Items are {0} and should be less than quota.MaxArrayLength", quota.MaxArrayLength)); } array_state = XmlNodeType.Element; break; default: if (BF.PrefixNElemIndexStart <= ident && ident <= BF.PrefixNElemIndexEnd || BF.PrefixNElemStringStart <= ident && ident <= BF.PrefixNElemStringEnd) { goto case BF.ElemString; } ReadTextOrValue((byte)ident, node, false); break; } return(true); }
internal static Exception CreateReadElementContentAsException(string methodName, XmlNodeType nodeType) { return((Exception) new InvalidOperationException(Res.GetString(51, (object[])new string[2] { methodName, nodeType.ToString() }))); }
void ShiftToArrayItemElement() { node.NodeType = XmlNodeType.Element; context.NamespaceManager.PushScope(); array_state = XmlNodeType.Element; }
public XmlValidatingReader([StringSyntax(StringSyntaxAttribute.Xml)] string xmlFragment, XmlNodeType fragType, XmlParserContext context) { ArgumentNullException.ThrowIfNull(xmlFragment); _impl = new XmlValidatingReaderImpl(xmlFragment, fragType, context); _impl.OuterReader = this; }
// Creates an XmlNode with the specified XmlNodeType, Name, and // NamespaceURI. public virtual XmlNode CreateNode(XmlNodeType type, string name, string namespaceURI) { return(CreateNode(type, null, name, namespaceURI)); }
private async Task <Tuple <string, object> > InternalReadContentAsObjectTupleAsync(bool unwrapTypedValue) { Tuple <string, object> tuple; string originalStringValue; XmlNodeType nodeType = this.NodeType; if (nodeType == XmlNodeType.Attribute) { originalStringValue = this.Value; if (attributePSVI != null && attributePSVI.typedAttributeValue != null) { if (validationState == ValidatingReaderState.OnDefaultAttribute) { XmlSchemaAttribute schemaAttr = attributePSVI.attributeSchemaInfo.SchemaAttribute; originalStringValue = (schemaAttr.DefaultValue != null) ? schemaAttr.DefaultValue : schemaAttr.FixedValue; } tuple = new Tuple <string, object>(originalStringValue, ReturnBoxedValue(attributePSVI.typedAttributeValue, AttributeSchemaInfo.XmlType, unwrapTypedValue)); return(tuple); } else //return string value { tuple = new Tuple <string, object>(originalStringValue, this.Value); return(tuple); } } else if (nodeType == XmlNodeType.EndElement) { if (atomicValue != null) { originalStringValue = originalAtomicValueString; tuple = new Tuple <string, object>(originalStringValue, atomicValue); return(tuple); } else { originalStringValue = string.Empty; tuple = new Tuple <string, object>(originalStringValue, string.Empty); return(tuple); } } else //Positioned on text, CDATA, PI, Comment etc { if (validator.CurrentContentType == XmlSchemaContentType.TextOnly) //if current element is of simple type { object value = ReturnBoxedValue(await ReadTillEndElementAsync().ConfigureAwait(false), xmlSchemaInfo.XmlType, unwrapTypedValue); originalStringValue = originalAtomicValueString; tuple = new Tuple <string, object>(originalStringValue, value); return(tuple); } else { XsdCachingReader cachingReader = this.coreReader as XsdCachingReader; if (cachingReader != null) { originalStringValue = cachingReader.ReadOriginalContentAsString(); } else { originalStringValue = await InternalReadContentAsStringAsync().ConfigureAwait(false); } tuple = new Tuple <string, object>(originalStringValue, originalStringValue); return(tuple); } } }
internal override bool IsValidChildType(XmlNodeType type) { return((type == XmlNodeType.Text) || (type == XmlNodeType.EntityReference)); }
// Determine if a particular node type can be inserted before another, // which may be null if the list is currently empty. internal override bool CanInsertBefore(XmlNodeType type, XmlNode refNode) { XmlNode temp; // Filter out types that are definitely not allowed. if (!CanInsert(type)) { return(false); } // If nothing in the list yet, then we can insert anything. if (refNode == null) { return(true); } // Handle special node categories. switch (type) { case XmlNodeType.DocumentType: { // Must not have an element before this position. temp = NodeList.GetPreviousSibling(refNode); while (temp != null) { if (temp.NodeType == XmlNodeType.Element) { return(false); } temp = NodeList.GetPreviousSibling(temp); } // Must not have an XmlDeclaration after this position. while (refNode != null) { if (refNode.NodeType == XmlNodeType.XmlDeclaration) { return(false); } refNode = NodeList.GetNextSibling(refNode); } } break; case XmlNodeType.Element: { // Must not have a document type or XmlDeclaration // after this position. while (refNode != null) { if (refNode.NodeType == XmlNodeType.DocumentType || refNode.NodeType == XmlNodeType.XmlDeclaration) { return(false); } refNode = NodeList.GetNextSibling(refNode); } } break; case XmlNodeType.XmlDeclaration: { // Xml declarations must come before everything else. return(refNode == NodeList.GetFirstChild(this)); } // Not reached. } // If we get here, then the node is allowed. return(true); }
public virtual XmlNode CreateNode(XmlNodeType type, String prefix, String name, String namespaceURI) { switch (type) { case XmlNodeType.Element: { if (prefix == null) { return(CreateElement(name, namespaceURI)); } else { return(CreateElement(prefix, name, namespaceURI)); } } // Not reached case XmlNodeType.Attribute: { if (prefix == null) { return(CreateAttribute(name, namespaceURI)); } else { return(CreateAttribute(prefix, name, namespaceURI)); } } // Not reached case XmlNodeType.Text: { return(CreateTextNode(String.Empty)); } // Not reached case XmlNodeType.CDATA: { return(CreateCDataSection(String.Empty)); } // Not reached case XmlNodeType.EntityReference: { return(CreateEntityReference(name)); } // Not reached case XmlNodeType.ProcessingInstruction: { return(CreateProcessingInstruction(name, String.Empty)); } // Not reached case XmlNodeType.Comment: { return(CreateComment(String.Empty)); } // Not reached case XmlNodeType.Document: { return(new XmlDocument()); } // Not reached case XmlNodeType.DocumentType: { return(CreateDocumentType(name, String.Empty, String.Empty, String.Empty)); } // Not reached case XmlNodeType.DocumentFragment: { return(CreateDocumentFragment()); } // Not reached case XmlNodeType.Whitespace: { return(CreateWhitespace(String.Empty)); } // Not reached case XmlNodeType.SignificantWhitespace: { return(CreateSignificantWhitespace(String.Empty)); } // Not reached } throw new ArgumentOutOfRangeException ("type", S._("Xml_InvalidNodeType")); }
public virtual void WriteNode(XmlDictionaryReader reader, bool defattr) { if (reader == null) { throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException(nameof(reader))); } int d = (reader.NodeType == XmlNodeType.None ? -1 : reader.Depth); do { XmlNodeType nodeType = reader.NodeType; Type type; if (nodeType == XmlNodeType.Text || nodeType == XmlNodeType.Whitespace || nodeType == XmlNodeType.SignificantWhitespace) { // This will advance if necessary, so we don't need to call Read() explicitly WriteTextNode(reader, false); } else if (reader.Depth > d && reader.IsStartArray(out type)) { WriteArrayNode(reader, type); } else { // These will not advance, so we must call Read() explicitly switch (nodeType) { case XmlNodeType.Element: WriteElementNode(reader, defattr); break; case XmlNodeType.CDATA: WriteCData(reader.Value); break; case XmlNodeType.EntityReference: WriteEntityRef(reader.Name); break; case XmlNodeType.XmlDeclaration: case XmlNodeType.ProcessingInstruction: WriteProcessingInstruction(reader.Name, reader.Value); break; case XmlNodeType.DocumentType: WriteDocType(reader.Name, reader.GetAttribute("PUBLIC"), reader.GetAttribute("SYSTEM"), reader.Value); break; case XmlNodeType.Comment: WriteComment(reader.Value); break; case XmlNodeType.EndElement: WriteFullEndElement(); break; } if (!reader.Read()) { break; } } }while (d < reader.Depth || (d == reader.Depth && reader.NodeType == XmlNodeType.EndElement)); }
internal XmlTextReader(bool dummy, XmlResolver resolver, string url, XmlNodeType fragType, XmlParserContext context) { source = new XmlTextReaderImpl(dummy, resolver, url, fragType, context); }
internal void SetNamedNode(XmlNodeType type, string localName) { SetNamedNode(type, localName, string.Empty, localName); }
// Creates a XmlNode with the specified XmlNodeType, Prefix, Name, and NamespaceURI. public virtual XmlNode CreateNode(XmlNodeType type, string prefix, string name, string namespaceURI) { switch (type) { case XmlNodeType.Element: if (prefix != null) { return(CreateElement(prefix, name, namespaceURI)); } else { return(CreateElement(name, namespaceURI)); } case XmlNodeType.Attribute: if (prefix != null) { return(CreateAttribute(prefix, name, namespaceURI)); } else { return(CreateAttribute(name, namespaceURI)); } case XmlNodeType.Text: return(CreateTextNode(string.Empty)); case XmlNodeType.CDATA: return(CreateCDataSection(string.Empty)); case XmlNodeType.EntityReference: return(CreateEntityReference(name)); case XmlNodeType.ProcessingInstruction: return(CreateProcessingInstruction(name, string.Empty)); case XmlNodeType.XmlDeclaration: return(CreateXmlDeclaration("1.0", null, null)); case XmlNodeType.Comment: return(CreateComment(string.Empty)); case XmlNodeType.DocumentFragment: return(CreateDocumentFragment()); case XmlNodeType.DocumentType: return(CreateDocumentType(name, string.Empty, string.Empty, string.Empty)); case XmlNodeType.Document: return(new XmlDocument()); case XmlNodeType.SignificantWhitespace: return(CreateSignificantWhitespace(string.Empty)); case XmlNodeType.Whitespace: return(CreateWhitespace(string.Empty)); default: throw new ArgumentException(SR.Format(SR.Arg_CannotCreateNode, type)); } }
public override bool Read() { switch (_state) { case State.Initial: _state = State.Interactive; if (base.reader.ReadState == ReadState.Initial) { goto case State.Interactive; } break; case State.Error: return(false); case State.InReadBinary: FinishReadBinary(); _state = State.Interactive; goto case State.Interactive; case State.Interactive: if (!base.reader.Read()) { return(false); } break; default: Debug.Assert(false); return(false); } XmlNodeType nodeType = base.reader.NodeType; if (!_checkCharacters) { switch (nodeType) { case XmlNodeType.Comment: if (_ignoreComments) { return(Read()); } break; case XmlNodeType.Whitespace: if (_ignoreWhitespace) { return(Read()); } break; case XmlNodeType.ProcessingInstruction: if (_ignorePis) { return(Read()); } break; case XmlNodeType.DocumentType: if (_dtdProcessing == DtdProcessing.Prohibit) { Throw(SR.Xml_DtdIsProhibitedEx, string.Empty); } else if (_dtdProcessing == DtdProcessing.Ignore) { return(Read()); } break; } return(true); } else { switch (nodeType) { case XmlNodeType.Element: if (_checkCharacters) { // check element name ValidateQName(base.reader.Prefix, base.reader.LocalName); // check values of attributes if (base.reader.MoveToFirstAttribute()) { do { ValidateQName(base.reader.Prefix, base.reader.LocalName); CheckCharacters(base.reader.Value); } while (base.reader.MoveToNextAttribute()); base.reader.MoveToElement(); } } break; case XmlNodeType.Text: case XmlNodeType.CDATA: if (_checkCharacters) { CheckCharacters(base.reader.Value); } break; case XmlNodeType.EntityReference: if (_checkCharacters) { // check name ValidateQName(base.reader.Name); } break; case XmlNodeType.ProcessingInstruction: if (_ignorePis) { return(Read()); } if (_checkCharacters) { ValidateQName(base.reader.Name); CheckCharacters(base.reader.Value); } break; case XmlNodeType.Comment: if (_ignoreComments) { return(Read()); } if (_checkCharacters) { CheckCharacters(base.reader.Value); } break; case XmlNodeType.DocumentType: if (_dtdProcessing == DtdProcessing.Prohibit) { Throw(SR.Xml_DtdIsProhibitedEx, string.Empty); } else if (_dtdProcessing == DtdProcessing.Ignore) { return(Read()); } if (_checkCharacters) { ValidateQName(base.reader.Name); CheckCharacters(base.reader.Value); string str; str = base.reader.GetAttribute("SYSTEM"); if (str != null) { CheckCharacters(str); } str = base.reader.GetAttribute("PUBLIC"); if (str != null) { int i; if ((i = _xmlCharType.IsPublicId(str)) >= 0) { Throw(SR.Xml_InvalidCharacter, XmlException.BuildCharExceptionArgs(str, i)); } } } break; case XmlNodeType.Whitespace: if (_ignoreWhitespace) { return(Read()); } if (_checkCharacters) { CheckWhitespace(base.reader.Value); } break; case XmlNodeType.SignificantWhitespace: if (_checkCharacters) { CheckWhitespace(base.reader.Value); } break; case XmlNodeType.EndElement: if (_checkCharacters) { ValidateQName(base.reader.Prefix, base.reader.LocalName); } break; default: break; } _lastNodeType = nodeType; return(true); } }
public XmlValidatingReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context) : this(new XmlTextReader(xmlFragment, fragType, context)) { }
public ValidatingReaderNodeData(XmlNodeType nodeType) { Clear(nodeType); }
private async Task <(string, object)> InternalReadContentAsObjectTupleAsync(bool unwrapTypedValue) { string originalStringValue; XmlNodeType nodeType = this.NodeType; if (nodeType == XmlNodeType.Attribute) { originalStringValue = this.Value; if (_attributePSVI != null && _attributePSVI.typedAttributeValue != null) { if (_validationState == ValidatingReaderState.OnDefaultAttribute) { XmlSchemaAttribute schemaAttr = _attributePSVI.attributeSchemaInfo.SchemaAttribute !; originalStringValue = (schemaAttr.DefaultValue != null) ? schemaAttr.DefaultValue : schemaAttr.FixedValue !; } return(originalStringValue, ReturnBoxedValue(_attributePSVI.typedAttributeValue, AttributeSchemaInfo.XmlType !, unwrapTypedValue)); } else { // return string value return(originalStringValue, this.Value); } } else if (nodeType == XmlNodeType.EndElement) { if (_atomicValue != null) { Debug.Assert(_originalAtomicValueString != null); originalStringValue = _originalAtomicValueString; return(originalStringValue, _atomicValue); } else { originalStringValue = string.Empty; return(originalStringValue, string.Empty); } } else { // Positioned on text, CDATA, PI, Comment etc if (_validator.CurrentContentType == XmlSchemaContentType.TextOnly) { // if current element is of simple type object?value = ReturnBoxedValue(await ReadTillEndElementAsync().ConfigureAwait(false), _xmlSchemaInfo.XmlType !, unwrapTypedValue); Debug.Assert(value != null); Debug.Assert(_originalAtomicValueString != null); originalStringValue = _originalAtomicValueString; return(originalStringValue, value); } else { XsdCachingReader?cachingReader = _coreReader as XsdCachingReader; if (cachingReader != null) { originalStringValue = cachingReader.ReadOriginalContentAsString(); } else { originalStringValue = await InternalReadContentAsStringAsync().ConfigureAwait(false); } return(originalStringValue, originalStringValue); } } }
public override bool Read() { XmlNodeType type; switch (this.state) { case State.Initial: this.state = State.Interactive; if (base.reader.ReadState != System.Xml.ReadState.Initial) { goto Label_0055; } break; case State.InReadBinary: this.FinishReadBinary(); this.state = State.Interactive; break; case State.Error: return(false); case State.Interactive: break; default: return(false); } if (!base.reader.Read()) { return(false); } Label_0055: type = base.reader.NodeType; if (this.checkCharacters) { switch (type) { case XmlNodeType.Element: if (this.checkCharacters) { this.ValidateQName(base.reader.Prefix, base.reader.LocalName); if (base.reader.MoveToFirstAttribute()) { do { this.ValidateQName(base.reader.Prefix, base.reader.LocalName); this.CheckCharacters(base.reader.Value); }while (base.reader.MoveToNextAttribute()); base.reader.MoveToElement(); } } break; case XmlNodeType.Text: case XmlNodeType.CDATA: if (this.checkCharacters) { this.CheckCharacters(base.reader.Value); } break; case XmlNodeType.EntityReference: if (this.checkCharacters) { this.ValidateQName(base.reader.Name); } break; case XmlNodeType.ProcessingInstruction: if (!this.ignorePis) { if (this.checkCharacters) { this.ValidateQName(base.reader.Name); this.CheckCharacters(base.reader.Value); } break; } return(this.Read()); case XmlNodeType.Comment: if (!this.ignoreComments) { if (this.checkCharacters) { this.CheckCharacters(base.reader.Value); } break; } return(this.Read()); case XmlNodeType.DocumentType: if (this.dtdProcessing != DtdProcessing.Prohibit) { if (this.dtdProcessing == DtdProcessing.Ignore) { return(this.Read()); } } else { this.Throw("Xml_DtdIsProhibitedEx", string.Empty); } if (this.checkCharacters) { int num; this.ValidateQName(base.reader.Name); this.CheckCharacters(base.reader.Value); string attribute = base.reader.GetAttribute("SYSTEM"); if (attribute != null) { this.CheckCharacters(attribute); } attribute = base.reader.GetAttribute("PUBLIC"); if ((attribute != null) && ((num = this.xmlCharType.IsPublicId(attribute)) >= 0)) { this.Throw("Xml_InvalidCharacter", XmlException.BuildCharExceptionArgs(attribute, num)); } } break; case XmlNodeType.Whitespace: if (!this.ignoreWhitespace) { if (this.checkCharacters) { this.CheckWhitespace(base.reader.Value); } break; } return(this.Read()); case XmlNodeType.SignificantWhitespace: if (this.checkCharacters) { this.CheckWhitespace(base.reader.Value); } break; case XmlNodeType.EndElement: if (this.checkCharacters) { this.ValidateQName(base.reader.Prefix, base.reader.LocalName); } break; } } else { switch (type) { case XmlNodeType.ProcessingInstruction: if (!this.ignorePis) { break; } return(this.Read()); case XmlNodeType.Comment: if (!this.ignoreComments) { break; } return(this.Read()); case XmlNodeType.DocumentType: if (this.dtdProcessing != DtdProcessing.Prohibit) { if (this.dtdProcessing == DtdProcessing.Ignore) { return(this.Read()); } break; } this.Throw("Xml_DtdIsProhibitedEx", string.Empty); break; case XmlNodeType.Whitespace: if (!this.ignoreWhitespace) { break; } return(this.Read()); } return(true); } this.lastNodeType = type; return(true); }
public XmlTextReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context) { source = new XmlTextReaderImpl(xmlFragment, fragType, context); }
public XmlTextReader(Stream xmlFragment, XmlNodeType fragType, XmlParserContext context) { impl = new XmlTextReaderImpl(xmlFragment, fragType, context); impl.OuterReader = this; }
public static XPathNavigator CreateNavigator(this XmlDocument document, XmlNode node) { XmlNodeType nodeType = node.NodeType; XmlNode parent; XmlNodeType parentType; switch (nodeType) { case XmlNodeType.EntityReference: case XmlNodeType.Entity: case XmlNodeType.DocumentType: case XmlNodeType.Notation: case XmlNodeType.XmlDeclaration: return(null); case XmlNodeType.Text: case XmlNodeType.CDATA: case XmlNodeType.SignificantWhitespace: parent = node.ParentNode; while (parent != null) { parentType = parent.NodeType; if (parentType == XmlNodeType.Attribute) { return(null); } else if (parentType == XmlNodeType.EntityReference) { parent = parent.ParentNode; } else { break; } } node = NormalizeText(node); break; case XmlNodeType.Whitespace: parent = node.ParentNode; while (parent != null) { parentType = parent.NodeType; if (parentType == XmlNodeType.Document || parentType == XmlNodeType.Attribute) { return(null); } else if (parentType == XmlNodeType.EntityReference) { parent = parent.ParentNode; } else { break; } } node = NormalizeText(node); break; default: break; } return(new DocumentXPathNavigator(document, node)); }
void ShiftToArrayItemEndElement() { ProcessEndElement(); array_state = XmlNodeType.EndElement; }
internal XmlNamespaceManager ParsePartialContent(XmlNode parentNode, string innerxmltext, XmlNodeType nt) { //the function shouldn't be used to set innerxml for XmlDocument node Debug.Assert(parentNode.NodeType != XmlNodeType.Document); _doc = parentNode.OwnerDocument; Debug.Assert(_doc != null); XmlParserContext pc = GetContext(parentNode); _reader = CreateInnerXmlReader(innerxmltext, nt, pc, _doc); try { _preserveWhitespace = true; bool bOrigLoading = _doc.IsLoading; _doc.IsLoading = true; if (nt == XmlNodeType.Entity) { XmlNode node = null; while (_reader.Read() && (node = LoadNodeDirect()) != null) { parentNode.AppendChildForLoad(node, _doc); } } else { XmlNode node = null; while (_reader.Read() && (node = LoadNode(true)) != null) { parentNode.AppendChildForLoad(node, _doc); } } _doc.IsLoading = bOrigLoading; } finally { _reader.Dispose(); } return(pc.NamespaceManager); }
internal virtual bool IsValidChildType(XmlNodeType type) { return(false); }
#pragma warning restore 618 static internal Exception UnexpectedNodeType(XmlNodeType nodetype) { return(new InvalidOperationException(string.Format(CultureInfo.InvariantCulture, SR.Xml_UnexpectedNodeType, nodetype.ToString()))); }
public XmlTextReader(string xmlFragment, XmlNodeType fragType, XmlParserContext context) { _impl = new XmlTextReaderImpl(xmlFragment, fragType, context); _impl.OuterReader = this; }
void ReadArrayItem() { ReadTextOrValue(array_item_type, node, false); array_state = XmlNodeType.Text; }