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"); } }
// Use this for initialization void Start() { string last_element = ""; int counter = 1; textAsset = (TextAsset) Resources.Load("XMLs/tea_dialog"); reader = XmlReader.Create(new StringReader(textAsset.text)); //pull in the animation names from the xml file while (reader.Read ()) { if(reader.NodeType == XmlNodeType.Element){ while(reader.MoveToNextAttribute()) { if(reader.Name == "id") { //print (counter + " : " + reader.Value); animIndices.Add (counter, reader.Value); counter += 1; } } } } //print out hash table, for testing purposes //printHashTable (); }
void IFlickrParsable.Load(XmlReader reader) { if (reader.LocalName != "photoset") { UtilityMethods.CheckParsingException(reader); } while (reader.MoveToNextAttribute()) { switch (reader.LocalName) { case "id": PhotosetId = reader.Value; break; case "primary": PrimaryPhotoId = reader.Value; break; case "owner": OwnerId = reader.Value; break; case "ownername": OwnerName = reader.Value; break; case "page": Page = int.Parse(reader.Value, NumberFormatInfo.InvariantInfo); break; case "total": Total = int.Parse(reader.Value, NumberFormatInfo.InvariantInfo); break; case "pages": Pages = int.Parse(reader.Value, NumberFormatInfo.InvariantInfo); break; case "perpage": case "per_page": PerPage = int.Parse(reader.Value, NumberFormatInfo.InvariantInfo); break; case "title": Title = reader.Value; break; default: UtilityMethods.CheckParsingException(reader); break; } } reader.Read(); while (reader.LocalName == "photo") { var photo = new Photo(); ((IFlickrParsable)photo).Load(reader); if (String.IsNullOrEmpty(photo.UserId)) { photo.UserId = OwnerId; } Add(photo); } reader.Skip(); }
internal object LoadData(XmlReader reader, Type type, object obj) { Dictionary <string, string> metadata = null; int depth = reader.Depth; while (reader.Read()) { if ((reader.NodeType == XmlNodeType.EndElement) && (reader.Depth <= depth)) { break; } if (reader.NodeType != XmlNodeType.Element) { continue; } if (reader.Name == "Meta") { if (metadata == null) { metadata = new Dictionary <string, string>(); } reader.MoveToFirstAttribute(); do { metadata.Add(reader.Name, reader.ReadContentAsString()); } while (reader.MoveToNextAttribute()); } if (reader.IsEmptyElement) { continue; } Destroyable dObj = obj as Destroyable; // A Type object has no reasonable default value. if ((type != typeof(Type)) && (obj == null || (dObj != null && dObj.IsDestroyed))) { object tag = obj is Tagged ? ((Tagged)obj).Tag : null; string stag = tag as string; if (!TryCreateObject(type, stag, out obj)) { throw new NullReferenceException("Object of type " + type.Name + " must be initialized before it can be loaded since there is no factory method or default constructor for it."); } } if (reader.Name == "Field" || reader.Name == "Property") { string mName = reader.GetAttribute("Name"); Type mType = TypeHelper.Parse(reader.GetAttribute("Type")); if (reader.Name == "Property") { PropertyInfo propInfo = type.GetProperty(mName, BindingFlags.GetProperty | AllOfInstance); if (propInfo == null) { throw new ArgumentException(type.Name + " does not contain property " + mName); } object mValue = propInfo.GetValue(obj, null); mValue = LoadData(reader, mType, mValue); propInfo.SetValue(obj, mValue, null); } else { FieldInfo fieldInfo = type.GetField(mName, BindingFlags.GetField | AllOfInstance); if (fieldInfo == null) { throw new ArgumentException(type.Name + " does not contain field " + mName); } object mValue = fieldInfo.GetValue(obj); mValue = LoadData(reader, mType, mValue); fieldInfo.SetValue(obj, mValue); } } else if (reader.Name == "SerializedObject") { // Used for legacy support only reader.Read(); object objValue = null; using (MemoryStream dataStream = new MemoryStream(Encoding.Unicode.GetBytes(reader.Value))) { XmlSerializer serializer = new XmlSerializer(type); objValue = serializer.Deserialize(dataStream); } while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement) { reader.Read(); } obj = objValue; } else if (reader.Name == "Value") { reader.Read(); if (type.IsEnum) { obj = Enum.Parse(type, reader.Value, false); } else { obj = GenParse(type, reader.Value); } while (!reader.EOF && reader.NodeType != XmlNodeType.EndElement) { reader.Read(); } } else if (reader.Name == "Array") { Type mType = TypeHelper.Parse(reader.GetAttribute("Type")); obj = LoadArray(reader, mType, obj); } else if (reader.Name == "List") { Type mType = TypeHelper.Parse(reader.GetAttribute("Type")); int itemCount = int.Parse(reader.GetAttribute("Count")); obj = LoadList(reader, mType, itemCount, obj); } } if (metadata != null) { foreach (KeyValuePair <string, string> entry in metadata) { applyMetadata(type, obj, entry.Key, entry.Value); } } return(obj); }
protected override object CreateInstance(WorkflowMarkupSerializationManager serializationManager, Type type) { Activity activity3; if (serializationManager == null) { throw new ArgumentNullException("serializationManager"); } if (type == null) { throw new ArgumentNullException("type"); } object obj2 = null; IDesignerHost service = serializationManager.GetService(typeof(IDesignerHost)) as IDesignerHost; XmlReader reader = serializationManager.WorkflowMarkupStack[typeof(XmlReader)] as XmlReader; if ((service == null) || (reader == null)) { return(obj2); } string str = string.Empty; while (reader.MoveToNextAttribute() && !reader.LocalName.Equals("Name", StringComparison.Ordinal)) { } if (reader.LocalName.Equals("Name", StringComparison.Ordinal) && reader.ReadAttributeValue()) { str = reader.Value; } reader.MoveToElement(); if (string.IsNullOrEmpty(str)) { serializationManager.ReportError(SR.GetString("Error_LayoutSerializationAssociatedActivityNotFound", new object[] { reader.LocalName, "Name" })); return(obj2); } CompositeActivityDesigner designer = serializationManager.Context[typeof(CompositeActivityDesigner)] as CompositeActivityDesigner; if (designer != null) { CompositeActivity activity2 = designer.Activity as CompositeActivity; if (activity2 == null) { goto Label_01D0; } activity3 = null; foreach (Activity activity4 in activity2.Activities) { if (str.Equals(activity4.Name, StringComparison.Ordinal)) { activity3 = activity4; break; } } } else { Activity rootComponent = service.RootComponent as Activity; if ((rootComponent != null) && !str.Equals(rootComponent.Name, StringComparison.Ordinal)) { foreach (IComponent component in service.Container.Components) { rootComponent = component as Activity; if ((rootComponent != null) && str.Equals(rootComponent.Name, StringComparison.Ordinal)) { break; } } } if (rootComponent != null) { obj2 = service.GetDesigner(rootComponent); } goto Label_01D0; } if (activity3 != null) { obj2 = service.GetDesigner(activity3); } Label_01D0: if (obj2 == null) { serializationManager.ReportError(SR.GetString("Error_LayoutSerializationActivityNotFound", new object[] { reader.LocalName, str, "Name" })); } return(obj2); }
static void Main(string[] args) { XmlReaderSettings readerSettings = new XmlReaderSettings(); readerSettings.IgnoreWhitespace = true; readerSettings.IgnoreComments = true; readerSettings.ValidationType = ValidationType.Schema; readerSettings.Schemas.Add(null, @"..\..\Personen.xsd"); readerSettings.ValidationEventHandler += ValidationCallback; XmlReader reader = XmlReader.Create(@"..\..\Personen.xml", readerSettings); try{ while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.XmlDeclaration: Console.WriteLine("{0,-20}<{1}>", "DEKLARATION", reader.Value); break; case XmlNodeType.CDATA: Console.WriteLine("{0,-20}{1}", "CDATA", reader.Value); break; case XmlNodeType.Whitespace: Console.WriteLine("{0,-20}", "WHITESPACE"); break; case XmlNodeType.Comment: Console.WriteLine("{0,-20}<!--{1}-->", "COMMENT", reader.Value); break; case XmlNodeType.Element: if (reader.IsEmptyElement) { Console.WriteLine("{0,-20}<{1} />", "EMPTY_ELEMENT", reader.Name); } else { Console.WriteLine("{0,-20}<{1}>", "ELEMENT", reader.Name); // Prüfen, ob der Knoten Attribute hat if (reader.HasAttributes) { // Durch die Attribute navigieren while (reader.MoveToNextAttribute()) { Console.WriteLine("{0,-20}{1}", "ATTRIBUT", reader.Name + "=" + reader.Value); } } } break; case XmlNodeType.EndElement: Console.WriteLine("{0,-20}</{1}>", "END_ELEMENT", reader.Name); break; case XmlNodeType.Text: Console.WriteLine("{0,-20}{1}", "TEXT", reader.Value); break; } } } catch (Exception ex) { Console.WriteLine("Validierung fehlgeschlagen.\n{0}", ex.Message); } reader.Close(); Console.ReadLine(); }
public bool ParseReaderNode() { if (reader.Depth > markupDepth) { if (processMarkup) { ProcessAppInfoDocMarkup(false); } return(true); } else if (reader.NodeType == XmlNodeType.Element) { if (builder.ProcessElement(reader.Prefix, reader.LocalName, reader.NamespaceURI)) { namespaceManager.PushScope(); if (reader.MoveToFirstAttribute()) { do { builder.ProcessAttribute(reader.Prefix, reader.LocalName, reader.NamespaceURI, reader.Value); if (Ref.Equal(reader.NamespaceURI, schemaNames.NsXmlNs) && isProcessNamespaces) { namespaceManager.AddNamespace(reader.Prefix.Length == 0 ? string.Empty : reader.LocalName, reader.Value); } }while (reader.MoveToNextAttribute()); reader.MoveToElement(); // get back to the element } builder.StartChildren(); if (reader.IsEmptyElement) { namespaceManager.PopScope(); builder.EndChildren(); if (reader.Depth == schemaXmlDepth) { return(false); // done } } else if (!builder.IsContentParsed()) //AppInfo and Documentation { markupDepth = reader.Depth; processMarkup = true; if (annotationNSManager == null) { annotationNSManager = new XmlNamespaceManager(nameTable); xmlns = nameTable.Add("xmlns"); } ProcessAppInfoDocMarkup(true); } } else if (!reader.IsEmptyElement) //UnsupportedElement in that context { markupDepth = reader.Depth; processMarkup = false; //Hack to not process unsupported elements } } else if (reader.NodeType == XmlNodeType.Text) //Check for whitespace { if (!xmlCharType.IsOnlyWhitespace(reader.Value)) { builder.ProcessCData(reader.Value); } } else if (reader.NodeType == XmlNodeType.EntityReference || reader.NodeType == XmlNodeType.SignificantWhitespace || reader.NodeType == XmlNodeType.CDATA) { builder.ProcessCData(reader.Value); } else if (reader.NodeType == XmlNodeType.EndElement) { if (reader.Depth == markupDepth) { if (processMarkup) { Debug.Assert(parentNode != null); XmlNodeList list = parentNode.ChildNodes; XmlNode[] markup = new XmlNode[list.Count]; for (int i = 0; i < list.Count; i++) { markup[i] = list[i]; } builder.ProcessMarkup(markup); namespaceManager.PopScope(); builder.EndChildren(); } markupDepth = int.MaxValue; } else { namespaceManager.PopScope(); builder.EndChildren(); } if (reader.Depth == schemaXmlDepth) { return(false); // done } } return(true); }
// Read and extract into InterfaceRight class each attribut of node name "group" InterfaceElement check_attribute_group(XmlReader xml_reader) { InterfaceElement s_InterfaceElement = new InterfaceElement(); s_InterfaceElement.mse_type = 0; s_InterfaceElement.b_toggle_type = false; s_InterfaceElement.s_content = "undefined"; s_InterfaceElement.s_text_area = "Choose a title"; if (xml_reader.HasAttributes) { while (xml_reader.MoveToNextAttribute() != false) { bool valide_type = true; string save_type = ""; string save_readstring = ""; string save_content = ""; // if type exist, else, a button will be created if ((save_type = xml_reader.GetAttribute("type")) != null) { if (Enum.IsDefined(typeof(me_button_type),save_type) == true) s_InterfaceElement.mse_type = (me_button_type)Enum.Parse(typeof(me_button_type), save_type); else valide_type = false; } // if content as attribute or string exist, else, "undefined" has been saved if ((save_content = xml_reader.GetAttribute("content")) != null || (save_readstring = xml_reader.ReadString()) != null) { s_InterfaceElement.s_content = save_content != null ? save_content : save_readstring; if (valide_type == false) s_InterfaceElement.s_content += " (Coming Soon)"; } } } return s_InterfaceElement; }
private void ProcessDisplayFolder(XmlReader rdr, ADOTabularTable table, IADOTabularFolderReference parent) { var folderReference = ""; string folderCaption = null; string objRef = ""; while (!(rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "DisplayFolder")) { if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "DisplayFolder") { while (rdr.MoveToNextAttribute()) { switch (rdr.LocalName) { case "Name": folderReference = rdr.Value; break; case "Caption": folderCaption = rdr.Value; break; } } // create folder and add to parent's folders IADOTabularFolderReference folder = new ADOTabularDisplayFolder(folderCaption, folderReference); parent.FolderItems.Add(folder); rdr.ReadToNextElement(); // recurse down to child items ProcessDisplayFolder(rdr, table, folder); rdr.Read(); //rdr.ReadToNextElement(); // read the end element } if ((rdr.NodeType == XmlNodeType.Element) && (rdr.LocalName == "PropertyRef")) { while (rdr.MoveToNextAttribute()) { switch (rdr.LocalName) { case "Name": objRef = rdr.Value; break; } } // create reference object IADOTabularObjectReference reference = new ADOTabularObjectReference("", objRef); parent.FolderItems.Add(reference); var column = table.Columns.GetByPropertyRef(objRef); if (column != null) { column.IsInDisplayFolder = true; } objRef = ""; rdr.Read(); } if ((rdr.NodeType != XmlNodeType.Element && rdr.NodeType != XmlNodeType.EndElement) && (rdr.LocalName != "DisplayFolder" && rdr.LocalName != "PropertyRef" && rdr.LocalName != "DisplaFolders")) { rdr.ReadToNextElement(); } if (rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "DisplayFolders") { rdr.Read(); break; } //rdr.Read(); } }
private List <ADOTabularVariation> ProcessVariations(XmlReader rdr) { string _name = string.Empty; bool _default = false; string navigationPropertyRef = string.Empty; string defaultHierarchyRef = string.Empty; List <ADOTabularVariation> _variations = new List <ADOTabularVariation>(); while (!(rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "Variations")) { if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "Variation") { while (rdr.MoveToNextAttribute()) { switch (rdr.LocalName) { case "Name": _name = rdr.Value; break; case "Default": _default = bool.Parse(rdr.Value); break; } } } if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "NavigationPropertyRef") { while (rdr.MoveToNextAttribute()) { if (rdr.LocalName == "Name") { navigationPropertyRef = rdr.Value; } } } if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "DefaultHierarchyRef") { while (rdr.MoveToNextAttribute()) { if (rdr.LocalName == "Name") { defaultHierarchyRef = rdr.Value; } } } if (rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "Variation") { _variations.Add(new ADOTabularVariation() { NavigationPropertyRef = navigationPropertyRef, DefaultHierarchyRef = defaultHierarchyRef, IsDefault = _default }); _default = false; navigationPropertyRef = string.Empty; defaultHierarchyRef = string.Empty; } rdr.Read(); } return(_variations); }
private void AddColumnsToTable(XmlReader rdr , ADOTabularTableCollection tables , string eEntityType) { var eProperty = rdr.NameTable.Add("Property"); var eMeasure = rdr.NameTable.Add("Measure"); var eSummary = rdr.NameTable.Add("Summary"); var eStatistics = rdr.NameTable.Add("Statistics"); var eMinValue = rdr.NameTable.Add("MinValue"); var eMaxValue = rdr.NameTable.Add("MaxValue"); // this routine effectively processes and <EntityType> element and it's children string caption = ""; string description = ""; bool isVisible = true; string name = null; string refName = ""; string tableId = ""; string dataType = ""; string contents = ""; string minValue = ""; string maxValue = ""; string formatString = ""; string defaultAggregateFunction = ""; long stringValueMaxLength = 0; long distinctValueCount = 0; bool nullable = true; List <ADOTabularVariation> _variations = new List <ADOTabularVariation>(); KpiDetails kpi = new KpiDetails(); var colType = ADOTabularObjectType.Column; while (!(rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == eEntityType)) { if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == eEntityType) { while (rdr.MoveToNextAttribute()) { switch (rdr.LocalName) { case "Name": tableId = rdr.Value; break; } } } if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "Hierarchy") { ProcessHierarchy(rdr, tables.GetById(tableId), eEntityType); } if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "DisplayFolder") { Debug.WriteLine("FoundFolder"); var tbl = tables.GetById(tableId); ProcessDisplayFolder(rdr, tbl, tbl); } if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "Kpi") { kpi = ProcessKpi(rdr, tables.GetById(tableId)); } if (rdr.NodeType == XmlNodeType.Element && (rdr.LocalName == eProperty || rdr.LocalName == eMeasure || rdr.LocalName == eSummary || rdr.LocalName == eStatistics || rdr.LocalName == eMinValue || rdr.LocalName == eMaxValue)) { if (rdr.LocalName == eMeasure) { colType = ADOTabularObjectType.Measure; } if (rdr.LocalName == eSummary) { description = rdr.ReadElementContentAsString(); } while (rdr.MoveToNextAttribute()) { switch (rdr.LocalName) { case "Name": refName = rdr.Value; break; case "ReferenceName": // reference name will always come after the Name and will override it if present name = rdr.Value; break; case "Type": dataType = rdr.Value; break; case "Caption": caption = rdr.Value; break; case "Contents": contents = rdr.Value; break; case "Hidden": isVisible = !bool.Parse(rdr.Value); break; case "Description": description = rdr.Value; break; case "DistinctValueCount": distinctValueCount = long.Parse(rdr.Value); break; case "StringValueMaxLength": stringValueMaxLength = long.Parse(rdr.Value); break; case "FormatString": formatString = rdr.Value; break; case "DefaultAggregateFunction": defaultAggregateFunction = rdr.Value; break; case "Nullable": nullable = bool.Parse(rdr.Value); break; // Precision Scale //TODO - Add RowCount } } } if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "Variations") { _variations = ProcessVariations(rdr); } if (rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == eProperty && rdr.LocalName == "Property") { if (caption.Length == 0) { caption = refName; } if (!string.IsNullOrWhiteSpace(caption)) { var tab = tables.GetById(tableId); if (kpi.IsBlank()) { var col = new ADOTabularColumn(tab, refName, name, caption, description, isVisible, colType, contents); col.DataType = Type.GetType(string.Format("System.{0}", dataType)); col.Nullable = nullable; col.MinValue = minValue; col.MaxValue = maxValue; col.DistinctValues = distinctValueCount; col.FormatString = formatString; col.StringValueMaxLength = stringValueMaxLength; col.Variations.AddRange(_variations); tables.Model.AddRole(col); tab.Columns.Add(col); _conn.Columns.Add(col.OutputColumnName, col); } else { colType = ADOTabularObjectType.KPI; var kpiCol = new ADOTabularKpi(tab, refName, name, caption, description, isVisible, colType, contents, kpi); kpiCol.DataType = Type.GetType(string.Format("System.{0}", dataType)); tab.Columns.Add(kpiCol); _conn.Columns.Add(kpiCol.OutputColumnName, kpiCol); } } // reset temp variables kpi = new KpiDetails(); refName = ""; caption = ""; name = null; description = ""; isVisible = true; contents = ""; dataType = ""; stringValueMaxLength = -1; formatString = ""; defaultAggregateFunction = ""; nullable = true; colType = ADOTabularObjectType.Column; _variations = new List <ADOTabularVariation>(); } rdr.Read(); } //TODO - link up back reference to backing measures for KPIs }
/// <summary> /// Find all links. /// </summary> private IEnumerable<string> findAllLinks( XmlReader xml, string baseUrl ) { var links = new List<string>(); while ( xml.Read() ) { switch ( xml.NodeType ) { // Added 2006-03-27: Inside comments, too. case XmlNodeType.Comment: XmlReader childXml = getDocReader( xml.Value, baseUrl ); IEnumerable<string> childLinks = findAllLinks( childXml, baseUrl ); links.AddRange( childLinks ); break; // A node element. case XmlNodeType.Element: string[] linkAttributeNames; // If this is a link element, store the URLs to modify. if ( isLinkElement( xml.Name, out linkAttributeNames ) ) { while ( xml.MoveToNextAttribute() ) { checkAddStyleAttributeLinks( xml.Name, xml.Value, links ); // ReSharper disable LoopCanBeConvertedToQuery foreach ( string a in linkAttributeNames ) // ReSharper restore LoopCanBeConvertedToQuery { if ( a.ToLower() == xml.Name.ToLower() ) { string linkUrl = xml.Value; if ( !isAbsoluteUrl( linkUrl ) ) { links.Add( linkUrl ); } } } } } else { // Also, look for style attributes. while ( xml.MoveToNextAttribute() ) { checkAddStyleAttributeLinks( xml.Name, xml.Value, links ); } } break; } } return links.ToArray(); }
} //ReadTransformWrite() /// <summary> /// Output the tranformed XML in annotated form to the console. /// Calls the Output method. /// </summary> /// <param name="reader"></param> private static void OutputXml (XmlReader reader) { while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.ProcessingInstruction: Output(reader, "ProcessingInstruction"); break; case XmlNodeType.DocumentType: Output(reader, "DocumentType"); break; case XmlNodeType.Document: Output(reader, "Document"); break; case XmlNodeType.Comment: Output(reader, "Comment"); break; case XmlNodeType.Element: Output(reader, "Element"); while(reader.MoveToNextAttribute()) { Output(reader, "Attribute"); } //while break; case XmlNodeType.Text: Boolean flag = false; // Do not display whitespace text nodes for (int i=0; i < reader.Value.Length; i++) { if (!System.Char.IsWhiteSpace(reader.Value[i])) flag = true; } //for if(flag) Output (reader, "Text"); break; } //switch } //while Console.WriteLine(); } //OutputXML()
/* Method to extract the client specific parts of the config file */ private bool ExtractClientConfig(XmlReader reader) { try { while (reader.Read()) { if (reader.IsStartElement()) { if (reader.Name == "client") { client_config.Add(new ClientConfig()); while (reader.MoveToNextAttribute()) { if (reader.Name == "name") client_config.Last().name.Add("short_name", reader.Value); else if (reader.Name == "lname") client_config.Last().name.Add("full_name", reader.Value); else Console.WriteLine("Unknown report configuration attribute: " + reader.Name); } } else if (reader.Name == "project") client_config.Last().projects.Add(reader.ReadString()); else if (reader.Name == "priority") client_config.Last().priority.Add(reader.ReadString()); else if (reader.Name == "email") client_config.Last().email.Add(reader.ReadString()); } } return true; } catch (Exception ex) { Console.WriteLine("Exception when extracting client data from config XML: " + ex.Message); return false; } }
/// <summary> /// Protected method that does the actual initialization of the Photo instance. Should be called by subclasses of the Photo class. /// </summary> /// <param name="reader">The reader containing the XML to be parsed.</param> /// <param name="allowExtraAtrributes">Wheither to allow unknown extra attributes. /// In debug builds will throw an exception if this parameter is false and an unknown attribute is found.</param> protected void Load(XmlReader reader, bool allowExtraAtrributes) { if (reader.LocalName != "photo" && reader.LocalName != "primary_photo_extras") { UtilityMethods.CheckParsingException(reader); } while (reader.MoveToNextAttribute()) { switch (reader.LocalName) { case "id": PhotoId = reader.Value; if (string.IsNullOrEmpty(reader.Value)) { reader.Skip(); return; } break; case "owner": UserId = reader.Value; break; case "secret": Secret = reader.Value; break; case "server": Server = reader.Value; break; case "farm": Farm = reader.Value; break; case "title": Title = reader.Value; break; case "ispublic": IsPublic = reader.Value == "1"; break; case "isfamily": IsFamily = reader.Value == "1"; break; case "isfriend": IsFriend = reader.Value == "1"; break; case "tags": foreach (string tag in reader.Value.Split(' ')) { Tags.Add(tag); } break; case "datetaken": case "date-taken": case "date_taken": // For example : 2007-11-04 08:55:18 DateTaken = UtilityMethods.ParseDateWithGranularity(reader.Value); break; case "datetakengranularity": break; case "datetakenunknown": DateTakenUnknown = reader.Value == "1"; break; case "dateupload": DateUploaded = UtilityMethods.UnixTimestampToDate(reader.Value); break; case "license": License = (LicenseType)int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture); break; case "ownername": OwnerName = reader.Value; break; case "lastupdate": LastUpdated = UtilityMethods.UnixTimestampToDate(reader.Value); break; case "originalformat": OriginalFormat = reader.Value; break; case "originalsecret": OriginalSecret = reader.Value; break; case "place_id": PlaceId = reader.Value; break; case "woeid": WoeId = reader.Value; break; case "accuracy": Accuracy = (GeoAccuracy)reader.ReadContentAsInt(); break; case "latitude": Latitude = reader.ReadContentAsDouble(); break; case "longitude": Longitude = reader.ReadContentAsDouble(); break; case "machine_tags": MachineTags = reader.Value; break; case "o_width": OriginalWidth = int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture); break; case "o_height": OriginalHeight = int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture); break; case "views": Views = int.Parse(reader.Value, System.Globalization.CultureInfo.InvariantCulture); break; case "media": Media = reader.Value; break; case "media_status": MediaStatus = reader.Value; break; case "iconserver": IconServer = reader.Value; break; case "iconfarm": IconFarm = reader.Value; break; case "username": OwnerName = reader.Value; break; case "isprimary": case "is_primary": break; case "pathalias": case "path_alias": PathAlias = reader.Value; break; case "url_sq": urlSquare = reader.Value; break; case "width_sq": SquareThumbnailWidth = reader.ReadContentAsInt(); break; case "height_sq": SquareThumbnailHeight = reader.ReadContentAsInt(); break; case "url_t": urlThumbnail = reader.Value; break; case "width_t": ThumbnailWidth = reader.ReadContentAsInt(); break; case "height_t": ThumbnailHeight = reader.ReadContentAsInt(); break; case "url_q": urlLargeSquare = reader.Value; break; case "width_q": LargeSquareThumbnailWidth = reader.ReadContentAsInt(); break; case "height_q": LargeSquareThumbnailHeight = reader.ReadContentAsInt(); break; case "url_n": urlSmall320 = reader.Value; break; case "width_n": Small320Width = reader.ReadContentAsInt(); break; case "height_n": Small320Height = reader.ReadContentAsInt(); break; case "url_s": urlSmall = reader.Value; break; case "width_s": SmallWidth = reader.ReadContentAsInt(); break; case "height_s": SmallHeight = reader.ReadContentAsInt(); break; case "url_m": urlMedium = reader.Value; break; case "width_m": MediumWidth = reader.ReadContentAsInt(); break; case "height_m": MediumHeight = reader.ReadContentAsInt(); break; case "url_c": urlMedium800 = reader.Value; break; case "width_c": Medium800Width = reader.ReadContentAsInt(); break; case "height_c": Medium800Height = reader.ReadContentAsInt(); break; case "url_l": urlLarge = reader.Value; break; case "width_l": LargeWidth = reader.ReadContentAsInt(); break; case "height_l": LargeHeight = reader.ReadContentAsInt(); break; case "url_z": urlMedium640 = reader.Value; break; case "width_z": Medium640Width = reader.ReadContentAsInt(); break; case "height_z": Medium640Height = reader.ReadContentAsInt(); break; case "url_o": urlOriginal = reader.Value; break; case "width_o": OriginalWidth = reader.ReadContentAsInt(); break; case "height_o": OriginalHeight = reader.ReadContentAsInt(); break; case "url_h": Large1600Url = reader.Value; break; case "width_h": Large1600Width = reader.ReadContentAsInt(); break; case "height_h": Large1600Height = reader.ReadContentAsInt(); break; case "url_k": Large2048Url = reader.Value; break; case "width_k": Large2048Width = reader.ReadContentAsInt(); break; case "height_k": Large2048Height = reader.ReadContentAsInt(); break; case "dateadded": DateAddedToGroup = UtilityMethods.UnixTimestampToDate(reader.Value); break; case "date_faved": DateFavorited = UtilityMethods.UnixTimestampToDate(reader.Value); break; case "has_comment": // Gallery photos return this, but we ignore it and set GalleryPhoto.Comment instead. break; case "can_comment": CanComment = reader.Value == "1"; break; case "can_addmeta": CanAddMeta = reader.Value == "1"; break; case "can_blog": CanBlog = reader.Value == "1"; break; case "can_print": CanPrint = reader.Value == "1"; break; case "can_download": CanDownload = reader.Value == "1"; break; case "can_share": CanShare = reader.Value == "1"; break; case "geo_is_family": if (GeoPermissions == null) { GeoPermissions = new GeoPermissions(); GeoPermissions.PhotoId = PhotoId; } GeoPermissions.IsFamily = reader.Value == "1"; break; case "geo_is_friend": if (GeoPermissions == null) { GeoPermissions = new GeoPermissions(); GeoPermissions.PhotoId = PhotoId; } GeoPermissions.IsFriend = reader.Value == "1"; break; case "geo_is_public": if (GeoPermissions == null) { GeoPermissions = new GeoPermissions(); GeoPermissions.PhotoId = PhotoId; } GeoPermissions.IsPublic = reader.Value == "1"; break; case "geo_is_contact": if (GeoPermissions == null) { GeoPermissions = new GeoPermissions(); GeoPermissions.PhotoId = PhotoId; } GeoPermissions.IsContact = reader.Value == "1"; break; case "context": GeoContext = (GeoContext)reader.ReadContentAsInt(); break; case "rotation": Rotation = reader.ReadContentAsInt(); break; case "count_faves": CountFaves = reader.ReadContentAsInt(); break; case "count_comments": CountComments = reader.ReadContentAsInt(); break; default: if (!allowExtraAtrributes) { UtilityMethods.CheckParsingException(reader); } break; } } reader.Read(); if (reader.LocalName == "description") { Description = reader.ReadElementContentAsString(); } }
/// <summary> /// Processes an XmlReader and builds up the output object. /// </summary> /// <param name="reader">Reader to get data from.</param> /// <param name="suppressVersionCheck">Suppresses wix.dll version mismatch check.</param> /// <returns>The Output represented by the Xml.</returns> internal static Output Read(XmlReader reader, bool suppressVersionCheck) { if (!reader.LocalName.Equals("wixOutput")) { throw new XmlException(); } bool empty = reader.IsEmptyElement; Output output = new Output(SourceLineNumber.CreateFromUri(reader.BaseURI)); SectionType sectionType = SectionType.Unknown; Version version = null; while (reader.MoveToNextAttribute()) { switch (reader.LocalName) { case "codepage": output.Codepage = Convert.ToInt32(reader.Value, CultureInfo.InvariantCulture.NumberFormat); break; case "type": switch (reader.Value) { case "Bundle": output.Type = OutputType.Bundle; sectionType = SectionType.Bundle; break; case "Module": output.Type = OutputType.Module; sectionType = SectionType.Module; break; case "Patch": output.Type = OutputType.Patch; break; case "PatchCreation": output.Type = OutputType.PatchCreation; sectionType = SectionType.PatchCreation; break; case "Product": output.Type = OutputType.Product; sectionType = SectionType.Product; break; case "Transform": output.Type = OutputType.Transform; break; default: throw new XmlException(); } break; case "version": version = new Version(reader.Value); break; } } if (!suppressVersionCheck && null != version && !Output.CurrentVersion.Equals(version)) { throw new WixException(WixDataErrors.VersionMismatch(SourceLineNumber.CreateFromUri(reader.BaseURI), "wixOutput", version.ToString(), Output.CurrentVersion.ToString())); } // create a section for all the rows to belong to output.entrySection = new Section(null, sectionType, output.Codepage); // loop through the rest of the xml building up the Output object TableDefinitionCollection tableDefinitions = null; List <Table> tables = new List <Table>(); if (!empty) { bool done = false; // loop through all the fields in a row while (!done && reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: switch (reader.LocalName) { case "subStorage": output.SubStorages.Add(SubStorage.Read(reader)); break; case "table": if (null == tableDefinitions) { throw new XmlException(); } tables.Add(Table.Read(reader, output.entrySection, tableDefinitions)); break; case "tableDefinitions": tableDefinitions = TableDefinitionCollection.Read(reader); break; default: throw new XmlException(); } break; case XmlNodeType.EndElement: done = true; break; } } if (!done) { throw new XmlException(); } } output.Tables = new TableIndexedCollection(tables); return(output); }
private KpiDetails ProcessKpi(XmlReader rdr, ADOTabularTable table) { KpiDetails kpi = new KpiDetails(); while (!(rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "Kpi")) { while (rdr.MoveToNextAttribute()) { if (rdr.LocalName == "StatusGraphic") { kpi.Graphic = rdr.Value; } } if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "KpiGoal") { while (!(rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "KpiGoal")) { if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "PropertyRef") { while (rdr.MoveToNextAttribute()) { if (rdr.LocalName == "Name") { kpi.Goal = rdr.Value; } } } rdr.Read(); } } if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "KpiStatus") { while (!(rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "KpiStatus")) { if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "PropertyRef") { while (rdr.MoveToNextAttribute()) { if (rdr.LocalName == "Name") { kpi.Status = rdr.Value; } } } rdr.Read(); } } rdr.Read(); } return(kpi); }
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()); }
private void ProcessHierarchy(XmlReader rdr, ADOTabularTable table, string eEntityType) { var hierName = ""; string hierCap = null; var hierHidden = false; ADOTabularHierarchy hier = null; ADOTabularLevel lvl = null; string lvlName = ""; string lvlCaption = ""; string lvlRef = ""; while (!(rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "Hierarchy")) { if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "Hierarchy") { while (rdr.MoveToNextAttribute()) { switch (rdr.LocalName) { case "Hidden": hierHidden = bool.Parse(rdr.Value); break; case "Name": hierName = rdr.Value; break; case "Caption": hierCap = rdr.Value; break; } } string structure = GetHierarchStructure(table, hierName, hierCap); hier = new ADOTabularHierarchy(table, hierName, hierName, hierCap ?? hierName, "", hierHidden, ADOTabularObjectType.Hierarchy, "", structure); table.Columns.Add(hier); rdr.Read(); } while (!(rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "Level")) { if ((rdr.NodeType == XmlNodeType.Element) && (rdr.LocalName == "Level")) { while (rdr.MoveToNextAttribute()) { switch (rdr.LocalName) { case "Name": lvlName = rdr.Value; break; case "Caption": lvlCaption = rdr.Value; break; } } } if ((rdr.NodeType == XmlNodeType.Element) && (rdr.LocalName == "PropertyRef")) { while (rdr.MoveToNextAttribute()) { switch (rdr.LocalName) { case "Name": lvlRef = rdr.Value; break; } } } rdr.Read(); } //End of Level lvl = new ADOTabularLevel(table.Columns.GetByPropertyRef(lvlRef)); lvl.LevelName = lvlName; lvl.Caption = lvlCaption; hier.Levels.Add(lvl); lvlName = ""; lvlCaption = ""; lvlRef = ""; while (true) { if (rdr.NodeType == XmlNodeType.Element && rdr.LocalName == "Level") { break; } if (rdr.NodeType == XmlNodeType.EndElement && rdr.LocalName == "Hierarchy") { break; } rdr.Read(); } } }
/// PRIVATE METHODS /// /// /* Method which extracts the attributes from an XML node. * All attributes in the XML file are declared here. Each * should have a unique name. It would be possible to allow * node scoped attributes by adding extra parameters. Might * do this in the future if need this method to do it. */ private bool ExtractAttributes(XmlReader reader) { if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { // Console.WriteLine(reader.Name); switch (reader.Name) { /* Jira Config variables */ case "host": jira_config.data.Add("host", reader.Value); break; case "user": jira_config.data.Add("user", reader.Value); break; case "pass": jira_config.data.Add("pass", reader.Value); break; /* File Config variables */ case "outputDir": file_config.output.Add("output_dir", reader.Value); break; case "outputName": file_config.output.Add("output_name", reader.Value); break; case "outputExt": file_config.output.Add("output_ext", reader.Value); break; /* Email Config variables */ case "serverName": email_config.email.Add("server_name", reader.Value); break; case "serverPort": email_config.email.Add("server_port", reader.Value); break; case "senderEmail": email_config.email.Add("sender_email", reader.Value); break; case "emailSubject": email_config.email.Add("email_subject", reader.Value); break; case "emailBody": email_config.email.Add("email_body", reader.Value); break; case "emailTemplate": email_config.email.Add("email_template", reader.Value); break; case "emailType": email_config.email.Add("email_type", reader.Value); break; /* Template config */ case "placeHolder": string ph = reader.Value; if (reader.MoveToNextAttribute()) { if (reader.Name == "content") { // Console.WriteLine("Template Markup defined: " + ph + " ; " + reader.Value); template_config.markup_delim.Add(ph, reader.Value); } else Console.WriteLine("Unknown template configuration attribute: " + reader.Name); } else Console.WriteLine("Unable to process Template Attribute: " + ph); break; default: Console.WriteLine("Unknown report configuration attribute: " + reader.Name); return false; } } } return true; }
public void ValidateWithXmlReader(XmlSchemaSet schemas, string xml, string xsd) { XmlNamespaceManager namespaceManager = new XmlNamespaceManager(new NameTable()); XmlSchemaValidationFlags validationFlags = XmlSchemaValidationFlags.ProcessIdentityConstraints | XmlSchemaValidationFlags.AllowXmlAttributes; XmlSchemaValidator validator = new XmlSchemaValidator(namespaceManager.NameTable, schemas, namespaceManager, validationFlags); validator.Initialize(); using (XmlReader r = XmlReader.Create(xsd)) { while (r.Read()) { switch (r.NodeType) { case XmlNodeType.Element: namespaceManager.PushScope(); if (r.MoveToFirstAttribute()) { do { if (r.NamespaceURI == "http://www.w3.org/2000/xmlns/") { namespaceManager.AddNamespace(r.LocalName, r.Value); } } while (r.MoveToNextAttribute()); r.MoveToElement(); } validator.ValidateElement(r.LocalName, r.NamespaceURI, null, null, null, null, null); if (r.MoveToFirstAttribute()) { do { if (r.NamespaceURI != "http://www.w3.org/2000/xmlns/") { validator.ValidateAttribute(r.LocalName, r.NamespaceURI, r.Value, null); } } while (r.MoveToNextAttribute()); r.MoveToElement(); } validator.ValidateEndOfAttributes(null); if (r.IsEmptyElement) { goto case XmlNodeType.EndElement; } break; case XmlNodeType.EndElement: validator.ValidateEndElement(null); namespaceManager.PopScope(); break; case XmlNodeType.Text: validator.ValidateText(r.Value); break; case XmlNodeType.SignificantWhitespace: case XmlNodeType.Whitespace: validator.ValidateWhitespace(r.Value); break; default: break; } } validator.EndValidation(); } XmlReaderSettings rs = new XmlReaderSettings(); rs.ValidationEventHandler += new ValidationEventHandler(ValidationCallback); rs.ValidationType = ValidationType.Schema; rs.Schemas.XmlResolver = new XmlUrlResolver(); rs.Schemas.Add(null, XmlReader.Create(xsd)); using (XmlReader r = XmlReader.Create(xml, rs)) { while (r.Read()) { ; } } Assert.Equal(warningCount, 0); Assert.Equal(errorCount, 0); }
private XmlElement LoadElementNode(bool root) { Debug.Assert(reader.NodeType == XmlNodeType.Element); XmlReader r = reader; bool fEmptyElement = r.IsEmptyElement; XmlElement element = dummyDocument.CreateElement(r.Prefix, r.LocalName, r.NamespaceURI); element.IsEmpty = fEmptyElement; if (root) { parentNode = element; } else { XmlAttributeCollection attributes = element.Attributes; if (r.MoveToFirstAttribute()) { do { if (Ref.Equal(r.NamespaceURI, schemaNames.NsXmlNs)) //Namespace Attribute { annotationNSManager.AddNamespace(r.Prefix.Length == 0 ? string.Empty : reader.LocalName, reader.Value); } XmlAttribute attr = LoadAttributeNode(); attributes.Append(attr); } while(r.MoveToNextAttribute()); } r.MoveToElement(); string ns = annotationNSManager.LookupNamespace(r.Prefix); if (ns == null) { XmlAttribute attr = CreateXmlNsAttribute(r.Prefix, namespaceManager.LookupNamespace(r.Prefix)); attributes.Append(attr); } else if (ns.Length == 0) //string.Empty prefix is mapped to string.Empty NS by default { string elemNS = namespaceManager.LookupNamespace(r.Prefix); if (elemNS != string.Empty) { XmlAttribute attr = CreateXmlNsAttribute(r.Prefix, elemNS); attributes.Append(attr); } } while (r.MoveToNextAttribute()) { if (r.Prefix.Length != 0) { string attNS = annotationNSManager.LookupNamespace(r.Prefix); if (attNS == null) { XmlAttribute attr = CreateXmlNsAttribute(r.Prefix, namespaceManager.LookupNamespace(r.Prefix)); attributes.Append(attr); } } } r.MoveToElement(); parentNode.AppendChild(element); if (!r.IsEmptyElement) { parentNode = element; } } return(element); }
private void AdvanceParser() { if (!_canPush) { return; } // Check for pending events if (_pendingEvent != null) { Push(_pendingEvent); if (_pendingEvent is EndDocument) { _documentStarted = false; } _pendingEvent = null; return; } // Check for empty buffer condition. // XmlParser requires that there are at least 6 characters in the stream, // or it will read the stream multiple times to get more data, // which will result in premature EOF in our case. if (_feeder.Length - _feeder.Position < 7 && DataAvailable) { GetNextStreamBuffer(); return; } if (_parser == null) { _parser = XmlReader.Create(_feeder, new XmlReaderSettings { IgnoreComments = false, IgnoreProcessingInstructions = false, IgnoreWhitespace = true, CloseInput = false, ConformanceLevel = ConformanceLevel.Fragment }); } try { _hasNext = _parser.Read(); } catch (Exception e) { FailStage(e); return; } if (!_hasNext) { if (!_parser.EOF) { if (IsClosed(_stage.In)) { _parser.Close(); FailStage(new IllegalStateException("Stream finished before event was fully parsed.")); } else { _parser.Close(); FailStage(new IllegalStateException("Unknown error occured. Parsing finished before stream was finished.")); } } CompleteStage(); return; } switch (_parser.NodeType) { // START_ELEMENT case XmlNodeType.Element: var attributes = new Dictionary <string, string>(); while (_parser.MoveToNextAttribute()) { attributes.Add(_parser.LocalName, _parser.Value); } _parser.MoveToElement(); if (_parser.Depth == 0 && !_documentStarted) { // START_DOCUMENT _documentStarted = true; Push(StartDocument.Instance); _pendingEvent = new StartElement(_parser.LocalName, attributes); } else { Push(new StartElement(_parser.LocalName, attributes)); } return; // END_ELEMENT case XmlNodeType.EndElement: Push(new EndElement(_parser.LocalName)); if (_parser.Depth == 0) { // END_DOCUMENT _pendingEvent = EndDocument.Instance; } return; // CHARACTERS case XmlNodeType.Text: Push(new Characters(_parser.Value)); return; // PROCESSING_INSTRUCTION case XmlNodeType.ProcessingInstruction: if (_parser.Depth == 0 && !_documentStarted) { // START_DOCUMENT _documentStarted = true; Push(StartDocument.Instance); _pendingEvent = new ProcessingInstruction(_parser.Name, _parser.Value); } else { Push(new ProcessingInstruction(_parser.Name, _parser.Value)); } return; // COMMENT case XmlNodeType.Comment: Push(new Comment(_parser.Value)); return; // CDATA case XmlNodeType.CDATA: Push(new CData(_parser.Value)); return; // Do not support DTD, SPACE, NAMESPACE, NOTATION_DECLARATION, ENTITY_DECLARATION // ATTRIBUTE is handled in START_ELEMENT implicitly // EVENT_INCOMPLETE is handled directly in AsyncXmlStream default: if (_feeder.Length - _feeder.Position < 7 && DataAvailable) { GetNextStreamBuffer(); return; } AdvanceParser(); return; } }
/// <summary> /// The reader is positioned on a <dependentassembly> element--read it. /// </summary> /// <param name="reader"></param> internal void Read(XmlReader reader) { ArrayList redirects = new ArrayList(); if (_bindingRedirects != null) { redirects.AddRange(_bindingRedirects); } while (reader.Read()) { // Look for the end element. if (reader.NodeType == XmlNodeType.EndElement && AppConfig.StringEquals(reader.Name, "dependentassembly")) { break; } // Look for a <assemblyIdentity> element if (reader.NodeType == XmlNodeType.Element && AppConfig.StringEquals(reader.Name, "assemblyIdentity")) { string name = null; string publicKeyToken = "null"; string culture = "neutral"; // App.config seems to have mixed case attributes. while (reader.MoveToNextAttribute()) { if (AppConfig.StringEquals(reader.Name, "name")) { name = reader.Value; } else if (AppConfig.StringEquals(reader.Name, "publicKeyToken")) { publicKeyToken = reader.Value; } else if (AppConfig.StringEquals(reader.Name, "culture")) { culture = reader.Value; } } string assemblyName = String.Format ( CultureInfo.InvariantCulture, "{0}, Version=0.0.0.0, Culture={1}, PublicKeyToken={2}", name, culture, publicKeyToken ); try { _partialAssemblyName = new AssemblyNameExtension(assemblyName).AssemblyName; } catch (System.IO.FileLoadException e) { // A badly formed assembly name. ErrorUtilities.VerifyThrowArgument(false, e, "AppConfig.InvalidAssemblyIdentityFields"); } } // Look for a <bindingRedirect> element. if (reader.NodeType == XmlNodeType.Element && AppConfig.StringEquals(reader.Name, "bindingRedirect")) { BindingRedirect bindingRedirect = new BindingRedirect(); bindingRedirect.Read(reader); redirects.Add(bindingRedirect); } } _bindingRedirects = (BindingRedirect[])redirects.ToArray(typeof(BindingRedirect)); }
private void Update(object sender, DoWorkEventArgs e) { string version = (string)(e.Argument); if (worker.CancellationPending) { e.Cancel = true; return; } worker.ReportProgress(0); SortedDictionary <string, List <Change> > versionChanges = new SortedDictionary <string, List <Change> >(); try { // Download the content of the Versions.xml using (WebClient client = new WebClient() { Proxy = null }) using (StringReader reader = new StringReader(client.DownloadString("https://www.dropbox.com/s/fk3ox7fx0i0w8me/Versions.xml?dl=1"))) using (XmlReader xml = XmlReader.Create(reader)) { if (worker.CancellationPending) { e.Cancel = true; return; } worker.ReportProgress(2); // Load versionChanges while (xml.ReadToFollowing("version")) { using (XmlReader inner = xml.ReadSubtree()) { // Read version inner.ReadToFollowing("ver"); inner.MoveToFirstAttribute(); string ver = inner.Value; if (Math.Sign(version.CompareTo(ver)) != -1) { continue; // we need only versions which are greater than the current one } // Read changes List <Change> changes = new List <Change>(); inner.ReadToFollowing("changes"); using (XmlReader changesReader = inner.ReadSubtree()) { while (changesReader.ReadToFollowing("change")) { changesReader.MoveToFirstAttribute(); string command = changesReader.Value; changesReader.MoveToNextAttribute(); string type = changesReader.Value; changesReader.MoveToNextAttribute(); string arg = changesReader.Value; string url = string.Empty; if (command == "create" || command == "update") { changesReader.MoveToNextAttribute(); url = changesReader.Value; } changes.Add(new Change(command, type, arg, url)); } } versionChanges.Add(ver, changes); // Read change descriptions List <string> descriptions = new List <string>(); bool asd = inner.ReadToFollowing("descriptions"); using (XmlReader descrReader = inner.ReadSubtree()) { while (descrReader.ReadToFollowing("description")) { descrReader.MoveToFirstAttribute(); descriptions.Add(descrReader.Value); } } versionDescriptions.Add(ver, descriptions); } } } } catch (Exception) { worker.ReportProgress(1); return; } if (worker.CancellationPending) { e.Cancel = true; return; } // Generate the final list about what should be updated, deleted etc. worker.ReportProgress(4); Thread.Sleep(3000); // To wait Great Snooper to exit! Dictionary <string, Change> realChanges = new Dictionary <string, Change>(); foreach (KeyValuePair <string, List <Change> > item in versionChanges) { foreach (Change change in item.Value) { if (!realChanges.ContainsKey(change.arg)) { realChanges.Add(change.arg, change); } else { realChanges[change.arg] = change; } } } if (worker.CancellationPending) { e.Cancel = true; return; } worker.ReportProgress(6, realChanges.Count + 1); using (WebClient client = new WebClient() { Proxy = null }) { foreach (KeyValuePair <string, Change> item in realChanges) { if (item.Value.arg.Contains("../") || item.Value.arg.Contains(":")) { continue; } string path = Path.GetFullPath(item.Value.arg); if (item.Value.command == "delete") { switch (item.Value.type) { case "directory": if (Directory.Exists(path)) { Directory.Delete(path, true); } break; case "file": if (File.Exists(path)) { File.Delete(path); } break; } } else if (item.Value.command == "create" || item.Value.command == "update") { switch (item.Value.type) { case "directory": if (!Directory.Exists(path)) { Directory.CreateDirectory(path); } break; case "file": if (File.Exists(path)) { File.Delete(path); } client.DownloadFile(item.Value.url, path); break; } } if (worker.CancellationPending) { e.Cancel = true; return; } worker.ReportProgress(7); } } }
public static Element?Read(XmlReader reader, IElementFactory elementFactory) { var elements = new List <Element>(); var stack = new Stack <Element>(); while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.None: break; case XmlNodeType.Element: { string localName = reader.LocalName; Element element; if (string.IsNullOrEmpty(reader.NamespaceURI) || elementFactory.Namespaces.Contains(reader.NamespaceURI)) { var parent = stack.Count > 0 ? stack.Peek() : null; element = elementFactory.Create(localName, parent); element.Parent = parent; if (reader.MoveToFirstAttribute()) { do { if (string.IsNullOrEmpty(reader.NamespaceURI) || elementFactory.Namespaces.Contains(reader.NamespaceURI)) { string attributeName = reader.LocalName; element.Attributes.Add(attributeName, reader.Value); } }while (reader.MoveToNextAttribute()); reader.MoveToElement(); } var children = parent != null ? parent.Children : elements; children.Add(element); } else { element = new UnknownElement() { Tag = localName, Parent = null }; } if (!reader.IsEmptyElement) { stack.Push(element); } } break; case XmlNodeType.Attribute: break; case XmlNodeType.Text: { var element = stack.Peek(); var content = new ContentElement() { Content = reader.Value }; element.Children.Add(content); } break; case XmlNodeType.CDATA: { var element = stack.Peek(); var content = new ContentElement() { Content = reader.Value }; element.Children.Add(content); } break; case XmlNodeType.EntityReference: { reader.ResolveEntity(); var element = stack.Peek(); var content = new ContentElement() { Content = reader.Value }; element.Children.Add(content); } break; case XmlNodeType.Entity: break; case XmlNodeType.ProcessingInstruction: break; case XmlNodeType.Comment: break; case XmlNodeType.Document: break; case XmlNodeType.DocumentType: break; case XmlNodeType.DocumentFragment: break; case XmlNodeType.Notation: break; case XmlNodeType.Whitespace: break; case XmlNodeType.SignificantWhitespace: break; case XmlNodeType.EndElement: { var element = stack.Pop(); foreach (var child in element.Children) { if (child is ContentElement content) { element.Content += content.Content; } } } break; case XmlNodeType.EndEntity: break; case XmlNodeType.XmlDeclaration: break; default: break; } } if (elements.Count == 1) { return(elements[0]); } return(null); }
private static OutputGroup ReadOutputElement(XmlReader reader) { var outputNode = new OutputGroup(); while (reader.Read()) { // get the attributes if (reader.Name == OutputElementName && reader.HasAttributes) { while (reader.MoveToNextAttribute()) { switch (reader.Name) { case PathAttributeName: outputNode.Path = reader.Value; break; case EncodingAttributeName: outputNode.EncodingName = reader.Value; break; case TypeAttributeName: switch (reader.Value.ToUpperInvariant()) { case "JS": case "JAVASCRIPT": case "JSCRIPT": outputNode.CodeType = CodeType.JavaScript; break; case "CSS": case "STYLESHEET": case "STYLESHEETS": outputNode.CodeType = CodeType.StyleSheet; break; } break; case MapPathAttributeName: outputNode.SymbolMap = new SymbolMap() { Path = reader.Value }; break; } } // back to element reader.MoveToElement(); } // process child elements if (reader.NodeType == XmlNodeType.Element) { switch (reader.Name) { case ArgumentsElementName: ReadArgumentsElement(reader.ReadSubtree(), outputNode.Arguments); break; case RenameElementName: ReadRenameElement(reader.ReadSubtree(), outputNode.RenameIdentifiers); break; case NoRenameElementName: ReadNoRenameElement(reader.ReadSubtree(), outputNode.NoRenameIdentifiers); break; case SymbolMapElementName: outputNode.SymbolMap = ReadSymbolMapElement(reader.ReadSubtree()); break; case ResourceElementName: outputNode.Resources.Add(ReadResourceElement(reader.ReadSubtree())); break; case InputElementName: outputNode.Inputs.Add(ReadInputElement(reader.ReadSubtree())); break; } } } reader.Close(); return(outputNode); }
/// <summary> /// Creates a Row from the XmlReader. /// </summary> /// <param name="reader">Reader to get data from.</param> /// <param name="table">Table for this row.</param> /// <returns>New row object.</returns> internal static Row Parse(XmlReader reader, Table table) { Debug.Assert("row" == reader.LocalName); bool empty = reader.IsEmptyElement; RowOperation operation = RowOperation.None; string sectionId = null; SourceLineNumberCollection sourceLineNumbers = null; while (reader.MoveToNextAttribute()) { switch (reader.LocalName) { case "op": switch (reader.Value) { case "add": operation = RowOperation.Add; break; case "delete": operation = RowOperation.Delete; break; case "modify": operation = RowOperation.Modify; break; default: throw new WixException(WixErrors.IllegalAttributeValue(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name, reader.Value, "Add", "Delete", "Modify")); } break; case "sectionId": sectionId = reader.Value; break; case "sourceLineNumber": sourceLineNumbers = new SourceLineNumberCollection(reader.Value); break; default: if (!reader.NamespaceURI.StartsWith("http://www.w3.org/", StringComparison.Ordinal)) { throw new WixException(WixErrors.UnexpectedAttribute(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name)); } break; } } Row row = table.CreateRow(sourceLineNumbers); row.Operation = operation; row.SectionId = sectionId; // loop through all the fields in a row if (!empty) { bool done = false; int field = 0; // loop through all the fields in a row while (!done && reader.Read()) { switch (reader.NodeType) { case XmlNodeType.Element: switch (reader.LocalName) { case "field": if (row.Fields.Length <= field) { if (!reader.IsEmptyElement) { throw new WixException(WixErrors.UnexpectedColumnCount(SourceLineNumberCollection.FromUri(reader.BaseURI), table.Name)); } } else { row.fields[field].Parse(reader); } ++field; break; default: throw new WixException(WixErrors.UnexpectedElement(SourceLineNumberCollection.FromUri(reader.BaseURI), "row", reader.Name)); } break; case XmlNodeType.EndElement: done = true; break; } } if (!done) { throw new WixException(WixErrors.ExpectedEndElement(SourceLineNumberCollection.FromUri(reader.BaseURI), "row")); } } return(row); }
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)); } }
public void work() { string change = ""; string sendd = ""; string city = ""; // string city1 = ""; double buyy; double selll; double[] buy = new double[20]; double[] sell = new double[20]; for (int i = 1; i < 20; i++) { buy[i] = -1; sell[i] = -1; } double[] buytest = new double[20]; double[] selltest = new double[20]; for (int i = 1; i < 20; i++) { buytest[i] = -1; selltest[i] = -1; } //int count = 0; String link = "http://www.sjc.com.vn/xml/tygiavang.xml"; HttpWebRequest request = WebRequest.CreateHttp(link); HttpWebResponse response = (HttpWebResponse)request.GetResponse(); StreamReader sr = new StreamReader(response.GetResponseStream(), Encoding.UTF8); string content = sr.ReadToEnd(); sr.Close(); XmlReader reader = XmlReader.Create(new StringReader(content)); reader.ReadToFollowing("ratelist"); reader.MoveToFirstAttribute(); //thuoc tinh "updated" System.Console.WriteLine("Cap nhat luc: " + reader.Value); OutputText("Cap nhat luc: " + reader.Value); reader.MoveToNextAttribute(); // Thuoc tinh unit System.Console.WriteLine("Don vi tinh: " + reader.Value); OutputText("Don vi tinh: " + reader.Value); while (reader.ReadToFollowing("city")) //duyet cac Element city { reader.MoveToFirstAttribute(); System.Console.WriteLine("Thanh pho: " + reader.Value); city = reader.Value; OutputText("Thanh pho: " + reader.Value); // while (r.ReadToFollowing("item")) { count++; } //while (r.ReadToFollowing("item")) if (city == "Hồ Chí Minh") { reader.MoveToElement(); XmlReader r = reader.ReadSubtree(); for (int i = 1; i <= 8; i++) { r.ReadToFollowing("item"); r.MoveToFirstAttribute();//buy System.Console.WriteLine("Gia mua: " + reader.Value); buy[i] = Convert.ToDouble(reader.Value); if (buy[i] >= 47.750) { change += "Gia mua: " + Convert.ToString(buy[i]) + "/"; // MessageBox.Show(Convert.ToString( buy[i])); buytest[i] = buy[i]; } OutputText("Gia mua: " + reader.Value); r.MoveToNextAttribute(); //sell System.Console.WriteLine("Gia ban: " + reader.Value); sell[i] = Convert.ToDouble(reader.Value); if (sell[i] >= 48.635) { change += "Gia ban: " + Convert.ToString(sell[i]) + "/"; selltest[i] = selltest[i]; } OutputText("Gia ban: " + reader.Value); r.MoveToNextAttribute(); //type System.Console.WriteLine("Loai: " + reader.Value); if (buytest[i] != (-1) || selltest[i] != (-1)) { change += ("loai: " + reader.Value + "\n\t"); } OutputText("Loai: " + reader.Value); } } if (city != "Hồ Chí Minh") { reader.MoveToElement(); XmlReader r = reader.ReadSubtree(); while (r.ReadToFollowing("item")) { // r.ReadToFollowing("item"); r.MoveToFirstAttribute();//buy System.Console.WriteLine("Gia mua: " + reader.Value); buyy = Convert.ToDouble(reader.Value); if (buyy >= 47.750) { change += "Gia mua: " + Convert.ToString(buyy) + "/"; } OutputText("Gia mua: " + reader.Value); r.MoveToNextAttribute(); //sell System.Console.WriteLine("Gia ban: " + reader.Value); selll = Convert.ToDouble(reader.Value); if (selll >= 48.635) { change += "Gia ban: " + Convert.ToString(selll) + "/"; } OutputText("Gia ban: " + reader.Value); r.MoveToNextAttribute(); //type System.Console.WriteLine("Loai: " + reader.Value); if (change != "") { change += "loai: " + reader.Value + "/"; } OutputText("Loai: " + reader.Value); } } if (change != "") { change += " cua tp: " + city + "\n\r"; sendd += change; change = ""; } } System.Console.WriteLine(sendd); string sent = sendd.Replace("\n\r", "<br/>"); string hcmSent = sent.Replace("\n\t", "<br/>"); if (sendd != "") { MessageBox.Show(sendd); maill(hcmSent); } }
private IPersistEntity ReadEntity(XmlReader input, Type suggestedType = null) { var expType = GetExpresType(input); if (expType == null && suggestedType != null && !suggestedType.IsAbstract) { expType = _metadata.ExpressType(suggestedType); } if (expType == null) { var typeName = input.GetAttribute("type") ?? input.LocalName; throw new XbimParserException(typeName + "is not an IPersistEntity type"); } var id = GetId(input, expType, out bool isRef); if (!id.HasValue) { throw new XbimParserException("Wrong entity XML format"); } var entity = _getOrCreate(id.Value, expType.Type); if (isRef) { if (!input.IsEmptyElement) { // Consume anything until the end of the entity. // this is usualy empty element but some people put data in there as well to indicate some of the // content for humans reading the XML (as much as it is silly) var depth = input.Depth; var hasContent = false; while (input.Read()) { if (input.NodeType == XmlNodeType.EndElement && input.Depth == depth) { break; } hasContent = true; } if (hasContent) { // Log a warning as it is a wrong practise to put content in ref elements Logger.LogWarning("Reference to element {0}, ref='{1}' is not empty. This is a wrong practise.", entity.ExpressType.Name, id); } } return(entity); } //read all attributes while (input.MoveToNextAttribute()) { var pInfo = GetMetaProperty(expType, input.LocalName); if (pInfo == null) { continue; } SetPropertyFromString(pInfo, entity, input.Value, null); } input.MoveToElement(); if (input.IsEmptyElement) { _finish(entity); return(entity); } //read all element properties var pDepth = input.Depth; while (input.Read()) { if (input.NodeType == XmlNodeType.EndElement && input.Depth == pDepth) { break; } if (input.NodeType != XmlNodeType.Element) { continue; } var pInfo = GetMetaProperty(expType, input.LocalName); if (pInfo == null) { continue; } SetPropertyFromElement(pInfo, entity, input, null); if (input.NodeType == XmlNodeType.EndElement && input.Depth == pDepth) { break; } } //finalize _finish(entity); return(entity); }
public void convertXMLtoDrawing() { Document currentDocument = Autodesk.AutoCAD.ApplicationServices.Application.DocumentManager.MdiActiveDocument; Database currentDatabase = currentDocument.Database; Editor editor = currentDocument.Editor; OpenFileDialog fileDialog = new OpenFileDialog("Select .xml-file for import", null, "xml", "XMLfileToLink", OpenFileDialog.OpenFileDialogFlags.DoNotTransferRemoteFiles); System.Windows.Forms.DialogResult result = fileDialog.ShowDialog(); if (result != System.Windows.Forms.DialogResult.OK) { editor.WriteMessage("\nWrong file format."); return; } XmlReaderSettings settings = new XmlReaderSettings(); settings.IgnoreWhitespace = true; settings.IgnoreComments = true; settings.IgnoreProcessingInstructions = true; XmlReader reader = XmlReader.Create(fileDialog.Filename, settings); String objectType = ""; String objectName = ""; List <Vector2D> vectorList = null; Vector2D[] vectorArray; double x_Value = 0; double y_Value = 0; Polygon2D newPolygon; Segment2D newSegment; double maxX_Value = 0; double maxY_Value = 0; double minX_Value = 0; double minY_Value = 0; bool objectUnderConstruction = false; while (reader.Read()) { switch (reader.NodeType) { case XmlNodeType.XmlDeclaration: break; case XmlNodeType.Element: if (reader.Name.Equals(scenario_Node)) { if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { if (reader.Name.Equals(id_Attribute)) { editor.WriteMessage("\n" + reader.Name + "=" + reader.Value); } else if (reader.Name.Equals(name_Attribute)) { editor.WriteMessage("\n" + reader.Name + "=" + reader.Value); } else if (reader.Name.Equals(maxX_Attribute)) { maxX_Value = reader.ReadContentAsDouble(); } else if (reader.Name.Equals(maxY_Attribute)) { maxY_Value = reader.ReadContentAsDouble(); } else if (reader.Name.Equals(minX_Attribute)) { minX_Value = reader.ReadContentAsDouble(); } else if (reader.Name.Equals(minY_Attribute)) { minY_Value = reader.ReadContentAsDouble(); ViewTableRecord oldView = editor.GetCurrentView(); ViewTableRecord newView = (ViewTableRecord)oldView.Clone(); Point2d minPoint = new Point2d(minX_Value, minY_Value); Point2d maxPoint = new Point2d(maxX_Value, maxY_Value); newView.CenterPoint = minPoint + ((maxPoint - minPoint) / 2.0); newView.Height = maxPoint.Y - minPoint.Y; newView.Width = maxPoint.X - minPoint.X; editor.SetCurrentView(newView); } } } } else if (reader.Name.Equals(area_Node) || reader.Name.Equals(obstacle_Node)) { objectUnderConstruction = true; vectorList = new List <Vector2D>(); if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { if (reader.Name.Equals(name_Attribute)) { objectName = reader.Value; } else if (reader.Name.Equals(type_Attribute)) { objectType = reader.Value; } } } } else if (reader.Name.Equals(point_Node)) { if (objectUnderConstruction) { if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { if (reader.Name.Equals(x_Attribute)) { x_Value = reader.ReadContentAsDouble(); } else if (reader.Name.Equals(y_Attribute)) { y_Value = reader.ReadContentAsDouble(); } } } vectorList.Add(new Vector2D(x_Value, y_Value)); } } break; case XmlNodeType.EndElement: if (reader.Name.Equals(area_Node)) { vectorArray = vectorList.ToArray(); newPolygon = new Polygon2D(vectorArray, objectName); GeometryFactory.polygon2DtoPolyline(newPolygon, objectType, currentDocument); objectUnderConstruction = false; } else if (reader.Name.Equals(obstacle_Node)) { vectorArray = vectorList.ToArray(); if (objectType.Equals(wall_Value) && vectorArray[0].isEqualTo(vectorArray[vectorArray.Length - 1])) { newPolygon = new Polygon2D(vectorArray, objectName); GeometryFactory.polygon2DtoPolyline(newPolygon, objectType, currentDocument); } else if (objectType.Equals(wall_Value)) { newSegment = new Segment2D(vectorArray, objectName); GeometryFactory.segment2DtoPolyline(newSegment, objectType, currentDocument); } else if (objectType.Equals(solid_Value)) { newPolygon = new Polygon2D(vectorArray, objectName); GeometryFactory.polygon2DtoPolyline(newPolygon, objectType, currentDocument); } objectUnderConstruction = false; } break; default: break; } } reader.Close(); }
internal static LoggerSettings FromXml(XmlReader reader) { var elementName = reader.Name; var empty = reader.IsEmptyElement; var settings = new LoggerSettings { IsEnabled = true }; // Read attributes. if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { switch (reader.Name.ToLowerInvariant()) { case Constants.LoggerFriendlyNameLower: settings.FriendlyName = reader.Value; break; case Constants.LoggerUriName: try { settings.Uri = new Uri(reader.Value); } catch (UriFormatException) { throw new SettingsException( String.Format( CultureInfo.CurrentCulture, Resources.Resources.InvalidUriInSettings, reader.Value, elementName)); } break; case Constants.LoggerAssemblyQualifiedNameLower: settings.AssemblyQualifiedName = reader.Value; break; case Constants.LoggerCodeBaseLower: settings.CodeBase = reader.Value; break; case Constants.LoggerEnabledName: bool.TryParse(reader.Value, out var value); settings.IsEnabled = value; break; default: throw new SettingsException( string.Format( CultureInfo.CurrentCulture, Resources.Resources.InvalidSettingsXmlAttribute, elementName, reader.Name)); } } } // Check for required atttributes. if (string.IsNullOrWhiteSpace(settings.FriendlyName) && string.IsNullOrWhiteSpace(settings.Uri?.ToString()) && string.IsNullOrWhiteSpace(settings.AssemblyQualifiedName)) { throw new SettingsException( string.Format( CultureInfo.CurrentCulture, Resources.Resources.MissingLoggerAttributes, elementName, Constants.LoggerFriendlyName)); } // Move to next node. reader.Read(); // Return empty settings if previous element is empty. if (empty) { return(settings); } // Read inner elements. while (reader.NodeType == XmlNodeType.Element) { switch (reader.Name.ToLowerInvariant()) { case Constants.LoggerConfigurationNameLower: var document = new XmlDocument(); var element = document.CreateElement(reader.Name); element.InnerXml = reader.ReadInnerXml(); settings.Configuration = element; break; default: throw new SettingsException( string.Format( CultureInfo.CurrentCulture, Resources.Resources.InvalidSettingsXmlElement, elementName, reader.Name)); } } reader.ReadEndElement(); return(settings); }
//DOC: Documentation Required /// <summary> /// /// </summary> public override bool MoveToNextAttribute() { return(innerReader.MoveToNextAttribute()); }
private void ReadNode(XmlReader reader, IConfigSection section) { while (true) { var remark = ""; if (reader.NodeType == XmlNodeType.Comment) { remark = reader.Value; } while (reader.NodeType == XmlNodeType.Comment || reader.NodeType == XmlNodeType.Whitespace) { reader.Skip(); } if (reader.NodeType != XmlNodeType.Element) { break; } var name = reader.Name; var cfg = section.AddChild(name); // 前一行是注释 if (!remark.IsNullOrEmpty()) { cfg.Comment = remark; } // 读取属性值 if (reader.HasAttributes) { reader.MoveToFirstAttribute(); do { var cfg2 = cfg.AddChild(reader.Name); cfg2.Value = reader.Value; } while (reader.MoveToNextAttribute()); } else { reader.ReadStartElement(); } while (reader.NodeType == XmlNodeType.Whitespace) { reader.Skip(); } // 遇到下一层节点 if (reader.NodeType == XmlNodeType.Element || reader.NodeType == XmlNodeType.Comment) { ReadNode(reader, cfg); } else if (reader.NodeType == XmlNodeType.Text) { cfg.Value = reader.ReadContentAsString(); } if (reader.NodeType == XmlNodeType.Attribute) { reader.Read(); } if (reader.NodeType == XmlNodeType.EndElement) { reader.ReadEndElement(); } while (reader.NodeType == XmlNodeType.Whitespace) { reader.Skip(); } } }
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()); }
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 == "X3DMaterial") { MaterialHandler.HandleMaterial(reader, cityGml2Go); } if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "ParameterizedTexture") { TextureHandler.HandleTexture(reader, cityGml2Go); } 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); }
// Read and extract into Element class each attribut of node name "element" Element check_attribute_element(XmlReader xml_reader, Element element) { if (xml_reader.HasAttributes) { while (xml_reader.MoveToNextAttribute() != false) { string prefab_name = ""; if ((prefab_name = xml_reader.GetAttribute("prefab")) != null) { if (Resources.Load(prefab_name) != null) element.prefab = Resources.Load(prefab_name) as GameObject; } } } return element; }
/// <summary> /// Parses a Fortify Result element from an <see cref="XmlReader"/>. /// </summary> /// <param name="xmlReader">The <see cref="XmlReader"/> from which an element containing a Fortify result shall be /// consumed. When this method returns, this <see cref="XmlReader"/> is positioned on the following element.</param> /// <param name="strings">Strings used in processing a Fortify report.</param> /// <returns>A <see cref="FortifyIssue"/> containing data from the node on which <paramref name="xmlReader"/> was /// placed when this method was called.</returns> public static FortifyIssue Parse(XmlReader xmlReader, FortifyStrings strings) { //<xs:element name="Result"> // <xs:complexType> // <xs:sequence> // <!-- Result Description --> // <xs:element name="Category" type="xs:string" minOccurs="1" maxOccurs="1"/> // <xs:element name="Folder" type="xs:string" minOccurs="1" maxOccurs="1"/> // <xs:element name="Kingdom" type="xs:string" minOccurs="1" maxOccurs="1"/> // <xs:element name="Abstract" type="xs:string" minOccurs="0" maxOccurs="1"/> // <xs:element name="AbstractCustom" type="xs:string" minOccurs="0" maxOccurs="1"/> // <xs:element name="Friority" type="xs:string" minOccurs="0" maxOccurs="1"/> // <!-- custom tags including Analysis --> // <xs:element name="Tag" minOccurs="0" maxOccurs="unbounded"> // <xs:complexType> // <xs:sequence> // <xs:element name="Name" type="xs:string" minOccurs="1" maxOccurs="1"/> // <xs:element name="Value" type="xs:string" minOccurs="1" maxOccurs="1"/> // </xs:sequence> // </xs:complexType> // </xs:element> // <xs:element name="Comment" minOccurs="0" maxOccurs="unbounded"> // <xs:complexType> // <xs:sequence> // <xs:element name="UserInfo" type="xs:string" minOccurs="1" maxOccurs="1"/> // <xs:element name="Comment" type="xs:string" minOccurs="1" maxOccurs="1"/> // </xs:sequence> // </xs:complexType> // </xs:element> // <!-- primary or sink --> // <xs:element name="Primary" type="PathElement" minOccurs="1" maxOccurs="1"/> // <!-- source --> // <xs:element name="Source" type="PathElement" minOccurs="0" maxOccurs="1"/> // <xs:element name="TraceDiagramPath" type="xs:string" minOccurs="0" maxOccurs="1"/> // <!-- optional external category (i.e. STIG) --> // <xs:element name="ExternalCategory" minOccurs="0" maxOccurs="1"> // <xs:complexType> // <xs:simpleContent> // <xs:extension base="xs:string"> // <xs:attribute name="type" type="xs:string" use="required"/> // </xs:extension> // </xs:simpleContent> // </xs:complexType> // </xs:element> // </xs:sequence> // <xs:attribute name="iid" type="xs:string" use="optional"/> // <xs:attribute name="ruleID" type="xs:string" use="optional"/> // </xs:complexType> //</xs:element> if (!xmlReader.IsStartElement(strings.Issue)) { throw xmlReader.CreateException(ConverterResources.FortifyNotValidResult); } string iid = null; string ruleId = null; while (xmlReader.MoveToNextAttribute()) { string name = xmlReader.LocalName; if (Ref.Equal(name, strings.Iid)) { iid = xmlReader.Value; } else if (Ref.Equal(name, strings.RuleId)) { ruleId = xmlReader.Value; } } xmlReader.MoveToElement(); xmlReader.Read(); // reads start element string category = xmlReader.ReadElementContentAsString(strings.Category, String.Empty); xmlReader.IgnoreElement(strings.Folder, IgnoreOptions.Required); string kingdom = xmlReader.ReadElementContentAsString(strings.Kingdom, String.Empty); string abstract_ = xmlReader.ReadOptionalElementContentAsString(strings.Abstract); string abstractCustom = xmlReader.ReadOptionalElementContentAsString(strings.AbstractCustom); string friority = xmlReader.ReadOptionalElementContentAsString(strings.Friority); xmlReader.IgnoreElement(strings.Tag, IgnoreOptions.Optional | IgnoreOptions.Multiple); xmlReader.IgnoreElement(strings.Comment, IgnoreOptions.Optional | IgnoreOptions.Multiple); FortifyPathElement primary = FortifyPathElement.Parse(xmlReader, strings); FortifyPathElement source; if (xmlReader.NodeType == XmlNodeType.Element && Ref.Equal(xmlReader.LocalName, strings.Source)) { source = FortifyPathElement.Parse(xmlReader, strings); } else { source = null; } xmlReader.IgnoreElement(strings.TraceDiagramPath, IgnoreOptions.Optional); ImmutableArray <int> cweIds = ImmutableArray <int> .Empty; if (xmlReader.NodeType == XmlNodeType.Element && Ref.Equal(xmlReader.LocalName, strings.ExternalCategory)) { if (xmlReader.GetAttribute(strings.Type) == "CWE") { cweIds = ParseCweIds(xmlReader.ReadElementContentAsString()); } else { xmlReader.Skip(); } } xmlReader.ReadEndElement(); // </Result> return(new FortifyIssue(ruleId, iid, category, kingdom, abstract_, abstractCustom, friority, primary, source, cweIds)); }
/// <summary> /// Reads a specific data tag from the xml document. /// </summary> /// <param name='reader'> /// Reader. /// </param> private void ReadData(XmlReader reader) { //If these values are not being set, //something is wrong. string key = "ERROR"; string value = "ERROR"; if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { if (reader.Name == "name") { key = reader.Value; } } } //Move back to the element reader.MoveToElement(); //Read the child nodes if (reader.ReadToDescendant("value")) { do { value = reader.ReadString(); } while (reader.ReadToNextSibling("value")); } //Add the raw values to the dictionary textDataBase.Add(key, value); //Add the localized parsed values to the localizedObjectDataBase LocalizedObject newLocalizedObject = new LocalizedObject(); newLocalizedObject.ObjectType = LocalizedObject.GetLocalizedObjectType(key); newLocalizedObject.TextValue = value; localizedObjectDataBase.Add(LocalizedObject.GetCleanKey(key,newLocalizedObject.ObjectType), newLocalizedObject); }
public override bool MoveToNextAttribute() { return(_tr.MoveToNextAttribute()); }