/// <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 (ExtensionFactories != null && ExtensionFactories.Count > 0)
{
Tracing.TraceMsg("Entring default Parsing for AbstractFeed");
foreach (IExtensionElementFactory f in 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 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>
/// 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
Authors.Clear();
Contributors.Clear();
Links.Clear();
Categories.Clear();
feedParser = new AtomFeedParser(this);
// create a new delegate for the parser
feedParser.NewAtomEntry += new FeedParserEventHandler(OnParsedNewEntry);
feedParser.NewExtensionElement += new ExtensionElementEventHandler(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);
}
}
/// <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 (ExtensionFactories != null && ExtensionFactories.Count > 0)
{
Tracing.TraceMsg("Entring default Parsing for AbstractEntry");
IExtensionElementFactory f = FindExtensionFactory(
node.LocalName,
node.NamespaceURI);
if (f != null)
{
ExtensionElements.Add(f.CreateInstance(node, parser));
e.DiscardEntry = true;
}
}
}
/// <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);
}
/// <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>
/// 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));
}
