/// <summary> /// Saves the current <see cref="AtomTextConstruct"/> 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, AtomUtility.AtomNamespace); AtomUtility.WriteCommonObjectAttributes(this, writer); if (this.TextType == AtomTextConstructType.Xhtml && String.IsNullOrEmpty(writer.LookupPrefix(AtomUtility.XhtmlNamespace))) { writer.WriteAttributeString("xmlns", "xhtml", null, AtomUtility.XhtmlNamespace); } if (this.TextType != AtomTextConstructType.None) { writer.WriteAttributeString("type", AtomTextConstruct.ConstructTypeAsString(this.TextType)); } if (this.TextType == AtomTextConstructType.Xhtml) { writer.WriteStartElement("div", AtomUtility.XhtmlNamespace); writer.WriteString(this.Content); writer.WriteEndElement(); } else { writer.WriteString(this.Content); } //------------------------------------------------------------ // Write the syndication extensions of the current instance //------------------------------------------------------------ SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer); writer.WriteEndElement(); }
/// <summary> /// Loads this <see cref="AtomGenerator"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <returns><b>true</b> if the <see cref="AtomGenerator"/> 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="AtomGenerator"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source) { bool wasLoaded = false; Guard.ArgumentNotNull(source, "source"); if (AtomUtility.FillCommonObjectAttributes(this, source)) { wasLoaded = true; } if (source.HasAttributes) { string uriAttribute = source.GetAttribute("uri", String.Empty); string versionAttribute = source.GetAttribute("version", String.Empty); if (!String.IsNullOrEmpty(uriAttribute)) { Uri uri; if (Uri.TryCreate(uriAttribute, UriKind.RelativeOrAbsolute, out uri)) { this.Uri = uri; wasLoaded = true; } } if (!String.IsNullOrEmpty(versionAttribute)) { this.Version = versionAttribute; wasLoaded = true; } } if (!String.IsNullOrEmpty(source.Value)) { this.Content = source.Value; wasLoaded = true; } return(wasLoaded); }
/// <summary> /// Loads this <see cref="AtomLogo"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <returns><b>true</b> if the <see cref="AtomLogo"/> 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="AtomLogo"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source) { bool wasLoaded = false; Guard.ArgumentNotNull(source, "source"); if (AtomUtility.FillCommonObjectAttributes(this, source)) { wasLoaded = true; } if (!String.IsNullOrEmpty(source.Value)) { Uri uri; if (Uri.TryCreate(source.Value, UriKind.RelativeOrAbsolute, out uri)) { this.Uri = uri; wasLoaded = true; } } return(wasLoaded); }
/// <summary> /// Compares the current instance with another object of the same type. /// </summary> /// <param name="obj">An object to compare with this instance.</param> /// <returns>A 32-bit signed integer that indicates the relative order of the objects being compared.</returns> /// <exception cref="ArgumentException">The <paramref name="obj"/> is not the expected <see cref="Type"/>.</exception> public int CompareTo(object obj) { if (obj == null) { return(1); } AtomLogo value = obj as AtomLogo; if (value != null) { int result = Uri.Compare(this.Uri, value.Uri, UriComponents.AbsoluteUri, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase); result = result | AtomUtility.CompareCommonObjectAttributes(this, value); return(result); } else { throw new ArgumentException(String.Format(null, "obj is not of type {0}, type was found to be '{1}'.", this.GetType().FullName, obj.GetType().FullName), "obj"); } }
/// <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> /// Compares the current instance with another object of the same type. /// </summary> /// <param name="obj">An object to compare with this instance.</param> /// <returns>A 32-bit signed integer that indicates the relative order of the objects being compared.</returns> /// <exception cref="ArgumentException">The <paramref name="obj"/> is not the expected <see cref="Type"/>.</exception> public int CompareTo(object obj) { if (obj == null) { return(1); } AtomTextConstruct value = obj as AtomTextConstruct; if (value != null) { int result = String.Compare(this.Content, value.Content, StringComparison.OrdinalIgnoreCase); result = result | this.TextType.CompareTo(value.TextType); result = result | AtomUtility.CompareCommonObjectAttributes(this, value); return(result); } else { throw new ArgumentException(String.Format(null, "obj is not of type {0}, type was found to be '{1}'.", this.GetType().FullName, obj.GetType().FullName), "obj"); } }
/// <summary> /// Saves the current <see cref="AtomId"/> 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("id", 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="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> /// Loads this <see cref="AtomPersonConstruct"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <returns><b>true</b> if the <see cref="AtomPersonConstruct"/> 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="AtomPersonConstruct"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source) { bool wasLoaded = false; Guard.ArgumentNotNull(source, "source"); XmlNamespaceManager manager = AtomUtility.CreateNamespaceManager(source.NameTable); if (AtomUtility.FillCommonObjectAttributes(this, source)) { wasLoaded = true; } XPathNavigator nameNavigator = source.SelectSingleNode("atom:name", manager); XPathNavigator uriNavigator = source.SelectSingleNode("atom:uri", manager); XPathNavigator emailNavigator = source.SelectSingleNode("atom:email", manager); if (nameNavigator != null) { this.Name = nameNavigator.Value; wasLoaded = true; } if (uriNavigator != null) { Uri uri; if (Uri.TryCreate(uriNavigator.Value, UriKind.RelativeOrAbsolute, out uri)) { this.Uri = uri; wasLoaded = true; } } if (emailNavigator != null) { this.EmailAddress = emailNavigator.Value; wasLoaded = true; } return(wasLoaded); }
/// <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(); }
//============================================================ // ICOMPARABLE IMPLEMENTATION //============================================================ #region CompareTo(object obj) /// <summary> /// Compares the current instance with another object of the same type. /// </summary> /// <param name="obj">An object to compare with this instance.</param> /// <returns>A 32-bit signed integer that indicates the relative order of the objects being compared.</returns> /// <exception cref="ArgumentException">The <paramref name="obj"/> is not the expected <see cref="Type"/>.</exception> public int CompareTo(object obj) { //------------------------------------------------------------ // If target is a null reference, instance is greater //------------------------------------------------------------ if (obj == null) { return(1); } //------------------------------------------------------------ // Determine comparison result using property state of objects //------------------------------------------------------------ AtomLink value = obj as AtomLink; if (value != null) { int result = this.Length.CompareTo(value.Length); result = result | String.Compare(this.ContentType, value.ContentType, StringComparison.OrdinalIgnoreCase); result = result | String.Compare(this.Relation, value.Relation, StringComparison.OrdinalIgnoreCase); string sourceLanguageName = this.ContentLanguage != null ? this.ContentLanguage.Name : String.Empty; string targetLanguageName = value.ContentLanguage != null ? value.ContentLanguage.Name : String.Empty; result = result | String.Compare(sourceLanguageName, targetLanguageName, StringComparison.OrdinalIgnoreCase); result = result | String.Compare(this.Title, value.Title, StringComparison.OrdinalIgnoreCase); result = result | Uri.Compare(this.Uri, value.Uri, UriComponents.AbsoluteUri, UriFormat.SafeUnescaped, StringComparison.OrdinalIgnoreCase); result = result | AtomUtility.CompareCommonObjectAttributes(this, value); return(result); } else { throw new ArgumentException(String.Format(null, "obj is not of type {0}, type was found to be '{1}'.", this.GetType().FullName, obj.GetType().FullName), "obj"); } }
/// <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> /// Modifies the <see cref="IAtomCommonObjectAttributes"/> to match the data source. /// </summary> /// <param name="target">The object that implements the <see cref="IAtomCommonObjectAttributes"/> interface to be filled.</param> /// <param name="source">The <see cref="XPathNavigator"/> to extract Atom common attribute information from.</param> /// <returns><b>true</b> if the <paramref name="target"/> was initialized using the supplied <paramref name="source"/>, otherwise <b>false</b>.</returns> /// <exception cref="ArgumentNullException">The <paramref name="target"/> 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> public static bool FillCommonObjectAttributes(IAtomCommonObjectAttributes target, XPathNavigator source) { bool wasLoaded = false; Guard.ArgumentNotNull(target, "target"); Guard.ArgumentNotNull(source, "source"); XmlNamespaceManager manager = AtomUtility.CreateNamespaceManager(source.NameTable); string xmlBaseAttribute = source.GetAttribute("base", manager.LookupNamespace("xml")); if (!String.IsNullOrEmpty(xmlBaseAttribute)) { Uri baseUri; if (Uri.TryCreate(xmlBaseAttribute, UriKind.RelativeOrAbsolute, out baseUri)) { target.BaseUri = baseUri; wasLoaded = true; } } string xmlLangAttribute = source.GetAttribute("lang", manager.LookupNamespace("xml")); if (!String.IsNullOrEmpty(xmlLangAttribute)) { try { CultureInfo language = new CultureInfo(source.XmlLang); target.Language = language; wasLoaded = true; } catch (ArgumentException) { System.Diagnostics.Trace.TraceWarning("Unable to determine CultureInfo with a name of {0}.", source.XmlLang); } } return(wasLoaded); }
/// <summary> /// Compares the current instance with another object of the same type. /// </summary> /// <param name="obj">An object to compare with this instance.</param> /// <returns>A 32-bit signed integer that indicates the relative order of the objects being compared.</returns> /// <exception cref="ArgumentException">The <paramref name="obj"/> is not the expected <see cref="Type"/>.</exception> public int CompareTo(object obj) { if (obj == null) { return(1); } AtomSource value = obj as AtomSource; if (value != null) { int result = AtomFeed.CompareSequence(this.Authors, value.Authors); result = result | AtomFeed.CompareSequence(this.Categories, value.Categories); result = result | AtomFeed.CompareSequence(this.Contributors, value.Contributors); if (this.Generator != null) { result = result | this.Generator.CompareTo(value.Generator); } else if (value.Generator != null) { result = result | -1; } if (this.Icon != null) { result = result | this.Icon.CompareTo(value.Icon); } else if (value.Icon != null) { result = result | -1; } if (this.Id != null) { result = result | this.Id.CompareTo(value.Id); } else if (value.Id != null) { result = result | -1; } result = result | AtomFeed.CompareSequence(this.Links, value.Links); if (this.Logo != null) { result = result | this.Logo.CompareTo(value.Logo); } else if (value.Logo != null) { result = result | -1; } if (this.Rights != null) { result = result | this.Rights.CompareTo(value.Rights); } else if (value.Rights != null) { result = result | -1; } if (this.Subtitle != null) { result = result | this.Subtitle.CompareTo(value.Subtitle); } else if (value.Subtitle != null) { result = result | -1; } if (this.Title != null) { result = result | this.Title.CompareTo(value.Title); } else if (value.Title != null) { result = result | -1; } result = result | this.UpdatedOn.CompareTo(value.UpdatedOn); result = result | AtomUtility.CompareCommonObjectAttributes(this, value); return(result); } else { throw new ArgumentException(String.Format(null, "obj is not of type {0}, type was found to be '{1}'.", this.GetType().FullName, obj.GetType().FullName), "obj"); } }
//============================================================ // PUBLIC METHODS //============================================================ #region Load(XPathNavigator source) /// <summary> /// Loads this <see cref="AtomLink"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <returns><b>true</b> if the <see cref="AtomLink"/> 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="AtomLink"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); //------------------------------------------------------------ // Attempt to extract common attributes information //------------------------------------------------------------ if (AtomUtility.FillCommonObjectAttributes(this, source)) { wasLoaded = true; } //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if (source.HasAttributes) { string hrefAttribute = source.GetAttribute("href", String.Empty); string relAttribute = source.GetAttribute("rel", String.Empty); string typeAttribute = source.GetAttribute("type", String.Empty); string hreflangAttribute = source.GetAttribute("hreflang", String.Empty); string titleAttribute = source.GetAttribute("title", String.Empty); string lengthAttribute = source.GetAttribute("length", String.Empty); if (!String.IsNullOrEmpty(hrefAttribute)) { Uri href; if (Uri.TryCreate(hrefAttribute, UriKind.RelativeOrAbsolute, out href)) { this.Uri = href; wasLoaded = true; } } if (!String.IsNullOrEmpty(relAttribute)) { this.Relation = relAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(typeAttribute)) { this.ContentType = typeAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(hreflangAttribute)) { try { CultureInfo language = new CultureInfo(hreflangAttribute); this.ContentLanguage = language; wasLoaded = true; } catch (ArgumentException) { System.Diagnostics.Trace.TraceWarning("AtomLink unable to determine CultureInfo with a name of {0}.", source.XmlLang); } } if (!String.IsNullOrEmpty(titleAttribute)) { this.Title = titleAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(lengthAttribute)) { long length; if (Int64.TryParse(lengthAttribute, NumberStyles.Integer, NumberFormatInfo.InvariantInfo, out length)) { this.Length = length; wasLoaded = true; } } } return(wasLoaded); }
//============================================================ // PUBLIC METHODS //============================================================ #region Load(XPathNavigator source) /// <summary> /// Loads this <see cref="AtomContent"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <returns><b>true</b> if the <see cref="AtomContent"/> 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="AtomContent"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); //------------------------------------------------------------ // Initialize XML namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = AtomUtility.CreateNamespaceManager(source.NameTable); //------------------------------------------------------------ // Attempt to extract common attributes information //------------------------------------------------------------ if (AtomUtility.FillCommonObjectAttributes(this, source)) { wasLoaded = true; } //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if (source.HasAttributes) { string typeAttribute = source.GetAttribute("type", String.Empty); string sourceAttribute = source.GetAttribute("src", String.Empty); if (!String.IsNullOrEmpty(typeAttribute)) { this.ContentType = typeAttribute; wasLoaded = true; } if (!String.IsNullOrEmpty(sourceAttribute)) { Uri src; if (Uri.TryCreate(sourceAttribute, UriKind.RelativeOrAbsolute, out src)) { this.Source = src; wasLoaded = true; } } } if (String.Compare(this.ContentType, "xhtml", StringComparison.OrdinalIgnoreCase) == 0) { XPathNavigator xhtmlDivNavigator = source.SelectSingleNode("xhtml:div", manager); if (xhtmlDivNavigator != null && !String.IsNullOrEmpty(xhtmlDivNavigator.Value)) { this.Content = xhtmlDivNavigator.InnerXml; wasLoaded = true; } } else if (!String.IsNullOrEmpty(source.Value)) { this.Content = source.Value; wasLoaded = true; } return(wasLoaded); }
//============================================================ // PUBLIC METHODS //============================================================ #region Load(XPathNavigator source) /// <summary> /// Loads this <see cref="AtomTextConstruct"/> using the supplied <see cref="XPathNavigator"/>. /// </summary> /// <param name="source">The <see cref="XPathNavigator"/> to extract information from.</param> /// <returns><b>true</b> if the <see cref="AtomTextConstruct"/> 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="AtomTextConstruct"/>. /// </remarks> /// <exception cref="ArgumentNullException">The <paramref name="source"/> is a null reference (Nothing in Visual Basic).</exception> public bool Load(XPathNavigator source) { //------------------------------------------------------------ // Local members //------------------------------------------------------------ bool wasLoaded = false; //------------------------------------------------------------ // Validate parameter //------------------------------------------------------------ Guard.ArgumentNotNull(source, "source"); //------------------------------------------------------------ // Initialize XML namespace resolver //------------------------------------------------------------ XmlNamespaceManager manager = AtomUtility.CreateNamespaceManager(source.NameTable); //------------------------------------------------------------ // Attempt to extract common attributes information //------------------------------------------------------------ if (AtomUtility.FillCommonObjectAttributes(this, source)) { wasLoaded = true; } //------------------------------------------------------------ // Attempt to extract syndication information //------------------------------------------------------------ if (source.HasAttributes) { string typeAttribute = source.GetAttribute("type", String.Empty); if (!String.IsNullOrEmpty(typeAttribute)) { AtomTextConstructType type = AtomTextConstruct.ConstructTypeByName(typeAttribute); if (type != AtomTextConstructType.None) { this.TextType = type; wasLoaded = true; } } } if (this.TextType == AtomTextConstructType.Xhtml) { XPathNavigator xhtmlDivNavigator = source.SelectSingleNode("xhtml:div", manager); if (xhtmlDivNavigator != null && !String.IsNullOrEmpty(xhtmlDivNavigator.Value)) { this.Content = xhtmlDivNavigator.Value; wasLoaded = true; } } else if (this.TextType == AtomTextConstructType.Html && !String.IsNullOrEmpty(source.InnerXml)) { this.Content = source.InnerXml; wasLoaded = true; } else if (!String.IsNullOrEmpty(source.Value)) { this.Content = source.Value; wasLoaded = true; } return(wasLoaded); }
/// <summary> /// Saves the current <see cref="AtomSource"/> 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("source", AtomUtility.AtomNamespace); AtomUtility.WriteCommonObjectAttributes(this, writer); if (this.Id != null) { this.Id.WriteTo(writer); } if (this.Title != null) { this.Title.WriteTo(writer, "title"); } if (this.UpdatedOn != DateTime.MinValue) { writer.WriteElementString("updated", AtomUtility.AtomNamespace, SyndicationDateTimeUtility.ToRfc3339DateTime(this.UpdatedOn)); } if (this.Generator != null) { this.Generator.WriteTo(writer); } if (this.Icon != null) { this.Icon.WriteTo(writer); } if (this.Logo != null) { this.Logo.WriteTo(writer); } if (this.Rights != null) { this.Rights.WriteTo(writer, "rights"); } if (this.Subtitle != null) { this.Subtitle.WriteTo(writer, "subtitle"); } foreach (AtomPersonConstruct author in this.Authors) { author.WriteTo(writer, "author"); } foreach (AtomCategory category in this.Categories) { category.WriteTo(writer); } foreach (AtomPersonConstruct contributor in this.Contributors) { contributor.WriteTo(writer, "contributor"); } foreach (AtomLink link in this.Links) { link.WriteTo(writer); } SyndicationExtensionAdapter.WriteExtensionsTo(this.Extensions, writer); writer.WriteEndElement(); }