//////////////////////////////////////////////////////////////////////
/// <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;
}
}
}
/////////////////////////////////////////////////////////////////////////////
#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>Parses an xml node to create a GsaExtension 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 GsaExtension object</returns>
//////////////////////////////////////////////////////////////////////
public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser)
{
Tracing.TraceCall();
GsaExtension gsa = null;
if (node != null)
{
object localname = node.LocalName;
if (localname.Equals(this.XmlName) == false ||
node.NamespaceURI.Equals(this.XmlNameSpace) == false)
{
return null;
}
}
gsa = new GsaExtension();
if (node != null)
{
if (node.Attributes == null || node.Attributes[PropertyName] == null)
{
throw new ArgumentException("GsaContent name can not found in this name space");
}
gsa.ContentName = node.Attributes[PropertyName].Value;
gsa.ContentValue = node.InnerText == null ? "" : node.InnerText;
}
return gsa;
}
/// <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 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>
/// 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 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 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)
{
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>
/// 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);
}
//////////////////////////////////////////////////////////////////////
/// <summary>parses an xml node to create a Recurrence object</summary>
/// <param name="node">Recurrence node</param>
/// <param name="parser">AtomFeedParser to use</param>
/// <returns> the created Recurrence object</returns>
//////////////////////////////////////////////////////////////////////
public static RecurrenceException ParseRecurrenceException(XmlNode node, AtomFeedParser parser)
{
Tracing.TraceCall();
RecurrenceException exception = 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.XmlRecurrenceExceptionElement))
{
exception = new RecurrenceException();
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(this.XmlName) ||
!node.NamespaceURI.Equals(this.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>
/// 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>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 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>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>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();
When when = null;
if (node != null)
{
object localname = node.LocalName;
if (localname.Equals(this.XmlName) == false ||
node.NamespaceURI.Equals(this.XmlNameSpace) == false)
{
return null;
}
}
bool startTimeFlag = false, endTimeFlag = false;
when = new When();
if (node != null)
{
if (node.Attributes != null)
{
String value = node.Attributes[GDataParserNameTable.XmlAttributeStartTime] != null ?
node.Attributes[GDataParserNameTable.XmlAttributeStartTime].Value : null;
if (value != null)
{
startTimeFlag = true;
when.startTime = DateTime.Parse(value);
when.AllDay = (value.IndexOf('T') == -1);
}
value = node.Attributes[GDataParserNameTable.XmlAttributeEndTime] != null ?
node.Attributes[GDataParserNameTable.XmlAttributeEndTime].Value : null;
if (value != null)
{
endTimeFlag = true;
when.endTime = DateTime.Parse(value);
when.AllDay = when.AllDay && (value.IndexOf('T') == -1);
}
if (node.Attributes[GDataParserNameTable.XmlAttributeValueString] != null)
{
when.valueString = node.Attributes[GDataParserNameTable.XmlAttributeValueString].Value;
}
}
// single event, g:reminder is inside g:when
if (node.HasChildNodes)
{
XmlNode whenChildNode = node.FirstChild;
IExtensionElementFactory f = new Reminder() as IExtensionElementFactory;
while (whenChildNode != null && whenChildNode is XmlElement)
{
if (String.Compare(whenChildNode.NamespaceURI, f.XmlNameSpace, true, CultureInfo.InvariantCulture) == 0)
{
if (String.Compare(whenChildNode.LocalName, f.XmlName, true, CultureInfo.InvariantCulture) == 0)
{
Reminder r = f.CreateInstance(whenChildNode, null) as Reminder;
when.Reminders.Add(r);
}
}
whenChildNode = whenChildNode.NextSibling;
}
}
}
if (!startTimeFlag)
{
throw new ClientFeedException("g:when/@startTime is required.");
}
if (endTimeFlag && when.startTime.CompareTo(when.endTime) > 0)
{
throw new ClientFeedException("g:when/@startTime must be less than or equal to g:when/@endTime.");
}
return when;
}
//////////////////////////////////////////////////////////////////////
/// <summary>Parses an xml node to create a Package object.</summary>
/// <param name="node">xml node</param>
/// <param name="parser">the atomfeedparser to use for deep dive parsing</param>
/// <returns>the created IExtensionElementFactory object</returns>
//////////////////////////////////////////////////////////////////////
public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser)
{
return ParsePackage(node, 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) == false ||
node.NamespaceURI.Equals(this.XmlNameSpace) == false)
{
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;
}
//////////////////////////////////////////////////////////////////////
/// <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) == false ||
node.NamespaceURI.Equals(this.XmlNameSpace) == false)
{
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>
/// 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>
/// Is 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) {
base.HandleExtensionElements(e, parser);
}
/// <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>
/// 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)
{
return(ParseBatchInterrupt(new XmlNodeReader(node), parser));
}
//////////////////////////////////////////////////////////////////////
/// <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 IExtensionElement CreateInstance(XmlNode node, AtomFeedParser parser)
{
IExtensionElement 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>
/// 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)
{
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>
/// get's called after we already handled the custom entry, to handle all
/// other potential parsing tasks
/// </summary>
/// <param name="e">the event arguments</param>
/// <param name="parser">the atom feed parser calling</param>
protected override void HandleExtensionElements(ExtensionElementEventArgs e, AtomFeedParser parser)
{
Tracing.TraceMsg("\t HandleExtensionElements for ListFeedcalled");
}
/// <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;
}
}
}
public IExtensionElementFactory CreateInstance(XmlNode node, AtomFeedParser parser)
{
return ParseGBaseAttribute(node);
}
//////////////////////////////////////////////////////////////////////
/// <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(this.XmlName) ||
!node.NamespaceURI.Equals(this.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>
/// 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>
/// 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>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(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 ExtensionBase;
e.InitInstance(this);
e.ProcessAttributes(node);
e.ProcessChildNodes(node, parser);
return e;
}
// end of accessor public ArrayList 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 IExtensionElement 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;
if (node != null && node.HasChildNodes)
{
XmlNode childNode = node.FirstChild;
while (childNode != null && 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);
sc.ExtensionElements.Add(f.CreateInstance(childNode, parser));
break;
}
}
}
childNode = childNode.NextSibling;
}
if (node.Attributes != null)
{
sc.ProcessAttributes(node);
}
}
return sc;
}
/////////////////////////////////////////////////////////////////////////////
#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();
parser.NewAtomEntry += new FeedParserEventHandler(link.OnParsedNewEntry);
parser.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 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);
}
/// <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>parses the inner state of the element</summary>
/// <param name="e">the extensionelement during the parsing process, xml node</param>
/// <param name="parser">the atomFeedParser that called this</param>
//////////////////////////////////////////////////////////////////////
public override void Parse(ExtensionElementEventArgs e, AtomFeedParser parser)
{
Tracing.TraceCall("AclEntry:Parse is called:" + e);
XmlNode node = e.ExtensionElement;
if (String.Compare(node.NamespaceURI, AclNameTable.gAclNamespace, true) == 0)
{
// Parse a Role Element
if (node.LocalName == AclNameTable.XmlAclRoleElement)
{
this.Role = AclRole.parse(node);
e.DiscardEntry = true;
}
// Parse a Where Element
else if (node.LocalName == AclNameTable.XmlAclScopeElement)
{
this.Scope = AclScope.parse(node);
e.DiscardEntry = true;
}
}
}