/// <summary>
/// Initializes the supplied <see cref="RssEnclosure"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>.
/// </summary>
/// <param name="enclosure">The <see cref="RssEnclosure"/> to be filled.</param>
/// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the enclosure XML data.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param>
/// <exception cref="ArgumentNullException">The <paramref name="enclosure"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillEnclosure(RssEnclosure enclosure, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(enclosure, "enclosure");
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Attempt to extract enclosure information
//------------------------------------------------------------
if (navigator.HasAttributes)
{
string urlAttribute = navigator.GetAttribute("url", String.Empty);
string lengthAttribute = navigator.GetAttribute("length", String.Empty);
string typeAttribute = navigator.GetAttribute("type", String.Empty);
Uri url;
if (Uri.TryCreate(urlAttribute, UriKind.RelativeOrAbsolute, out url))
{
enclosure.Url = url;
}
long length;
if (Int64.TryParse(lengthAttribute, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out length))
{
enclosure.Length = length;
}
if (!String.IsNullOrEmpty(typeAttribute))
{
enclosure.ContentType = typeAttribute;
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings);
adapter.Fill(enclosure);
}
/// <summary>
/// Saves the current <see cref="ApmlConcept"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
Guard.ArgumentNotNull(writer, "writer");
writer.WriteStartElement("Concept", ApmlUtility.ApmlNamespace);
writer.WriteAttributeString("key", this.Key);
writer.WriteAttributeString("value", this.Value.ToString("0.00", System.Globalization.NumberFormatInfo.InvariantInfo));
if (!String.IsNullOrEmpty(this.From))
{
writer.WriteAttributeString("from", this.From);
}
if (this.UpdatedOn != DateTime.MinValue)
{
writer.WriteAttributeString("updated", SyndicationDateTimeUtility.ToRfc3339DateTime(this.UpdatedOn));
}
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="BlogMLCategory"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
Guard.ArgumentNotNull(writer, "writer");
writer.WriteStartElement("category", BlogMLUtility.BlogMLNamespace);
BlogMLUtility.WriteCommonObjectAttributes(this, writer);
if (!String.IsNullOrEmpty(this.ParentId))
{
writer.WriteAttributeString("parentref", this.ParentId);
}
if (!String.IsNullOrEmpty(this.Description))
{
writer.WriteAttributeString("description", this.Description);
}
BlogMLUtility.WriteCommonObjectElements(this, writer);
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="AtomWorkspace"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
Guard.ArgumentNotNull(writer, "writer");
writer.WriteStartElement("workspace", AtomUtility.AtomPublishingNamespace);
AtomUtility.WriteCommonObjectAttributes(this, writer);
if (this.Title != null)
{
this.Title.WriteTo(writer, "title");
}
foreach (AtomMemberResources collection in this.Collections)
{
collection.WriteTo(writer);
}
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
//============================================================
// PRIVATE METHODS
//============================================================
#region FillChannel(RssChannel channel, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
/// <summary>
/// Initializes the supplied <see cref="RssChannel"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>.
/// </summary>
/// <param name="channel">The <see cref="RssChannel"/> to be filled.</param>
/// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the channel XML data.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param>
/// <exception cref="ArgumentNullException">The <paramref name="channel"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillChannel(RssChannel channel, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(channel, "channel");
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Load required channel information
//------------------------------------------------------------
XPathNavigator descriptionNavigator = navigator.SelectSingleNode("rss:description", manager);
XPathNavigator linkNavigator = navigator.SelectSingleNode("rss:link", manager);
XPathNavigator titleNavigator = navigator.SelectSingleNode("rss:title", manager);
if (descriptionNavigator != null && !String.IsNullOrEmpty(descriptionNavigator.Value))
{
channel.Description = descriptionNavigator.Value;
}
if (linkNavigator != null)
{
Uri link;
if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link))
{
channel.Link = link;
}
}
if (titleNavigator != null && !String.IsNullOrEmpty(titleNavigator.Value))
{
channel.Title = titleNavigator.Value;
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings);
adapter.Fill(channel);
}
/// <summary>
/// Modifies the <see cref="AtomEntry"/> to match the supplied <see cref="XPathNavigator"/> data source.
/// </summary>
/// <param name="entry">The <see cref="AtomEntry"/> to be filled.</param>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents an Atom 0.3 element.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="entry"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillEntry(AtomEntry entry, XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
Guard.ArgumentNotNull(entry, "entry");
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
AtomUtility.FillCommonObjectAttributes(entry, source);
XPathNavigator idNavigator = source.SelectSingleNode("atom:id", manager);
XPathNavigator titleNavigator = source.SelectSingleNode("atom:title", manager);
XPathNavigator modifiedNavigator = source.SelectSingleNode("atom:modified", manager);
if (idNavigator != null)
{
entry.Id = new AtomId();
entry.Id.Load(idNavigator, settings);
}
if (titleNavigator != null)
{
entry.Title = Atom03SyndicationResourceAdapter.CreateTextContent(titleNavigator, manager, settings);
}
if (modifiedNavigator != null)
{
DateTime updatedOn;
if (SyndicationDateTimeUtility.TryParseRfc3339DateTime(modifiedNavigator.Value, out updatedOn))
{
entry.UpdatedOn = updatedOn;
}
}
Atom03SyndicationResourceAdapter.FillEntryOptionals(entry, source, manager, settings);
Atom03SyndicationResourceAdapter.FillEntryCollections(entry, source, manager, settings);
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(entry, manager);
}
/// <summary>
/// Saves the current <see cref="AtomPersonConstruct"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <param name="elementName">The local name of the person construct being written.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="elementName"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="elementName"/> is an empty string.</exception>
public void WriteTo(XmlWriter writer, string elementName)
{
Guard.ArgumentNotNull(writer, "writer");
Guard.ArgumentNotNullOrEmptyString(elementName, "elementName");
writer.WriteStartElement(elementName, AtomUtility.AtomNamespace);
AtomUtility.WriteCommonObjectAttributes(this, writer);
writer.WriteElementString("name", AtomUtility.AtomNamespace, this.Name);
if (this.Uri != null)
{
writer.WriteElementString("uri", AtomUtility.AtomNamespace, this.Uri.ToString());
}
if (!String.IsNullOrEmpty(this.EmailAddress))
{
writer.WriteElementString("email", AtomUtility.AtomNamespace, this.EmailAddress);
}
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="ApmlHead"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(writer, "writer");
//------------------------------------------------------------
// Write XML representation of the current instance
//------------------------------------------------------------
writer.WriteStartElement("Head", ApmlUtility.ApmlNamespace);
if (!String.IsNullOrEmpty(this.Title))
{
writer.WriteElementString("Title", ApmlUtility.ApmlNamespace, this.Title);
}
if (!String.IsNullOrEmpty(this.Generator))
{
writer.WriteElementString("Generator", ApmlUtility.ApmlNamespace, this.Generator);
}
if (!String.IsNullOrEmpty(this.EmailAddress))
{
writer.WriteElementString("UserEmail", ApmlUtility.ApmlNamespace, this.EmailAddress);
}
if (this.CreatedOn != DateTime.MinValue)
{
writer.WriteElementString("DateCreated", ApmlUtility.ApmlNamespace, SyndicationDateTimeUtility.ToRfc3339DateTime(this.CreatedOn));
}
//------------------------------------------------------------
// Write the syndication extensions of the current instance
//------------------------------------------------------------
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="AtomContent"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
Guard.ArgumentNotNull(writer, "writer");
writer.WriteStartElement("content", AtomUtility.AtomNamespace);
AtomUtility.WriteCommonObjectAttributes(this, writer);
if (!String.IsNullOrEmpty(this.ContentType))
{
writer.WriteAttributeString("type", this.ContentType);
}
if (this.Source != null)
{
writer.WriteAttributeString("src", this.Source.ToString());
}
if (String.Compare(this.ContentType, "xhtml", StringComparison.OrdinalIgnoreCase) == 0 && String.IsNullOrEmpty(writer.LookupPrefix(AtomUtility.XhtmlNamespace)))
{
writer.WriteAttributeString("xmlns", "xhtml", null, AtomUtility.XhtmlNamespace);
}
if (!String.IsNullOrEmpty(this.Content))
{
if (String.Compare(this.ContentType, "xhtml", StringComparison.OrdinalIgnoreCase) == 0)
{
writer.WriteStartElement("div", AtomUtility.XhtmlNamespace);
writer.WriteString(this.Content);
writer.WriteEndElement();
}
else
{
writer.WriteString(this.Content);
}
}
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="AtomIcon"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(writer, "writer");
//------------------------------------------------------------
// Write XML representation of the current instance
//------------------------------------------------------------
writer.WriteStartElement("icon", AtomUtility.AtomNamespace);
AtomUtility.WriteCommonObjectAttributes(this, writer);
writer.WriteString(this.Uri != null ? this.Uri.ToString() : String.Empty);
//------------------------------------------------------------
// Write the syndication extensions of the current instance
//------------------------------------------------------------
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="ApmlSource"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(writer, "writer");
//------------------------------------------------------------
// Write XML representation of the current instance
//------------------------------------------------------------
writer.WriteStartElement("Source", ApmlUtility.ApmlNamespace);
writer.WriteAttributeString("key", this.Key);
writer.WriteAttributeString("name", this.Name);
writer.WriteAttributeString("value", this.Value.ToString("0.00", System.Globalization.NumberFormatInfo.InvariantInfo));
writer.WriteAttributeString("type", this.MimeType);
if (!String.IsNullOrEmpty(this.From))
{
writer.WriteAttributeString("from", this.From);
}
if (this.UpdatedOn != DateTime.MinValue)
{
writer.WriteAttributeString("updated", SyndicationDateTimeUtility.ToRfc3339DateTime(this.UpdatedOn));
}
foreach (ApmlAuthor author in this.Authors)
{
author.WriteTo(writer);
}
//------------------------------------------------------------
// Write the syndication extensions of the current instance
//------------------------------------------------------------
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Creates a <see cref="AtomPersonConstruct"/> using the supplied <see cref="XPathNavigator"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the fill operation.</param>
/// <returns>A <see cref="AtomPersonConstruct"/> instance initialized using the supplied <paramref name="source"/>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a Atom 0.3 Person construct.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static AtomPersonConstruct CreatePerson(XPathNavigator source, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
AtomPersonConstruct person = new AtomPersonConstruct();
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
AtomUtility.FillCommonObjectAttributes(person, source);
XPathNavigator nameNavigator = source.SelectSingleNode("atom:name", manager);
XPathNavigator urlNavigator = source.SelectSingleNode("atom:url", manager);
XPathNavigator emailNavigator = source.SelectSingleNode("atom:email", manager);
if (nameNavigator != null)
{
person.Name = nameNavigator.Value;
}
if (urlNavigator != null)
{
Uri uri;
if (Uri.TryCreate(urlNavigator.Value, UriKind.RelativeOrAbsolute, out uri))
{
person.Uri = uri;
}
}
if (emailNavigator != null)
{
person.EmailAddress = emailNavigator.Value;
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(person, manager);
return(person);
}
/// <summary>
/// Saves the current <see cref="RssGuid"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(writer, "writer");
//------------------------------------------------------------
// Write XML representation of the current instance
//------------------------------------------------------------
writer.WriteStartElement("guid");
writer.WriteAttributeString("isPermaLink", this.IsPermanentLink ? "true" : "false");
writer.WriteValue(this.Value);
//------------------------------------------------------------
// Write the syndication extensions of the current instance
//------------------------------------------------------------
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="RsdApplicationInterface"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
Guard.ArgumentNotNull(writer, "writer");
writer.WriteStartElement("api", RsdUtility.RsdNamespace);
writer.WriteAttributeString("name", this.Name);
writer.WriteAttributeString("preferred", this.IsPreferred ? "true" : "false");
writer.WriteAttributeString("apiLink", this.Link != null ? this.Link.ToString() : String.Empty);
writer.WriteAttributeString("blogID", this.WeblogId);
if (this.Documentation != null || !String.IsNullOrEmpty(this.Notes) || this.Settings.Count > 0)
{
writer.WriteStartElement("settings", RsdUtility.RsdNamespace);
if (this.Documentation != null)
{
writer.WriteElementString("docs", RsdUtility.RsdNamespace, this.Documentation.ToString());
}
if (!String.IsNullOrEmpty(this.Notes))
{
writer.WriteElementString("notes", RsdUtility.RsdNamespace, this.Notes);
}
foreach (string settingName in this.Settings.Keys)
{
writer.WriteStartElement("setting", RsdUtility.RsdNamespace);
writer.WriteAttributeString("name", settingName);
writer.WriteString(this.Settings[settingName]);
writer.WriteEndElement();
}
writer.WriteEndElement();
}
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="RssEnclosure"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(writer, "writer");
//------------------------------------------------------------
// Write XML representation of the current instance
//------------------------------------------------------------
writer.WriteStartElement("enclosure");
writer.WriteAttributeString("length", this.Length != Int64.MinValue ? this.Length.ToString(System.Globalization.NumberFormatInfo.InvariantInfo) : String.Empty);
writer.WriteAttributeString("type", this.ContentType);
writer.WriteAttributeString("url", this.Url != null ? this.Url.ToString() : String.Empty);
//------------------------------------------------------------
// Write the syndication extensions of the current instance
//------------------------------------------------------------
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="AtomCategory"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
Guard.ArgumentNotNull(writer, "writer");
writer.WriteStartElement("category", AtomUtility.AtomNamespace);
AtomUtility.WriteCommonObjectAttributes(this, writer);
writer.WriteAttributeString("term", this.Term);
if (this.Scheme != null)
{
writer.WriteAttributeString("scheme", this.Scheme.ToString());
}
if (!String.IsNullOrEmpty(this.Label))
{
writer.WriteAttributeString("label", this.Label);
}
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="AtomGenerator"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
Guard.ArgumentNotNull(writer, "writer");
writer.WriteStartElement("generator", AtomUtility.AtomNamespace);
AtomUtility.WriteCommonObjectAttributes(this, writer);
if (this.Uri != null)
{
writer.WriteAttributeString("uri", this.Uri.ToString());
}
if (!String.IsNullOrEmpty(this.Version))
{
writer.WriteAttributeString("version", this.Version);
}
writer.WriteString(this.Content);
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="BlogMLTextConstruct"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <param name="elementName">The local name of the text construct being written.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="elementName"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="elementName"/> is an empty string.</exception>
public void WriteTo(XmlWriter writer, string elementName)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(writer, "writer");
Guard.ArgumentNotNullOrEmptyString(elementName, "elementName");
//------------------------------------------------------------
// Write XML representation of the current instance
//------------------------------------------------------------
writer.WriteStartElement(elementName, BlogMLUtility.BlogMLNamespace);
if (this.ContentType != BlogMLContentType.None)
{
writer.WriteAttributeString("type", BlogMLTextConstruct.ConstructTypeAsString(this.ContentType));
}
if (!String.IsNullOrEmpty(this.Content))
{
if (this.EscapeContent)
{
writer.WriteCData(this.Content);
}
else
{
writer.WriteString(this.Content);
}
}
//------------------------------------------------------------
// Write the syndication extensions of the current instance
//------------------------------------------------------------
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="BlogMLComment"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
Guard.ArgumentNotNull(writer, "writer");
writer.WriteStartElement("comment", BlogMLUtility.BlogMLNamespace);
BlogMLUtility.WriteCommonObjectAttributes(this, writer);
writer.WriteAttributeString("user-name", this.UserName);
if (!String.IsNullOrEmpty(this.UserEmailAddress))
{
writer.WriteAttributeString("user-email", this.UserEmailAddress);
}
if (this.UserUrl != null)
{
writer.WriteAttributeString("user-url", this.UserUrl.ToString());
}
BlogMLUtility.WriteCommonObjectElements(this, writer);
this.Content.WriteTo(writer, "content");
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="AtomLink"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
Guard.ArgumentNotNull(writer, "writer");
writer.WriteStartElement("link", AtomUtility.AtomNamespace);
AtomUtility.WriteCommonObjectAttributes(this, writer);
writer.WriteAttributeString("href", this.Uri != null ? this.Uri.ToString() : String.Empty);
if (!String.IsNullOrEmpty(this.Relation))
{
writer.WriteAttributeString("rel", this.Relation);
}
if (!String.IsNullOrEmpty(this.ContentType))
{
writer.WriteAttributeString("type", this.ContentType);
}
if (this.ContentLanguage != null)
{
writer.WriteAttributeString("hreflang", this.ContentLanguage.Name);
}
if (!String.IsNullOrEmpty(this.Title))
{
writer.WriteAttributeString("title", this.Title);
}
if (this.Length != Int64.MinValue)
{
writer.WriteAttributeString("length", this.Length.ToString(NumberFormatInfo.InvariantInfo));
}
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="RssTextInput"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(writer, "writer");
//------------------------------------------------------------
// Write XML representation of the current instance
//------------------------------------------------------------
writer.WriteStartElement("textInput");
writer.WriteElementString("description", this.Description);
writer.WriteElementString("link", this.Link != null ? this.Link.ToString() : String.Empty);
writer.WriteElementString("name", this.Name);
writer.WriteElementString("title", this.Title);
//------------------------------------------------------------
// Write the syndication extensions of the current instance
//------------------------------------------------------------
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Saves the current <see cref="RssImage"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(writer, "writer");
//------------------------------------------------------------
// Write XML representation of the current instance
//------------------------------------------------------------
writer.WriteStartElement("image");
writer.WriteElementString("link", this.Link != null ? this.Link.ToString() : String.Empty);
writer.WriteElementString("title", this.Title);
writer.WriteElementString("url", this.Url != null ? this.Url.ToString() : String.Empty);
if (!String.IsNullOrEmpty(this.Description))
{
writer.WriteElementString("description", this.Description);
}
if (this.Height != Int32.MinValue)
{
writer.WriteElementString("height", this.Height.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
if (this.Width != Int32.MinValue)
{
writer.WriteElementString("width", this.Width.ToString(System.Globalization.NumberFormatInfo.InvariantInfo));
}
//------------------------------------------------------------
// Write the syndication extensions of the current instance
//------------------------------------------------------------
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Initializes the supplied <see cref="RssItem"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>.
/// </summary>
/// <param name="item">The <see cref="RssItem"/> to be filled.</param>
/// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the item XML data.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param>
/// <exception cref="ArgumentNullException">The <paramref name="item"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillItem(RssItem item, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
Guard.ArgumentNotNull(item, "item");
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
XPathNavigator titleNavigator = navigator.SelectSingleNode("title", manager);
XPathNavigator linkNavigator = navigator.SelectSingleNode("link", manager);
XPathNavigator descriptionNavigator = navigator.SelectSingleNode("description", manager);
XPathNavigator sourceNavigator = navigator.SelectSingleNode("source", manager);
XPathNodeIterator enclosureIterator = navigator.Select("enclosure", manager);
XPathNodeIterator categoryIterator = navigator.Select("category", manager);
if (titleNavigator != null)
{
item.Title = titleNavigator.Value;
}
if (descriptionNavigator != null)
{
item.Description = descriptionNavigator.Value;
}
if (linkNavigator != null)
{
Uri link;
if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link))
{
item.Link = link;
}
}
if (sourceNavigator != null)
{
item.Source = new RssSource();
if (sourceNavigator.HasAttributes)
{
string urlAttribute = sourceNavigator.GetAttribute("url", String.Empty);
Uri url;
if (Uri.TryCreate(urlAttribute, UriKind.RelativeOrAbsolute, out url))
{
item.Source.Url = url;
}
}
if (!String.IsNullOrEmpty(sourceNavigator.Value))
{
item.Source.Title = sourceNavigator.Value;
}
}
if (enclosureIterator != null && enclosureIterator.Count > 0)
{
while (enclosureIterator.MoveNext())
{
RssEnclosure enclosure = new RssEnclosure();
Rss092SyndicationResourceAdapter.FillEnclosure(enclosure, enclosureIterator.Current, manager, settings);
item.Enclosures.Add(enclosure);
}
}
if (categoryIterator != null && categoryIterator.Count > 0)
{
while (categoryIterator.MoveNext())
{
RssCategory category = new RssCategory();
Rss092SyndicationResourceAdapter.FillCategory(category, categoryIterator.Current, manager, settings);
item.Categories.Add(category);
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings);
adapter.Fill(item);
}
/// <summary>
/// Initializes the supplied <see cref="RssImage"/> using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>.
/// </summary>
/// <param name="image">The <see cref="RssImage"/> to be filled.</param>
/// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the image XML data.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param>
/// <exception cref="ArgumentNullException">The <paramref name="image"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillImage(RssImage image, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
Guard.ArgumentNotNull(image, "image");
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
XPathNavigator linkNavigator = navigator.SelectSingleNode("link", manager);
XPathNavigator titleNavigator = navigator.SelectSingleNode("title", manager);
XPathNavigator urlNavigator = navigator.SelectSingleNode("url", manager);
XPathNavigator descriptionNavigator = navigator.SelectSingleNode("description", manager);
XPathNavigator heightNavigator = navigator.SelectSingleNode("height", manager);
XPathNavigator widthNavigator = navigator.SelectSingleNode("width", manager);
if (linkNavigator != null)
{
Uri link;
if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link))
{
image.Link = link;
}
}
if (titleNavigator != null)
{
if (!String.IsNullOrEmpty(titleNavigator.Value))
{
image.Title = titleNavigator.Value;
}
}
if (urlNavigator != null)
{
Uri url;
if (Uri.TryCreate(urlNavigator.Value, UriKind.RelativeOrAbsolute, out url))
{
image.Url = url;
}
}
if (descriptionNavigator != null)
{
image.Description = descriptionNavigator.Value;
}
if (heightNavigator != null)
{
int height;
if (Int32.TryParse(heightNavigator.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out height))
{
image.Height = height < RssImage.HeightMaximum ? height : RssImage.HeightMaximum;
}
}
if (widthNavigator != null)
{
int width;
if (Int32.TryParse(widthNavigator.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out width))
{
image.Width = width < RssImage.WidthMaximum ? width : RssImage.WidthMaximum;
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(navigator, settings);
adapter.Fill(image);
}
//============================================================
// PUBLIC METHODS
//============================================================
#region Fill(RssFeed resource)
/// <summary>
/// Modifies the <see cref="RssFeed"/> to match the data source.
/// </summary>
/// <param name="resource">The <see cref="RssFeed"/> to be filled.</param>
/// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception>
public void Fill(RssFeed resource)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(resource, "resource");
//------------------------------------------------------------
// Create namespace resolver
//------------------------------------------------------------
XmlNamespaceManager manager = new XmlNamespaceManager(this.Navigator.NameTable);
manager.AddNamespace("rdf", "http://www.w3.org/1999/02/22-rdf-syntax-ns#");
manager.AddNamespace("rss", "http://my.netscape.com/rdf/simple/0.9/");
//------------------------------------------------------------
// Attempt to fill syndication resource
//------------------------------------------------------------
XPathNavigator channelNavigator = this.Navigator.SelectSingleNode("rdf:RDF/rss:channel", manager);
if (channelNavigator != null)
{
Rss090SyndicationResourceAdapter.FillChannel(resource.Channel, channelNavigator, manager, this.Settings);
}
XPathNavigator imageNavigator = this.Navigator.SelectSingleNode("rdf:RDF/rss:image", manager);
if (imageNavigator != null)
{
resource.Channel.Image = new RssImage();
Rss090SyndicationResourceAdapter.FillImage(resource.Channel.Image, imageNavigator, manager, this.Settings);
}
XPathNavigator textInputNavigator = this.Navigator.SelectSingleNode("rdf:RDF/rss:textinput", manager);
if (textInputNavigator != null)
{
resource.Channel.TextInput = new RssTextInput();
Rss090SyndicationResourceAdapter.FillTextInput(resource.Channel.TextInput, textInputNavigator, manager, this.Settings);
}
XPathNodeIterator itemIterator = this.Navigator.Select("rdf:RDF/rss:item", manager);
if (itemIterator != null && itemIterator.Count > 0)
{
int counter = 0;
while (itemIterator.MoveNext())
{
RssItem item = new RssItem();
counter++;
if (this.Settings.RetrievalLimit != 0 && counter > this.Settings.RetrievalLimit)
{
break;
}
XPathNavigator titleNavigator = itemIterator.Current.SelectSingleNode("rss:title", manager);
XPathNavigator linkNavigator = itemIterator.Current.SelectSingleNode("rss:link", manager);
if (titleNavigator != null)
{
item.Title = titleNavigator.Value;
}
if (linkNavigator != null)
{
Uri link;
if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link))
{
item.Link = link;
}
}
SyndicationExtensionAdapter itemExtensionAdapter = new SyndicationExtensionAdapter(itemIterator.Current, this.Settings);
itemExtensionAdapter.Fill(item, manager);
((Collection <RssItem>)resource.Channel.Items).Add(item);
}
}
SyndicationExtensionAdapter feedExtensionAdapter = new SyndicationExtensionAdapter(this.Navigator.SelectSingleNode("rdf:RDF", manager), this.Settings);
feedExtensionAdapter.Fill(resource, manager);
}
/// <summary>
/// Saves the current <see cref="ApmlProfile"/> to the specified <see cref="XmlWriter"/>.
/// </summary>
/// <param name="writer">The <see cref="XmlWriter"/> to which you want to save.</param>
/// <exception cref="ArgumentNullException">The <paramref name="writer"/> is a null reference (Nothing in Visual Basic).</exception>
public void WriteTo(XmlWriter writer)
{
Guard.ArgumentNotNull(writer, "writer");
writer.WriteStartElement("Profile", ApmlUtility.ApmlNamespace);
writer.WriteAttributeString("name", this.Name);
if (this.ImplicitConcepts.Count > 0 || this.ImplicitSources.Count > 0)
{
writer.WriteStartElement("ImplicitData", ApmlUtility.ApmlNamespace);
if (this.ImplicitConcepts.Count > 0)
{
writer.WriteStartElement("Concepts", ApmlUtility.ApmlNamespace);
foreach (ApmlConcept concept in this.ImplicitConcepts)
{
concept.WriteTo(writer);
}
writer.WriteEndElement();
}
if (this.ImplicitSources.Count > 0)
{
writer.WriteStartElement("Sources", ApmlUtility.ApmlNamespace);
foreach (ApmlSource source in this.ImplicitSources)
{
source.WriteTo(writer);
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
if (this.ExplicitConcepts.Count > 0 || this.ExplicitSources.Count > 0)
{
writer.WriteStartElement("ExplicitData", ApmlUtility.ApmlNamespace);
if (this.ExplicitConcepts.Count > 0)
{
writer.WriteStartElement("Concepts", ApmlUtility.ApmlNamespace);
foreach (ApmlConcept concept in this.ExplicitConcepts)
{
concept.WriteTo(writer);
}
writer.WriteEndElement();
}
if (this.ExplicitSources.Count > 0)
{
writer.WriteStartElement("Sources", ApmlUtility.ApmlNamespace);
foreach (ApmlSource source in this.ExplicitSources)
{
source.WriteTo(writer);
}
writer.WriteEndElement();
}
writer.WriteEndElement();
}
SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer);
writer.WriteEndElement();
}
/// <summary>
/// Loads this <see cref="ApmlProfile"/> using the supplied <see cref="XPathNavigator"/> and <see cref="SyndicationResourceLoadSettings"/>.
/// </summary>
/// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> used to configure the load operation.</param>
/// <returns><b>true</b> if the <see cref="ApmlProfile"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns>
/// <remarks>
/// This method expects the supplied <paramref name="source"/> to be positioned on the XML element that represents a <see cref="ApmlProfile"/>.
/// </remarks>
/// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
public bool Load(XPathNavigator source, SyndicationResourceLoadSettings settings)
{
bool wasLoaded = false;
Guard.ArgumentNotNull(source, "source");
Guard.ArgumentNotNull(settings, "settings");
XmlNamespaceManager manager = ApmlUtility.CreateNamespaceManager(source.NameTable);
if (source.HasAttributes)
{
string nameAttribute = source.GetAttribute("name", String.Empty);
if (!String.IsNullOrEmpty(nameAttribute))
{
this.Name = nameAttribute;
wasLoaded = true;
}
}
if (source.HasChildren)
{
XPathNavigator implicitDataNavigator = source.SelectSingleNode("apml:ImplicitData", manager);
XPathNavigator explicitDataNavigator = source.SelectSingleNode("apml:ExplicitData", manager);
if (implicitDataNavigator != null)
{
XPathNodeIterator conceptsIterator = implicitDataNavigator.Select("apml:Concepts/apml:Concept", manager);
if (conceptsIterator != null && conceptsIterator.Count > 0)
{
while (conceptsIterator.MoveNext())
{
ApmlConcept concept = new ApmlConcept();
if (concept.Load(conceptsIterator.Current, settings))
{
this.ImplicitConcepts.Add(concept);
wasLoaded = true;
}
}
}
XPathNodeIterator sourcesIterator = implicitDataNavigator.Select("apml:Sources/apml:Source", manager);
if (sourcesIterator != null && sourcesIterator.Count > 0)
{
while (sourcesIterator.MoveNext())
{
ApmlSource attentionSource = new ApmlSource();
if (attentionSource.Load(sourcesIterator.Current, settings))
{
this.ImplicitSources.Add(attentionSource);
wasLoaded = true;
}
}
}
}
if (explicitDataNavigator != null)
{
XPathNodeIterator conceptsIterator = explicitDataNavigator.Select("apml:Concepts/apml:Concept", manager);
if (conceptsIterator != null && conceptsIterator.Count > 0)
{
while (conceptsIterator.MoveNext())
{
ApmlConcept concept = new ApmlConcept();
if (concept.Load(conceptsIterator.Current, settings))
{
this.ExplicitConcepts.Add(concept);
wasLoaded = true;
}
}
}
XPathNodeIterator sourcesIterator = explicitDataNavigator.Select("apml:Sources/apml:Source", manager);
if (sourcesIterator != null && sourcesIterator.Count > 0)
{
while (sourcesIterator.MoveNext())
{
ApmlSource attentionSource = new ApmlSource();
if (attentionSource.Load(sourcesIterator.Current, settings))
{
this.ExplicitSources.Add(attentionSource);
wasLoaded = true;
}
}
}
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(source, settings);
adapter.Fill(this);
return(wasLoaded);
}
//============================================================
// PUBLIC METHODS
//============================================================
#region Fill(RsdDocument resource)
/// <summary>
/// Modifies the <see cref="RsdDocument"/> to match the data source.
/// </summary>
/// <param name="resource">The <see cref="RsdDocument"/> to be filled.</param>
/// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception>
public void Fill(RsdDocument resource)
{
//------------------------------------------------------------
// Validate parameter
//------------------------------------------------------------
Guard.ArgumentNotNull(resource, "resource");
//------------------------------------------------------------
// Create namespace resolver
//------------------------------------------------------------
XmlNamespaceManager manager = RsdUtility.CreateNamespaceManager(this.Navigator.NameTable);
//------------------------------------------------------------
// Attempt to fill syndication resource
//------------------------------------------------------------
XPathNavigator serviceNavigator = RsdUtility.SelectSafeSingleNode(this.Navigator, "rsd:rsd/rsd:service", manager);
if (serviceNavigator == null)
{
// dasBlog places an empty default XML namespace on the <service> element, this is a hack/compromise
serviceNavigator = RsdUtility.SelectSafeSingleNode(this.Navigator, "rsd:rsd/service", manager);
}
if (serviceNavigator != null)
{
XPathNavigator engineNameNavigator = RsdUtility.SelectSafeSingleNode(serviceNavigator, "rsd:engineName", manager);
XPathNavigator engineLinkNavigator = RsdUtility.SelectSafeSingleNode(serviceNavigator, "rsd:engineLink", manager);
XPathNavigator homePageLinkNavigator = RsdUtility.SelectSafeSingleNode(serviceNavigator, "rsd:homePageLink", manager);
XPathNodeIterator apiIterator = RsdUtility.SelectSafe(serviceNavigator, "rsd:apis/rsd:api", manager);
if (engineNameNavigator != null && !String.IsNullOrEmpty(engineNameNavigator.Value))
{
resource.EngineName = engineNameNavigator.Value;
}
if (engineLinkNavigator != null)
{
Uri link;
if (Uri.TryCreate(engineLinkNavigator.Value, UriKind.RelativeOrAbsolute, out link))
{
resource.EngineLink = link;
}
}
if (homePageLinkNavigator != null)
{
Uri homepage;
if (Uri.TryCreate(homePageLinkNavigator.Value, UriKind.RelativeOrAbsolute, out homepage))
{
resource.Homepage = homepage;
}
}
if (apiIterator != null && apiIterator.Count > 0)
{
int counter = 0;
while (apiIterator.MoveNext())
{
RsdApplicationInterface api = new RsdApplicationInterface();
counter++;
Uri link;
string rpcLinkAttribute = apiIterator.Current.GetAttribute("rpcLink", String.Empty);
if (Uri.TryCreate(rpcLinkAttribute, UriKind.RelativeOrAbsolute, out link))
{
api.Link = link;
}
if (api.Load(apiIterator.Current, this.Settings) || api.Link != null)
{
if (this.Settings.RetrievalLimit != 0 && counter > this.Settings.RetrievalLimit)
{
break;
}
((Collection <RsdApplicationInterface>)resource.Interfaces).Add(api);
}
}
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(RsdUtility.SelectSafeSingleNode(this.Navigator, "rsd:rsd", manager), this.Settings);
adapter.Fill(resource, manager);
}
/// <summary>
/// Modifies the <see cref="AtomCategoryDocument"/> to match the data source.
/// </summary>
/// <param name="resource">The <see cref="AtomCategoryDocument"/> to be filled.</param>
/// <exception cref="ArgumentNullException">The <paramref name="resource"/> is a null reference (Nothing in Visual Basic).</exception>
public void Fill(AtomCategoryDocument resource)
{
Guard.ArgumentNotNull(resource, "resource");
XmlNamespaceManager manager = AtomUtility.CreateNamespaceManager(this.Navigator.NameTable);
XPathNavigator documentNavigator = this.Navigator.SelectSingleNode("app:categories", manager);
if (documentNavigator != null)
{
AtomUtility.FillCommonObjectAttributes(resource, documentNavigator);
if (documentNavigator.HasChildren)
{
if (documentNavigator.HasAttributes)
{
string fixedAttribute = documentNavigator.GetAttribute("fixed", String.Empty);
string schemeAttribute = documentNavigator.GetAttribute("scheme", String.Empty);
string hrefAttribute = documentNavigator.GetAttribute("href", String.Empty);
if (!String.IsNullOrEmpty(fixedAttribute))
{
if (String.Compare(fixedAttribute, "yes", StringComparison.OrdinalIgnoreCase) == 0)
{
resource.IsFixed = true;
}
else if (String.Compare(fixedAttribute, "no", StringComparison.OrdinalIgnoreCase) == 0)
{
resource.IsFixed = false;
}
}
if (!String.IsNullOrEmpty(schemeAttribute))
{
Uri scheme;
if (Uri.TryCreate(schemeAttribute, UriKind.RelativeOrAbsolute, out scheme))
{
resource.Scheme = scheme;
}
}
if (!String.IsNullOrEmpty(hrefAttribute))
{
Uri href;
if (Uri.TryCreate(hrefAttribute, UriKind.RelativeOrAbsolute, out href))
{
resource.Uri = href;
}
}
}
if (documentNavigator.HasChildren)
{
XPathNodeIterator categoryIterator = documentNavigator.Select("atom:category", manager);
if (categoryIterator != null && categoryIterator.Count > 0)
{
while (categoryIterator.MoveNext())
{
AtomCategory category = new AtomCategory();
if (category.Load(categoryIterator.Current, this.Settings))
{
resource.AddCategory(category);
}
}
}
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(documentNavigator, this.Settings);
adapter.Fill(resource, manager);
}
}
/// <summary>
/// Initializes the supplied <see cref="RssChannel"/> collection entities using the specified <see cref="XPathNavigator"/> and <see cref="XmlNamespaceManager"/>.
/// </summary>
/// <param name="channel">The <see cref="RssChannel"/> to be filled.</param>
/// <param name="navigator">The <see cref="XPathNavigator"/> used to navigate the channel XML data.</param>
/// <param name="manager">The <see cref="XmlNamespaceManager"/> used to resolve XML namespace prefixes.</param>
/// <param name="settings">The <see cref="SyndicationResourceLoadSettings"/> object used to configure the load operation.</param>
/// <exception cref="ArgumentNullException">The <paramref name="channel"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="navigator"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="manager"/> is a null reference (Nothing in Visual Basic).</exception>
/// <exception cref="ArgumentNullException">The <paramref name="settings"/> is a null reference (Nothing in Visual Basic).</exception>
private static void FillChannelCollections(RssChannel channel, XPathNavigator navigator, XmlNamespaceManager manager, SyndicationResourceLoadSettings settings)
{
//------------------------------------------------------------
// Validate parameters
//------------------------------------------------------------
Guard.ArgumentNotNull(channel, "channel");
Guard.ArgumentNotNull(navigator, "navigator");
Guard.ArgumentNotNull(manager, "manager");
Guard.ArgumentNotNull(settings, "settings");
//------------------------------------------------------------
// Extract channel collections information
//------------------------------------------------------------
XPathNodeIterator skipDaysIterator = navigator.Select("skipDays/day", manager);
XPathNodeIterator skipHoursIterator = navigator.Select("skipHours/hour", manager);
XPathNodeIterator itemIterator = navigator.Select("item", manager);
if (skipDaysIterator != null && skipDaysIterator.Count > 0)
{
while (skipDaysIterator.MoveNext())
{
if (!String.IsNullOrEmpty(skipDaysIterator.Current.Value))
{
try
{
DayOfWeek day = (DayOfWeek)Enum.Parse(typeof(DayOfWeek), skipDaysIterator.Current.Value, true);
if (!channel.SkipDays.Contains(day))
{
channel.SkipDays.Add(day);
}
}
catch (ArgumentException)
{
System.Diagnostics.Trace.TraceWarning("Rss091SyndicationResourceAdapter unable to determine DayOfWeek with a name of {0}.", skipDaysIterator.Current.Value);
}
}
}
}
if (skipHoursIterator != null && skipHoursIterator.Count > 0)
{
while (skipHoursIterator.MoveNext())
{
int hour;
if (Int32.TryParse(skipHoursIterator.Current.Value, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out hour))
{
hour = hour - 1; // Convert to zero-based range
if (!channel.SkipHours.Contains(hour) && (hour >= 0 && hour <= 23))
{
channel.SkipHours.Add(hour);
}
else
{
System.Diagnostics.Trace.TraceWarning("Rss091SyndicationResourceAdapter unable to add duplicate or out-of-range skip hour with a value of {0}.", hour);
}
}
}
}
if (itemIterator != null && itemIterator.Count > 0)
{
int counter = 0;
while (itemIterator.MoveNext())
{
RssItem item = new RssItem();
counter++;
if (settings.RetrievalLimit != 0 && counter > settings.RetrievalLimit)
{
break;
}
XPathNavigator titleNavigator = itemIterator.Current.SelectSingleNode("title", manager);
XPathNavigator linkNavigator = itemIterator.Current.SelectSingleNode("link", manager);
XPathNavigator descriptionNavigator = itemIterator.Current.SelectSingleNode("description", manager);
if (titleNavigator != null)
{
item.Title = titleNavigator.Value;
}
if (descriptionNavigator != null)
{
item.Description = descriptionNavigator.Value;
}
if (linkNavigator != null)
{
Uri link;
if (Uri.TryCreate(linkNavigator.Value, UriKind.RelativeOrAbsolute, out link))
{
item.Link = link;
}
}
SyndicationExtensionAdapter adapter = new SyndicationExtensionAdapter(itemIterator.Current, settings);
adapter.Fill(item);
((Collection <RssItem>)channel.Items).Add(item);
}
}
}
