public void DumpReader (XmlReader xr, bool attValue) { Console.WriteLine ("NodeType: " + xr.NodeType); Console.WriteLine ("Prefix: " + xr.Prefix); Console.WriteLine ("Name: " + xr.Name); Console.WriteLine ("LocalName: " + xr.LocalName); Console.WriteLine ("NamespaceURI: " + xr.NamespaceURI); Console.WriteLine ("Value: " + xr.Value); Console.WriteLine ("Depth: " + xr.Depth); Console.WriteLine ("IsEmptyElement: " + xr.IsEmptyElement); if (xr.NodeType == XmlNodeType.Attribute) { Console.WriteLine ("Attribute Values::::"); while (xr.ReadAttributeValue ()) DumpReader (xr, true); Console.WriteLine (":::Attribute Values End"); } else if (!attValue) { Console.WriteLine ("Attributes::::"); Console.Write (xr.AttributeCount); if (xr.MoveToFirstAttribute ()) { do { DumpReader (xr, false); } while (xr.MoveToNextAttribute ()); xr.MoveToElement (); } Console.WriteLine (":::Attributes End"); } }
// returns remaining attributes to be processed List <StringPair> ProcessAttributes(XmlReader r, List <Pair> members, out string typeArgNames) { // base (top element) if (!xmlbase_done) { xmlbase_done = true; string xmlbase = r.GetAttribute("base", XamlLanguage.Xml1998Namespace) ?? r.BaseURI; if (xmlbase != null) { members.Add(new Pair(XamlLanguage.Base, xmlbase)); } } typeArgNames = null; var atts = new List <StringPair>(); var tagNamespace = r.NamespaceURI; if (r.MoveToFirstAttribute()) { do { switch (r.NamespaceURI) { case XamlLanguage.Xml1998Namespace: switch (r.LocalName) { case "base": continue; // already processed. case "lang": members.Add(new Pair(XamlLanguage.Lang, r.Value)); continue; case "space": members.Add(new Pair(XamlLanguage.Space, r.Value)); continue; } break; case XamlLanguage.Xmlns2000Namespace: continue; case XamlLanguage.Xaml2006Namespace: XamlDirective d = FindStandardDirective(r.LocalName, AllowedMemberLocations.Attribute); if (d != null) { // check TypeArguments to resolve Type, and remove them from the list. They don't appear as a node. if (ReferenceEquals(d, XamlLanguage.TypeArguments)) { typeArgNames = r.Value; continue; } members.Add(new Pair(d, r.Value)); continue; } throw new NotSupportedException(String.Format("Attribute '{0}' is not supported", r.Name)); default: if (string.IsNullOrEmpty(r.NamespaceURI) || tagNamespace == r.NamespaceURI || r.LocalName.IndexOf('.') > 0) { atts.Add(new StringPair(r.Name, r.Value)); continue; } // Custom directive members.Add(new Pair(SchemaContext.GetXamlDirective(r.NamespaceURI, r.LocalName), r.Value)); break; } } while (r.MoveToNextAttribute()); r.MoveToElement(); } return(atts); }
//[Variation("ReadSubtree only works on Element Node")] public void ReadSubtreeOnlyWorksOnElementNode() { XmlReader DataReader = GetReader(); while (DataReader.Read()) { if (DataReader.NodeType != XmlNodeType.Element) { string nodeType = DataReader.NodeType.ToString(); bool flag = true; try { DataReader.ReadSubtree(); } catch (InvalidOperationException) { flag = false; } if (flag) { TestLog.WriteLine("ReadSubtree doesn't throw InvalidOp Exception on NodeType : " + nodeType); throw new TestException(TestResult.Failed, ""); } // now try next read try { DataReader.Read(); } catch (XmlException) { TestLog.WriteLine("Cannot Read after an invalid operation exception"); throw new TestException(TestResult.Failed, ""); } } else { if (DataReader.HasAttributes) { bool flag = true; DataReader.MoveToFirstAttribute(); try { DataReader.ReadSubtree(); } catch (InvalidOperationException) { flag = false; } if (flag) { TestLog.WriteLine("ReadSubtree doesn't throw InvalidOp Exception on Attribute Node Type"); throw new TestException(TestResult.Failed, ""); } //now try next read. try { DataReader.Read(); } catch (XmlException) { TestLog.WriteLine("Cannot Read after an invalid operation exception"); throw new TestException(TestResult.Failed, ""); } } } }//end while }
internal void Parse(XmlReader reader) { GetPositionInfo(reader); var hasEndElement = !reader.IsEmptyElement; Debug.Assert(reader.NodeType == XmlNodeType.Element); for (var more = reader.MoveToFirstAttribute(); more; more = reader.MoveToNextAttribute()) { ParseAttribute(reader); } HandleAttributesComplete(); var done = !hasEndElement; var skipToNextElement = false; while (!done) { if (skipToNextElement) { skipToNextElement = false; reader.Skip(); if (reader.EOF) { break; } } else { if (!reader.Read()) { break; } } switch (reader.NodeType) { case XmlNodeType.Element: skipToNextElement = ParseElement(reader); break; case XmlNodeType.EndElement: { done = true; break; } case XmlNodeType.CDATA: case XmlNodeType.Text: case XmlNodeType.SignificantWhitespace: ParseText(reader); break; // we ignore these childless elements case XmlNodeType.Whitespace: case XmlNodeType.XmlDeclaration: case XmlNodeType.Comment: case XmlNodeType.Notation: case XmlNodeType.ProcessingInstruction: { break; } // we ignore these elements that can have children case XmlNodeType.DocumentType: case XmlNodeType.EntityReference: { skipToNextElement = true; break; } default: { AddError( ErrorCode.UnexpectedXmlNodeType, EdmSchemaErrorSeverity.Error, reader, Strings.UnexpectedXmlNodeType(reader.NodeType)); skipToNextElement = true; break; } } } HandleChildElementsComplete(); if (reader.EOF && reader.Depth > 0) { AddError( ErrorCode.MalformedXml, EdmSchemaErrorSeverity.Error, 0, 0, Strings.MalformedXml(LineNumber, LinePosition)); } }
/// <summary>读取</summary> /// <param name="reader"></param> /// <param name="value">数值</param> public static void ReadXml(XmlReader reader, Object value) { var pis = value.GetType().GetProperties(true); var names = new HashSet <String>(StringComparer.OrdinalIgnoreCase); foreach (var pi in pis) { if (!pi.CanRead) { continue; } if (pi.GetCustomAttribute <XmlIgnoreAttribute>(false) != null) { continue; } // 已处理的特性 names.Add(pi.Name); var v = reader.GetAttribute(pi.Name); if (String.IsNullOrEmpty(v)) { continue; } if (pi.PropertyType == typeof(String[])) { var ss = v.Split(new String[] { "," }, StringSplitOptions.RemoveEmptyEntries); // 去除前后空格,因为手工修改xml的时候,可能在逗号后加上空格 for (int i = 0; i < ss.Length; i++) { ss[i] = ss[i].Trim(); } value.SetValue(pi, ss); } else { value.SetValue(pi, v.ChangeType(pi.PropertyType)); } } var pi1 = pis.FirstOrDefault(e => e.Name == "Name"); var pi2 = pis.FirstOrDefault(e => e.Name == "TableName" || e.Name == "ColumnName"); if (pi1 != null && pi2 != null) { // 兼容旧版本 var v2 = reader.GetAttribute("Alias"); if (!String.IsNullOrEmpty(v2)) { value.SetValue(pi2, value.GetValue(pi1)); value.SetValue(pi1, v2); } // 写入的时候省略了相同的TableName/ColumnName v2 = (String)value.GetValue(pi2); if (String.IsNullOrEmpty(v2)) { value.SetValue(pi2, value.GetValue(pi1)); } } // 自增字段非空 if (value is IDataColumn) { var dc = value as IDataColumn; if (dc.Identity) { dc.Nullable = false; } } //reader.Skip(); // 剩余特性作为扩展属性 if (reader.MoveToFirstAttribute()) { if (value is IDataTable || value is IDataColumn) { var dic = (value is IDataTable) ? (value as IDataTable).Properties : (value as IDataColumn).Properties; do { if (!names.Contains(reader.Name)) { dic[reader.Name] = reader.Value; } } while (reader.MoveToNextAttribute()); } } }
public static void HandleBuilding(XmlReader reader, CityGml2GO cityGml2Go) { var buildingName = ""; while (reader.MoveToNextAttribute()) { if (reader.LocalName == "id") { buildingName = reader.Value; } } var buildingGo = new GameObject(string.IsNullOrEmpty(buildingName) ? "Building" : buildingName); var buildingProperties = buildingGo.AddComponent <Scripts.BuildingProperties>(); var semanticType = buildingGo.AddComponent <SemanticType>(); buildingGo.transform.SetParent(cityGml2Go.Parent.transform); while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "Polygon") { var polyGo = PolygonHandler.PolyToMesh(reader, buildingName, cityGml2Go, semanticType); if (polyGo != null) { polyGo.transform.SetParent(buildingGo.transform); } } if (cityGml2Go.ShowCurves) { if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "MultiCurve") { MultiCurveHandler.HandleMultiCurve(reader, buildingGo, semanticType, cityGml2Go); } } if (cityGml2Go.Semantics) { if (reader.NodeType == XmlNodeType.Element && cityGml2Go.SemanticSurfaces.Any(x => x == reader.LocalName)) { semanticType.Name = reader.LocalName; reader.MoveToFirstAttribute(); if (reader.LocalName == "id") { semanticType.Id = reader.Value; } else { while (reader.MoveToNextAttribute()) { semanticType.Id = reader.Value; } } } } BuildingPropertiesHandler.HandleBuildingProperties(reader, buildingProperties); if (reader.NodeType == XmlNodeType.EndElement && reader.LocalName == "Building") { break; } } Object.Destroy(semanticType); }
private void Read(ConfigurationNode node, StringCollection fileNames) { var name = node.Name; var endOfNode = _xmlReader.IsEmptyElement; if (name != null) { var hasNext = _xmlReader.MoveToFirstAttribute(); while (hasNext) { var attributeName = _xmlReader.Name; var attributeValue = _xmlReader.Value; if (attributeName == "name") { } else if (attributeName == "description") { node.Description = attributeValue; } else { var attribute = new ConfigurationAttribute(attributeName, attributeValue, null); node.Attributes.Add(attribute); } hasNext = _xmlReader.MoveToNextAttribute(); } } while (!endOfNode && _xmlReader.Read()) { switch (_xmlReader.NodeType) { case XmlNodeType.Element: { var elementName = _xmlReader.Name; switch (elementName) { case ConfigurationElementName.Attribute: ReadAttribute(node); break; case ConfigurationElementName.Node: { var nodeName = _xmlReader.GetAttribute("name"); var childNode = new ConfigurationNode(nodeName); node.AddChildNode(childNode); Read(childNode, fileNames); } break; case "include": { var fileName = _xmlReader.GetAttribute("fileName"); fileName = Environment.ExpandEnvironmentVariables(fileName); var reader2 = new ConfigurationReader(); var includeNode = reader2.Read(fileName, _sectionName, fileNames); node.Attributes.Add(includeNode.Attributes); foreach (var childNode in includeNode.ChildNodes) { node.AddChildNode(childNode); } if (_enableFileSystemWatcher && !fileNames.Contains(fileName)) { fileNames.Add(fileName); } } break; default: { var nodeName = XmlConvert.DecodeName(elementName); var childNode = new ConfigurationNode(nodeName); node.AddChildNode(childNode); Read(childNode, fileNames); } break; } } break; case XmlNodeType.EndElement: endOfNode = true; break; default: break; } } }
internal bool MoveToFirstAttribute() { return(isEndOfEmptyElement ? false : reader.MoveToFirstAttribute()); }
public override bool MoveToFirstAttribute() { return(_baseReader.MoveToFirstAttribute()); }
// function for parsing an XML file from web via URL public async Task <string> XmlParser(string URL) { // block of settings XmlReaderSettings settings = new XmlReaderSettings(); settings.XmlResolver = new XmlUrlResolver(); settings.DtdProcessing = DtdProcessing.Parse; settings.ValidationType = ValidationType.DTD; settings.Async = true; string XMLtext = ""; // block of parsing using (XmlReader reader = XmlReader.Create(URL, settings)) { while (await reader.ReadAsync()) { if (reader.NodeType == XmlNodeType.Element && reader.Name == "offer" && reader.MoveToFirstAttribute()) { XMLtext += reader.GetAttribute("id"); XMLtext += " "; } } } return(XMLtext); }
private void ParseStep(XmlReader reader, Stack <ElementRecord> elementStack, ref TextRecord textChunk, PhpArray values, PhpArray indices) { string elementName; bool emptyElement; ElementRecord currentElementRecord = null; switch (reader.NodeType) { case XmlNodeType.Element: elementName = reader.Name; emptyElement = reader.IsEmptyElement; PhpArray attributeArray = new PhpArray(); if (_processNamespaces && elementName.IndexOf(":") >= 0) { string localName = elementName.Substring(elementName.IndexOf(":") + 1); elementName = reader.NamespaceURI + _namespaceSeparator + localName; } if (reader.MoveToFirstAttribute()) { do { if (_processNamespaces && reader.Name.StartsWith("xmlns:")) { string namespaceID = reader.Name.Substring(6); string namespaceUri = reader.Value; if (_startNamespaceDeclHandler.Callback != null) { _startNamespaceDeclHandler.Invoke(this, namespaceID, namespaceUri); } continue; } attributeArray.Add(_enableCaseFolding ? reader.Name.ToUpperInvariant() : reader.Name, reader.Value); }while (reader.MoveToNextAttribute()); } // update current top of stack if (elementStack.Count != 0) { currentElementRecord = elementStack.Peek(); UpdateValueAndIndexArrays(currentElementRecord, ref textChunk, values, indices, true); if (currentElementRecord.State == ElementState.Beginning) { currentElementRecord.State = ElementState.Interior; } } // push the element into the stack (needed for parse_into_struct) elementStack.Push( new ElementRecord() { ElementName = elementName, Level = reader.Depth, State = ElementState.Beginning, Attributes = (PhpArray)attributeArray.DeepCopy() }); if (_startElementHandler.Callback != null) { _startElementHandler.Invoke(this, _enableCaseFolding ? elementName.ToUpperInvariant() : elementName, attributeArray); } else if (_defaultHandler.Callback != null) { _defaultHandler.Invoke(this, ""); } if (emptyElement) { goto case XmlNodeType.EndElement; // and end the element immediately (<element/>, XmlNodeType.EndElement will not be called) } break; case XmlNodeType.EndElement: elementName = reader.Name; if (_processNamespaces && elementName.IndexOf(":") >= 0) { string localName = elementName.Substring(elementName.IndexOf(":") + 1); elementName = reader.NamespaceURI + _namespaceSeparator + localName; } // pop the top element record currentElementRecord = elementStack.Pop(); UpdateValueAndIndexArrays(currentElementRecord, ref textChunk, values, indices, false); if (_endElementHandler.Callback != null) { _endElementHandler.Invoke(this, _enableCaseFolding ? elementName.ToUpperInvariant() : elementName); } else if (_defaultHandler.Callback != null) { _defaultHandler.Invoke(this, ""); } break; case XmlNodeType.Whitespace: case XmlNodeType.Text: case XmlNodeType.CDATA: if (textChunk == null) { textChunk = new TextRecord() { Text = reader.Value }; } else { textChunk.Text += reader.Value; } if (_characterDataHandler.Callback != null) { _characterDataHandler.Invoke(this, reader.Value); } else if (_defaultHandler.Callback != null) { _defaultHandler.Invoke(this, reader.Value); } break; case XmlNodeType.ProcessingInstruction: if (_processingInstructionHandler.Callback != null) { _processingInstructionHandler.Invoke(this, reader.Name, reader.Value); } else if (_defaultHandler.Callback != null) { _defaultHandler.Invoke(this, string.Empty); } break; } }
public void getXmlData(string letterId, string word) { XmlReader reader = XmlReader.Create("Madrasi.xml"); while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { if (reader.Name == "letter") { if (true == reader.MoveToFirstAttribute()) { letterName = reader.Value; } } else if (reader.Name == "word" && letterName == letterId) { if (true == reader.MoveToFirstAttribute()) { wordName = reader.Value; } if (String.Compare(word, 0, wordName, 0, word.Length) == 0) { if (true == reader.MoveToNextAttribute()) { wordMeaning = reader.Value; } if (true == reader.MoveToNextAttribute()) { wordLanguage = reader.Value; } } else { wordName = ""; wordMeaning = ""; wordLanguage = ""; wordOrigin = ""; } } } else if (reader.NodeType == XmlNodeType.EndElement && letterName == letterId && wordName == word) { if (reader.Name == "word") { break; } } else if (reader.NodeType == XmlNodeType.Text && letterName == letterId && wordName == word) { wordOrigin = reader.Value; } } reader.Close(); // + "\n\nWord Meaning : " + wordMeaning + "\n\n Word Origin Language : " + wordLanguage + "\n\nWord Origin : " + wordOrigin; }
/// <summary>读取</summary> /// <param name="table"></param> /// <param name="reader"></param> /// <returns></returns> public static IDataTable ReadXml(this IDataTable table, XmlReader reader) { // 读属性 if (reader.HasAttributes) { reader.MoveToFirstAttribute(); ReadXml(reader, table); } reader.ReadStartElement(); // 读字段 reader.MoveToElement(); // 有些数据表模型没有字段 if (reader.NodeType == XmlNodeType.Element && reader.Name.EqualIgnoreCase("Table")) { return(table); } while (reader.NodeType != XmlNodeType.EndElement) //while (reader.NodeType == XmlNodeType.Element) { switch (reader.Name) { case "Columns": reader.ReadStartElement(); while (reader.IsStartElement()) { var dc = table.CreateColumn(); var v = reader.GetAttribute("DataType"); if (v != null) { dc.DataType = v.GetTypeEx(false); v = reader.GetAttribute("Length"); if (v != null && Int32.TryParse(v, out var len)) { dc.Length = len; } dc = FixDefaultByType(dc, null); // 清空默认的原始类型,让其从xml读取 dc.RawType = null; } (dc as IXmlSerializable).ReadXml(reader); table.Columns.Add(dc); } reader.ReadEndElement(); // 修正可能的主字段 if (!table.Columns.Any(e => e.Master)) { var f = table.Columns.FirstOrDefault(e => e.Name.EqualIgnoreCase("Name", "Title")); if (f != null) { f.Master = true; } } break; case "Indexes": reader.ReadStartElement(); while (reader.IsStartElement()) { var di = table.CreateIndex(); (di as IXmlSerializable).ReadXml(reader); di.Fix(); table.Indexes.Add(di); } reader.ReadEndElement(); break; case "Relations": reader.ReadStartElement(); reader.Skip(); reader.ReadEndElement(); break; default: // 这里必须处理,否则加载特殊Xml文件时将会导致死循环 reader.Read(); break; } } if (reader.NodeType == XmlNodeType.EndElement) { reader.ReadEndElement(); } // 修正 table.Fix(); return(table); }
internal void ReadContentFrom(XmlReader r, LoadOptions o) { if ((o & (LoadOptions.SetBaseUri | LoadOptions.SetLineInfo)) == 0) { ReadContentFrom(r); return; } if (r.ReadState != ReadState.Interactive) throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive); XContainer c = this; XNode n = null; NamespaceCache eCache = new NamespaceCache(); NamespaceCache aCache = new NamespaceCache(); string baseUri = (o & LoadOptions.SetBaseUri) != 0 ? r.BaseURI : null; IXmlLineInfo li = (o & LoadOptions.SetLineInfo) != 0 ? r as IXmlLineInfo : null; do { string uri = r.BaseURI; switch (r.NodeType) { case XmlNodeType.Element: { XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName)); if (baseUri != null && baseUri != uri) { e.SetBaseUri(uri); } if (li != null && li.HasLineInfo()) { e.SetLineInfo(li.LineNumber, li.LinePosition); } if (r.MoveToFirstAttribute()) { do { XAttribute a = new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value); if (li != null && li.HasLineInfo()) { a.SetLineInfo(li.LineNumber, li.LinePosition); } e.AppendAttributeSkipNotify(a); } while (r.MoveToNextAttribute()); r.MoveToElement(); } c.AddNodeSkipNotify(e); if (!r.IsEmptyElement) { c = e; if (baseUri != null) { baseUri = uri; } } break; } case XmlNodeType.EndElement: { if (c.content == null) { c.content = string.Empty; } // Store the line info of the end element tag. // Note that since we've got EndElement the current container must be an XElement XElement e = c as XElement; Debug.Assert(e != null, "EndElement received but the current container is not an element."); if (e != null && li != null && li.HasLineInfo()) { e.SetEndElementLineInfo(li.LineNumber, li.LinePosition); } if (c == this) return; if (baseUri != null && c.HasBaseUri) { baseUri = c.parent.BaseUri; } c = c.parent; break; } case XmlNodeType.Text: case XmlNodeType.SignificantWhitespace: case XmlNodeType.Whitespace: if ((baseUri != null && baseUri != uri) || (li != null && li.HasLineInfo())) { n = new XText(r.Value); } else { c.AddStringSkipNotify(r.Value); } break; case XmlNodeType.CDATA: n = new XCData(r.Value); break; case XmlNodeType.Comment: n = new XComment(r.Value); break; case XmlNodeType.ProcessingInstruction: n = new XProcessingInstruction(r.Name, r.Value); break; case XmlNodeType.DocumentType: n = new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value); break; case XmlNodeType.EntityReference: if (!r.CanResolveEntity) throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference); r.ResolveEntity(); break; case XmlNodeType.EndEntity: break; default: throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType)); } if (n != null) { if (baseUri != null && baseUri != uri) { n.SetBaseUri(uri); } if (li != null && li.HasLineInfo()) { n.SetLineInfo(li.LineNumber, li.LinePosition); } c.AddNodeSkipNotify(n); n = null; } } while (r.Read()); }
public bool ParseContent(TextReader sr) { var setting = new XmlReaderSettings(); setting.DtdProcessing = DtdProcessing.Ignore; XmlReader xmlReader = XmlReader.Create(sr, setting); int dataindex = 0; int Width = 0; int Height = 0; while (xmlReader.Read()) { string name = xmlReader.Name; switch (xmlReader.NodeType) { case XmlNodeType.Element: string[] attrs = null; if (name == "map") { Width = CCUtils.CCParseInt(xmlReader.GetAttribute("width")); Height = CCUtils.CCParseInt(xmlReader.GetAttribute("height")); } if (xmlReader.HasAttributes) { attrs = new string[xmlReader.AttributeCount * 2]; xmlReader.MoveToFirstAttribute(); int i = 0; attrs[0] = xmlReader.Name; attrs[1] = xmlReader.Value; i += 2; while (xmlReader.MoveToNextAttribute()) { attrs[i] = xmlReader.Name; attrs[i + 1] = xmlReader.Value; i += 2; } // Move the reader back to the element node. xmlReader.MoveToElement(); } StartElement(this, name, attrs); byte[] buffer = null; //read data content of tmx file if (name == "data") { if (attrs != null) { string encoding = ""; for (int i = 0; i < attrs.Length; i++) { if (attrs [i] == "encoding") { encoding = attrs [i + 1]; } } if (encoding == "base64") { var base64String = xmlReader.ReadElementContentAsString().Trim(); buffer = Convert.FromBase64String(base64String); } else { string value = xmlReader.ReadElementContentAsString(); buffer = Encoding.UTF8.GetBytes(value); } } // Pure XML TileMap else { int dataSize = (Width * Height * 4) + 1024; buffer = new byte[dataSize]; } TextHandler(this, buffer, buffer.Length); EndElement(this, name); } else if (name == "key" || name == "integer" || name == "real" || name == "string") { string value = xmlReader.ReadElementContentAsString(); buffer = Encoding.UTF8.GetBytes(value); TextHandler(this, buffer, buffer.Length); EndElement(this, name); } else if (xmlReader.IsEmptyElement) { EndElement(this, name); } break; case XmlNodeType.EndElement: EndElement(this, xmlReader.Name); dataindex++; break; default: break; } } return(true); }
internal void ReadContentFrom(XmlReader r) { if (r.ReadState != ReadState.Interactive) throw new InvalidOperationException(SR.InvalidOperation_ExpectedInteractive); XContainer c = this; NamespaceCache eCache = new NamespaceCache(); NamespaceCache aCache = new NamespaceCache(); do { switch (r.NodeType) { case XmlNodeType.Element: XElement e = new XElement(eCache.Get(r.NamespaceURI).GetName(r.LocalName)); if (r.MoveToFirstAttribute()) { do { e.AppendAttributeSkipNotify(new XAttribute(aCache.Get(r.Prefix.Length == 0 ? string.Empty : r.NamespaceURI).GetName(r.LocalName), r.Value)); } while (r.MoveToNextAttribute()); r.MoveToElement(); } c.AddNodeSkipNotify(e); if (!r.IsEmptyElement) { c = e; } break; case XmlNodeType.EndElement: if (c.content == null) { c.content = string.Empty; } if (c == this) return; c = c.parent; break; case XmlNodeType.Text: case XmlNodeType.SignificantWhitespace: case XmlNodeType.Whitespace: c.AddStringSkipNotify(r.Value); break; case XmlNodeType.CDATA: c.AddNodeSkipNotify(new XCData(r.Value)); break; case XmlNodeType.Comment: c.AddNodeSkipNotify(new XComment(r.Value)); break; case XmlNodeType.ProcessingInstruction: c.AddNodeSkipNotify(new XProcessingInstruction(r.Name, r.Value)); break; case XmlNodeType.DocumentType: c.AddNodeSkipNotify(new XDocumentType(r.LocalName, r.GetAttribute("PUBLIC"), r.GetAttribute("SYSTEM"), r.Value)); break; case XmlNodeType.EntityReference: if (!r.CanResolveEntity) throw new InvalidOperationException(SR.InvalidOperation_UnresolvedEntityReference); r.ResolveEntity(); break; case XmlNodeType.EndEntity: break; default: throw new InvalidOperationException(SR.Format(SR.InvalidOperation_UnexpectedNodeType, r.NodeType)); } } while (r.Read()); }
/// <summary> /// Main function that retrieves the list from API, including paging /// </summary> /// <param name="url">URL of API request</param> /// <param name="haveSoFar">Number of pages already retrieved, for upper limit control</param> /// <returns>List of pages</returns> public List <Article> ApiMakeList(string url, int haveSoFar) {// TODO: error handling List <Article> list = new List <Article>(); string postfix = ""; string newUrl = url; if (Hack1_12) { newUrl = RemoveCmcategory.Replace(newUrl, ""); } while (list.Count + haveSoFar < Limit) { string text = Tools.GetHTML(newUrl + postfix); if (text.Contains("code=\"cmtitleandcategory\"")) { if (Hack1_12) { throw new ListProviderException("cmtitleandcategory persists."); } Hack1_12 = true; newUrl = RemoveCmcategory.Replace(url, ""); text = Tools.GetHTML(newUrl + postfix); } XmlTextReader xml = new XmlTextReader(new StringReader(text)); xml.MoveToContent(); postfix = ""; while (xml.Read()) { if (xml.Name == "query-continue") { XmlReader r = xml.ReadSubtree(); r.Read(); while (r.Read()) { if (!r.IsStartElement()) { continue; } if (!r.MoveToFirstAttribute()) { throw new FormatException("Malformed element '" + r.Name + "' in <query-continue>"); } postfix += "&" + r.Name + "=" + HttpUtility.UrlEncode(r.Value); } } else if (PageElements.Contains(xml.Name) && xml.IsStartElement()) { int ns = -1; int.TryParse(xml.GetAttribute("ns"), out ns); string name = xml.GetAttribute("title"); if (string.IsNullOrEmpty(name)) { System.Windows.Forms.MessageBox.Show(xml.ReadInnerXml()); break; } // HACK: commented out until we make AWB always load namespaces from the wiki, // to avoid problems with unknown namespace //if (ns >= 0) list.Add(new Article(name, ns)); //else list.Add(new Article(name)); } } if (string.IsNullOrEmpty(postfix)) { break; } } return(list); }
internal List <PlaceholderModel> Parse(string hudOptionsPath) { int xmlVersion = GetXmlVersion(hudOptionsPath); if (xmlVersion < CURRENT_XML_VERSION) { UpdateXmlVersion(xmlVersion, hudOptionsPath); } Dictionary <string, PlaceholderModel> placeHolders = new Dictionary <string, PlaceholderModel>(); string fileContent = File.ReadAllText(hudOptionsPath); using (XmlReader xmlReader = XmlReader.Create(new StringReader(fileContent))) { while (xmlReader.ReadToFollowing("name")) { string name = xmlReader.ReadElementContentAsString(); if (!IsGeometricItem(name)) { continue; } GeometricItem item = GetGeometricItem(name); if (blackList.IsFiltered(item.Name)) { continue; } if (!placeHolders.ContainsKey(item.Name)) { PlaceholderModel placeholder = PlaceholderFactory.NewPlaceholder(item.Name); placeHolders.Add(placeholder.Name, placeholder); } xmlReader.ReadToFollowing("value"); xmlReader.MoveToFirstAttribute(); string valueType = xmlReader.Value; if (valueType != ValueType.VECTOR) { throw new Exception($"Expected value is a {ValueType.VECTOR}"); } xmlReader.MoveToContent(); string value = xmlReader.ReadElementContentAsString(); switch (item.ItemType) { case ItemType.POSITION: placeHolders[item.Name].Position = ParseVector(value); break; case ItemType.SIZE: placeHolders[item.Name].Size = ParseVector(value); break; case ItemType.ANCHOR: placeHolders[item.Name].Anchor = ParseVector(value); break; } } } return(placeHolders.Values.ToList()); }
private static void CopyXmlToWriter(XmlReader r, XmlWriter w) { while (r.Read()) { switch (r.NodeType) { case XmlNodeType.Element: w.WriteStartElement(r.Prefix, r.LocalName, r.NamespaceURI); if (r.HasAttributes) { r.MoveToFirstAttribute(); do { if (r.LocalName == "xop" && r.Prefix == "xmlns" && r.Value == "http://www.w3.org/2004/08/xop/include") { // special case: do not need to rewrite the xmlns:xop for MTOM // skip } else { w.WriteAttributeString(r.Prefix, r.LocalName, r.NamespaceURI, r.Value); } } while (r.MoveToNextAttribute()); r.MoveToElement(); } if (r.IsEmptyElement) { w.WriteEndElement(); } break; case XmlNodeType.CDATA: w.WriteCData(r.Value); break; case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: w.WriteWhitespace(r.Value); break; case XmlNodeType.Text: w.WriteString(r.Value); break; case XmlNodeType.XmlDeclaration: string stdAlone = r.GetAttribute("standalone"); if (stdAlone == null) { w.WriteStartDocument(); } else { bool isStandAlone = false; if (bool.TryParse(stdAlone, out isStandAlone)) { w.WriteStartDocument(isStandAlone); } else { w.WriteStartDocument(); } } break; case XmlNodeType.Comment: w.WriteComment(r.Value); break; case XmlNodeType.EndElement: w.WriteFullEndElement(); break; } } }
public override bool MoveToFirstAttribute() { return(initial ? false : Reader.MoveToFirstAttribute()); }
/// <summary> /// Load a model from an input stream /// </summary> /// <param name="inputStream">The stream to input from.</param> /// <returns>A <see cref="Store"/> with the model loaded.</returns> public Store Load(Stream inputStream) { List <string> unrecognizedNamespaces = null; Stream namespaceStrippedStream = null; Store store = null; try { XmlReaderSettings readerSettings = new XmlReaderSettings(); ExtensionLoader extensionLoader = myExtensionLoader; readerSettings.CloseInput = false; Dictionary <string, ExtensionModelBinding> documentExtensions = null; using (XmlReader reader = XmlReader.Create(inputStream, readerSettings)) { reader.MoveToContent(); if (reader.NodeType == XmlNodeType.Element) { if (reader.MoveToFirstAttribute()) { do { if (reader.Prefix == "xmlns") { string URI = reader.Value; if (!string.Equals(URI, ORMCoreDomainModel.XmlNamespace, StringComparison.Ordinal) && !string.Equals(URI, ORMShapeDomainModel.XmlNamespace, StringComparison.Ordinal) && !string.Equals(URI, ORMSerializationEngine.RootXmlNamespace, StringComparison.Ordinal)) { ExtensionModelBinding?extensionType = extensionLoader.GetExtensionDomainModel(URI); if (extensionType.HasValue) { if (documentExtensions == null) { documentExtensions = new Dictionary <string, ExtensionModelBinding>(); } documentExtensions[URI] = extensionType.Value; } else { (unrecognizedNamespaces ?? (unrecognizedNamespaces = new List <string>())).Add(URI); } } } } while (reader.MoveToNextAttribute()); } } } extensionLoader.VerifyRequiredExtensions(ref documentExtensions); if (unrecognizedNamespaces != null) { inputStream.Position = 0; namespaceStrippedStream = ExtensionLoader.CleanupStream(inputStream, extensionLoader.StandardDomainModels, documentExtensions.Values, unrecognizedNamespaces); if (namespaceStrippedStream != null) { inputStream = namespaceStrippedStream; } else { unrecognizedNamespaces = null; } } inputStream.Position = 0; store = CreateStore(); store.UndoManager.UndoState = UndoState.Disabled; store.LoadDomainModels(extensionLoader.GetRequiredDomainModels(documentExtensions)); try { ModelingEventManager eventManager = ModelingEventManager.GetModelingEventManager(store); using (Transaction t = store.TransactionManager.BeginTransaction("File load and fixup")) { foreach (IModelingEventSubscriber subscriber in Utility.EnumerateDomainModels <IModelingEventSubscriber>(store.DomainModels)) { subscriber.ManageModelingEventHandlers(eventManager, EventSubscriberReasons.DocumentLoading | EventSubscriberReasons.ModelStateEvents, EventHandlerAction.Add); } if (inputStream.Length > 1) { (new ORMSerializationEngine(store)).Load(inputStream); } t.Commit(); } foreach (IModelingEventSubscriber subscriber in Utility.EnumerateDomainModels <IModelingEventSubscriber>(store.DomainModels)) { subscriber.ManageModelingEventHandlers(eventManager, EventSubscriberReasons.DocumentLoaded | EventSubscriberReasons.ModelStateEvents, EventHandlerAction.Add); } store.UndoManager.UndoState = UndoState.Enabled; } catch (TypeInitializationException ex) { // If the type that failed to load is an extensions, then remove it from // the list of available extensions and try again. if (documentExtensions != null) { string typeName = ex.TypeName; foreach (KeyValuePair <string, ExtensionModelBinding> pair in documentExtensions) { Type testType = pair.Value.Type; if (testType.FullName == typeName) { if (extensionLoader.CustomExtensionUnavailable(testType)) { return(Load(inputStream)); } break; } } } throw; } } finally { if (namespaceStrippedStream != null) { namespaceStrippedStream.Dispose(); } } return(store); }
/// <summary>读取</summary> /// <param name="table"></param> /// <param name="reader"></param> /// <returns></returns> public static IDataTable ReadXml(this IDataTable table, XmlReader reader) { // 读属性 if (reader.HasAttributes) { reader.MoveToFirstAttribute(); ReadXml(reader, table); } reader.ReadStartElement(); // 读字段 reader.MoveToElement(); // 有些数据表模型没有字段 if (reader.NodeType == XmlNodeType.Element && reader.Name.EqualIgnoreCase("Table")) { return(table); } while (reader.NodeType != XmlNodeType.EndElement) //while (reader.NodeType == XmlNodeType.Element) { switch (reader.Name) { case "Columns": reader.ReadStartElement(); var id = 1; while (reader.IsStartElement()) { var dc = table.CreateColumn(); dc.ID = id++; var v = reader.GetAttribute("DataType"); if (v != null) { dc.DataType = v.GetTypeEx(); v = reader.GetAttribute("Length"); var len = 0; if (v != null && Int32.TryParse(v, out len)) { dc.Length = len; } // 含有ID表示是旧的,不需要特殊处理,否则一些默认值会不对 v = reader.GetAttribute("ID"); if (v == null) { dc = Fix(dc, dc); } } (dc as IXmlSerializable).ReadXml(reader); table.Columns.Add(dc); } reader.ReadEndElement(); // 修正可能的主字段 if (!table.Columns.Any(e => e.Master)) { var f = table.Columns.FirstOrDefault(e => e.Name.EqualIgnoreCase("Name", "Title")); if (f != null) { f.Master = true; } } break; case "Indexes": reader.ReadStartElement(); while (reader.IsStartElement()) { var di = table.CreateIndex(); (di as IXmlSerializable).ReadXml(reader); di.Fix(); table.Indexes.Add(di); } reader.ReadEndElement(); break; case "Relations": reader.ReadStartElement(); while (reader.IsStartElement()) { var dr = table.CreateRelation(); (dr as IXmlSerializable).ReadXml(reader); if (table.GetRelation(dr) == null) { table.Relations.Add(dr); } } reader.ReadEndElement(); break; default: // 这里必须处理,否则加载特殊Xml文件时将会导致死循环 reader.Read(); break; } } //if (reader.NodeType != XmlNodeType.Element && reader.NodeType != XmlNodeType.EndElement) reader.Read(); //reader.ReadEndElement(); if (reader.NodeType == XmlNodeType.EndElement) { reader.ReadEndElement(); } return(table); }
protected void Process(CXmlBase rParentNode) { CXmlNode rNewNode; while (true) { //We want to pop if Read() returns false, aka EOF if (_fReadNode) { if (!_rXmlReader.Read()) { DebugTrace("Read() == false"); return; } } else { if (!_rXmlReader.ReadAttributeValue()) { DebugTrace("ReadAttributeValue() == false"); return; } } DebugTrace(_rXmlReader); //We also want to pop if we get an EndElement or EndEntity if (_rXmlReader.NodeType == XmlNodeType.EndElement || _rXmlReader.NodeType == XmlNodeType.EndEntity) { DebugTrace("NodeType == EndElement or EndEntity"); return; } rNewNode = GetNewNode(_rXmlReader); rNewNode._nDepth = _rXmlReader.Depth; // Test for MixedContent and set Indent if necessary if ((rParentNode.Flags & NodeFlags.MixedContent) != 0) { rNewNode._eFlags |= NodeFlags.MixedContent; // Indent is off for all new nodes } else { rNewNode._eFlags |= NodeFlags.Indent; // Turn on Indent for current Node } // Set all Depth 0 nodes to No Mixed Content and Indent True if (_rXmlReader.Depth == 0) { rNewNode._eFlags |= NodeFlags.Indent; // Turn on Indent rNewNode._eFlags &= ~NodeFlags.MixedContent; // Turn off MixedContent } rParentNode.InsertNode(rNewNode); //Do some special stuff based on NodeType switch (_rXmlReader.NodeType) { case XmlNodeType.EntityReference: if (_eValidationMode == ValidationType.DTD) { _rXmlReader.ResolveEntity(); Process(rNewNode); } break; case XmlNodeType.Element: if (_rXmlReader.MoveToFirstAttribute()) { do { CXmlAttribute rNewAttribute = new CXmlAttribute(_rXmlReader); rNewNode.AddAttribute(rNewAttribute); if (_fExpandAttributeValues) { DebugTrace("Attribute: " + _rXmlReader.Name); _fReadNode = false; Process(rNewAttribute); _fReadNode = true; } else { CXmlNode rValueNode = new CXmlNode("", "", XmlNodeType.Text); rValueNode._eFlags = _eDefaultFlags | NodeFlags.HasValue; rValueNode._strValue = _rXmlReader.Value; DebugTrace(" Value=" + rValueNode.Value, _rXmlReader.Depth + 1); rNewAttribute.InsertNode(rValueNode); } } while (_rXmlReader.MoveToNextAttribute()); } if ((rNewNode.Flags & NodeFlags.EmptyElement) == 0) { Process(rNewNode); } break; case XmlNodeType.XmlDeclaration: if (_rXmlReader is XmlTextReader) { _eEncoding = ((XmlTextReader)_rXmlReader).Encoding; } #pragma warning disable 0618 else if (_rXmlReader is XmlValidatingReader) { _eEncoding = ((XmlValidatingReader)_rXmlReader).Encoding; } #pragma warning restore 0618 else { string strValue = rNewNode.NodeValue; int nPos = strValue.IndexOf("encoding"); if (nPos != -1) { int nEnd; nPos = strValue.IndexOf("=", nPos); //Find the = sign nEnd = strValue.IndexOf("\"", nPos) + 1; //Find the next " character nPos = strValue.IndexOf("'", nPos) + 1; //Find the next ' character if (nEnd == 0 || (nPos < nEnd && nPos > 0)) //Pick the one that's closer to the = sign { nEnd = strValue.IndexOf("'", nPos); } else { nPos = nEnd; nEnd = strValue.IndexOf("\"", nPos); } string sEncodeName = strValue.Substring(nPos, nEnd - nPos); DebugTrace("XMLDecl contains encoding " + sEncodeName); if (sEncodeName.ToUpper() == "UCS-2") { sEncodeName = "unicode"; } _eEncoding = System.Text.Encoding.GetEncoding(sEncodeName); } } break; case XmlNodeType.ProcessingInstruction: break; case XmlNodeType.Text: if (!_fReadNode) { rNewNode._eFlags = _eDefaultFlags | NodeFlags.AttributeTextNode; } rNewNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for current node rNewNode._eFlags &= ~NodeFlags.Indent; // turn off Indent for current node rParentNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for Parent Node break; case XmlNodeType.Whitespace: case XmlNodeType.SignificantWhitespace: case XmlNodeType.CDATA: rNewNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for current node rNewNode._eFlags &= ~NodeFlags.Indent; // turn off Indent for current node rParentNode._eFlags |= NodeFlags.MixedContent; // turn on Mixed Content for Parent Node break; case XmlNodeType.Comment: case XmlNodeType.Notation: break; case XmlNodeType.DocumentType: if (_rXmlReader.MoveToFirstAttribute()) { do { CXmlAttribute rNewAttribute = new CXmlAttribute(_rXmlReader); rNewNode.AddAttribute(rNewAttribute); CXmlNode rValueNode = new CXmlNode(_rXmlReader); rValueNode._strValue = _rXmlReader.Value; rNewAttribute.InsertNode(rValueNode); } while (_rXmlReader.MoveToNextAttribute()); } break; default: _output.WriteLine("UNHANDLED TYPE, " + _rXmlReader.NodeType.ToString() + " IN Process()!"); break; } } }
private object ParseReadXmlDefault(XmlReader reader, Type valueType) { var key = ""; var values = new Dictionary <string, string>(); while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Attribute: values.Add(reader.Name, reader.Value); while (reader.MoveToNextAttribute()) { goto case XmlNodeType.Attribute; } reader.MoveToElement(); break; case XmlNodeType.Element: if (reader.Depth == 0) { continue; } key = reader.Name; if (reader.HasAttributes) { if (reader.MoveToFirstAttribute()) { goto case XmlNodeType.Attribute; } } break; case XmlNodeType.CDATA: case XmlNodeType.Text: values.AddOrUpdate(key, reader.Value); break; } } var constructors = valueType.GetConstructors(ReflectionUtility.BindingInstancePublicAndPrivate).ToList(); var properties = valueType.GetProperties(ReflectionUtility.BindingInstancePublicAndPrivate).Where(info => info.CanWrite).ToDictionary(info => info.Name); var propertyNames = properties.Select(info => info.Key).Intersect(values.Select(pair => pair.Key), StringComparer.OrdinalIgnoreCase).ToList(); List <object> args = new List <object>(); foreach (var ctr in constructors) { var arguments = ctr.GetParameters(); var argumentsLength = arguments.Select(info => info.Name).Intersect(values.Select(pair => pair.Key), StringComparer.OrdinalIgnoreCase).Count(); if (arguments.Length == argumentsLength) { foreach (var arg in arguments) { args.Add(ObjectConverter.ChangeType(values.First(pair => pair.Key.Equals(arg.Name, StringComparison.OrdinalIgnoreCase)).Value, arg.ParameterType)); } break; } } if (args.Count == 0) { var staticMethods = valueType.GetMethods(ReflectionUtility.BindingInstancePublicAndPrivateNoneInheritedIncludeStatic).Where(info => info.ReturnType == valueType && info.IsStatic && !info.IsSpecialName).ToList(); foreach (var method in staticMethods) { var arguments = method.GetParameters(); var argumentsLength = arguments.Select(info => info.Name).Intersect(values.Select(pair => pair.Key), StringComparer.OrdinalIgnoreCase).Count(); if (arguments.Length == argumentsLength) { foreach (var arg in arguments) { args.Add(ObjectConverter.ChangeType(values.First(pair => pair.Key.Equals(arg.Name, StringComparison.OrdinalIgnoreCase)).Value, arg.ParameterType)); } return(method.Invoke(null, args.ToArray())); } } throw new SerializationException("Unable to find a suitable constructor or static method for deserialization."); } var instance = Activator.CreateInstance(valueType, args.ToArray()); foreach (var propertyName in propertyNames) { var property = properties[propertyName]; property.SetValue(instance, ObjectConverter.ChangeType(values.First(pair => pair.Key == propertyName).Value, property.PropertyType)); } return(instance); }
internal static string GetComparableForm(StringBuilder builder, XmlReader reader) { List <Attr> attrSet = new List <Attr>(); int valueLength = -1; while (!reader.EOF) { XmlNodeType type = reader.MoveToContent(); switch (type) { case XmlNodeType.Element: CompleteValue(builder, valueLength); valueLength = -1; builder.Append("<"); AppendString(builder, reader.LocalName); builder.Append(":"); AppendString(builder, reader.NamespaceURI); builder.Append(" "); // Scan attributes attrSet.Clear(); if (reader.MoveToFirstAttribute()) { do { // Ignore namespaces if (reader.Prefix == "xmlns" || reader.Name == "xmlns") { continue; } if (reader.LocalName == AddressingStrings.IsReferenceParameter && reader.NamespaceURI == Addressing10Strings.Namespace) { continue; // ignore IsReferenceParameter } string val = reader.Value; if ((reader.LocalName == TypeLN && reader.NamespaceURI == XsiNs) || (reader.NamespaceURI == SerNs && (reader.LocalName == ItemTypeLN || reader.LocalName == FactoryTypeLN))) { XmlUtil.ParseQName(reader, val, out string local, out string ns); val = local + "^" + local.Length.ToString(CultureInfo.InvariantCulture) + ":" + ns + "^" + ns.Length.ToString(CultureInfo.InvariantCulture); } else if (reader.LocalName == XD.UtilityDictionary.IdAttribute.Value && reader.NamespaceURI == XD.UtilityDictionary.Namespace.Value) { // ignore wsu:Id attributes added by security to sign the header continue; } attrSet.Add(new Attr(reader.LocalName, reader.NamespaceURI, val)); } while (reader.MoveToNextAttribute()); } reader.MoveToElement(); if (attrSet.Count > 0) { attrSet.Sort(); for (int i = 0; i < attrSet.Count; ++i) { Attr a = attrSet[i]; AppendString(builder, a._local); builder.Append(":"); AppendString(builder, a._ns); builder.Append("=\""); AppendString(builder, a._val); builder.Append("\" "); } } if (reader.IsEmptyElement) { builder.Append("></>"); // Should be the same as an empty tag. } else { builder.Append(">"); } break; case XmlNodeType.EndElement: CompleteValue(builder, valueLength); valueLength = -1; builder.Append("</>"); break; // Need to escape CDATA values case XmlNodeType.CDATA: CompleteValue(builder, valueLength); valueLength = -1; builder.Append("<![CDATA["); AppendString(builder, reader.Value); builder.Append("]]>"); break; case XmlNodeType.SignificantWhitespace: case XmlNodeType.Text: if (valueLength < 0) { valueLength = builder.Length; } builder.Append(reader.Value); break; default: // Do nothing break; } reader.Read(); } return(builder.ToString()); }
private void getModels(string filePath) { Stream stream = null; ImportedModel currentModel = null; IParameterSet currentSet = null; IGroup group = null; bool parametersXmlArea = true; //int i = 0; try { using (XmlReader reader = ProjectBase.getXmlReader(filePath, out stream)) { string modelClass; string name; //reader.ReadToFollowing("models"); while (reader.Read() && parametersXmlArea) { switch (reader.Name) { case "spectra": if (reader.MoveToFirstAttribute()) { modelClass = String.Empty; name = String.Empty; do { switch (reader.Name) { case "name": name = reader.Value; break; case "class": modelClass = reader.Value; break; // AvailableAssemblies.getModel(reader.Value); break; } } while (reader.MoveToNextAttribute()); if (name != String.Empty && modelClass != String.Empty) { _importedModels.Add(currentModel = new ImportedModel(modelClass, name)); _modelNames.Add(name); } } reader.MoveToElement(); break; case "spectrum": //only start elemement has attributes. end elements are not analysed if (reader.IsStartElement()) { if (currentModel == null) { throw new Exception(); } //if (currentSet != null) // currentModel.parameters.Add(currentSet); if (reader.ReadToFollowing("ps")) { currentSet = new ParameterSet(); } } else { currentModel.parameters.Add(currentSet); reader.MoveToElement(); currentSet = null; } break; case "group": if (reader.HasAttributes) { if (currentSet == null) { throw new Exception(); } //while (reader.Read()) { //groups if (reader.Name == "group") { XmlReader groupReader = reader.ReadSubtree(); group = SpectrumBase.getGroup(groupReader, null, currentModel.model); currentSet.addGroup(group); groupReader.Close(); } } break; case "models": if (!reader.HasAttributes) { parametersXmlArea = false; } break; } } if (_modelNames.Count > 0) { _modelNames.Insert(0, "(none)"); } } } catch (Exception) { throw new ImportException(String.Format("Failed to import parameters from {0}", filePath)); } finally { if (stream != null) { stream.Close(); } } if (_modelNames.Count == 0) { throw new ImportException(String.Format("{0}\ndoesn't contain any importable parameter values.", filePath)); } }
/// <summary> /// Generates an object from its XML representation. /// </summary> /// <param name="reader"> /// The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized. /// </param> public void ReadXml(XmlReader reader) { XmlSerializer keySerializer = new XmlSerializer(typeof(TKey)); XmlSerializer valueSerializer = new XmlSerializer(typeof(TValue)); bool wasEmpty = reader.IsEmptyElement; reader.Read(); if (wasEmpty) { return; } // var isSimpleKey = false; bool isSimpleKey = _overide ? false : typeof(TKey) == typeof(int) || typeof(TKey) == typeof(string); while (reader.NodeType != XmlNodeType.EndElement) { if (isSimpleKey) { TKey key = default(TKey); reader.Read(); reader.MoveToFirstAttribute(); if (typeof(TKey) == typeof(int)) { int realKey; if (int.TryParse(reader.Value, out realKey)) { key = (TKey)(object)realKey; } } else { key = (TKey)(object)reader.Value; } Console.WriteLine(key); reader.MoveToContent(); reader.Read(); TValue value = (TValue)valueSerializer.Deserialize(reader); reader.Read(); reader.ReadEndElement(); Add(key, value); } else { reader.ReadStartElement("item"); reader.ReadStartElement("key"); TKey key = (TKey)keySerializer.Deserialize(reader); reader.ReadEndElement(); reader.ReadStartElement("value"); TValue value = (TValue)valueSerializer.Deserialize(reader); reader.ReadEndElement(); Add(key, value); reader.ReadEndElement(); reader.MoveToContent(); } } if (!isSimpleKey) { reader.ReadEndElement(); } }
public override bool MoveToFirstAttribute() { return(_me.MoveToFirstAttribute()); }
public bool parse(string pszFile) { Thread.CurrentThread.CurrentCulture = new CultureInfo("en-US"); Thread.CurrentThread.CurrentUICulture = new CultureInfo("en-US"); CCContent data = CCApplication.sharedApplication().content.Load <CCContent>(pszFile); string str = data.Content; if (data == null) { return(false); } TextReader textReader = new StringReader(str); XmlReaderSettings setting = new XmlReaderSettings(); setting.DtdProcessing = DtdProcessing.Ignore; XmlReader xmlReader = XmlReader.Create(textReader, setting); int dataindex = 0; int Width = 0; int Height = 0;; while (xmlReader.Read()) { string name = xmlReader.Name; switch (xmlReader.NodeType) { case XmlNodeType.Element: string[] attrs = null; if (name == "map") { Width = ccUtils.ccParseInt(xmlReader.GetAttribute("width")); Height = ccUtils.ccParseInt(xmlReader.GetAttribute("height")); } if (xmlReader.HasAttributes) { attrs = new string[xmlReader.AttributeCount * 2]; xmlReader.MoveToFirstAttribute(); int i = 0; attrs[0] = xmlReader.Name; attrs[1] = xmlReader.Value; i += 2; while (xmlReader.MoveToNextAttribute()) { attrs[i] = xmlReader.Name; attrs[i + 1] = xmlReader.Value; i += 2; } // Move the reader back to the element node. xmlReader.MoveToElement(); } startElement(this, name, attrs); byte[] buffer = null; //read data content of tmx file if (name == "data") { if (attrs != null) { string encoding = ""; for (int i = 0; i < attrs.Length; i++) { if (attrs[i] == "encoding") { encoding = attrs[i + 1]; } } if (encoding == "base64") { int dataSize = (Width * Height * 4) + 1024; buffer = new byte[dataSize]; xmlReader.ReadElementContentAsBase64(buffer, 0, dataSize); } else { string value = xmlReader.ReadElementContentAsString(); buffer = Encoding.UTF8.GetBytes(value); } } textHandler(this, buffer, buffer.Length); endElement(this, name); } else if (name == "key" || name == "integer" || name == "real" || name == "string" || name == "true" || name == "false") // http://www.cocos2d-x.org/boards/17/topics/11355 { string value = xmlReader.ReadElementContentAsString(); buffer = Encoding.UTF8.GetBytes(value); textHandler(this, buffer, buffer.Length); endElement(this, name); } else { IXmlLineInfo info = (IXmlLineInfo)xmlReader; CCLog.Log("Failed to handle XML tag: " + name + " in " + info.LineNumber + "@" + info.LinePosition + ":" + pszFile); } break; case XmlNodeType.EndElement: endElement(this, xmlReader.Name); dataindex++; break; default: break; } } return(true); }
public override bool MoveToFirstAttribute() { return(innerReader.MoveToFirstAttribute()); }
// read void ReadXml(XmlReader reader, bool fromSerializable) { if (reader == null) { throw new ArgumentNullException("reader"); } SetItem(CreateItemInstance()); reader.MoveToContent(); if (reader.MoveToFirstAttribute()) { do { if (reader.NamespaceURI == "http://www.w3.org/2000/xmlns/") { continue; } if (!TryParseAttribute(reader.LocalName, reader.NamespaceURI, reader.Value, Item, Version) && PreserveAttributeExtensions) { Item.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value); } } while (reader.MoveToNextAttribute()); } reader.ReadStartElement(); for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (reader.NodeType != XmlNodeType.Element) { throw new XmlException("Only element node is expected under 'entry' element"); } if (reader.NamespaceURI == AtomNamespace) { switch (reader.LocalName) { case "author": SyndicationPerson p = Item.CreatePerson(); ReadPerson(reader, p); Item.Authors.Add(p); continue; case "category": SyndicationCategory c = Item.CreateCategory(); ReadCategory(reader, c); Item.Categories.Add(c); continue; case "contributor": p = Item.CreatePerson(); ReadPerson(reader, p); Item.Contributors.Add(p); continue; case "id": Item.Id = reader.ReadElementContentAsString(); continue; case "link": SyndicationLink l = Item.CreateLink(); ReadLink(reader, l); Item.Links.Add(l); continue; case "published": Item.PublishDate = XmlConvert.ToDateTimeOffset(reader.ReadElementContentAsString()); continue; case "rights": Item.Copyright = ReadTextSyndicationContent(reader); continue; case "source": Item.SourceFeed = ReadSourceFeed(reader); continue; case "summary": Item.Summary = ReadTextSyndicationContent(reader); continue; case "title": Item.Title = ReadTextSyndicationContent(reader); continue; case "updated": Item.LastUpdatedTime = XmlConvert.ToDateTimeOffset(reader.ReadElementContentAsString()); continue; // Atom 1.0 does not specify "content" element, but it is required to distinguish Content property from extension elements. case "content": if (reader.GetAttribute("src") != null) { Item.Content = new UrlSyndicationContent(CreateUri(reader.GetAttribute("src")), reader.GetAttribute("type")); reader.Skip(); continue; } switch (reader.GetAttribute("type")) { case "text": case "html": case "xhtml": Item.Content = ReadTextSyndicationContent(reader); continue; default: SyndicationContent content; if (!TryParseContent(reader, Item, reader.GetAttribute("type"), Version, out content)) { Item.Content = new XmlSyndicationContent(reader); } continue; } } } if (!TryParseElement(reader, Item, Version)) { if (PreserveElementExtensions) { // FIXME: what to specify for maxExtensionSize LoadElementExtensions(reader, Item, int.MaxValue); } else { reader.Skip(); } } } reader.ReadEndElement(); // </item> }
/// <summary> /// Processes a GPX file, invoking callbacks on a <see cref="GpxVisitorBase"/> instance as /// elements are observed. /// </summary> /// <param name="reader"> /// The <see cref="XmlReader"/> to read from. /// </param> /// <param name="settings"> /// The <see cref="GpxReaderSettings"/> instance to use to control how GPX instances get /// read in, or <c>null</c> to use a general-purpose default. /// </param> /// <param name="visitor"> /// The <see cref="GpxVisitorBase"/> instance that will receive callbacks. /// </param> /// <remarks> /// This method is the "core" reading method; everything else builds off of this. /// </remarks> /// <exception cref="ArgumentNullException"> /// Thrown when <paramref name="reader"/> or <paramref name="visitor"/> is /// <see langword="null"/>. /// </exception> /// <exception cref="XmlException"> /// Thrown when <paramref name="reader"/> does not specify a valid GPX file (i.e., cases /// where XSD schema validation would fail, and/or some values are <b>well</b> outside of /// the slightly stricter, but still completely reasonable, limits imposed by the idiomatic /// .NET data types above and beyond the XSD limits). /// </exception> public static void Read(XmlReader reader, GpxReaderSettings settings, GpxVisitorBase visitor) { if (reader is null) { throw new ArgumentNullException(nameof(reader)); } if (visitor is null) { throw new ArgumentNullException(nameof(visitor)); } settings = settings ?? new GpxReaderSettings(); while (reader.ReadToFollowing("gpx", Helpers.GpxNamespace)) { string version = null; string creator = settings.DefaultCreatorIfMissing; for (bool hasAttribute = reader.MoveToFirstAttribute(); hasAttribute; hasAttribute = reader.MoveToNextAttribute()) { switch (reader.Name) { case "version": version = reader.Value; break; case "creator": creator = reader.Value; break; } } if (version != "1.1" && !settings.IgnoreVersionAttribute) { throw new XmlException("'version' must be '1.1'"); } if (creator is null) { throw new XmlException("'creator' must be specified"); } if (!ReadTo(reader, XmlNodeType.Element, XmlNodeType.EndElement)) { visitor.VisitMetadata(new GpxMetadata(creator)); break; } bool expectingMetadata = true; bool expectingExtensions = true; do { if (expectingMetadata) { expectingMetadata = false; if (reader.Name == "metadata") { ReadMetadata(reader, settings, creator, visitor); } else { visitor.VisitMetadata(new GpxMetadata(creator)); } } switch (reader.Name) { // ideally, it should all be in this order, since the XSD validation // would fail otherwise, but whatever. case "wpt": ReadWaypoint(reader, settings, visitor); break; case "rte": ReadRoute(reader, settings, visitor); break; case "trk": ReadTrack(reader, settings, visitor); break; case "extensions" when expectingExtensions: expectingExtensions = false; var extensionElement = (XElement)XNode.ReadFrom(reader); object extensions = settings.ExtensionReader.ConvertGpxExtensionElement(extensionElement.Elements()); if (!(extensions is null)) { visitor.VisitExtensions(extensions); } break; } }while (ReadTo(reader, XmlNodeType.Element, XmlNodeType.EndElement)); } }
void ReadLink(XmlReader reader, SyndicationLink link) { if (reader.MoveToFirstAttribute()) { do { if (reader.NamespaceURI == "http://www.w3.org/2000/xmlns/") { continue; } if (reader.NamespaceURI == String.Empty) { switch (reader.LocalName) { case "href": link.Uri = CreateUri(reader.Value); continue; case "rel": link.RelationshipType = reader.Value; continue; case "type": link.MediaType = reader.Value; continue; case "length": link.Length = XmlConvert.ToInt64(reader.Value); continue; case "title": link.Title = reader.Value; continue; } } if (!TryParseAttribute(reader.LocalName, reader.NamespaceURI, reader.Value, link, Version) && PreserveAttributeExtensions) { link.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value); } } while (reader.MoveToNextAttribute()); reader.MoveToElement(); } if (!reader.IsEmptyElement) { reader.Read(); for (reader.MoveToContent(); reader.NodeType != XmlNodeType.EndElement; reader.MoveToContent()) { if (!TryParseElement(reader, link, Version)) { if (PreserveElementExtensions) { // FIXME: what should be used for maxExtenswionSize LoadElementExtensions(reader, link, int.MaxValue); } else { reader.Skip(); } } } } reader.Read(); // </link> or <link ... /> }