/// <summary>
/// Converts to I RSS GUID.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IRssGuid ConvertToIRssGuid(XmlReader input)
{
RssGuid guid = new RssGuid();
input.ReadToDescendant("guid");
guid.IsPermaLink = CachedPropertiesProvider.ConvertToBoolNullable(input.GetAttribute("isPermaLink"));
guid.UniqueIdentifier = input.ReadElementContentAsString();
input.Close();
return(guid);
}
/// <summary>
/// Converts to I RSS source.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IRssSource ConvertToIRssSource(XmlReader input)
{
RssSource source = new RssSource();
input.ReadToDescendant("source");
source.Link = CachedPropertiesProvider.ConvertToUri(input.GetAttribute("url"));
source.Description = input.ReadElementContentAsString();
input.Close();
return(source);
}
/// <summary>
/// Converts to I RSS enclosure.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IRssEnclosure ConvertToIRssEnclosure(XmlReader input)
{
RssEnclosure enc = new RssEnclosure();
input.ReadToDescendant("enclosure");
enc.Length = CachedPropertiesProvider.ConvertToInt(input.GetAttribute("length"));
enc.Link = CachedPropertiesProvider.ConvertToUri(input.GetAttribute("url"));
enc.Type = input.GetAttribute("type");
input.Close();
return(enc);
}
/// <summary>
/// Converts to I atom category.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IAtomCategory ConvertToIAtomCategory(XmlReader input)
{
AtomCategory cat = new AtomCategory();
input.ReadToDescendant("link");
cat.Label = input.GetAttribute("label");
cat.Term = input.GetAttribute("term");
cat.Scheme = CachedPropertiesProvider.ConvertToUri(input.GetAttribute("scheme"), input.BaseURI);
input.Close();
return(cat);
}
/// <summary>
/// Converts the content of to I atom.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IAtomContent ConvertToIAtomContent(XmlReader input)
{
AtomContent content = new AtomContent();
input.ReadToDescendant("content");
content.Type = input.GetAttribute("type");
content.Src = CachedPropertiesProvider.ConvertToUri(input.GetAttribute("src"), input.BaseURI);
content.Content = input.ReadInnerXml();
input.Close();
return(content);
}
/// <summary>
/// Converts to I atom generator.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IAtomGenerator ConvertToIAtomGenerator(XmlReader input)
{
AtomGenerator gen = new AtomGenerator();
input.ReadToDescendant("generator");
gen.GeneratorUri = CachedPropertiesProvider.ConvertToUri(input.GetAttribute("uri"), input.BaseURI);
gen.Version = input.GetAttribute("version");
gen.Description = input.ReadElementContentAsString();
input.Close();
return(gen);
}
/// <summary>
/// Converts to I RSS cloud.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IRssCloud ConvertToIRssCloud(XmlReader input)
{
RssCloud cloud = new RssCloud();
input.ReadToDescendant("cloud");
cloud.Domain = input.GetAttribute("domain");
cloud.Port = CachedPropertiesProvider.ConvertToInt(input.GetAttribute("port"));
cloud.Path = input.GetAttribute("path");
cloud.Protocol = ConvertToRssCloudProtocol(input.GetAttribute("protocol"));
cloud.RegisterProcedure = input.GetAttribute("registerProcedure");
input.Close();
return(cloud);
}
internal static IOpmlOutline ConvertToIOpmlOutline(XmlReader input)
{
OpmlOutline outline = new OpmlOutline();
input.ReadToDescendant("outline");
outline.Text = input.GetAttribute("text");
outline.Type = input.GetAttribute("type");
outline.IsBreakpoint = CachedPropertiesProvider.ConvertToBoolNullable(input.GetAttribute("isBreakpoint"));
outline.IsComment = CachedPropertiesProvider.ConvertToBoolNullable(input.GetAttribute("isComment"));
ReadOutlines(input, outline);
input.Close();
return(outline);
}
/// <summary>
/// Converts to I atom link.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IAtomLink ConvertToIAtomLink(XmlReader input)
{
AtomLink link = new AtomLink();
input.ReadToDescendant("link");
link.Href = CachedPropertiesProvider.ConvertToUri(input.GetAttribute("href"), input.BaseURI);
link.Relationship = input.GetAttribute("rel");
link.Type = input.GetAttribute("type");
link.LinkLanguage = input.GetAttribute("hreflang");
link.Title = input.GetAttribute("title");
link.Length = CachedPropertiesProvider.ConvertToIntNullable(input.GetAttribute("length"));
input.Close();
return(link);
}
/// <summary>
/// Converts to I RSS image.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IRssImage ConvertToIRssImage(XmlReader input)
{
RssImage image = new RssImage();
input.ReadToDescendant("image");
bool readContent = false;
while (readContent || input.Read())
{
readContent = false;
if (input.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (input.Name)
{
case "description":
image.Description = input.ReadElementContentAsString();
break;
case "link":
image.Link = CachedPropertiesProvider.ConvertToUri(input.ReadElementContentAsString());
break;
case "location":
image.Location = CachedPropertiesProvider.ConvertToUri(input.ReadElementContentAsString());
break;
case "title":
image.Title = input.ReadElementContentAsString();
break;
case "width":
image.Width = CachedPropertiesProvider.ConvertToInt(input.ReadElementContentAsString());
break;
case "height":
image.Height = CachedPropertiesProvider.ConvertToInt(input.ReadElementContentAsString());
break;
default:
readContent = false;
break;
}
}
}
input.Close();
return(image);
}
/// <summary>
/// Converts to skip hour list.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IList <uint> ConvertToSkipHourList(XmlReader input)
{
IList <uint> skipHours = new List <uint>();
input.ReadToDescendant("skipHours");
bool readContent = false;
while (readContent || input.Read())
{
readContent = false;
if (input.NodeType == XmlNodeType.Element && input.Name == "hour")
{
skipHours.Add(CachedPropertiesProvider.ConvertToUInt(input.ReadElementContentAsString()));
readContent = true;
}
}
input.Close();
return(skipHours);
}
/// <summary>
/// Converts to I RSS text input.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IRssTextInput ConvertToIRssTextInput(XmlReader input)
{
RssTextInput text = new RssTextInput();
input.ReadToDescendant("textInput");
bool readContent = false;
while (readContent || input.Read())
{
readContent = false;
if (input.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (input.Name)
{
case "description":
text.Description = input.ReadElementContentAsString();
break;
case "link":
text.Link = CachedPropertiesProvider.ConvertToUri(input.ReadElementContentAsString());
break;
case "name":
text.Name = input.ReadElementContentAsString();
break;
case "title":
text.Title = input.ReadElementContentAsString();
break;
default:
readContent = false;
break;
}
}
}
input.Close();
return(text);
}
/// <summary>
/// Converts to I atom person.
/// </summary>
/// <param name="input">The input.</param>
/// <returns></returns>
public static IAtomPerson ConvertToIAtomPerson(XmlReader input)
{
AtomPerson person = new AtomPerson();
input.Read();
bool readContent = false;
while (readContent || input.Read())
{
readContent = false;
if (input.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (input.Name)
{
case "name":
person.Name = input.ReadElementContentAsString();
break;
case "uri":
person.Homepage = CachedPropertiesProvider.ConvertToUri(input.ReadElementContentAsString(), input.BaseURI);
break;
case "email":
person.Email = input.ReadElementContentAsString();
break;
default:
readContent = false;
break;
}
}
}
input.Close();
return(person);
}
/// <summary>
/// Parses the item.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public IFeedItem ParseItem(XmlReader reader)
{
IRssFeedItem item = new RssFeedItem();
reader.ReadToDescendant("item");
bool readContent = false;
while (readContent || reader.Read())
{
readContent = false;
if (reader.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (reader.Name)
{
case "author":
item.Author = reader.ReadElementContentAsString();
break;
case "category":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Category = ConvertToIRssCategory(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "comments":
item.Comments = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString());
break;
case "description":
item.Description = reader.ReadElementContentAsString();
break;
case "enclosure":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Enclosure = ConvertToIRssEnclosure(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "guid":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Guid = ConvertToIRssGuid(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "link":
item.Link = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString());
break;
case "pubDate":
item.PublicationDate = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "source":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Source = ConvertToIRssSource(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "title":
item.Title = reader.ReadElementContentAsString();
break;
default:
UnhandledElement(item, reader);
break;
}
}
}
reader.Close();
return(item);
}
/// <summary>
/// Parses the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public override T Parse <T>(System.Xml.XmlReader reader)
{
IAtomFeed ret = (IAtomFeed) new AtomFeed();
reader.Read();
bool readContent = false;
while (readContent || reader.Read())
{
readContent = false;
if (reader.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (reader.Name)
{
case "id":
ret.FeedUri = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString(), reader.BaseURI);
break;
case "title":
ret.Title = reader.ReadElementContentAsString();
break;
case "updated":
ret.LastUpdated = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "generator":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Generator = ConvertToIAtomGenerator(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "author":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Authors.Add(ConvertToIAtomPerson(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "link":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Links.Add(ConvertToIAtomLink(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "category":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Categories.Add(ConvertToIAtomCategory(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "entry":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Items.Add(ParseItem(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "contributor":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Contributors.Add(ConvertToIAtomPerson(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "logo":
ret.Logo = reader.ReadElementContentAsString();
break;
case "icon":
ret.Icon = reader.ReadElementContentAsString();
break;
case "rights":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Rights = ConvertToIAtomText(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "subtitle":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Subtitle = ConvertToIAtomText(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
default:
UnhandledElement(ret, reader);
break;
}
}
}
reader.Close();
return((T)ret);
}
/// <summary>
/// Parses the item.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public IFeedItem ParseItem(XmlReader reader)
{
IAtomFeedItem item = new AtomFeedItem();
reader.ReadToDescendant("entry");
bool readContent = false;
while (readContent || reader.Read())
{
readContent = false;
if (reader.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (reader.Name)
{
case "id":
item.Id = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString(), reader.BaseURI);
break;
case "title":
item.Title = reader.ReadElementContentAsString();
break;
case "updated":
item.LastUpdated = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "author":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Authors.Add(ConvertToIAtomPerson(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "link":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Links.Add(ConvertToIAtomLink(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "category":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Categories.Add(ConvertToIAtomCategory(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "contributor":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Contributors.Add(ConvertToIAtomPerson(subReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "rights":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Rights = ConvertToIAtomText(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "summary":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Summary = ConvertToIAtomText(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "content":
using (XmlReader subReader = reader.ReadSubtree())
{
item.Content = ConvertToIAtomContent(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "published":
item.Published = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "source":
item.Source = ConvertToIAtomFeed(reader.ReadOuterXml());
break;
default:
UnhandledElement(item, reader);
break;
}
}
}
reader.Close();
return(item);
}
/// <summary>
/// Parses the specified reader.
/// </summary>
/// <param name="reader">The reader.</param>
/// <returns></returns>
public override T Parse <T>(System.Xml.XmlReader reader)
{
IRssFeed ret = (IRssFeed) new RssFeed();
reader.Read();
// RDF versions of RSS don't have version tags.
//double version = double.Parse(reader.GetAttribute("version"));
reader.ReadToDescendant("channel");
bool readContent = false;
while (readContent || reader.Read())
{
readContent = false;
if (reader.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (reader.Name)
{
case "title":
ret.Title = reader.ReadElementContentAsString();
break;
case "link":
ret.FeedUri = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString());
break;
case "description":
ret.Description = reader.ReadElementContentAsString();
break;
case "language":
ret.Culture = CachedPropertiesProvider.ConvertToCultureInfo(reader.ReadElementContentAsString());
break;
case "copyright":
ret.Copyright = reader.ReadElementContentAsString();
break;
case "managingEditor":
ret.ManagingEditor = reader.ReadElementContentAsString();
break;
case "webMaster":
ret.WebMaster = reader.ReadElementContentAsString();
break;
case "pubDate":
ret.PublicationDate = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "lastBuildDate":
ret.LastChanged = CachedPropertiesProvider.ConvertToTzDateTime(reader.ReadElementContentAsString());
break;
case "category":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Category = ConvertToIRssCategory(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "generator":
ret.Generator = reader.ReadElementContentAsString();
break;
case "docs":
ret.Doc = CachedPropertiesProvider.ConvertToUri(reader.ReadElementContentAsString());
break;
case "cloud":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Cloud = ConvertToIRssCloud(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "ttl":
ret.TimeToLive = CachedPropertiesProvider.ConvertToInt(reader.ReadElementContentAsString());
break;
case "image":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.Image = ConvertToIRssImage(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
/*case "rating":
* break;*/
case "textInput":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.TextInput = ConvertToIRssTextInput(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "skipHours":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.SkipHours = ConvertToSkipHourList(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "skipDays":
using (XmlReader subReader = reader.ReadSubtree())
{
ret.SkipDays = ConvertToDayOfWeekList(subReader);
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
case "item":
using (XmlReader itemReader = reader.ReadSubtree())
{
ret.Items.Add(ParseItem(itemReader));
}
if (reader.IsEmptyElement)
{
readContent = false;
}
break;
default:
UnhandledElement(ret, reader);
break;
}
}
}
reader.Close();
return((T)ret);
}
internal static IOpmlHead ConvertToIOpmlHead(XmlReader input)
{
OpmlHead head = new OpmlHead();
input.ReadToDescendant("head");
bool readContent = false;
while (readContent || input.Read())
{
readContent = false;
if (input.NodeType == XmlNodeType.Element)
{
readContent = true;
switch (input.Name)
{
case "title":
head.Title = input.ReadElementContentAsString();
break;
case "dateCreated":
head.DateCreated = CachedPropertiesProvider.ConvertToTzDateTime(input.ReadElementContentAsString());
break;
case "dateModified":
head.DateModified = CachedPropertiesProvider.ConvertToTzDateTime(input.ReadElementContentAsString());
break;
case "ownerName":
head.Owner = input.ReadElementContentAsString();
break;
case "ownerEmail":
head.OwnerEmail = input.ReadElementContentAsString();
break;
case "expansionState":
head.ExpansionState = input.ReadElementContentAsString();
break;
case "vertScrollState":
head.VerticalScrollState = CachedPropertiesProvider.ConvertToIntNullable(input.ReadElementContentAsString());
break;
case "windowTop":
head.WindowTop = CachedPropertiesProvider.ConvertToIntNullable(input.ReadElementContentAsString());
break;
case "windowLeft":
head.WindowLeft = CachedPropertiesProvider.ConvertToIntNullable(input.ReadElementContentAsString());
break;
case "windowBottom":
head.WindowBottom = CachedPropertiesProvider.ConvertToIntNullable(input.ReadElementContentAsString());
break;
case "windowRight":
head.WindowRight = CachedPropertiesProvider.ConvertToIntNullable(input.ReadElementContentAsString());
break;
default:
readContent = false;
break;
}
}
}
input.Close();
return(head);
}
