public void ReadLog(XmlReader reader) { while (reader.Read() && reader.NodeType != XmlNodeType.EndElement) { Dictionary<string, string> attributes = new Dictionary<string, string>(); if (reader.Name == "ME") { if (reader.HasAttributes) { for (int i = 0; i < reader.AttributeCount; i++) { reader.MoveToAttribute(i); attributes.Add(reader.Name, reader.Value); } } MouseEvent e = new MouseEvent(attributes); Evnts.AddLast(e); //do shit here } else if (reader.Name == "Clickthrough") { if (reader.HasAttributes) { for (int i = 0; i < reader.AttributeCount; i++) { reader.MoveToAttribute(i); attributes.Add(reader.Name, reader.Value); } } Clickthrough c = new Clickthrough(attributes); c.ReadLog(reader); Evnts.AddLast(c); } } }
/// <summary> /// Recupera os dados do xml. /// </summary> /// <param name="reader"></param> public void ReadXml(System.Xml.XmlReader reader) { if (reader.MoveToAttribute("name")) { Name = reader.ReadContentAsString(); reader.MoveToElement(); } if (reader.MoveToAttribute("address")) { Address = reader.ReadContentAsString(); reader.MoveToElement(); } reader.ReadStartElement(); while (reader.NodeType != System.Xml.XmlNodeType.EndElement) { if (reader.Name == "Configuration") { if (!reader.IsEmptyElement) { var config = new ServiceAddressNode(); config.ReadXml(reader); Configuration = config; } else { reader.Skip(); } } else { reader.Skip(); } } reader.ReadEndElement(); }
public void ReadXml(System.Xml.XmlReader reader) { reader.MoveToAttribute("Width"); Width = reader.ReadContentAsInt(); reader.MoveToAttribute("Height"); Height = reader.ReadContentAsInt(); reader.MoveToElement(); SetupWorld(Width, Height); while (reader.Read()) { switch (reader.Name) { case "Tiles": ReadXML_Tiles(reader); break; case "StaticObjects": ReadXml_StaticObjects(reader); break; case "Characters": ReadXml_Characters(reader); break; } } }
private static void read_microservices_client_details(XmlReader readerXml, MicroservicesClient_Configuration config, string SystemBaseUrl) { // Just step through the subtree of this while (readerXml.Read()) { if (readerXml.NodeType == XmlNodeType.Element) { switch (readerXml.Name.ToLower()) { case "add": string key = String.Empty; string url = String.Empty; string protocol = "JSON"; if (readerXml.MoveToAttribute("Key")) key = readerXml.Value; if (readerXml.MoveToAttribute("URL")) url = readerXml.Value.Replace("[BASEURL]", SystemBaseUrl); if (readerXml.MoveToAttribute("Protocol")) protocol = readerXml.Value; if (( !String.IsNullOrEmpty(key)) && ( !String.IsNullOrEmpty(url))) config.Add_Endpoint(key, url, protocol); break; } } } }
public Mass(Model model, XmlReader xml) : base(model,xml) {//throws Exception { //super(model, xml); //foreach(XmlAttribute attribute in xml.Attributes) //{ //string key = attribute.Name; if (xml.MoveToAttribute("VX".ToLower())) { velocityX = double.Parse(xml.ReadContentAsString()); } if (xml.MoveToAttribute("VY".ToLower())) { velocityY = double.Parse(xml.ReadContentAsString()); } //} //Enumeration enum = xml.enumerateAttributeNames(); //while (enum.hasMoreElements()) { // String key = enum.nextElement().toString(); // if (key.equals("VX")) { // velocityX = xml.getDoubleAttribute(key); // } // if (key.equals("VY")) { // velocityY = xml.getDoubleAttribute(key); // } //} }
private static void ReadAscii(XmlReader reader, string name, uint offset, bool visible, IPluginVisitor visitor, uint pluginLine) { int size = 0; if (reader.MoveToAttribute("size") || reader.MoveToAttribute("length")) size = ParseInt(reader.Value); visitor.VisitAscii(name, offset, visible, size, pluginLine); }
public MarkerModel(XmlReader reader, Set set) { reader.MoveToAttribute("name"); name = reader.Value; reader.MoveToAttribute("id"); id = new Guid(reader.Value); reader.Read(); // <marker /> this.set = set; }
private static ClassEntry BuildClassEntry(XmlReader xmlReader, string fileName, string assemblyName, string @namespace, Assembly assembly) { xmlReader.MoveToAttribute("name"); string className = xmlReader.Value; string extends = null; if (xmlReader.MoveToAttribute("extends")) { extends = xmlReader.Value; } return new ClassEntry(extends, className, assemblyName, @namespace, fileName, assembly); }
public void Load (XmlReader x) { if(x.MoveToAttribute("ShowParameters")) ShowFuncParams = Boolean.Parse(x.ReadContentAsString()); if(x.MoveToAttribute("ShowVariables")) ShowFuncVariables = Boolean.Parse(x.ReadContentAsString()); if(x.MoveToAttribute("ShowTypes")) ShowBaseTypes = Boolean.Parse(x.ReadContentAsString()); if(x.MoveToAttribute("GrayOutNonPublic")) GrayOutNonPublic = Boolean.Parse(x.ReadContentAsString()); if(x.MoveToAttribute("ExpansionBehaviour")) Enum.TryParse(x.ReadContentAsString(),out ExpansionBehaviour); }
protected override void DeserializeElement(XmlReader reader, bool serializeCollectionKey) { reader.MoveToAttribute("name"); Name = reader.Value; ConnectionStringName = reader.MoveToAttribute("connectionStringName") ? reader.Value : null; while (reader.Read()) { if (reader.NodeType == XmlNodeType.EndElement) break; if (reader.NodeType == XmlNodeType.CDATA) Select = reader.Value; } }
/// <summary> /// Recupera os dados do xml. /// </summary> /// <param name="reader"></param> public void ReadXml(System.Xml.XmlReader reader) { if (reader.MoveToAttribute("name")) { Name = reader.ReadContentAsString(); reader.MoveToElement(); } if (reader.MoveToAttribute("value")) { Value = reader.ReadContentAsString(); reader.MoveToElement(); } reader.Skip(); }
public static Firewall load(XmlReader reader) { while (reader.Name != "firewall") reader.Read(); var complexity = 0; string solution = null; var additionalTime = 0.0f; if (reader.MoveToAttribute("complexity")) complexity = reader.ReadContentAsInt(); if (reader.MoveToAttribute("solution")) solution = reader.ReadContentAsString(); if (reader.MoveToAttribute("additionalDelay")) additionalTime = reader.ReadContentAsFloat(); return new Firewall(complexity, solution, additionalTime); }
public static UserDetail loadUserDetail(XmlReader reader) { reader.MoveToAttribute("name"); var user = reader.ReadContentAsString(); reader.MoveToAttribute("pass"); var password = reader.ReadContentAsString(); reader.MoveToAttribute("type"); var accountType = (byte) reader.ReadContentAsInt(); reader.MoveToAttribute("known"); var flag = reader.ReadContentAsString().ToLower().Equals("true"); return new UserDetail(user, password, accountType) { known = flag }; }
public void ReadXml(System.Xml.XmlReader reader) { if (reader.MoveToAttribute("Disabled")) { Disabled = reader.Value == "1"; } reader.ReadStartElement("RuleList"); while (reader.IsStartElement()) { IXmlSerializable r = null; switch (reader.Name) { case "RegExpRule": r = new RegExpRule(); break; case "HostRule": r = new HostRule(); break; case "PathRule": r = new PathRule(); break; } if (r != null) { r.ReadXml(reader.ReadSubtree()); this.Add((IRule)r); } reader.ReadEndElement(); } }
public override void ReadXml(XmlReader reader) { if (reader.MoveToAttribute("Description")) Description = reader.Value; base.ReadXml(reader); }
public void Restore(XmlReader reader) { int count = reader.AttributeCount; for (int i = 0; i < count; ++i) { reader.MoveToAttribute(i); switch (reader.Name) { case "top": Top = reader.ReadContentAsDouble(); break; case "left": Left = reader.ReadContentAsDouble(); break; case "width": Width = reader.ReadContentAsDouble(); break; case "height": Height = reader.ReadContentAsDouble(); break; case "state": State = (WindowState) Enum.Parse(typeof (WindowState), reader.Value); break; } } }
internal void ConfigureEmulator(XmlReader reader) { while (true) { reader.Read(); if (reader.IsStartElement()) { switch (reader.Name.ToLower()) { case "import": reader.MoveToAttribute( "filename" ); _emulator.ApplyConfig(reader.Value); break; case "types": ProcessTypes( reader ); break; case "emulatorcomponents": ProcessEmulatorComponents( reader ); break; default: throw new Exception( "Unknown element: " + reader.Name ); } } else { break; } } }
public void ReadXml(XmlReader reader) { if (!reader.MoveToAttribute("State")) throw new ArgumentException("State attribute not present"); InitFromString(reader.Value); }
public static Quaternion ParseQuaternion(XmlReader r) { float w = 0; float x = 0; float y = 0; float z = 0; for (int i = 0; i < r.AttributeCount; i++) { r.MoveToAttribute(i); // set the field in this object based on the element we just read switch (r.Name) { case "w": w = float.Parse(r.Value); break; case "x": x = float.Parse(r.Value); break; case "y": y = float.Parse(r.Value); break; case "z": z = float.Parse(r.Value); break; } } r.MoveToElement(); //Moves the reader back to the element node. return new Quaternion(w, x, y, z); }
public static ColorEx ParseColorAttributes(XmlReader r) { float R = 0; float G = 0; float B = 0; for (int i = 0; i < r.AttributeCount; i++) { r.MoveToAttribute(i); // set the field in this object based on the element we just read switch (r.Name) { case "R": R = float.Parse(r.Value); break; case "G": G = float.Parse(r.Value); break; case "B": B = float.Parse(r.Value); break; } } r.MoveToElement(); //Moves the reader back to the element node. r.MoveToElement(); //Moves the reader back to the element node. if (R > 1 || G > 1 || B > 1) { R = R / 255; G = G / 255; B = B / 255; } return new ColorEx(R, G, B); }
void IXmlSerializable.ReadXml(XmlReader reader) { try { // First read attributes, then check for empty start element if (!reader.MoveToAttribute("Id")) throw new ArgumentException("Id attribute not present"); _id = new Guid(reader.Value); if (reader.IsEmptyElement) return; } finally { reader.ReadStartElement(); } _additionalProperties = reader.DeserializeXml<Dictionary>(); _timeshiftContexes = reader.DeserializeXml<List<ITimeshiftContext>>(); while (reader.NodeType != XmlNodeType.EndElement) { MediaItemAspect mia = MediaItemAspect.Deserialize(reader); _aspects[mia.Metadata.AspectId] = mia; } reader.ReadEndElement(); // MI }
public static IFeed GetFeed(Uri url, XmlReader reader) { reader.MoveToContent(); string language = string.Empty; FeedType feedType; string namespaceUri = reader.NamespaceURI; if(reader.LocalName.Equals("RDF") && reader.NamespaceURI.Equals("http://www.w3.org/1999/02/22-rdf-syntax-ns#")) { feedType = FeedType.Rdf; reader.Read(); reader.MoveToContent(); } else if(reader.LocalName.Equals("rss")) { feedType = FeedType.Rss; do { reader.Read(); reader.MoveToContent(); } while(!reader.LocalName.Equals("channel") && !reader.LocalName.Equals("rss")); } else if(reader.NamespaceURI.Equals("http://purl.org/atom/ns#") && reader.LocalName.Equals("feed")) { if(reader.MoveToAttribute("version") && reader.Value.Equals("0.3")) { feedType = FeedType.Atom; language = reader.XmlLang; reader.MoveToElement(); } else { throw new ApplicationException(string.Format("Unsupported Atom Version {0}", reader.Value)); } } else if(reader.NamespaceURI.Equals("http://www.w3.org/2005/Atom") && reader.LocalName.Equals("feed")) { feedType = FeedType.Atom; language = reader.XmlLang; } else { throw new ApplicationException("Unknown Xml Dialect"); } return PopulateFeed(url, reader, namespaceUri, feedType, language); }
/// <summary>Initializes a new instance of OpmlOutline</summary> public OpmlOutline(System.Xml.XmlReader xmlTextReader) : this() { if (!xmlTextReader.HasAttributes) { return; } // get attributes System.Reflection.PropertyInfo propertyInfo = null; for (int i = 0; i < xmlTextReader.AttributeCount; i++) { xmlTextReader.MoveToAttribute(i); // try to find some common used alias names for attributes string attributeName = xmlTextReader.Name; if (attributeName.IndexOf("url") != -1) { attributeName = "xmlUrl"; } if (attributeName.IndexOf("title") != -1) { attributeName = "text"; } // find related property by name propertyInfo = GetType().GetProperty(attributeName, System.Reflection.BindingFlags.IgnoreCase | BindingFlags.Public | BindingFlags.Instance); if (propertyInfo != null) { propertyInfo.SetValue(this, System.ComponentModel.TypeDescriptor.GetConverter(propertyInfo.PropertyType).ConvertFromString(xmlTextReader.ReadInnerXml().Trim()), null); } } }
/// <summary> /// Parses an XML plugin, calling the corresponding method in /// IPluginVisitor for each XML tag it encounters. /// </summary> /// <param name="reader">The XmlReader to read the plugin XML from.</param> /// <param name="visitor">The IPluginVisitor to call for each XML tag.</param> public static void LoadPlugin(XmlReader reader, IPluginVisitor visitor) { if (!reader.ReadToNextSibling("plugin")) throw new ArgumentException("The XML file is missing a <plugin> tag."); int baseSize = 0; if (reader.MoveToAttribute("headersize") || reader.MoveToAttribute("baseSize")) baseSize = ParseInt(reader.Value); if (visitor.EnterPlugin(baseSize)) { var loader = new UniversalPluginLoader(); loader.ReadElements(reader, true, visitor); visitor.LeavePlugin(); } }
public bool IsSatisfiedBy(IIdentity parameter) => _reader.HasAttributes && _reader.MoveToAttribute(parameter.Name, parameter.Identifier == _defaultNamespace ? string.Empty : parameter.Identifier);
public HeightfieldTerrainGenerator(XmlReader r) { for (int i = 0; i < r.AttributeCount; i++) { r.MoveToAttribute(i); switch (r.Name) { case "Type": string type = r.Value; Debug.Assert(type == "HeightfieldMosaic"); break; case "MosaicName": heightfieldName = r.Value; break; case "PreloadRadius": preloadRadius = int.Parse(r.Value); break; case "OutsideHeight": outsideHeight = float.Parse(r.Value); break; } } r.MoveToElement(); if (!r.IsEmptyElement) { do { r.Read(); } while (r.NodeType != XmlNodeType.EndElement); } Mosaic = new HeightfieldMosaic(heightfieldName, preloadRadius, outsideHeight); Mosaic.MosaicModificationStateChanged += Mosaic_OnMosaicModificationStateChanged; Mosaic.MosaicChanged += Mosaic_OnMosaicChanged; }
/// <summary> /// reader ��g�p���� XML �h�L�������g�Ƃ��č\����͂��܂��B /// </summary> /// <param name="reader">XML �h�L�������g�̃��[�h�C�e���[�^�B</param> /// <returns>��͌�� XmlDocument �I�u�W�F�N�g�B</returns> public XmlDocument parse(XmlReader reader) { if ( reader == null ) throw new ArgumentNullException( "reader" ); XmlNode current; XmlAttribute attribute; Stack<XmlNode> node_stack = new Stack<XmlNode>(); node_stack.Push( this.document_ ); while ( reader.Read() ) { if ( reader.NodeType == XmlNodeType.Whitespace ) continue; switch ( reader.NodeType ) { case XmlNodeType.XmlDeclaration: if ( reader.HasAttributes ) { this.document_.AppendChild( this.document_.CreateXmlDeclaration( reader.GetAttribute( "version" ), reader.GetAttribute( "encoding" ), "no" ) ); } break; case XmlNodeType.Element: node_stack.Push( this.document_.CreateElement( reader.Name ) ); if ( reader.HasAttributes ) { current = node_stack.Peek(); for ( int i = 0; i < reader.AttributeCount; ++i ) { reader.MoveToAttribute( i ); attribute = this.document_.CreateAttribute( reader.Name ); attribute.Value = reader.Value; current.Attributes.Append( attribute ); } } if ( reader.IsEmptyElement ) { foldElement( node_stack ); } break; case XmlNodeType.Text: current = node_stack.Peek(); current.AppendChild( this.document_.CreateTextNode( reader.Value ) ); break; case XmlNodeType.EndElement: foldElement( node_stack ); break; } } return this.document_; }
public override bool Matches(XmlReader reader, IXmlNamespaceResolver resolver) { bool preCondition = false; switch (mode) { case MatchMode.StartElement: preCondition = reader.NodeType == XmlNodeType.Element; break; case MatchMode.StartElementClosed: if (reader.NodeType == XmlNodeType.Attribute) { string name = reader.LocalName; string ns = reader.NamespaceURI; if (reader.MoveToNextAttribute()) { // If we moved, we didn't match and // we restore the cursor. reader.MoveToAttribute(name, ns); preCondition = false; } else { // We need to evaluate the element name/ns match from // the base here, moving to the element first reader.MoveToElement(); preCondition = base.Matches(reader, resolver); // Restore cursor always. reader.MoveToAttribute(name, ns); return preCondition; } } else if (reader.NodeType == XmlNodeType.Element) { // Matches the same as StartElement if there are no attributes preCondition = !reader.HasAttributes; } break; case MatchMode.EndElement: preCondition = reader.NodeType == XmlNodeType.EndElement; break; } return preCondition && base.Matches(reader, resolver); }
private static void ReadAttributes(ZXmlNode Node, XmlReader rd) { for (int i = 0; i < rd.AttributeCount; i++) { rd.MoveToAttribute(i); Node.Attributes.Add(rd.Name, rd.Value); } rd.MoveToElement(); }
public void AddAttr(XmlReader reader) { for (int i = 0; i < reader.AttributeCount; ++i) { reader.MoveToAttribute(i); _attributes.Add(new KeyValuePair<string, string>(reader.Name, reader.Value)); } }
public void Parse (XmlReader reader) { while (reader.Read ()) { if (reader.NodeType == XmlNodeType.Element) { var attrs = Enumerable.Range (0, reader.AttributeCount).ToDictionary (i => { reader.MoveToAttribute (i); return reader.Name; }, i => { reader.MoveToAttribute (i); return reader.Value; }); reader.MoveToElement (); startElement (reader.LocalName, reader.Name, attrs); } else if (reader.NodeType == XmlNodeType.EndElement) { endElement (reader.LocalName, reader.Name); } } }
public void ReadXml(System.Xml.XmlReader reader) { if (reader.MoveToAttribute("Title")) { mTitle = reader.Value; } else { throw new Exception(); } if (reader.MoveToAttribute("Path")) { mPath = reader.Value; } else { throw new Exception(); } }
protected override void DeserializeElement(XmlReader reader, bool serializeCollectionKey) { reader.MoveToAttribute("name"); Name = reader.Value; while (reader.Read()) { if (reader.NodeType == XmlNodeType.EndElement) break; } }
public object DeserializeObject(XmlReader reader) { if (reader.MoveToAttribute(_attributeName)) { var value = _parseValue(reader.Value); reader.MoveToElement(); return value; } return null; }
public void ReadXml(XmlReader reader) { reader.MoveToAttribute("span"); if (reader.NodeType == XmlNodeType.Attribute) Span = (int)reader.ReadContentAsDouble(); reader.MoveToElement(); Text = reader.ReadElementContentAsString(); double length; if (double.TryParse(Text, out length)) Length = length; }
Record ReadRow(System.Xml.XmlReader rdr) { var record = _file.CreateRecord(); for (Int32 i = 0; i < rdr.AttributeCount; i++) { rdr.MoveToAttribute(i); ReadValue(record, rdr.Name, rdr.Value); } return(record); }
/// <summary> /// Generates a collection from its XML representation. /// </summary> /// <param name="reader">System.Xml.XmlReader</param> public void ReadXml(XmlReader reader) { this.Clear(); if (reader.ReadToDescendant("SerializableStringDictionary")) { if (reader.ReadToDescendant("DictionaryEntry")) { do { reader.MoveToAttribute("Key"); string key = reader.ReadContentAsString(); reader.MoveToAttribute("Value"); string value = reader.ReadContentAsString(); this.Add(key, value); } while (reader.ReadToNextSibling("DictionaryEntry")); } } }
/// <summary> /// Initializes a new instance of the <see cref="PostOpportunityUpdate"/> class. /// </summary> /// <param name="unsecure">Contains public (unsecure) configuration information.</param> /// <param name="secure">Contains non-public (secure) configuration information. /// When using Microsoft Dynamics CRM for Outlook with Offline Access, /// the secure string is not passed to a plug-in that executes while the client is offline.</param> public PostOpportunityUpdate(string unsecure, string secure) : base(typeof(PostOpportunityUpdate)) { base.RegisteredEvents.Add(new Tuple <int, string, string, Action <LocalPluginContext> >(40, "Update", "opportunity", new Action <LocalPluginContext>(ExecutePostOpportunityUpdate))); // Note : you can register for more events here if this plugin is not specific to an individual entity and message combination. // You may also need to update your RegisterFile.crmregister plug-in registration file to reflect any change. try { // TODO: Implement your custom configuration handling. using (System.Xml.XmlReader reader = XmlReader.Create(new StringReader(unsecure))) { // Load fields from settings reader.MoveToContent(); reader.MoveToAttribute("APIKey"); NexmoApiKey = Convert.ToString(reader.GetAttribute("APIKey")); reader.MoveToAttribute("APISecret"); NexmoApiSecret = Convert.ToString(reader.GetAttribute("APISecret")); //reader.MoveToAttribute("FromUser"); //FromUser = Convert.ToString(reader.GetAttribute("FromUser")); reader.MoveToAttribute("EnableNexmoSMS"); EnableSMS = Convert.ToString(reader.GetAttribute("EnableNexmoSMS")); reader.MoveToAttribute("Threshold"); if (!string.IsNullOrEmpty(reader.GetAttribute("Threshold"))) { Threshold = Convert.ToDouble(reader.GetAttribute("Threshold")); } } } catch (Exception ex) { throw new InvalidPluginExecutionException(string.Format("An error occured in ExecutePostOpportunityCreate plugin: {0} {1} {2}", ex.ToString(), ex.InnerException, ex.StackTrace)); } }
public static Settings LoadFromXml( XmlReader xmlReader ) { Settings settings = new Settings(); xmlReader.MoveToAttribute( 0 ); do { switch ( xmlReader.Name.ToLower() ) { case "paddingwidth": { int pw = 0; if ( !int.TryParse( xmlReader.Value, out pw ) ) throw new Exception( "Failed to parse paddingwidth" ); settings.Padding.Width = pw; } break; case "paddingheight": { int ph = 0; if ( !int.TryParse( xmlReader.Value, out ph ) ) throw new Exception( "Failed to parse paddingheight" ); settings.Padding.Height = ph; } break; case "outputwidth": { int ow = 0; if ( !int.TryParse( xmlReader.Value, out ow ) ) throw new Exception( "Failed to parse outputwidth" ); settings.OutputBitmapSize.Width = ow; } break; case "outputheight": { int oh = 0; if ( !int.TryParse( xmlReader.Value, out oh ) ) throw new Exception( "Failed to parse outputheight" ); settings.OutputBitmapSize.Height = oh; } break; case "allowrotation": { bool ar = false; if ( !bool.TryParse( xmlReader.Value, out ar ) ) throw new Exception( "Failed to parse allowrotation" ); settings.AllowRotation = ar; } break; } } while ( xmlReader.MoveToNextAttribute() ); return settings; }
private bool DeterminVisible(System.Xml.XmlReader reader) { bool result = true; if (reader.MoveToAttribute("visible")) { if (reader.HasValue) { result = reader.ReadContentAsBoolean(); } } return(result); }
public void DoSearch(string[] parts, ArrayList result, System.Xml.XmlReader reader, bool securityTrimmingEnabled) { if (reader.ReadToFollowing("category", ns) && reader.MoveToAttribute("name") && reader.Value == "Root" && reader.MoveToElement()) { int i = 1; if (i < parts.Length) { ReadSubElements(reader, parts, i, result, securityTrimmingEnabled); } else { ReadSubItems(reader, result, securityTrimmingEnabled); } } }
public bool LoadFrom(DCompilerConfiguration cmpCfg, System.Xml.XmlReader x) { if (x.ReadState == ReadState.Initial) { x.Read(); } if (x.MoveToAttribute("Target") && !Enum.TryParse(x.ReadContentAsString(), true, out TargetType)) { return(false); } while (x.Read()) { switch (x.LocalName) { // For backward compatibility keep on parsing this case "CompilerCommand": cmpCfg.SourceCompilerCommand = x.ReadString(); break; case "LinkerCommand": Linker = x.ReadString(); break; case "Patterns": // ditto var s = x.ReadSubtree(); cmpCfg.ArgumentPatterns.ReadFrom(s); s.Close(); break; case "DebugArgs": s = x.ReadSubtree(); DebugArguments.ReadFrom(cmpCfg, s); s.Close(); break; case "ReleaseArgs": s = x.ReadSubtree(); ReleaseArguments.ReadFrom(cmpCfg, s); s.Close(); break; } } return(true); }
public void LoadFrom(System.Xml.XmlReader x) { if (x.ReadState == ReadState.Initial) { x.Read(); } if (x.MoveToAttribute("Target")) { TargetType = (DCompileTarget)Enum.Parse(typeof(DCompileTarget), x.ReadContentAsString()); } while (x.Read()) { switch (x.LocalName) { case "CompilerCommand": Compiler = x.ReadString(); break; case "LinkerCommand": Linker = x.ReadString(); break; case "ObjectLinkPattern": ObjectFileLinkPattern = x.ReadString(); break; case "IncludePathPattern": IncludePathPattern = x.ReadString(); break; case "DebugArgs": var s = x.ReadSubtree(); DebugArguments.ReadFrom(s); s.Close(); break; case "ReleaseArgs": var s2 = x.ReadSubtree(); ReleaseArguments.ReadFrom(s2); s2.Close(); break; } } }
/// <summary> /// Recupera os dados contidos no xml informado. /// </summary> /// <param name="reader"></param> public void ReadXml(System.Xml.XmlReader reader) { if (reader.MoveToAttribute("name")) { Name = reader.ReadContentAsString(); } reader.MoveToElement(); reader.ReadStartElement(); while (reader.NodeType != System.Xml.XmlNodeType.EndElement) { if (reader.Name == "Parameters") { if (!reader.IsEmptyElement) { ((System.Xml.Serialization.IXmlSerializable)Parameters).ReadXml(reader); } else { reader.Skip(); } } else if (reader.Name == "Children") { if (!reader.IsEmptyElement) { ReadChildrenXml(reader); } else { reader.Skip(); } } else { reader.Skip(); } } reader.ReadEndElement(); }
private void ReadSubElements(System.Xml.XmlReader reader, string[] parts, int i, ArrayList result, bool securityTrimmingEnabled) { string nextName = parts[i]; int depth = reader.Depth + 1; while (reader.Read()) { if (reader.Depth == depth) { switch (reader.NodeType) { case System.Xml.XmlNodeType.Attribute: case System.Xml.XmlNodeType.CDATA: case System.Xml.XmlNodeType.Comment: case System.Xml.XmlNodeType.Whitespace: continue; case System.Xml.XmlNodeType.EndElement: break; case System.Xml.XmlNodeType.Element: break; default: throw new System.Xml.XmlException("读取到错误的节点"); } if (reader.NodeType == System.Xml.XmlNodeType.Element) { bool hit = false; if (reader.MoveToAttribute("name")) { hit = reader.Value == nextName; if (hit) { hit = DeterminVisible(reader); } reader.MoveToElement(); } if (hit) { i++; if (i < parts.Length) { ReadSubElements(reader, parts, i, result, securityTrimmingEnabled); } else { ReadSubItems(reader, result, securityTrimmingEnabled); } break; } else { //reader.Skip(); } } } else if (reader.Depth > depth) { reader.Skip(); } else { break; } } }
public virtual void WriteNode(XmlReader reader, bool defattr) { if (reader == null) { throw new ArgumentException(); } if (reader.ReadState == ReadState.Initial) { reader.Read(); do { WriteNode(reader, defattr); } while (!reader.EOF); return; } switch (reader.NodeType) { case XmlNodeType.Element: WriteStartElement(reader.Prefix, reader.LocalName, reader.NamespaceURI); #if false WriteAttributes(reader, defattr); reader.MoveToElement(); #else // Well, I found that MS.NET took this way, since // there was a error-prone SgmlReader that fails // MoveToNextAttribute(). if (reader.HasAttributes) { for (int i = 0; i < reader.AttributeCount; i++) { reader.MoveToAttribute(i); WriteAttribute(reader, defattr); } reader.MoveToElement(); } #endif if (reader.IsEmptyElement) { WriteEndElement(); } else { int depth = reader.Depth; reader.Read(); if (reader.NodeType != XmlNodeType.EndElement) { do { WriteNode(reader, defattr); } while (depth < reader.Depth); } WriteFullEndElement(); } break; // In case of XmlAttribute, don't proceed reader, and it will never be written. case XmlNodeType.Attribute: return; case XmlNodeType.Text: WriteString(reader.Value); break; case XmlNodeType.CDATA: WriteCData(reader.Value); break; case XmlNodeType.EntityReference: WriteEntityRef(reader.Name); break; case XmlNodeType.XmlDeclaration: // LAMESPEC: It means that XmlWriter implementation _must not_ check // whether PI name is "xml" (it is XML error) or not. case XmlNodeType.ProcessingInstruction: WriteProcessingInstruction(reader.Name, reader.Value); break; case XmlNodeType.Comment: WriteComment(reader.Value); break; case XmlNodeType.DocumentType: WriteDocType(reader.Name, reader ["PUBLIC"], reader ["SYSTEM"], reader.Value); break; case XmlNodeType.SignificantWhitespace: goto case XmlNodeType.Whitespace; case XmlNodeType.Whitespace: WriteWhitespace(reader.Value); break; case XmlNodeType.EndElement: WriteFullEndElement(); break; case XmlNodeType.EndEntity: break; case XmlNodeType.None: break; // Do nothing, nor reporting errors. default: throw new XmlException("Unexpected node " + reader.Name + " of type " + reader.NodeType); } reader.Read(); }
private CategoryDirectory ReadResult(System.Xml.XmlReader reader, bool securityTrimmingEnabled) { CategoryDirectory result = null; if (reader.NodeType == System.Xml.XmlNodeType.Element) { if (reader.LocalName == "category" && reader.NamespaceURI == ns) { if (DeterminVisible(reader) && DeterminSecure(securityTrimmingEnabled, reader)) { result = new CategoryDirectory(); if (reader.MoveToAttribute("name")) { result.Name = reader.Value; } if (reader.MoveToAttribute("title")) { result.Title = reader.Value; } reader.MoveToElement(); } } else if (reader.LocalName == "item" && reader.NamespaceURI == ns) { if (DeterminVisible(reader) && DeterminSecure(securityTrimmingEnabled, reader)) { result = new CategoryLink(); if (reader.MoveToAttribute("name")) { result.Name = reader.Value; } if (reader.MoveToAttribute("title")) { result.Title = reader.Value; } if (reader.MoveToAttribute("group")) { ((CategoryLink)result).Group = reader.ReadContentAsInt(); } if (reader.MoveToAttribute("href")) { ((CategoryLink)result).Url = reader.Value; } if (reader.MoveToAttribute("role")) { ((CategoryLink)result).Role = reader.Value; } if (reader.MoveToAttribute("feature")) { ((CategoryLink)result).Feature = reader.Value; } } } else if (reader.LocalName == "group" && reader.NamespaceURI == ns) { if (DeterminVisible(reader) && DeterminSecure(securityTrimmingEnabled, reader)) { result = new CategoryGroup(); if (reader.MoveToAttribute("name")) { result.Name = reader.Value; } if (reader.MoveToAttribute("title")) { result.Title = reader.Value; } reader.MoveToElement(); ArrayList list = new ArrayList(); ReadSubItems(reader, list, securityTrimmingEnabled); ((CategoryGroup)result).Categories = (CategoryDirectory[])list.ToArray(typeof(CategoryDirectory)); } else { var level = reader.Depth; while (reader.Read() && reader.Depth > level) { reader.Skip(); //跳过其任何子节点 } } } } reader.MoveToElement(); return(result); }
public override bool MoveToAttribute(string name) { CheckAsync(); return(_coreReader.MoveToAttribute(name)); }