public void ReadXml(XmlReader reader) { var elementName = string.Empty; while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element) { elementName = reader.Name; switch (elementName) { case "TypeAliases": { var subReader = reader.ReadSubtree(); var aliases = new List<NetTypeAlias>(); while (subReader.ReadToFollowing("TypeAlias")) { var aliasReader = subReader.ReadSubtree(); var typeAlias = new NetTypeAlias(); typeAlias.ReadXml(aliasReader); aliases.Add(typeAlias); } TypeAliases = aliases.ToArray(); break; } case "Snippets": { var subReader = reader.ReadSubtree(); var snippets = new List<Snippet>(); while (subReader.ReadToFollowing("Snippet")) { var snippet = new Snippet(); snippet.ReadXml(subReader); snippets.Add(snippet); } Snippets = snippets.ToArray(); break; } } } else if (reader.NodeType == XmlNodeType.Text) { switch (elementName) { case "Modifiers": Modifiers = reader.Value.Split(' '); break; case "MemberIdentifiers": MemberIdentifiers = reader.Value.Split(' '); break; case "Keywords": Keywords = reader.Value.Split(' '); break; } } else if (reader.NodeType == XmlNodeType.EndElement) { elementName = string.Empty; } } }
public static ServiceResponse Deserialize(XmlReader reader, ServiceResponse serviceResponse) { if (reader.IsStartElement(DTD.Response.TagServiceResponse)) { if (serviceResponse == null) { serviceResponse = new ServiceResponse(); } if (!reader.IsEmptyElement) { reader.ReadStartElement(); do { #region <ERROR> if (reader.IsStartElement(DTD.Response.ServiceResponse.TagError)) { if(int.Parse(reader.GetAttribute(DTD.Error.TagNumber))!=0) { throw XMLErrorSerializer.Deserialize(reader.ReadSubtree()); } else { reader.Skip(); } } #endregion <ERROR> #region <OID> if (reader.IsStartElement(DTD.TagOID)) { serviceResponse.Oid = XMLAdaptorOIDSerializer.Deserialize(reader.ReadSubtree()); } #endregion <OID> #region <Arguments> if (reader.IsStartElement(DTD.Response.ServiceResponse.TagArguments)) { serviceResponse.Arguments = XMLArgumentsSerializer.Deserialize(reader.ReadSubtree()); } #endregion <Arguments> } while (reader.Read()); } else { reader.Skip(); } } else { throw new ArgumentException("Xml Reader don't have the Service.Response in Start Element.", "XmlReader reader"); } return serviceResponse; }
public void ReadFrom(System.Xml.XmlReader x) { XmlReader s = null; while (x.Read()) { switch (x.LocalName) { case "BinaryPath": BinPath = x.ReadString(); break; case "TargetConfiguration": s = x.ReadSubtree(); var t = new LinkTargetConfiguration(); t.LoadFrom(s); LinkTargetConfigurations [t.TargetType] = t; s.Close(); break; case "DefaultLibs": s = x.ReadSubtree(); while (s.Read()) { if (s.LocalName == "lib") { DefaultLibraries.Add(s.ReadString()); } } s.Close(); break; case "Includes": s = x.ReadSubtree(); var paths = new List <string> (); while (s.Read()) { if (s.LocalName == "Path") { ParseCache.ParsedDirectories.Add(s.ReadString()); } } s.Close(); break; } } }
/// <summary> Reads the dmdSec at the current position in the XmlTextReader and associates it with the /// entire package </summary> /// <param name="Input_XmlReader"> Open XmlReader from which to read the metadata </param> /// <param name="Return_Package"> Package into which to read the metadata</param> /// <param name="Options"> Dictionary of any options which this METS section reader may utilize</param> /// <returns> TRUE if successful, otherwise FALSE</returns> public bool Read_dmdSec(XmlReader Input_XmlReader, SobekCM_Item Return_Package, Dictionary<string, object> Options) { // Ensure this metadata module extension exists LearningObjectMetadata lomInfo = Return_Package.Get_Metadata_Module(GlobalVar.IEEE_LOM_METADATA_MODULE_KEY) as LearningObjectMetadata; if (lomInfo == null) { lomInfo = new LearningObjectMetadata(); Return_Package.Add_Metadata_Module(GlobalVar.IEEE_LOM_METADATA_MODULE_KEY, lomInfo); } // Loop through reading each XML node do { // If this is the end of this section, return if ((Input_XmlReader.NodeType == XmlNodeType.EndElement) && ((Input_XmlReader.Name == "METS:mdWrap") || (Input_XmlReader.Name == "mdWrap"))) return true; // get the right division information based on node type if (Input_XmlReader.NodeType == XmlNodeType.Element) { string name = Input_XmlReader.Name.ToLower(); if (( lom_namespace.Length > 0 ) && ( name.IndexOf( lom_namespace ) == 0)) name = name.Substring(lom_namespace.Length); switch (name) { case "general": read_general(Input_XmlReader.ReadSubtree(), lomInfo); break; case "lifecycle": read_lifecycle(Input_XmlReader.ReadSubtree(), lomInfo); break; case "technical": read_technical(Input_XmlReader.ReadSubtree(), lomInfo); break; case "educational": read_educational(Input_XmlReader.ReadSubtree(), lomInfo); break; case "classification": read_classification(Input_XmlReader.ReadSubtree(), lomInfo); break; } } } while (Input_XmlReader.Read()); return true; }
/// <summary> /// Deserializes an ChangedItem from an XML file. /// </summary> /// <param name="reader">XMLReader where the ChangedItem is.</param> /// <returns>ChangedItem.</returns> public static ChangedItem Deserialize(XmlReader reader) { ChangedItem lResult = null; if (reader.IsStartElement(DTD.Error.ChangedItems.TagChangedItem)) { lResult = new ChangedItem(); string stringModelType = reader.GetAttribute(DTD.Error.ChangedItems.ChangedItem.TagType); ModelType modelType = Convert.StringTypeToMODELType(stringModelType); if (modelType == ModelType.Oid) { lResult.Type = Convert.MODELTypeToStringType(ModelType.Oid); lResult.ClassName = stringModelType; } else { lResult.Type = stringModelType; lResult.ClassName = string.Empty; } lResult.Name = reader.GetAttribute(DTD.Error.ChangedItems.ChangedItem.TagName); if (!reader.IsEmptyElement) { reader.ReadStartElement(); if (reader.IsStartElement(DTD.Error.ChangedItems.ChangedItem.TagChangedItemOldValue)) { lResult.OldValue = XMLChangedItemValueSerializer.Deserialize(reader.ReadSubtree(),lResult.Type, lResult.ClassName); reader.ReadEndElement(); } if (reader.IsStartElement(DTD.Error.ChangedItems.ChangedItem.TagChangedItemNewValue)) { lResult.NewValue = XMLChangedItemValueSerializer.Deserialize(reader.ReadSubtree(), lResult.Type, lResult.ClassName); reader.ReadEndElement(); } } else { reader.Skip(); } } else { throw new ArgumentException("Xml Reader don't have the ChangedItem in Start Element.", "XmlReader reader"); } return lResult; }
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 ReadFrom(System.Xml.XmlReader x) { XmlReader s = null; while (x.Read()) { switch (x.LocalName) { case "TargetConfiguration": s = x.ReadSubtree(); var t = new LinkTargetConfiguration(); t.LoadFrom(s); LinkTargetConfigurations.Add(t); s.Close(); break; case "DefaultLibs": s = x.ReadSubtree(); while (s.Read()) { if (s.LocalName == "lib") { DefaultLibraries.Add(s.ReadString()); } } s.Close(); break; case "Includes": s = x.ReadSubtree(); while (s.Read()) { if (s.LocalName == "Path") { GlobalParseCache.Add(s.ReadString()); } } s.Close(); break; } } }
/// <summary> /// Parses the specified reader. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> public override T Parse <T>(System.Xml.XmlReader reader) { // Need a specific parser IParser subparser = null; IFeed ret = null; string localRootName = reader.LocalName.ToLower().Trim(); if (localRootName == "rss" || localRootName == "rdf") { subparser = new RssFeedParser(); } else if (localRootName == "feed") { subparser = new AtomFeedParser(); } if (subparser != null) { using (XmlReader subreader = reader.ReadSubtree()) { ret = (IFeed)subparser.Parse <T>(subreader); } } else { throw new Exception(string.Format("Unknown feed type '{0}'.", reader.Name)); } reader.Close(); return((T)ret); }
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 void ReadXml(System.Xml.XmlReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } if (reader.LocalName == "TagValueCollection") { XmlReader subReader = reader.ReadSubtree(); XPathDocument doc = new XPathDocument(subReader); var nav = doc.CreateNavigator(); XPathNavigator iter = nav.SelectSingleNode("/TagValueCollection/@Version"); if (iter == null) { throw new XmlSchemaException("TagValueCollection does not have a version element"); } long ver = iter.ValueAsLong; if (ver == Version) { ReadCurrentVersion(nav); } else { throw new InvalidOperationException(); } } }
public void ReadXml(System.Xml.XmlReader reader) { reader.MoveToElement(); reader.ReadStartElement(); Type instanceType = base.GetType().BaseType; while (reader.IsStartElement()) { if (reader.HasAttributes) { XmlNodeType nodeType = reader.NodeType; Type t = typeof(FileProcessingJournalEntryData <>); t = t.MakeGenericType(Type.GetType(reader.GetAttribute("type"))); string name = reader.GetAttribute("name"); var ser = XmlSerializerCache.GetOrAdd(t, name); object obj = ser.Deserialize(reader.ReadSubtree()); reader.ReadEndElement(); this.EntryData.Add((FileProcessingJournalEntryDataBase)obj); } else { PropertyInfo Prop = instanceType.GetProperty(reader.Name); if (Prop != null) { var h = reader.ReadElementContentAsObject(Prop.Name, ""); Prop.SetValue(this, Convert.ChangeType(h, Prop.PropertyType), null); } } } }
/// <summary> /// Generate object from its XML representation</summary> /// <param name="reader">XmlReader stream from which object is deserialized</param> public void ReadXml(System.Xml.XmlReader reader) { if (reader.ReadToFollowing(this.GetType().Name)) { reader.ReadStartElement(this.GetType().Name); if (reader.LocalName == typeof(TabLayout).Name || reader.LocalName == "MultiContent") // MultiContent is old name and is used here for compatibility with old saved layouts { DockedContent = new TabLayout(Root, reader.ReadSubtree()); if (DockedContent.Children.Count > 0) { ContentSettings contentSettings = DockedContent.Children[0].Settings; Left = contentSettings.Location.X; Top = contentSettings.Location.Y; Width = contentSettings.Size.Width; Height = contentSettings.Size.Height; Width = Math.Max(Width, SystemParameters.MinimumWindowWidth); Height = Math.Max(Height, SystemParameters.MinimumWindowHeight); Left = Math.Max(SystemParameters.VirtualScreenLeft, Math.Min(Left, SystemParameters.VirtualScreenWidth + SystemParameters.VirtualScreenLeft - Width)); Top = Math.Max(SystemParameters.VirtualScreenTop, Math.Min(Top, SystemParameters.VirtualScreenHeight + SystemParameters.VirtualScreenTop - Height)); reader.ReadEndElement(); } } reader.ReadEndElement(); } }
public static ServiceRequest Deserialize(XmlReader reader, ServiceRequest serviceRequest) { if (reader.IsStartElement(DTD.Request.TagServiceRequest)) { if (serviceRequest == null) { serviceRequest = new ServiceRequest(); } serviceRequest.Class = reader.GetAttribute(DTD.Request.ServiceRequest.TagClass); serviceRequest.Name = reader.GetAttribute(DTD.Request.ServiceRequest.TagService); if (!reader.IsEmptyElement) { reader.ReadStartElement(); serviceRequest.Arguments = XMLArgumentsSerializer.Deserialize(reader.ReadSubtree()); } else { reader.Skip(); } } else { throw new ArgumentException("Xml Reader don't have the Service.Request in Start Element.", "XmlReader reader"); } return serviceRequest; }
public virtual void ReadXml(System.Xml.XmlReader topReader) { this.m_isBeingRead = true; string infoName = topReader.Name; XmlReader reader = topReader.ReadSubtree(); XPathDocument doc = new XPathDocument(reader); var nav = doc.CreateNavigator(); XPathNavigator iter = nav.SelectSingleNode(String.Format("/{0}/Version", infoName)); if (iter == null) { throw new XmlException("ExperimentInfo is missing version information."); } else { long ver = iter.ValueAsLong; if (ver == CurrentVersion) { ReadCurrentVersion(nav, infoName); } else if (ver == 1) { ReadVersion1(nav, infoName); } else { throw new InvalidOperationException("ExperimentInfo has an invalid version number"); } } this.m_isBeingRead = false; }
/// <summary> /// return a TreeNode that is the root of a tree representing this Element node with descendants /// </summary> /// <param name="xmlDoc"></param> /// <returns></returns> private TreeNode getTreeRootedAtElementNode(XmlReader xmlDoc) { TreeNode MainTreeRoot = getSingleNode(xmlDoc); TreeNode Attributes = new TreeNode(); Attributes.Text = "<Attributes>"; while (xmlDoc.MoveToNextAttribute()) { Attributes.Nodes.Add(getSingleNode(xmlDoc)); } MainTreeRoot.Nodes.Add(Attributes); xmlDoc.Read(); while(!xmlDoc.EOF) { if(xmlDoc.NodeType == XmlNodeType.Element) { using (XmlReader childElement = xmlDoc.ReadSubtree()) { childElement.Read(); MainTreeRoot.Nodes.Add(getTreeRootedAtElementNode(childElement)); } } else if(xmlDoc.NodeType == XmlNodeType.EndElement) { return MainTreeRoot; } else { MainTreeRoot.Nodes.Add(getSingleNode(xmlDoc)); } xmlDoc.Read(); } return MainTreeRoot; }
private void expandNamespace_function(TreeNodeCollection outNodes, string strSection, string strNamespace, XmlReader reader) { bool bContinue = reader.ReadToDescendant("function"); while (bContinue) { NodeDocPythonFunction node = newnode(strSection, strNamespace, reader.GetAttribute("name")); outNodes.Add(node); bool bInstance = reader.GetAttribute("instance") == "true"; node.bIsInstanceMethod = bInstance; string strSyntax = reader.GetAttribute("fullsyntax"); if (strSyntax != null && strSyntax != "") node.strFullSyntax = strSyntax; node.strDocumentation = getFunctionDocAndExample(reader.ReadSubtree()); //assumes doc before example if (this.emphasizeStaticness()) { if (!bInstance) { //change visible node text to emphasize static-ness node.Text = node.strNamespacename + "." + node.strFunctionname; } } bContinue = ReadToNextSibling(reader, "function"); } reader.Close(); }
public override void ReadXml(XmlReader reader) { Keyword.Clear(); var subReader = reader.ReadSubtree(); if (CheckEmptyNode(subReader, "KeywordList", string.Empty, true)) return; while (!subReader.EOF) { subReader.MoveToContent(); if (subReader.LocalName == "Keyword") { var att = subReader.GetAttribute("vocabulary"); reader.ReadStartElement("Keyword"); var val = reader.ReadContentAsString(); reader.ReadEndElement(); Keyword.Add(new Keyword { Vocabulary = att, Value = val }); } else { subReader.ReadEndElement(); } } reader.Skip(); }
//===================================================================== /// <summary> /// Constructor /// </summary> /// <param name="configuration">The XML reader from which to get the configuration</param> public TypeFilter(XmlReader configuration) { if(configuration.NodeType != XmlNodeType.Element || configuration.Name != "type") throw new InvalidOperationException("The configuration element must be named 'type'"); memberFilters = new List<MemberFilter>(); name = configuration.GetAttribute("name"); exposed = Convert.ToBoolean(configuration.GetAttribute("expose"), CultureInfo.InvariantCulture); // If not exposed, check for a required attribute which forces it to be exposed. This allows a // way to expose it and indicate that it should always be exposed in the configuration file. if(!exposed) { required = Convert.ToBoolean(configuration.GetAttribute("required"), CultureInfo.InvariantCulture); if(required) exposed = true; } XmlReader subtree = configuration.ReadSubtree(); while(subtree.Read()) if(subtree.NodeType == XmlNodeType.Element && subtree.Name == "member") memberFilters.Add(new MemberFilter(subtree)); subtree.Close(); }
public static void ProcessLinks(XmlReader reader, NpgsqlConnection connection) { var page_title = reader.GetAttribute("title"); List<string> titles; XmlReader inner; inner = reader.ReadSubtree(); titles = new List<string>(); while (inner.ReadToFollowing("link")) titles.Add(inner.ReadElementContentAsString()); if (titles.Count() == 0) return; // Now we have a list of titles construct a subquery to get the ID's // I could use this query, which looks nicer, but EXPLAIN says it costs a little bit more. // SELECT id FROM pages WHERE title IN ('Apple','ElementalAllotropes') // AND redirect IS NULL UNION SELECT p2.id FROM pages AS p1 // JOIN pages AS p2 ON p1.title IN ('Apple','ElementalAllotropes') AND p2.title = p1.redirect AND p2.redirect IS NULL; var select_command_text = string.Format(PostgresSchema.LINK_ID_QUERY, string.Join(",", (from val in Enumerable.Range(0, titles.Count) select string.Format(":title_{0}", val)))); // Update our links to be the array of ID's using the subquery above var command = new NpgsqlCommand(string.Format("UPDATE pages SET links = ARRAY({0}) WHERE title = :title", select_command_text), connection); foreach (var val in Enumerable.Range(0, titles.Count)) command.Parameters.AddWithValue("title_"+val, titles[val]); command.Parameters.Add(new NpgsqlParameter("title", page_title)); command.ExecuteNonQuery(); }
public override void ReadXml(XmlReader reader) { if (CheckEmptyNode(reader, "DCPType", Namespace)) return; reader.MoveToContent(); Http.ReadXml(reader.ReadSubtree()); }
public void ReadXml(XmlReader reader) { if (reader.LocalName != "Envelope" && !reader.ReadToDescendant("Envelope", SoapEnvelopeNamespace)) throw new InvalidDataException(); XmlHelper.ParseXml(reader, new XmlParseSet { {"Header", () => XmlHelper.ParseXmlDictionary(reader.ReadSubtree(), this.Headers)}, {"Body", () => XmlHelper.ParseXml(reader.ReadSubtree(), new XmlParseSet { () => { this.Namespace = reader.NamespaceURI; this.Method = reader.LocalName; XmlHelper.ParseXmlDictionary(reader, this.Arguments); }})} }); }
public bool ParseLogs() { try { foreach (string f in _root.Files) { _reader = new XmlTextReader(f); Console.WriteLine("Loading Log"); while (_reader.Read()) { if (_reader.Name == "State") { Dictionary<String, String> attributes = GetAttributes(); _root.States.Add(new Model.PMState(attributes)); ParseState(_reader.ReadSubtree()); } } } } catch { return false; } return true; }
private void expandNamespace_function(TreeNodeCollection outNodes, TreeNode outInstanceMethods, string strSection, string strNamespace, XmlReader reader) { bool bContinue = reader.ReadToDescendant("function"); while (bContinue) { // if (reader.GetAttribute("args") != null) MessageBox.Show("instance?"); NodeDocLnzFunction node = new NodeDocLnzFunction(strSection, strNamespace, reader.GetAttribute("name")); bool bInstance = reader.GetAttribute("instance") == "true"; node.bIsInstanceMethod = bInstance; string strArgs = reader.GetAttribute("args"); if (strArgs != null && strArgs != "") node.strArguments = strArgs; string strReturns = reader.GetAttribute("returns"); if (strReturns != null && strReturns != "") node.strReturns = strReturns; node.strDocumentationAndExample = getFunctionDocAndExample(reader.ReadSubtree()); //assumes doc before example if (bInstance) { //MessageBox.Show("instance found"); outInstanceMethods.Nodes.Add(node); } else outNodes.Add(node); bContinue = ReadToNextSibling(reader, "function"); } reader.Close(); }
/// <summary> /// Generates an object from its XML representation. /// </summary> /// <param name="reader">The <see cref="T:System.Xml.XmlReader"/> stream from which the object is deserialized.</param> public override void ReadXml(XmlReader reader) { if (reader == null) throw new ArgumentNullException("reader"); if (reader.LocalName == "DirectoryPath") { XmlReader subReader = reader.ReadSubtree(); XPathDocument doc = new XPathDocument(subReader); var nav = doc.CreateNavigator(); XPathNavigator iter = nav.SelectSingleNode("/DirectoryPath/Version"); if (iter != null) { long ver = iter.ValueAsLong; if (ver == CurrentVersion) { ReadCurrentVersion(nav); } else { throw new NotSupportedException("Version not supported."); } } else { throw new NotSupportedException("Could not read version of DirectoryPath. "); } } }
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> /// Parses the specified reader. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> public override T Parse <T>(System.Xml.XmlReader reader) { IOpmlFeed ret = new OpmlFeed(); bool readContent = false; while (readContent || reader.Read()) { readContent = false; if (reader.NodeType == XmlNodeType.Element) { readContent = true; switch (reader.Name) { case "head": using (XmlReader subReader = reader.ReadSubtree()) { ret.Head = ConvertToIOpmlHead(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "body": using (XmlReader subReader = reader.ReadSubtree()) { ret.Body = ConvertToIOpmlBody(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; default: UnhandledElement(ret, reader); break; } } } reader.Close(); return((T)ret); }
public override void ReadXml(XmlReader reader) { reader.MoveToContent(); XmlReader xr = reader.ReadSubtree(); xr.MoveToContent(); if (xr.Value != "") _replyMessage = xr.Value; base.ReadXml(xr); }
/// <summary> /// Reads a list of maze genomes from an XML file. /// </summary> /// <param name="xr">Reference to the XmlReader.</param> /// <param name="genomeFactory">A MazeGenomeFactory to construct genomes against.</param> /// <returns>Instantiated list of maze genomes.</returns> public static List<MazeGenome> ReadCompleteGenomeList(XmlReader xr, MazeGenomeFactory genomeFactory) { // Find <Root> XmlIoUtils.MoveToElement(xr, false, __ElemRoot); // Find <Mazes> XmlIoUtils.MoveToElement(xr, true, __ElemMazes); // Read mazes List<MazeGenome> genomeList = new List<MazeGenome>(); using (XmlReader xrSubtree = xr.ReadSubtree()) { // Re-scan for the root <Mazes> element XmlIoUtils.MoveToElement(xrSubtree, false); // Move to first Maze element XmlIoUtils.MoveToElement(xrSubtree, true, __ElemMaze); // Read maze elements do { MazeGenome genome = ReadGenome(xrSubtree); genomeList.Add(genome); } while (xrSubtree.ReadToNextSibling(__ElemMaze)); } // Check for empty list if (genomeList.Count == 0) { return genomeList; } // Determine the max genome ID uint maxGenomeId = genomeList.Aggregate<MazeGenome, uint>(0, (current, genome) => Math.Max(current, genome.Id)); // Determine the max gene innovation ID uint maxInnovationId = genomeList.Aggregate<MazeGenome, uint>(0, (curMaxPopulationInnovationId, genome) => genome.GeneList.Aggregate(curMaxPopulationInnovationId, (curMaxGenomeInnovationId, mazeGene) => Math.Max(curMaxGenomeInnovationId, mazeGene.InnovationId))); // Set the genome factory ID generator and innovation ID generator to one more than the max genomeFactory.GenomeIdGenerator.Reset(Math.Max(genomeFactory.GenomeIdGenerator.Peek, maxGenomeId + 1)); genomeFactory.InnovationIdGenerator.Reset(Math.Max(genomeFactory.InnovationIdGenerator.Peek, maxInnovationId + 1)); // Retrospecitively assign the genome factory to the genomes foreach (MazeGenome genome in genomeList) { genome.GenomeFactory = genomeFactory; } return genomeList; }
public static IEnumerable<Message> ReadAllXml (XmlReader r) { while (r.Read ()) { if (r.IsStartElement ("Message")) { var m = new Message (); m.ReadXml (r.ReadSubtree ()); yield return m; } } }
public void ReadXml(XmlReader reader) { while (!reader.EOF) { if (reader.IsStartElement()) { switch (reader.Name) { case FontFamiliesElementName: ReadFonts(reader.ReadSubtree()); break; case CSSElementsElementName: ReadCSSElements(reader.ReadSubtree()); break; } } reader.Read(); } }
public virtual void ReadXml(XmlReader reader) { reader.MoveToContent(); XmlReader xr = reader.ReadSubtree(); while (!xr.EOF) { xr.MoveToContent(); _parameters.Add(xr.GetAttribute("key"), xr.Value); } }
public void ReadXml(System.Xml.XmlReader r) { using (XmlReader reader = r.ReadSubtree()) { if (reader.Read()) { while (reader.Read()) { if (reader.NodeType == System.Xml.XmlNodeType.Element && !reader.IsEmptyElement) { EntityDbField field = new EntityDbField( XmlConvert.EncodeLocalName(reader.LocalName), (SqlDbType)Enum.Parse(typeof(SqlDbType), reader["dbType"]), Int32.Parse(reader["length"]), GetDbType()); int pos; if ((pos = m_FieldMap.BinarySearch(new EntityFieldMapping(field))) >= 0) { if (m_FieldMap[pos].EntityField.FieldType == typeof(Byte[])) { using (MemoryStream ms = new MemoryStream()) { Byte[] buffer = new Byte[1024]; int read = 0; while ((read = reader.ReadElementContentAsBase64(buffer, 0, 1024)) > 0) { ms.Write(buffer, 0, read); } m_FieldMap[pos].EntityField.SetValue(this, ms.ToArray()); ms.Close(); } } else if (m_FieldMap[pos].EntityField.FieldType.IsGenericType && m_FieldMap[pos].EntityField.FieldType.GetGenericTypeDefinition() == typeof(Nullable <>)) { if (m_FieldMap[pos].EntityField.FieldType.GetGenericArguments()[0] == typeof(Guid)) { m_FieldMap[pos].EntityField.SetValue(this, new Guid(reader.ReadElementContentAsString())); } else { m_FieldMap[pos].EntityField.SetValue(this, reader.ReadElementContentAs(m_FieldMap[pos].EntityField.FieldType.GetGenericArguments()[0], null)); } } else { m_FieldMap[pos].EntityField.SetValue(this, reader.ReadElementContentAs(m_FieldMap[pos].EntityField.FieldType, null)); } } } } } } r.Read(); }
/// <summary> /// 读取子属性 /// </summary> /// <param name="reader"></param> /// <param name="func"></param> private void ReadSubProp(System.Xml.XmlReader reader, Action <DocumentProperty> func) { var part = new DocumentProperty(); var SubReader = reader.ReadSubtree(); SubReader.Read(); part.ReadXml(SubReader); func(part); reader.ReadEndElement(); reader.MoveToContent(); }
public RootFilter(XmlReader configuration) { exposed = Convert.ToBoolean(configuration.GetAttribute("expose")); XmlReader subtree = configuration.ReadSubtree(); while (subtree.Read()) { if ((subtree.NodeType == XmlNodeType.Element) && (subtree.Name == "namespace")) { NamespaceFilter namespaceFilter = new NamespaceFilter(subtree); namespaceFilters.Add(namespaceFilter); } } subtree.Close(); }
private static FaultCode Deserialize(XmlReader reader) { using (reader) { var code = new FaultCode (); reader.ReadToFollowing ("UPnPError", "urn:schemas-upnp-org:control-1-0"); while (Helper.ReadToNextElement (reader)) { Deserialize (reader.ReadSubtree (), reader.Name, ref code); } return code; } }
internal override void Load (XmlReader reader) { while (reader.Read () && reader.NodeType != XmlNodeType.Element) ; FillLocation (reader); using (XmlReader subReader = reader.ReadSubtree ()) { document = new XmlDocument (); document.Load (subReader); element = document.DocumentElement; } }
private static void HandleTopLevelElement(XmlReader reader, IPluginVisitor visitor) { if (reader.Name == "revisions" && visitor.EnterRevisions()) { ReadRevisions(reader.ReadSubtree(), visitor); visitor.LeaveRevisions(); } else { HandleElement(reader, visitor); } }
public static YodiiEngine CreateEngineFromXml( XmlReader r ) { YodiiEngine e = new YodiiEngine( new YodiiEngineHostMock() ); DiscoveredInfo d = new DiscoveredInfo(); // Used to index reference links between plugins and services. List<PendingGeneralization> pendingGeneralizations = new List<PendingGeneralization>(); List<PendingPluginService> pendingPluginServices = new List<PendingPluginService>(); List<PendingServiceReference> pendingServiceReferences = new List<PendingServiceReference>(); CKSortedArrayKeyList<PluginInfo, string> loadedPlugins; CKSortedArrayKeyList<ServiceInfo, string> loadedServices; loadedServices = new CKSortedArrayKeyList<ServiceInfo, string>( s => s.ServiceFullName, false ); loadedPlugins = new CKSortedArrayKeyList<PluginInfo, string>( p => p.PluginFullName, false ); while( r.Read() ) { // Load services if( r.IsStartElement() && r.Name == "Services" ) { ReadServices( r.ReadSubtree(), d, loadedServices, loadedPlugins, pendingGeneralizations, pendingPluginServices, pendingServiceReferences ); } // Load plugins if( r.IsStartElement() && r.Name == "Plugins" ) { ReadPlugins( r.ReadSubtree(), d, loadedServices, loadedPlugins, pendingPluginServices, pendingServiceReferences ); } // Read configuration manager if( r.IsStartElement() && r.Name == "Configuration" ) { ReadConfigurationManager( e.Configuration, r.ReadSubtree() ); } } e.SetDiscoveredInfo( d ); return e; }
/// <summary> /// Parses the XML and if there's an in-stream error in it it will return it. /// </summary> /// <param name="reader">The reader to read the XML from.</param> /// <returns>If there was an in-stream error this will return it as an exception instance, otherwise it returns null.</returns> public static Exception ParseInStreamError(XmlReader reader) { while (reader.Read()) { if (reader.NodeType == XmlNodeType.Element && reader.LocalName == "error" && reader.NamespaceURI == UnitTestsUtil.MetadataNamespace.NamespaceName) { return ParseInStreamSingleError(reader.ReadSubtree()); } } return null; }
public void ReadXml(XmlReader reader) { if (reader.MoveToContent() == XmlNodeType.Element && reader.LocalName == "repeat") { index = int.Parse(reader["index"]); if (reader.ReadToDescendant("template")) template = XElement.Load(reader.ReadSubtree()) .Elements() .First(); } }
public TypeFilter(XmlReader configuration) { if ((configuration.NodeType != XmlNodeType.Element) || (configuration.Name != "type")) throw new InvalidOperationException(); name = configuration.GetAttribute("name"); exposed = Convert.ToBoolean(configuration.GetAttribute("expose")); XmlReader subtree = configuration.ReadSubtree(); while (subtree.Read()) { if ((subtree.NodeType == XmlNodeType.Element) && (subtree.Name == "member")) { MemberFilter memberFilter = new MemberFilter(subtree); memberFilters.Add(memberFilter); } } subtree.Close(); }
public void ReadXml(XmlReader reader) { reader.Read(); var sub = reader.ReadSubtree(); do { if (sub.NodeType == XmlNodeType.Element) { string name = sub.Name; string val = sub.ReadElementContentAsString(); Values.Add(name, Convert.ToDouble(val)); } } while (sub.Read()); }
internal override void ProcessXmlCore (XmlReader reader) { switch (reader.Name) { case "title": title = reader.ReadString (); break; case "artist": artist = new Artist (reader.ReadSubtree ()); break; default: base.ProcessXmlCore (reader); break; } }
public void ReadXml(System.Xml.XmlReader reader) { if (reader.ReadToFollowing(this.GetType().Name)) { reader.ReadStartElement(); if (reader.LocalName == typeof(TabLayout).Name || reader.LocalName == "MultiContent") // MultiContent is old name and is used here for compatibility with old saved layouts { DockedContent = new TabLayout(Root, reader.ReadSubtree()); Content = DockedContent; reader.ReadEndElement(); } reader.ReadEndElement(); } }
public void ReadXml(System.Xml.XmlReader reader) { reader.ReadToFollowing(xmlFlujogramaType.Name); XmlSerializer serializer = new XmlSerializer(xmlFlujogramaType); FlujogramaDef = serializer.Deserialize(reader) as IFlujograma; //EntidadIDentificable.IdEntidad = FlujogramaDef.IdEntidad; //EntidadIDentificable.Entidad = FlujogramaDef.Entidad; reader.ReadToFollowing(xmlEstadoType.Name); if (reader.Name.Equals(xmlEstadoType.Name)) { serializer = new XmlSerializer(xmlEstadoType); EstadoActual = serializer.Deserialize(reader) as IEstado; EstadoActual.Flujograma = FlujogramaDef; } reader.ReadToFollowing(xmlTransicionType.Name); if (reader.Name.Equals(xmlTransicionType.Name)) { serializer = new XmlSerializer(xmlTransicionType); UltimaTransicion = serializer.Deserialize(reader) as ITransicion; UltimaTransicion.Flujograma = FlujogramaDef; UltimaTransicion.Origen = FlujogramaDef.Estados[UltimaTransicion.Origen.Estado]; UltimaTransicion.Destino = FlujogramaDef.Estados[UltimaTransicion.Destino.Estado]; } reader.ReadToFollowing("Historico"); if (reader.Name.Equals("Historico")) { XmlReader hijos = reader.ReadSubtree(); serializer = new XmlSerializer(xmlTransicionType); while (hijos.ReadToFollowing(xmlTransicionType.Name)) { ITransicion tran = serializer.Deserialize(hijos) as ITransicion; tran.Flujograma = FlujogramaDef; tran.Origen = FlujogramaDef.Estados[tran.Origen.Estado]; tran.Destino = FlujogramaDef.Estados[tran.Destino.Estado]; _procesosAnteriores.Add(tran.FechaTransicion, tran); } } }
private void ReadBackground(ref XmlReadState state, System.Xml.XmlReader node) { node.Read(); if (!state.Silent) { Console.WriteLine("Background shader"); } var shader = new Shader(Client, Shader.ShaderType.World) { Name = Guid.NewGuid().ToString() }; Utilities.Instance.ReadNodeGraph(ref shader, node.ReadSubtree()); state.Scene.AddShader(shader); state.Scene.Background.Shader = shader; }
public void ReadXml(System.Xml.XmlReader reader) { if (reader == null) { throw new ArgumentNullException("reader"); } if (reader.LocalName == "Settings") { XmlReader topReader = reader.ReadSubtree(); XPathDocument doc = new XPathDocument(topReader); var nav = doc.CreateNavigator(); XPathNavigator iter = nav.SelectSingleNode("/Settings/Version"); if (iter == null) { throw new XmlSchemaException("Settings does not have a version element"); } } }
public void ReadShader(ref XmlReadState state, System.Xml.XmlReader node) { node.Read(); var name = node.GetAttribute("name"); if (!state.Silent) { Console.WriteLine("Shader: {0}", node.GetAttribute("name")); } if (string.IsNullOrEmpty(name)) { return; } var shader = new Shader(Client, Shader.ShaderType.Material) { Name = name }; Utilities.Instance.ReadNodeGraph(ref shader, node.ReadSubtree()); state.Scene.AddShader(shader); }
public new void ReadXml(System.Xml.XmlReader reader) { while (reader.Read()) { base.ReadXml(reader); if (reader.NodeType == System.Xml.XmlNodeType.Element) { switch (reader.Name) { case "PollType": this.PollType = (QuestionPollType)reader.ReadString().ToInt32(1); break; case "AnonymousAllowed": AnonymousAllowed = bool.Parse(reader.ReadString()); break; case "ShowResult": ShowResult = (QuestionShowResult)reader.ReadString().ToInt32(1); break; case "ShowAnswerCount": ShowAnswerCount = (QuestionShowAnswerCount)reader.ReadString().ToInt32(1); break; case "PollLayout": PollLayout = (QuestionPollLayout)reader.ReadString().ToInt32(1); break; case "TextRight": TextRight = reader.ReadString(); break; case "TextFalse": TextFalse = reader.ReadString(); break; case "TextPartially": TextPartially = reader.ReadString(); break; case "Answers": PollAnswer item = null; System.Xml.XmlReader subReader = reader.ReadSubtree(); while (subReader.Read()) { if (subReader.NodeType == System.Xml.XmlNodeType.Element) { if (subReader.Name == "Answer") { if (item != null) { list.Add(item); } item = new PollAnswer(); item.Answer = subReader.ReadString(); } } else if (subReader.NodeType == System.Xml.XmlNodeType.Attribute) { switch (subReader.Name) { case "Position": item.Position = Convert.ToInt32(subReader.ReadString()); break; case "Anonnymous": item.Anonnymous = Convert.ToInt32(subReader.ReadString()); break; case "Registerd": item.Registerd = Convert.ToInt32(subReader.ReadString()); break; case "IsRight": item.IsRight = Convert.ToBoolean(subReader.ReadString()); break; } } } break; } } } }
private static ITestCommand ReadTestCommand(System.Xml.XmlReader reader, string comment, string sessionId) { var cmd = ReadCommand(reader, comment, sessionId); if (cmd != null) { return(cmd); } switch (reader.LocalName) { case "AssertMatch": var result = new AssertMatch() { Comment = comment, Match = reader.GetAttribute("match") }; var removeSys = reader.GetAttribute("removeSysProps"); result.RemoveSystemProperties = (removeSys != "0"); using (var subReader = reader.ReadSubtree()) { subReader.Read(); while (!subReader.EOF) { if (reader.NodeType == XmlNodeType.Element) { switch (reader.LocalName) { case "Remove": result.Removes.Add(reader.GetAttribute("match")); subReader.Read(); break; case "Expected": bool isXml; result.Expected = ProcessXmlValue(reader.ReadInnerXml(), out isXml); result.IsXml = isXml; break; default: subReader.Read(); break; } } else { subReader.Read(); } } } reader.Read(); return(result); case "DownloadFile": return(new DownloadFile() { Comment = comment, Text = reader.ReadInnerXml() }); } return(null); }
public void ReadFrom(System.Xml.XmlReader x) { XmlReader s = null; while (x.Read()) { switch (x.LocalName) { case "BinaryPath": BinPath = x.ReadString(); break; case "TargetConfiguration": s = x.ReadSubtree(); var t = new LinkTargetConfiguration(); if (t.LoadFrom(this, s)) { LinkTargetConfigurations [t.TargetType] = t; } s.Close(); break; case "DefaultLibs": s = x.ReadSubtree(); while (s.Read()) { if (s.LocalName == "lib") { DefaultLibraries.Add(s.ReadString()); } } s.Close(); break; case "Includes": s = x.ReadSubtree(); while (s.Read()) { if (s.LocalName == "Path") { ParseCache.ParsedDirectories.Add(s.ReadString()); } } s.Close(); break; case "VersionId": PredefinedVersionConstant = x.ReadString(); break; case "CompilerCommand": SourceCompilerCommand = x.ReadString(); break; case "Patterns": s = x.ReadSubtree(); ArgumentPatterns.ReadFrom(s); s.Close(); break; case "gdcLibPrefixing": EnableGDCLibPrefixing = x.ReadString() == "true"; break; } } }
private void ReadScene(ref XmlReadState state, System.Xml.XmlReader node) { while (node.Read()) { if (!node.IsStartElement()) { continue; } if (!state.Silent) { Console.WriteLine("XML node: {0}", node.Name); } switch (node.Name) { case "camera": ReadCamera(ref state, node.ReadSubtree()); break; case "background": ReadBackground(ref state, node.ReadSubtree()); break; case "transform": var transform_substate = new XmlReadState(state); var t = transform_substate.Transform; ReadTransform(node, ref t); transform_substate.Transform = t; node.Read(); /* advance forward one, otherwise we'll end up in internal loop */ ReadScene(ref transform_substate, node.ReadSubtree()); break; case "lookat": var lookat_substate = new XmlReadState(state); var lat = lookat_substate.Transform; ReadLookAt(node, ref lat); lookat_substate.Transform = lat; node.Read(); /* advance forward one, otherwise we'll end up in internal loop */ ReadScene(ref lookat_substate, node.ReadSubtree()); break; case "state": var state_substate = new XmlReadState(state); ReadState(ref state_substate, node.ReadSubtree()); node.Read(); /* advance one forward */ ReadScene(ref state_substate, node.ReadSubtree()); break; case "integrator": ReadIntegrator(ref state, node.ReadSubtree()); break; case "shader": var shader_substate = new XmlReadState(state); ReadShader(ref shader_substate, node.ReadSubtree()); break; case "mesh": ReadMesh(ref state, node.ReadSubtree()); break; case "object": ReadObject(ref state, node.ReadSubtree()); break; case "light": ReadLight(ref state, node.ReadSubtree()); break; case "include": var src = node.GetAttribute("src"); if (!string.IsNullOrEmpty(src)) { ReadInclude(ref state, src); } break; default: Console.WriteLine("Uknown node {0}", node.Name); break; } } }
public void ReadXml(System.Xml.XmlReader reader) { if (reader.ReadToFollowing(this.GetType().Name)) { String s = reader.GetAttribute(Orientation.GetType().Name); m_orientation = (Orientation)(Enum.Parse(Orientation.GetType(), s)); switch (m_orientation) { case Orientation.Horizontal: if (reader.ReadToDescendant("Column")) { RowDefinitions.Add(NewRowDefinition(new GridLength(1, GridUnitType.Star), m_minGridSize.Height)); do { double width = double.Parse(reader.GetAttribute("Width")); IDockLayout layout = null; reader.ReadStartElement(); if (reader.LocalName == typeof(DockedWindow).Name) { DockedWindow dockedWindow = new DockedWindow(Root, reader.ReadSubtree()); layout = dockedWindow.DockedContent.Children.Count != 0 ? dockedWindow : null; reader.ReadEndElement(); } else if (reader.LocalName == typeof(GridLayout).Name) { GridLayout gridLayout = new GridLayout(Root, reader.ReadSubtree()); layout = gridLayout.Layouts.Count > 0 ? gridLayout : null; reader.ReadEndElement(); } if (layout != null) { if (Children.Count > 0) { ColumnDefinitions.Add(NewColumnDefinition(new GridLength(1, GridUnitType.Auto), 0)); Children.Add(NewGridSplitter(Orientation)); } ColumnDefinitions.Add(NewColumnDefinition(new GridLength(width, GridUnitType.Star), m_minGridSize.Width)); m_children.Add(layout); Children.Add((FrameworkElement)layout); } } while (reader.ReadToNextSibling("Column")); } break; case Orientation.Vertical: if (reader.ReadToDescendant("Row")) { ColumnDefinitions.Add(NewColumnDefinition(new GridLength(1, GridUnitType.Star), m_minGridSize.Width)); do { double height = double.Parse(reader.GetAttribute("Height")); IDockLayout layout = null; reader.ReadStartElement(); if (reader.LocalName == typeof(DockedWindow).Name) { DockedWindow dockedWindow = new DockedWindow(Root, reader.ReadSubtree()); layout = dockedWindow.DockedContent.Children.Count != 0 ? dockedWindow : null; reader.ReadEndElement(); } else if (reader.LocalName == typeof(GridLayout).Name) { GridLayout gridLayout = new GridLayout(Root, reader.ReadSubtree()); layout = gridLayout.Layouts.Count > 0 ? gridLayout : null; reader.ReadEndElement(); } if (layout != null) { if (Children.Count > 0) { RowDefinitions.Add(NewRowDefinition(new GridLength(1, GridUnitType.Auto), 0)); Children.Add(NewGridSplitter(Orientation)); } RowDefinitions.Add(NewRowDefinition(new GridLength(height, GridUnitType.Star), m_minGridSize.Height)); m_children.Add(layout); Children.Add((FrameworkElement)layout); } } while (reader.ReadToNextSibling("Row")); } break; } for (int i = 0; i < Children.Count; i++) { Grid.SetColumn(Children[i], Orientation == Orientation.Horizontal ? i : 0); Grid.SetRow(Children[i], Orientation == Orientation.Vertical ? i : 0); } reader.ReadEndElement(); } }
public override void ReadXml(System.Xml.XmlReader reader) { using (System.Xml.XmlReader subTree = reader.ReadSubtree()) { subTree.Read(); string tmp = subTree.ReadOuterXml(); //seek for template tag using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) { xr.Read(); base.ReadXml(xr); } //process content using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) { xr.Read(); //skip current node while (!xr.EOF) { xr.Read(); //read first child if (!xr.IsStartElement()) { continue; } if (xr.Name == "Template") { xr.Skip(); if (!xr.IsStartElement()) { continue; } } Type t = Type.GetType("Crow." + xr.Name); if (t == null) { Assembly a = Assembly.GetEntryAssembly(); foreach (Type expT in a.GetExportedTypes()) { if (expT.Name == xr.Name) { t = expT; } } } if (t == null) { throw new Exception(xr.Name + " type not found"); } GraphicObject go = (GraphicObject)Activator.CreateInstance(t); (go as IXmlSerializable).ReadXml(xr); Content = go; xr.Read(); //closing tag } } } }
public override void ReadXml(System.Xml.XmlReader reader) { //Template could be either an attribute containing path or expressed inlined //as a Template Element using (System.Xml.XmlReader subTree = reader.ReadSubtree()) { subTree.Read(); string template = reader.GetAttribute("Template"); string tmp = subTree.ReadOuterXml(); //Load template from path set as attribute in templated control if (string.IsNullOrEmpty(template)) { //seek for template tag first using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) { //load template first if inlined xr.Read(); //read first child xr.Read(); //skip root node while (!xr.EOF) { if (!xr.IsStartElement()) { xr.Read(); continue; } if (xr.Name == "ItemTemplate") { string dataType = "default", datas = "", itemTmp; while (xr.MoveToNextAttribute()) { if (xr.Name == "DataType") { dataType = xr.Value; } else if (xr.Name == "Data") { datas = xr.Value; } } xr.MoveToElement(); itemTmp = xr.ReadInnerXml(); if (ItemTemplates == null) { ItemTemplates = new Dictionary <string, ItemTemplate> (); } using (IMLReader iTmp = new IMLReader(null, itemTmp)) { ItemTemplates [dataType] = new ItemTemplate(iTmp.RootType, iTmp.GetLoader(), dataType, datas); } if (!string.IsNullOrEmpty(datas)) { ItemTemplates [dataType].CreateExpandDelegate(this); } continue; } if (xr.Name == "Template") { xr.Read(); Type t = Type.GetType("Crow." + xr.Name); if (t == null) { Assembly a = Assembly.GetEntryAssembly(); foreach (Type expT in a.GetExportedTypes()) { if (expT.Name == xr.Name) { t = expT; } } } GraphicObject go = (GraphicObject)Activator.CreateInstance(t); (go as IXmlSerializable).ReadXml(xr); loadTemplate(go); continue; } xr.ReadInnerXml(); } } } else { loadTemplate(CurrentInterface.Load(template)); } //if no template found, load default one if (this.child == null) { loadTemplate(); } //normal xml read using (XmlReader xr = new XmlTextReader(tmp, XmlNodeType.Element, null)) { xr.Read(); base.ReadXml(xr); } } }
public new void ReadXml(System.Xml.XmlReader reader) { List <string> largePictures = new List <string>(); List <string> pictureCaptions = new List <string>(); while (reader.Read()) { base.ReadXml(reader); if (reader.NodeType == System.Xml.XmlNodeType.Element) { switch (reader.Name) { case "NewsText": NewsText = reader.ReadString(); break; case "NewsRefURL": string url = reader.ReadString(); if (!string.IsNullOrEmpty(url)) { ReferenceURL = new Uri(url); } break; case "NewsPicList": System.Xml.XmlReader picListReader = reader.ReadSubtree(); while (picListReader.Read()) { if (picListReader.NodeType == System.Xml.XmlNodeType.Element) { switch (picListReader.Name) { case "Pic": largePictures.Add(picListReader.ReadString()); break; case "Caption": pictureCaptions.Add(picListReader.ReadString()); break; } } } break; case "Links": List <Link> links = new List <Link>(); Link link = null; System.Xml.XmlReader linksListReader = reader.ReadSubtree(); while (linksListReader.Read()) { if (linksListReader.NodeType == System.Xml.XmlNodeType.Element) { switch (linksListReader.Name) { case "Link": link = new Link(); break; case "Title": link.Title = linksListReader.ReadString().StripHTMLTags(); break; case "URL": string url2 = linksListReader.ReadString(); if (!string.IsNullOrEmpty(url2)) { link.URL = new Uri(url2); } break; } } if (link != null && !string.IsNullOrEmpty(link.Title) && link.URL != null) { links.Add(link); link = null; } } Links = links; break; } } } LargePictures = largePictures; PictureCaptions = pictureCaptions; }
/// <summary> /// Parses the specified reader. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> public override T Parse <T>(System.Xml.XmlReader reader) { IAtomFeed ret = (IAtomFeed) new AtomFeed(); reader.Read(); bool readContent = false; while (readContent || reader.Read()) { readContent = false; if (reader.NodeType == XmlNodeType.Element) { readContent = true; switch (reader.Name) { case "id": ret.FeedUri = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString(), reader.BaseURI); break; case "title": ret.Title = reader.ReadElementContentAsString(); break; case "updated": ret.LastUpdated = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString()); break; case "generator": using (XmlReader subReader = reader.ReadSubtree()) { ret.Generator = ConvertToIAtomGenerator(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "author": using (XmlReader subReader = reader.ReadSubtree()) { ret.Authors.Add(ConvertToIAtomPerson(subReader)); } if (reader.IsEmptyElement) { readContent = false; } break; case "link": using (XmlReader subReader = reader.ReadSubtree()) { ret.Links.Add(ConvertToIAtomLink(subReader)); } if (reader.IsEmptyElement) { readContent = false; } break; case "category": using (XmlReader subReader = reader.ReadSubtree()) { ret.Categories.Add(ConvertToIAtomCategory(subReader)); } if (reader.IsEmptyElement) { readContent = false; } break; case "entry": using (XmlReader subReader = reader.ReadSubtree()) { ret.Items.Add(ParseItem(subReader)); } if (reader.IsEmptyElement) { readContent = false; } break; case "contributor": using (XmlReader subReader = reader.ReadSubtree()) { ret.Contributors.Add(ConvertToIAtomPerson(subReader)); } if (reader.IsEmptyElement) { readContent = false; } break; case "logo": ret.Logo = reader.ReadElementContentAsString(); break; case "icon": ret.Icon = reader.ReadElementContentAsString(); break; case "rights": using (XmlReader subReader = reader.ReadSubtree()) { ret.Rights = ConvertToIAtomText(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "subtitle": using (XmlReader subReader = reader.ReadSubtree()) { ret.Subtitle = ConvertToIAtomText(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; default: UnhandledElement(ret, reader); break; } } } reader.Close(); return((T)ret); }
/// <summary> /// Parses the specified reader. /// </summary> /// <param name="reader">The reader.</param> /// <returns></returns> public override T Parse <T>(System.Xml.XmlReader reader) { IRssFeed ret = (IRssFeed) new RssFeed(); reader.Read(); // RDF versions of RSS don't have version tags. //double version = double.Parse(reader.GetAttribute("version")); reader.ReadToDescendant("channel"); bool readContent = false; while (readContent || reader.Read()) { readContent = false; if (reader.NodeType == XmlNodeType.Element) { readContent = true; switch (reader.Name) { case "title": ret.Title = reader.ReadElementContentAsString(); break; case "link": ret.FeedUri = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString()); break; case "description": ret.Description = reader.ReadElementContentAsString(); break; case "language": ret.Culture = CachedPropertiesProvider.ConvertToCultureInfo(reader.ReadElementContentAsString()); break; case "copyright": ret.Copyright = reader.ReadElementContentAsString(); break; case "managingEditor": ret.ManagingEditor = reader.ReadElementContentAsString(); break; case "webMaster": ret.WebMaster = reader.ReadElementContentAsString(); break; case "pubDate": ret.PublicationDate = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString()); break; case "lastBuildDate": ret.LastChanged = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString()); break; case "category": using (XmlReader subReader = reader.ReadSubtree()) { ret.Category = ConvertToIRssCategory(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "generator": ret.Generator = reader.ReadElementContentAsString(); break; case "docs": ret.Doc = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString()); break; case "cloud": using (XmlReader subReader = reader.ReadSubtree()) { ret.Cloud = ConvertToIRssCloud(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "ttl": ret.TimeToLive = CachedPropertiesProvider.ConvertToInt(reader.ReadElementContentAsString()); break; case "image": using (XmlReader subReader = reader.ReadSubtree()) { ret.Image = ConvertToIRssImage(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; /*case "rating": * break;*/ case "textInput": using (XmlReader subReader = reader.ReadSubtree()) { ret.TextInput = ConvertToIRssTextInput(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "skipHours": using (XmlReader subReader = reader.ReadSubtree()) { ret.SkipHours = ConvertToSkipHourList(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "skipDays": using (XmlReader subReader = reader.ReadSubtree()) { ret.SkipDays = ConvertToDayOfWeekList(subReader); } if (reader.IsEmptyElement) { readContent = false; } break; case "item": using (XmlReader itemReader = reader.ReadSubtree()) { ret.Items.Add(ParseItem(itemReader)); } if (reader.IsEmptyElement) { readContent = false; } break; default: UnhandledElement(ret, reader); break; } } } reader.Close(); return((T)ret); }