/// <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); }
/// <summary> /// used to copy the unknown childnodes for later saving /// </summary> /// <param name="node">the node to process</param> /// <param name="parser">the feed parser to pass down if need be</param> public override void ProcessChildNodes(XmlNode node, AtomFeedParser parser) { if (node != null && node.HasChildNodes) { XmlNode childNode = node.FirstChild; while (childNode != null) { bool fProcessed = false; if (childNode is XmlElement) { foreach (IExtensionElementFactory f in this.ExtensionFactories) { if (String.Compare(childNode.NamespaceURI, f.XmlNameSpace) == 0) { if (String.Compare(childNode.LocalName, f.XmlName) == 0) { //Tracing.TraceMsg("Added extension to SimpleContainer for: " + f.XmlName); ExtensionElements.Add(f.CreateInstance(childNode, parser)); fProcessed = true; break; } } } } if (fProcessed == false) { this.ChildNodes.Add(childNode); } childNode = childNode.NextSibling; } } }
/// <summary>Parses an xml node to create an instance of this object.</summary> /// <param name="node">the xml parses node, can be NULL</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created IExtensionElement object</returns> public virtual IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); ExtensionBase e = null; if (node != null) { object localname = node.LocalName; if (!localname.Equals(XmlName) || !node.NamespaceURI.Equals(XmlNameSpace)) { return(null); } } // memberwise close is fine here, as everything is identical beside the value e = MemberwiseClone() as ExtensionBase; e.InitInstance(this); e.ProcessAttributes(node); e.ProcessChildNodes(node, parser); return(e); }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a File object.</summary> /// <param name="node">File node</param> /// <param name="parser">AtomFeedParser to use</param> /// <returns>the created File object</returns> ////////////////////////////////////////////////////////////////////// public static File ParseFile(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); File file = null; Tracing.Assert(node != null, "node should not be null"); if (node == null) { throw new ArgumentNullException("node"); } // Ensure that the namespace is correct. if (String.Compare(node.NamespaceURI, GCodeSearchParserNameTable.CSNamespace, true) == 0) { file = new File(); if (node.Attributes != null) { file.filename = node.Attributes[ GCodeSearchParserNameTable.ATTRIBUTE_NAME].Value; } else { throw new ArgumentNullException( BaseNameTable.gBatchNamespace + ":" + GCodeSearchParserNameTable.EVENT_FILE + " must contain exactly one " + GCodeSearchParserNameTable.ATTRIBUTE_NAME + " attribute"); } } return(file); }
/// <summary> /// Parses an XML node to create a Custom object /// </summary> /// <param name="node">Custom node</param> /// <param name="parser">AtomFeedParser to use</param> /// <returns>The created Custom object</returns> public static Custom ParseCustom(XmlNode node, AtomFeedParser parser) { if (node == null) { throw new ArgumentNullException("node"); } Custom custom = new Custom(); if (node.Attributes.Count > 1) { throw new ArgumentException("Custom elements should have 0 attributes"); } if (node.HasChildNodes && node.FirstChild.NodeType != XmlNodeType.Text) { // throw new ArgumentException("Custom elements should have 0 children"); } custom.LocalName = node.LocalName; if (node.HasChildNodes) { custom.Value = node.FirstChild.Value; } else { custom.value = ""; } return(custom); }
////////////////////////////////////////////////////////////////////// /// <summary>parses the inner state of the element</summary> /// <param name="e">the Event arguments</param> /// <param name="parser">the atomFeedParser that called this</param> ////////////////////////////////////////////////////////////////////// public override void Parse(ExtensionElementEventArgs e, AtomFeedParser parser) { XmlNode eventNode = e.ExtensionElement; Tracing.TraceMsg(eventNode.LocalName); // Ensure that the namespace is correct. if (String.Compare(eventNode.NamespaceURI, GCodeSearchParserNameTable.CSNamespace, true) == 0) { // Parse a File Element if (eventNode.LocalName == GCodeSearchParserNameTable.EVENT_FILE) { file = File.ParseFile(eventNode, parser); e.DiscardEntry = true; } // Parse a Package Element else if ((eventNode.LocalName == GCodeSearchParserNameTable.EVENT_PACKAGE)) { package = Package.ParsePackage(eventNode, parser); e.DiscardEntry = true; } // Parse Match Elements else if (eventNode.LocalName == GCodeSearchParserNameTable.EVENT_MATCH) { matches.Add(Match.ParseMatch(eventNode, parser)); e.DiscardEntry = true; } } }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Who object.</summary> /// <param name="node">the xml parses node, can be NULL</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created SimpleElement object</returns> ////////////////////////////////////////////////////////////////////// public override IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); SimpleElement e = null; if (node != null) { object localname = node.LocalName; if (localname.Equals(this.XmlName) == false || node.NamespaceURI.Equals(this.XmlNameSpace) == false) { return(null); } } // memberwise close is fine here, as everything is identical beside the value e = this.MemberwiseClone() as SimpleElement; e.InitInstance(this); if (node != null) { e.Value = node.InnerText; } e.ProcessAttributes(node); e.ProcessChildNodes(node, parser); return(e); }
public void ShouldParseDatasetFileAtomFeed() { var dataset = Helper.NewDataset(); List <DatasetFile> result = new AtomFeedParser().ParseDatasetFiles(File.ReadAllText("AdministrativeEnheterFylker_AtomFeedGEOJSON.fmw.xml"), dataset.Title, dataset.Url); result.Count.Should().Be(10); }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create an Rfc822Msg object.</summary> /// <param name="node">the xml parses node, can be NULL</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created SimpleElement object</returns> ////////////////////////////////////////////////////////////////////// public override IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); Rfc822MsgElement e = null; if (node != null) { object localname = node.LocalName; if (!localname.Equals(this.XmlName) || !node.NamespaceURI.Equals(this.XmlNameSpace)) { return(null); } } // memberwise close is fine here, as everything is identical beside the value e = this.MemberwiseClone() as Rfc822MsgElement; e.InitInstance(this); if (node != null) { e.Value = System.Text.Encoding.ASCII.GetBytes(node.InnerText); } e.ProcessAttributes(node); e.ProcessChildNodes(node, parser); return(e); }
/// <summary> /// Parses the inner state of the element. TODO. /// </summary> /// <param name="e">The extension element that should be added to this entry</param> /// <param name="parser">The AtomFeedParser that called this</param> public override void Parse(ExtensionElementEventArgs e, AtomFeedParser parser) { if (String.Compare(e.ExtensionElement.NamespaceURI, GDataSpreadsheetsNameTable.NSGSpreadsheetsExtended, true) == 0) { Elements.Add(Custom.ParseCustom(e.ExtensionElement, parser)); e.DiscardEntry = true; } }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Where object.</summary> /// <param name="node">the node to parse node</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created Where object</returns> ////////////////////////////////////////////////////////////////////// public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); Where where = null; if (node != null) { object localname = node.LocalName; if (!localname.Equals(XmlName) || !node.NamespaceURI.Equals(XmlNameSpace)) { return(null); } } where = new Where(); if (node != null) { if (node.Attributes != null) { if (node.Attributes[GDataParserNameTable.XmlAttributeRel] != null) { where.Rel = node.Attributes[GDataParserNameTable.XmlAttributeRel].Value; } if (node.Attributes[GDataParserNameTable.XmlAttributeLabel] != null) { where.Label = node.Attributes[GDataParserNameTable.XmlAttributeLabel].Value; } if (node.Attributes[GDataParserNameTable.XmlAttributeValueString] != null) { where.ValueString = node.Attributes[GDataParserNameTable.XmlAttributeValueString].Value; } } if (node.HasChildNodes) { foreach (XmlNode childNode in node.ChildNodes) { if (childNode.LocalName == GDataParserNameTable.XmlEntryLinkElement) { if (where.EntryLink == null) { where.EntryLink = EntryLink.ParseEntryLink(childNode, parser); } else { throw new ArgumentException("Only one entryLink is allowed inside the g:where"); } } } } } return(where); }
/// <summary> /// retrieves a category collection from the given URL /// The owner should be a new Collection object, like: /// <code> /// GetCategories(new Uri("http://gdata.youtube.com/schemas/2007/categories.cat"), /// new YouTubeCategoryCollection()) /// </code> /// </summary> /// <returns></returns> public static AtomCategoryCollection GetCategories(Uri uri, AtomBase owner) { // first order is to get the document into an xml dom XmlTextReader textReader = new XmlTextReader(uri.AbsoluteUri); AtomFeedParser parser = new AtomFeedParser(); AtomCategoryCollection collection = parser.ParseCategories(textReader, owner); return(collection); }
/// <summary> /// this is the subclassing method for AtomBase derived /// classes to overload what childelements should be created /// needed to create CustomLink type objects, like WebContentLink etc /// </summary> /// <param name="reader">The XmlReader that tells us what we are working with</param> /// <param name="parser">the parser is primarily used for nametable comparisons</param> /// <returns>AtomBase</returns> public override AtomBase CreateAtomSubElement(XmlReader reader, AtomFeedParser parser) { Object localname = reader.LocalName; if (localname.Equals(parser.Nametable.Link)) { if (reader.GetAttribute(GDataParserNameTable.XmlAttributeRel) == WebContentLink.WEB_CONTENT_REL) { return(new WebContentLink(false)); } } return(base.CreateAtomSubElement(reader, parser)); }
/// <summary> /// used to copy the unknown childnodes for later saving /// </summary> public virtual void ProcessChildNodes(XmlNode node, AtomFeedParser parser) { if (node != null && node.HasChildNodes) { XmlNode childNode = node.FirstChild; while (childNode != null) { if (childNode.NodeType == XmlNodeType.Element) { this.ChildNodes.Add(childNode); } childNode = childNode.NextSibling; } } }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Where object.</summary> /// <param name="node">the node to parse node</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created Where object</returns> ////////////////////////////////////////////////////////////////////// public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); RecurrenceException exception = null; if (node != null) { object localname = node.LocalName; if (localname.Equals(this.XmlName) == false || node.NamespaceURI.Equals(this.XmlNameSpace) == false) { return(null); } } exception = new RecurrenceException(); if (node != null) { if (node.Attributes != null) { if (node.Attributes[GDataParserNameTable.XmlAttributeSpecialized] != null) { exception.Specialized = bool.Parse(node.Attributes[GDataParserNameTable.XmlAttributeSpecialized].Value); } } if (node.HasChildNodes) { XmlNode childNode = node.FirstChild; while (childNode != null && childNode is XmlElement) { if (childNode.LocalName == GDataParserNameTable.XmlEntryLinkElement) { exception.EntryLink = EntryLink.ParseEntryLink(childNode, parser); } childNode = childNode.NextSibling; } } if (exception.EntryLink == null) { throw new ArgumentException("g:recurringException/entryLink is required."); } } return(exception); }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Where object.</summary> /// <param name="node">the node to parse node</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created Where object</returns> ////////////////////////////////////////////////////////////////////// public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); Comments comments = null; if (node != null) { object localname = node.LocalName; if (!localname.Equals(XmlName) || !node.NamespaceURI.Equals(XmlNameSpace)) { return(null); } } comments = new Comments(); if (node != null) { if (node.HasChildNodes) { XmlNode commentsChild = node.FirstChild; while (commentsChild != null && commentsChild is XmlElement) { if (commentsChild.LocalName == GDataParserNameTable.XmlFeedLinkElement && commentsChild.NamespaceURI == BaseNameTable.gNamespace) { if (comments.FeedLink == null) { comments.FeedLink = FeedLink.ParseFeedLink(commentsChild); } else { throw new ArgumentException("Only one feedLink is allowed inside the gd:comments"); } } commentsChild = commentsChild.NextSibling; } } } return(comments); }
/// <summary> /// this is the subclassing method for AtomBase derived /// classes to overload what childelements should be created /// needed to create CustomLink type objects, like WebContentLink etc /// </summary> /// <param name="reader">The XmlReader that tells us what we are working with</param> /// <param name="parser">the parser is primarily used for nametable comparisons</param> /// <returns>AtomBase</returns> public override AtomBase CreateAtomSubElement(XmlReader reader, AtomFeedParser parser) { if (reader == null) { throw new ArgumentNullException("reader"); } if (parser == null) { throw new ArgumentNullException("parser"); } Object localname = reader.LocalName; if (localname.Equals(parser.Nametable.Category)) { return(new YouTubeCategory()); } return(base.CreateAtomSubElement(reader, parser)); }
protected override void OnFill(Parser parser, ICollection <ItemViewModel> collection) { AtomFeedParser rssParser = parser as AtomFeedParser; if (rssParser == null) { return; } if (collection == null) { return; } //TODO : fill out blog data var items = rssParser.Items; if (items != null) { this._Dispatcher.BeginInvoke(() => { collection.Clear(); int index = 0; foreach (var item in items) { string title = item.Element(XName.Get("title", "http://www.w3.org/2005/Atom")).Value; var author = item.Element(XName.Get("author", "http://www.w3.org/2005/Atom")); string name = author.Element(XName.Get("name", "http://www.w3.org/2005/Atom")).Value; var itemVM = new ItemViewModel() { LineOne = title, LineTwo = name }; collection.Add(itemVM); ++index; } }); } }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Package object.</summary> /// <param name="node">Package node</param> /// <param name="parser">AtomFeedParser to use</param> /// <returns>the created Package object</returns> ////////////////////////////////////////////////////////////////////// public static Package ParsePackage(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); Package package = null; Tracing.Assert(node != null, "node should not be null"); if (node == null) { throw new ArgumentNullException("node"); } object localname = node.LocalName; // Ensure that the namespace is correct. if (String.Compare(node.NamespaceURI, GCodeSearchParserNameTable.CSNamespace, true) == 0) { if (localname.Equals(GCodeSearchParserNameTable.EVENT_PACKAGE)) { package = new Package(); if (node.Attributes != null) { package.name = node.Attributes[ GCodeSearchParserNameTable.ATTRIBUTE_NAME].Value; package.uri = node.Attributes[ GCodeSearchParserNameTable.ATTRIBUTE_URI].Value; } else { throw new ArgumentNullException( BaseNameTable.gBatchNamespace + ":" + GCodeSearchParserNameTable.EVENT_PACKAGE + " must contain the attributes " + GCodeSearchParserNameTable.ATTRIBUTE_NAME + " and " + GCodeSearchParserNameTable.ATTRIBUTE_URI); } } } return(package); }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Who object.</summary> /// <param name="node">the xml parses node, can be NULL</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created IExtensionElement object</returns> ////////////////////////////////////////////////////////////////////// public override IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { IExtensionElementFactory ele = base.CreateInstance(node, parser); OriginalEvent ev = ele as OriginalEvent; if (ev != null) { if (ev.IdOriginal == null) { throw new ArgumentException("g:originalEvent/@id is required."); } if (ev.OriginalStartTime == null) { throw new ArgumentException("g:when inside g:originalEvent is required."); } } return(ev); }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Reminder object.</summary> /// <param name="node">the node to parse node</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created Reminder object</returns> ////////////////////////////////////////////////////////////////////// public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); if (node != null) { object localname = node.LocalName; if (!localname.Equals(this.XmlName) || !node.NamespaceURI.Equals(this.XmlNameSpace)) { return(null); } } Recurrence recurrence = new Recurrence(); if (node != null) { recurrence.Value = node.InnerText.Trim(); } return(recurrence); }
/// <summary>Parses an xml node to create an instance object.</summary> /// <param name="node">the parsed xml node, can be NULL</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created SimpleElement object</returns> public override IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); SimpleElement e = null; if (node != null) { object localname = node.LocalName; if (!localname.Equals(this.XmlName) || !node.NamespaceURI.Equals(this.XmlNameSpace)) { return(null); } } // memberwise close is fine here, as everything is identical besides the value e = this.MemberwiseClone() as SimpleElement; e.InitInstance(this); if (node != null) { e.ProcessAttributes(node); if (node.HasChildNodes) { XmlNode n = node.ChildNodes[0]; if (n.NodeType == XmlNodeType.Text && node.ChildNodes.Count == 1) { e.Value = node.InnerText; } else { e.ProcessChildNodes(node, parser); } } } return(e); }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Match object.</summary> /// <param name="node">Match node</param> /// <param name="parser">AtomFeedParser to use</param> /// <returns>the created Match object</returns> ////////////////////////////////////////////////////////////////////// public static Match ParseMatch(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); Match match = null; Tracing.Assert(node != null, "node should not be null"); if (node == null) { throw new ArgumentNullException("node"); } object localname = node.LocalName; // Ensure that the namespace is correct. if (String.Compare(node.NamespaceURI, GCodeSearchParserNameTable.CSNamespace, true) == 0) { if (localname.Equals(GCodeSearchParserNameTable.EVENT_MATCH)) { match = new Match(); if (node.Attributes != null) { match.linenumber = node.Attributes[ GCodeSearchParserNameTable.ATTRIBUTE_LINE_NUMBER].Value; } match.linetext = node.InnerText; } else { throw new ArgumentNullException( BaseNameTable.gBatchNamespace + ":" + GCodeSearchParserNameTable.EVENT_MATCH + " must contain the attribute " + GCodeSearchParserNameTable.ATTRIBUTE_LINE_NUMBER); } } return(match); }
// end of accessor public ExtensionList Extensions ////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Who object.</summary> /// <param name="node">the node to work on, can be NULL</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created SimpleElement object</returns> ////////////////////////////////////////////////////////////////////// public override IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { //Tracing.TraceCall("for: " + XmlName); if (node != null) { object localname = node.LocalName; if (localname.Equals(this.XmlName) == false || node.NamespaceURI.Equals(this.XmlNameSpace) == false) { return(null); } } SimpleContainer sc = null; // create a new container sc = this.MemberwiseClone() as SimpleContainer; sc.InitInstance(this); sc.ProcessAttributes(node); sc.ProcessChildNodes(node, parser); return(sc); }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Where object.</summary> /// <param name="node">the node to parse node</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created Where object</returns> ////////////////////////////////////////////////////////////////////// public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { return(FeedLink.ParseFeedLink(node)); }
public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { return(ParseCustom(node, parser)); }
///////////////////////////////////////////////////////////////////////////// #region EntryLink Parser ////////////////////////////////////////////////////////////////////// /// <summary>parses an xml node to create an EntryLink object</summary> /// <param name="node">entrylink node</param> /// <param name="parser">AtomFeedParser to use</param> /// <returns> the created EntryLink object</returns> ////////////////////////////////////////////////////////////////////// public static EntryLink ParseEntryLink(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); EntryLink link = null; Tracing.Assert(node != null, "node should not be null"); if (node == null) { throw new ArgumentNullException("node"); } object localname = node.LocalName; if (localname.Equals(GDataParserNameTable.XmlEntryLinkElement)) { link = new EntryLink(); if (node.Attributes != null) { if (node.Attributes[GDataParserNameTable.XmlAttributeHref] != null) { link.Href = node.Attributes[GDataParserNameTable.XmlAttributeHref].Value; } if (node.Attributes[GDataParserNameTable.XmlAttributeReadOnly] != null) { link.ReadOnly = node.Attributes[GDataParserNameTable.XmlAttributeReadOnly].Value.Equals(Utilities.XSDTrue); } if (node.Attributes[GDataParserNameTable.XmlAttributeRel] != null) { link.Rel = node.Attributes[GDataParserNameTable.XmlAttributeRel].Value; } } if (node.HasChildNodes) { XmlNode entryChild = node.FirstChild; while (entryChild != null && entryChild is XmlElement) { if (entryChild.LocalName == AtomParserNameTable.XmlAtomEntryElement && entryChild.NamespaceURI == BaseNameTable.NSAtom) { if (link.Entry == null) { XmlReader reader = new XmlNodeReader(entryChild); // move the reader to the first node reader.Read(); AtomFeedParser p = new AtomFeedParser(); p.NewAtomEntry += new FeedParserEventHandler(link.OnParsedNewEntry); p.ParseEntry(reader); } else { throw new ArgumentException("Only one entry is allowed inside the g:entryLink"); } } entryChild = entryChild.NextSibling; } } } return(link); }
////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a Reminder object.</summary> /// <param name="node">the node to parse node</param> /// <param name="parser">the xml parser to use if we need to dive deeper</param> /// <returns>the created Reminder object</returns> ////////////////////////////////////////////////////////////////////// public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); Reminder reminder = null; if (node != null) { object localname = node.LocalName; if (!localname.Equals(this.XmlName) || !node.NamespaceURI.Equals(this.XmlNameSpace)) { return(null); } } reminder = new Reminder(); if (node != null && node.Attributes != null) { if (node.Attributes[GDataParserNameTable.XmlAttributeAbsoluteTime] != null) { try { reminder.AbsoluteTime = DateTime.Parse(node.Attributes[GDataParserNameTable.XmlAttributeAbsoluteTime].Value); } catch (FormatException fe) { throw new ArgumentException("Invalid g:reminder/@absoluteTime.", fe); } } if (node.Attributes[GDataParserNameTable.XmlAttributeDays] != null) { try { reminder.Days = Int32.Parse(node.Attributes[GDataParserNameTable.XmlAttributeDays].Value); } catch (FormatException fe) { throw new ArgumentException("Invalid g:reminder/@days.", fe); } } if (node.Attributes[GDataParserNameTable.XmlAttributeHours] != null) { try { reminder.Hours = Int32.Parse(node.Attributes[GDataParserNameTable.XmlAttributeHours].Value); } catch (FormatException fe) { throw new ArgumentException("Invalid g:reminder/@hours.", fe); } } if (node.Attributes[GDataParserNameTable.XmlAttributeMinutes] != null) { try { reminder.Minutes = Int32.Parse(node.Attributes[GDataParserNameTable.XmlAttributeMinutes].Value); } catch (FormatException fe) { throw new ArgumentException("Invalid g:reminder/@minutes.", fe); } } if (node.Attributes[GDataParserNameTable.XmlAttributeMethod] != null) { try { reminder.Method = (ReminderMethod)Enum.Parse(typeof(ReminderMethod), node.Attributes[GDataParserNameTable.XmlAttributeMethod].Value, true); } catch (Exception e) { throw new ArgumentException("Invalid g:reminder/@method.", e); } } } return(reminder); }
/// <summary> /// get's called after we already handled the custom entry, to handle all /// other potential parsing tasks /// </summary> /// <param name="e"></param> /// <param name="parser">the atom feed parser used</param> protected override void HandleExtensionElements(ExtensionElementEventArgs e, AtomFeedParser parser) { }
// end of accessor public SortedList GadgetPreferences #region WebContent Parser ////////////////////////////////////////////////////////////////////// /// <summary>Parses an xml node to create a webcontent object.</summary> /// <param name="node">xml node</param> /// <param name="parser">the atomfeedparser to use for deep dive parsing</param> /// <returns>the created SimpleElement object</returns> ////////////////////////////////////////////////////////////////////// public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { Tracing.TraceCall(); if (node != null) { object localname = node.LocalName; if (!localname.Equals(this.XmlName) || !node.NamespaceURI.Equals(this.XmlNameSpace)) { return(null); } } WebContent webContent = null; webContent = new WebContent(); if (node.Attributes != null) { String value = node.Attributes[GDataParserNameTable.XmlAttributeUrl] != null ? node.Attributes[GDataParserNameTable.XmlAttributeUrl].Value : null; if (value != null) { webContent.Url = value; } value = node.Attributes[GDataParserNameTable.XmlAttributeDisplay] != null ? node.Attributes[GDataParserNameTable.XmlAttributeDisplay].Value : null; if (value != null) { webContent.Display = value; } value = node.Attributes[GDataParserNameTable.XmlAttributeWidth] != null ? node.Attributes[GDataParserNameTable.XmlAttributeWidth].Value : null; if (value != null) { webContent.Width = uint.Parse(value, System.Globalization.NumberStyles.Integer, CultureInfo.InvariantCulture); } value = node.Attributes[GDataParserNameTable.XmlAttributeHeight] != null ? node.Attributes[GDataParserNameTable.XmlAttributeHeight].Value : null; if (value != null) { webContent.Height = uint.Parse(value, System.Globalization.NumberStyles.Integer, CultureInfo.InvariantCulture); } } // single event, g:reminder is inside g:when if (node.HasChildNodes) { XmlNode gadgetPrefs = node.FirstChild; while (gadgetPrefs != null && gadgetPrefs is XmlElement) { if (String.Compare(gadgetPrefs.NamespaceURI, XmlNameSpace, true) == 0) { if (String.Compare(gadgetPrefs.LocalName, GDataParserNameTable.XmlWebContentGadgetElement) == 0) { if (gadgetPrefs.Attributes != null) { string value = gadgetPrefs.Attributes[BaseNameTable.XmlValue] != null ? gadgetPrefs.Attributes[BaseNameTable.XmlValue].Value : null; string name = gadgetPrefs.Attributes[BaseNameTable.XmlName] != null ? gadgetPrefs.Attributes[BaseNameTable.XmlName].Value : null; if (name != null) { webContent.GadgetPreferences.Add(name, value); } } } } gadgetPrefs = gadgetPrefs.NextSibling; } } return(webContent); }