/// <summary> /// parses a single error element /// </summary> /// <param name="reader">XmlReader positioned at the start of the status element</param> /// <param name="parser">the feedparser to be used</param> /// <returns>GDataBatchError</returns> public static GDataBatchError ParseBatchError(XmlReader reader, AtomFeedParser parser) { if (reader == null) { throw new System.ArgumentNullException("reader"); } object localname = reader.LocalName; GDataBatchError error = null; if (localname.Equals(parser.Nametable.BatchError)) { error = new GDataBatchError(); if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { localname = reader.LocalName; if (localname.Equals(parser.Nametable.BatchReason)) { error.Reason = Utilities.DecodedValue(reader.Value); } else if (localname.Equals(parser.Nametable.Type)) { error.Type = Utilities.DecodedValue(reader.Value); } else if (localname.Equals(parser.Nametable.BatchField)) { error.Field = Utilities.DecodedValue(reader.Value); } } } } return(error); }
///////////////////////////////////////////////////////////////////////////// #endregion /// <summary> /// Parses the inner state of the element /// </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 virtual void Parse(ExtensionElementEventArgs e, AtomFeedParser parser) { if (e == null) { throw new ArgumentNullException("e"); } //Tracing.TraceMsg("Entering Parse on AbstractEntry"); XmlNode node = e.ExtensionElement; if (this.ExtensionFactories != null && this.ExtensionFactories.Count > 0) { //Tracing.TraceMsg("Entring default Parsing for AbstractEntry"); IExtensionElementFactory f = FindExtensionFactory(node.LocalName, node.NamespaceURI); if (f != null) { this.ExtensionElements.Add(f.CreateInstance(node, parser)); e.DiscardEntry = true; } } return; }
/// <summary> /// reads the current positioned reader and creates a batchstatus element /// </summary> /// <param name="reader">XmlReader positioned at the start of the status element</param> /// <param name="parser">The Feedparser to be used</param> /// <returns>GDataBatchStatus</returns> public static GDataBatchStatus ParseBatchStatus(XmlReader reader, AtomFeedParser parser) { //Tracing.Assert(reader != null, "reader should not be null"); if (reader == null) { throw new ArgumentNullException("reader"); } GDataBatchStatus status = null; object localname = reader.LocalName; if (localname.Equals(parser.Nametable.BatchStatus)) { status = new GDataBatchStatus(); if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { localname = reader.LocalName; if (localname.Equals(parser.Nametable.BatchReason)) { status.Reason = Utilities.DecodedValue(reader.Value); } else if (localname.Equals(parser.Nametable.BatchContentType)) { status.ContentType = Utilities.DecodedValue(reader.Value); } else if (localname.Equals(parser.Nametable.BatchStatusCode)) { status.Code = int.Parse(Utilities.DecodedValue(reader.Value), CultureInfo.InvariantCulture); } } } reader.MoveToElement(); // FIX: THIS CODE SEEMS TO MAKE AN INFINITE LOOP WITH NextChildElement() int lvl = -1; // status can have one child element, errors while (Utilities.NextChildElement(reader, ref lvl)) { localname = reader.LocalName; if (localname.Equals(parser.Nametable.BatchErrors)) { GDataBatchError.ParseBatchErrors(reader, parser, status); } } } return(status); }
/// <summary> /// parses a batchinterrupt element from a correctly positioned reader /// </summary> /// <param name="reader">XmlReader at the start of the element</param> /// <param name="parser">the feedparser to be used</param> /// <returns>GDataBatchInterrupt</returns> public static GDataBatchInterrupt ParseBatchInterrupt(XmlReader reader, AtomFeedParser parser) { if (reader == null) { throw new ArgumentNullException("reader"); } object localname = reader.LocalName; GDataBatchInterrupt interrupt = null; if (localname.Equals(parser.Nametable.BatchInterrupt)) { interrupt = new GDataBatchInterrupt(); if (reader.HasAttributes) { while (reader.MoveToNextAttribute()) { localname = reader.LocalName; if (localname.Equals(parser.Nametable.BatchReason)) { interrupt.Reason = Utilities.DecodedValue(reader.Value); } else if (localname.Equals(parser.Nametable.BatchSuccessCount)) { interrupt.Successes = int.Parse(Utilities.DecodedValue(reader.Value), CultureInfo.InvariantCulture); } else if (localname.Equals(parser.Nametable.BatchFailureCount)) { interrupt.Failures = int.Parse(Utilities.DecodedValue(reader.Value), CultureInfo.InvariantCulture); } else if (localname.Equals(parser.Nametable.BatchParsedCount)) { interrupt.Parsed = int.Parse(Utilities.DecodedValue(reader.Value), CultureInfo.InvariantCulture); } else if (localname.Equals(parser.Nametable.BatchUnprocessed)) { interrupt.Unprocessed = int.Parse(Utilities.DecodedValue(reader.Value), CultureInfo.InvariantCulture); } } } } return(interrupt); }
///////////////////////////////////////////////////////////////////////////// #endregion ////////////////////////////////////////////////////////////////////// /// <summary>given a stream, parses it to construct the Feed object out of it</summary> /// <param name="stream"> a stream representing hopefully valid XML</param> /// <param name="format"> indicates if the stream is Atom or Rss</param> ////////////////////////////////////////////////////////////////////// public void Parse(Stream stream, AlternativeFormat format) { //Tracing.TraceCall("parsing stream -> Start:" + format.ToString()); BaseFeedParser feedParser = null; // make sure we reset our collections this.Authors.Clear(); this.Contributors.Clear(); this.Links.Clear(); this.Categories.Clear(); feedParser = new AtomFeedParser(this); // create a new delegate for the parser feedParser.NewAtomEntry += new FeedParserEventHandler(this.OnParsedNewEntry); feedParser.NewExtensionElement += new ExtensionElementEventHandler(this.OnNewExtensionElement); feedParser.Parse(stream, this); //Tracing.TraceInfo("Parsing stream -> Done"); // done parsing }
/// <summary>eventhandler - called for event extension element /// </summary> /// <param name="sender">the object which send the event</param> /// <param name="e">FeedParserEventArguments, holds the feedEntry</param> /// <returns> </returns> protected void OnNewExtensionsElement(object sender, ExtensionElementEventArgs e) { if (e == null) { throw new ArgumentNullException("e"); } AtomFeedParser parser = sender as AtomFeedParser; if (e.Base.XmlName == AtomParserNameTable.XmlAtomEntryElement) { // the base is the Entry of the feed, let's call our parsing on the Entry AtomEntry entry = e.Base as AtomEntry; if (entry != null) { entry.Parse(e, parser); } } else { HandleExtensionElements(e, parser); } }
///////////////////////////////////////////////////////////////////////////// #endregion /// <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.Source)) { return(new AtomSource()); } else if (localname.Equals(parser.Nametable.Content)) { return(new AtomContent()); } return(base.CreateAtomSubElement(reader, parser)); }
/// <summary> /// parses a list of errors /// </summary> /// <param name="reader">XmlReader positioned at the start of the status element</param> /// <param name="status">the batch status element to add the errors tohe</param> /// <param name="parser">the feedparser to be used</param> public static void ParseBatchErrors(XmlReader reader, AtomFeedParser parser, GDataBatchStatus status) { if (reader == null) { throw new System.ArgumentNullException("reader"); } object localname = reader.LocalName; if (localname.Equals(parser.Nametable.BatchErrors)) { int lvl = -1; while (Utilities.NextChildElement(reader, ref lvl)) { localname = reader.LocalName; if (localname.Equals(parser.Nametable.BatchError)) { status.Errors.Add(ParseBatchError(reader, parser)); } } } return; }
/// <summary> /// event on the Feed to handle extension elements during parsing /// </summary> /// <param name="e">the event arguments</param> /// <param name="parser">the parser that caused this</param> protected virtual void HandleExtensionElements(ExtensionElementEventArgs e, AtomFeedParser parser) { //Tracing.TraceMsg("Entering HandleExtensionElements on AbstractFeed"); XmlNode node = e.ExtensionElement; if (this.ExtensionFactories != null && this.ExtensionFactories.Count > 0) { //Tracing.TraceMsg("Entring default Parsing for AbstractFeed"); foreach (IExtensionElementFactory f in this.ExtensionFactories) { //Tracing.TraceMsg("Found extension Factories"); if (String.Compare(node.NamespaceURI, f.XmlNameSpace, true, CultureInfo.InvariantCulture) == 0) { if (String.Compare(node.LocalName, f.XmlName, true, CultureInfo.InvariantCulture) == 0) { e.Base.ExtensionElements.Add(f.CreateInstance(node, parser)); e.DiscardEntry = true; break; } } } } return; }
/// <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 virtual 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.Id)) { return(new AtomId()); } else if (localname.Equals(parser.Nametable.Link)) { return(new AtomLink()); } else if (localname.Equals(parser.Nametable.Icon)) { return(new AtomIcon()); } else if (localname.Equals(parser.Nametable.Logo)) { return(new AtomLogo()); } else if (localname.Equals(parser.Nametable.Author)) { return(new AtomPerson(AtomPersonType.Author)); } else if (localname.Equals(parser.Nametable.Contributor)) { return(new AtomPerson(AtomPersonType.Contributor)); } else if (localname.Equals(parser.Nametable.Title)) { return(new AtomTextConstruct(AtomTextConstructElementType.Title)); } else if (localname.Equals(parser.Nametable.Subtitle)) { return(new AtomTextConstruct(AtomTextConstructElementType.Subtitle)); } else if (localname.Equals(parser.Nametable.Rights)) { return(new AtomTextConstruct(AtomTextConstructElementType.Rights)); } else if (localname.Equals(parser.Nametable.Summary)) { return(new AtomTextConstruct(AtomTextConstructElementType.Summary)); } else if (localname.Equals(parser.Nametable.Generator)) { return(new AtomGenerator()); } else if (localname.Equals(parser.Nametable.Category)) { return(new AtomCategory()); } throw new NotImplementedException("AtomBase CreateChild should NEVER be called for: " + reader.LocalName); }
/// <summary> /// creates a new GDataBatchEntryData /// </summary> /// <param name="node"></param> /// <param name="parser"></param> /// <returns></returns> public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { //we really don't know how to create an instance of ourself. throw new Exception("The method or operation is not implemented."); }
/// <summary> /// factory method to create an instance of a batchinterrupt during parsing /// </summary> /// <param name="node">the xmlnode that is going to be parsed</param> /// <param name="parser">the feedparser that is used right now</param> /// <returns></returns> public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { throw new Exception("The method or operation is not implemented."); }
/// <summary> /// factory method to create an instance of a batchinterrupt during parsing /// </summary> /// <param name="node">the xmlnode that is going to be parsed</param> /// <param name="parser">the feedparser that is used right now</param> /// <returns></returns> public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser) { return(ParseBatchInterrupt(new XmlNodeReader(node), parser)); }