mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
1343 lines
56 KiB
C#
1343 lines
56 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Syndication
|
|
{
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Collections.ObjectModel;
|
|
using System.Globalization;
|
|
using System.Text;
|
|
using System.Xml;
|
|
using System.Xml.Serialization;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Xml.Schema;
|
|
using System.Collections;
|
|
using DiagnosticUtility = System.ServiceModel.DiagnosticUtility;
|
|
using System.ServiceModel.Channels;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
[TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
|
|
[XmlRoot(ElementName = Atom10Constants.FeedTag, Namespace = Atom10Constants.Atom10Namespace)]
|
|
public class Atom10FeedFormatter : SyndicationFeedFormatter, IXmlSerializable
|
|
{
|
|
internal static readonly TimeSpan zeroOffset = new TimeSpan(0, 0, 0);
|
|
internal const string XmlNs = "http://www.w3.org/XML/1998/namespace";
|
|
internal const string XmlNsNs = "http://www.w3.org/2000/xmlns/";
|
|
static readonly XmlQualifiedName Atom10Href = new XmlQualifiedName(Atom10Constants.HrefTag, string.Empty);
|
|
static readonly XmlQualifiedName Atom10Label = new XmlQualifiedName(Atom10Constants.LabelTag, string.Empty);
|
|
static readonly XmlQualifiedName Atom10Length = new XmlQualifiedName(Atom10Constants.LengthTag, string.Empty);
|
|
static readonly XmlQualifiedName Atom10Relative = new XmlQualifiedName(Atom10Constants.RelativeTag, string.Empty);
|
|
static readonly XmlQualifiedName Atom10Scheme = new XmlQualifiedName(Atom10Constants.SchemeTag, string.Empty);
|
|
static readonly XmlQualifiedName Atom10Term = new XmlQualifiedName(Atom10Constants.TermTag, string.Empty);
|
|
static readonly XmlQualifiedName Atom10Title = new XmlQualifiedName(Atom10Constants.TitleTag, string.Empty);
|
|
static readonly XmlQualifiedName Atom10Type = new XmlQualifiedName(Atom10Constants.TypeTag, string.Empty);
|
|
static readonly UriGenerator idGenerator = new UriGenerator();
|
|
const string Rfc3339LocalDateTimeFormat = "yyyy-MM-ddTHH:mm:sszzz";
|
|
const string Rfc3339UTCDateTimeFormat = "yyyy-MM-ddTHH:mm:ssZ";
|
|
Type feedType;
|
|
int maxExtensionSize;
|
|
bool preserveAttributeExtensions;
|
|
bool preserveElementExtensions;
|
|
|
|
public Atom10FeedFormatter()
|
|
: this(typeof(SyndicationFeed))
|
|
{
|
|
}
|
|
|
|
public Atom10FeedFormatter(Type feedTypeToCreate)
|
|
: base()
|
|
{
|
|
if (feedTypeToCreate == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feedTypeToCreate");
|
|
}
|
|
if (!typeof(SyndicationFeed).IsAssignableFrom(feedTypeToCreate))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("feedTypeToCreate",
|
|
SR.GetString(SR.InvalidObjectTypePassed, "feedTypeToCreate", "SyndicationFeed"));
|
|
}
|
|
this.maxExtensionSize = int.MaxValue;
|
|
this.preserveAttributeExtensions = this.preserveElementExtensions = true;
|
|
this.feedType = feedTypeToCreate;
|
|
}
|
|
|
|
public Atom10FeedFormatter(SyndicationFeed feedToWrite)
|
|
: base(feedToWrite)
|
|
{
|
|
// No need to check that the parameter passed is valid - it is checked by the c'tor of the base class
|
|
this.maxExtensionSize = int.MaxValue;
|
|
preserveAttributeExtensions = preserveElementExtensions = true;
|
|
this.feedType = feedToWrite.GetType();
|
|
}
|
|
|
|
public bool PreserveAttributeExtensions
|
|
{
|
|
get { return this.preserveAttributeExtensions; }
|
|
set { this.preserveAttributeExtensions = value; }
|
|
}
|
|
|
|
public bool PreserveElementExtensions
|
|
{
|
|
get { return this.preserveElementExtensions; }
|
|
set { this.preserveElementExtensions = value; }
|
|
}
|
|
|
|
public override string Version
|
|
{
|
|
get { return SyndicationVersions.Atom10; }
|
|
}
|
|
|
|
protected Type FeedType
|
|
{
|
|
get
|
|
{
|
|
return this.feedType;
|
|
}
|
|
}
|
|
|
|
public override bool CanRead(XmlReader reader)
|
|
{
|
|
if (reader == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
|
|
}
|
|
return reader.IsStartElement(Atom10Constants.FeedTag, Atom10Constants.Atom10Namespace);
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The IXmlSerializable implementation is only for exposing under WCF DataContractSerializer. The funcionality is exposed to derived class through the ReadFrom\\WriteTo methods")]
|
|
XmlSchema IXmlSerializable.GetSchema()
|
|
{
|
|
return null;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The IXmlSerializable implementation is only for exposing under WCF DataContractSerializer. The funcionality is exposed to derived class through the ReadFrom\\WriteTo methods")]
|
|
void IXmlSerializable.ReadXml(XmlReader reader)
|
|
{
|
|
if (reader == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
|
|
}
|
|
TraceFeedReadBegin();
|
|
ReadFeed(reader);
|
|
TraceFeedReadEnd();
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1033:InterfaceMethodsShouldBeCallableByChildTypes", Justification = "The IXmlSerializable implementation is only for exposing under WCF DataContractSerializer. The funcionality is exposed to derived class through the ReadFrom\\WriteTo methods")]
|
|
void IXmlSerializable.WriteXml(XmlWriter writer)
|
|
{
|
|
if (writer == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
|
|
}
|
|
TraceFeedWriteBegin();
|
|
WriteFeed(writer);
|
|
TraceFeedWriteEnd();
|
|
}
|
|
|
|
public override void ReadFrom(XmlReader reader)
|
|
{
|
|
TraceFeedReadBegin();
|
|
if (!CanRead(reader))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnknownFeedXml, reader.LocalName, reader.NamespaceURI)));
|
|
}
|
|
ReadFeed(reader);
|
|
TraceFeedReadEnd();
|
|
}
|
|
|
|
public override void WriteTo(XmlWriter writer)
|
|
{
|
|
if (writer == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
|
|
}
|
|
TraceFeedWriteBegin();
|
|
writer.WriteStartElement(Atom10Constants.FeedTag, Atom10Constants.Atom10Namespace);
|
|
WriteFeed(writer);
|
|
writer.WriteEndElement();
|
|
TraceFeedWriteEnd();
|
|
}
|
|
|
|
internal static void ReadCategory(XmlReader reader, SyndicationCategory category, string version, bool preserveAttributeExtensions, bool preserveElementExtensions, int maxExtensionSize)
|
|
{
|
|
MoveToStartElement(reader);
|
|
bool isEmpty = reader.IsEmptyElement;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (reader.LocalName == Atom10Constants.TermTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
category.Name = reader.Value;
|
|
}
|
|
else if (reader.LocalName == Atom10Constants.SchemeTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
category.Scheme = reader.Value;
|
|
}
|
|
else if (reader.LocalName == Atom10Constants.LabelTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
category.Label = reader.Value;
|
|
}
|
|
else
|
|
{
|
|
string ns = reader.NamespaceURI;
|
|
string name = reader.LocalName;
|
|
if (FeedUtils.IsXmlns(name, ns))
|
|
{
|
|
continue;
|
|
}
|
|
string val = reader.Value;
|
|
if (!TryParseAttribute(name, ns, val, category, version))
|
|
|
|
{
|
|
if (preserveAttributeExtensions)
|
|
{
|
|
category.AttributeExtensions.Add(new XmlQualifiedName(name, ns), val);
|
|
}
|
|
else
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!isEmpty)
|
|
{
|
|
reader.ReadStartElement();
|
|
XmlBuffer buffer = null;
|
|
XmlDictionaryWriter extWriter = null;
|
|
try
|
|
{
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (TryParseElement(reader, category, version))
|
|
{
|
|
continue;
|
|
}
|
|
else if (!preserveElementExtensions)
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
reader.Skip();
|
|
}
|
|
else
|
|
{
|
|
CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
|
|
}
|
|
}
|
|
LoadElementExtensions(buffer, extWriter, category);
|
|
}
|
|
finally
|
|
{
|
|
if (extWriter != null)
|
|
{
|
|
((IDisposable) extWriter).Dispose();
|
|
}
|
|
}
|
|
reader.ReadEndElement();
|
|
}
|
|
else
|
|
{
|
|
reader.ReadStartElement();
|
|
}
|
|
}
|
|
|
|
internal static TextSyndicationContent ReadTextContentFrom(XmlReader reader, string context, bool preserveAttributeExtensions)
|
|
{
|
|
string type = reader.GetAttribute(Atom10Constants.TypeTag);
|
|
return ReadTextContentFromHelper(reader, type, context, preserveAttributeExtensions);
|
|
}
|
|
|
|
internal static void WriteCategory(XmlWriter writer, SyndicationCategory category, string version)
|
|
{
|
|
writer.WriteStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace);
|
|
WriteAttributeExtensions(writer, category, version);
|
|
string categoryName = category.Name ?? string.Empty;
|
|
if (!category.AttributeExtensions.ContainsKey(Atom10Term))
|
|
{
|
|
writer.WriteAttributeString(Atom10Constants.TermTag, categoryName);
|
|
}
|
|
if (!string.IsNullOrEmpty(category.Label) && !category.AttributeExtensions.ContainsKey(Atom10Label))
|
|
{
|
|
writer.WriteAttributeString(Atom10Constants.LabelTag, category.Label);
|
|
}
|
|
if (!string.IsNullOrEmpty(category.Scheme) && !category.AttributeExtensions.ContainsKey(Atom10Scheme))
|
|
{
|
|
writer.WriteAttributeString(Atom10Constants.SchemeTag, category.Scheme);
|
|
}
|
|
WriteElementExtensions(writer, category, version);
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
internal void ReadItemFrom(XmlReader reader, SyndicationItem result)
|
|
{
|
|
ReadItemFrom(reader, result, null);
|
|
}
|
|
|
|
internal bool TryParseFeedElementFrom(XmlReader reader, SyndicationFeed result)
|
|
{
|
|
if (reader.IsStartElement(Atom10Constants.AuthorTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Authors.Add(ReadPersonFrom(reader, result));
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Categories.Add(ReadCategoryFrom(reader, result));
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.ContributorTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Contributors.Add(ReadPersonFrom(reader, result));
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.GeneratorTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Generator = reader.ReadElementString();
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.IdTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Id = reader.ReadElementString();
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.LinkTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Links.Add(ReadLinkFrom(reader, result));
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.LogoTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.ImageUrl = new Uri(reader.ReadElementString(), UriKind.RelativeOrAbsolute);
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.RightsTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Copyright = ReadTextContentFrom(reader, "//atom:feed/atom:rights[@type]");
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.SubtitleTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Description = ReadTextContentFrom(reader, "//atom:feed/atom:subtitle[@type]");
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Title = ReadTextContentFrom(reader, "//atom:feed/atom:title[@type]");
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.UpdatedTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
reader.ReadStartElement();
|
|
result.LastUpdatedTime = DateFromString(reader.ReadString(), reader);
|
|
reader.ReadEndElement();
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
internal bool TryParseItemElementFrom(XmlReader reader, SyndicationItem result)
|
|
{
|
|
if (reader.IsStartElement(Atom10Constants.AuthorTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Authors.Add(ReadPersonFrom(reader, result));
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Categories.Add(ReadCategoryFrom(reader, result));
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.ContentTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Content = ReadContentFrom(reader, result);
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.ContributorTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Contributors.Add(ReadPersonFrom(reader, result));
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.IdTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Id = reader.ReadElementString();
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.LinkTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Links.Add(ReadLinkFrom(reader, result));
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.PublishedTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
reader.ReadStartElement();
|
|
result.PublishDate = DateFromString(reader.ReadString(), reader);
|
|
reader.ReadEndElement();
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.RightsTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Copyright = ReadTextContentFrom(reader, "//atom:feed/atom:entry/atom:rights[@type]");
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.SourceFeedTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
reader.ReadStartElement();
|
|
result.SourceFeed = ReadFeedFrom(reader, new SyndicationFeed(), true); // isSourceFeed
|
|
reader.ReadEndElement();
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.SummaryTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Summary = ReadTextContentFrom(reader, "//atom:feed/atom:entry/atom:summary[@type]");
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Title = ReadTextContentFrom(reader, "//atom:feed/atom:entry/atom:title[@type]");
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.UpdatedTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
reader.ReadStartElement();
|
|
result.LastUpdatedTime = DateFromString(reader.ReadString(), reader);
|
|
reader.ReadEndElement();
|
|
}
|
|
else
|
|
{
|
|
return false;
|
|
}
|
|
return true;
|
|
}
|
|
|
|
internal void WriteContentTo(XmlWriter writer, string elementName, SyndicationContent content)
|
|
{
|
|
if (content != null)
|
|
{
|
|
content.WriteTo(writer, elementName, Atom10Constants.Atom10Namespace);
|
|
}
|
|
}
|
|
|
|
internal void WriteElement(XmlWriter writer, string elementName, string value)
|
|
{
|
|
if (value != null)
|
|
{
|
|
writer.WriteElementString(elementName, Atom10Constants.Atom10Namespace, value);
|
|
}
|
|
}
|
|
|
|
internal void WriteFeedAuthorsTo(XmlWriter writer, Collection<SyndicationPerson> authors)
|
|
{
|
|
for (int i = 0; i < authors.Count; ++i)
|
|
{
|
|
SyndicationPerson p = authors[i];
|
|
WritePersonTo(writer, p, Atom10Constants.AuthorTag);
|
|
}
|
|
}
|
|
|
|
internal void WriteFeedContributorsTo(XmlWriter writer, Collection<SyndicationPerson> contributors)
|
|
{
|
|
for (int i = 0; i < contributors.Count; ++i)
|
|
{
|
|
SyndicationPerson p = contributors[i];
|
|
WritePersonTo(writer, p, Atom10Constants.ContributorTag);
|
|
}
|
|
}
|
|
|
|
internal void WriteFeedLastUpdatedTimeTo(XmlWriter writer, DateTimeOffset lastUpdatedTime, bool isRequired)
|
|
{
|
|
if (lastUpdatedTime == DateTimeOffset.MinValue && isRequired)
|
|
{
|
|
lastUpdatedTime = DateTimeOffset.UtcNow;
|
|
}
|
|
if (lastUpdatedTime != DateTimeOffset.MinValue)
|
|
{
|
|
WriteElement(writer, Atom10Constants.UpdatedTag, AsString(lastUpdatedTime));
|
|
}
|
|
}
|
|
|
|
internal void WriteItemAuthorsTo(XmlWriter writer, Collection<SyndicationPerson> authors)
|
|
{
|
|
for (int i = 0; i < authors.Count; ++i)
|
|
{
|
|
SyndicationPerson p = authors[i];
|
|
WritePersonTo(writer, p, Atom10Constants.AuthorTag);
|
|
}
|
|
}
|
|
|
|
internal void WriteItemContents(XmlWriter dictWriter, SyndicationItem item)
|
|
{
|
|
WriteItemContents(dictWriter, item, null);
|
|
}
|
|
|
|
internal void WriteItemContributorsTo(XmlWriter writer, Collection<SyndicationPerson> contributors)
|
|
{
|
|
for (int i = 0; i < contributors.Count; ++i)
|
|
{
|
|
SyndicationPerson p = contributors[i];
|
|
WritePersonTo(writer, p, Atom10Constants.ContributorTag);
|
|
}
|
|
}
|
|
|
|
internal void WriteItemLastUpdatedTimeTo(XmlWriter writer, DateTimeOffset lastUpdatedTime)
|
|
{
|
|
if (lastUpdatedTime == DateTimeOffset.MinValue)
|
|
{
|
|
lastUpdatedTime = DateTimeOffset.UtcNow;
|
|
}
|
|
writer.WriteElementString(Atom10Constants.UpdatedTag,
|
|
Atom10Constants.Atom10Namespace,
|
|
AsString(lastUpdatedTime));
|
|
}
|
|
|
|
internal void WriteLink(XmlWriter writer, SyndicationLink link, Uri baseUri)
|
|
{
|
|
writer.WriteStartElement(Atom10Constants.LinkTag, Atom10Constants.Atom10Namespace);
|
|
Uri baseUriToWrite = FeedUtils.GetBaseUriToWrite(baseUri, link.BaseUri);
|
|
if (baseUriToWrite != null)
|
|
{
|
|
writer.WriteAttributeString("xml", "base", XmlNs, FeedUtils.GetUriString(baseUriToWrite));
|
|
}
|
|
link.WriteAttributeExtensions(writer, SyndicationVersions.Atom10);
|
|
if (!string.IsNullOrEmpty(link.RelationshipType) && !link.AttributeExtensions.ContainsKey(Atom10Relative))
|
|
{
|
|
writer.WriteAttributeString(Atom10Constants.RelativeTag, link.RelationshipType);
|
|
}
|
|
if (!string.IsNullOrEmpty(link.MediaType) && !link.AttributeExtensions.ContainsKey(Atom10Type))
|
|
{
|
|
writer.WriteAttributeString(Atom10Constants.TypeTag, link.MediaType);
|
|
}
|
|
if (!string.IsNullOrEmpty(link.Title) && !link.AttributeExtensions.ContainsKey(Atom10Title))
|
|
{
|
|
writer.WriteAttributeString(Atom10Constants.TitleTag, link.Title);
|
|
}
|
|
if (link.Length != 0 && !link.AttributeExtensions.ContainsKey(Atom10Length))
|
|
{
|
|
writer.WriteAttributeString(Atom10Constants.LengthTag, Convert.ToString(link.Length, CultureInfo.InvariantCulture));
|
|
}
|
|
if (!link.AttributeExtensions.ContainsKey(Atom10Href))
|
|
{
|
|
writer.WriteAttributeString(Atom10Constants.HrefTag, FeedUtils.GetUriString(link.Uri));
|
|
}
|
|
link.WriteElementExtensions(writer, SyndicationVersions.Atom10);
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
protected override SyndicationFeed CreateFeedInstance()
|
|
{
|
|
return SyndicationFeedFormatter.CreateFeedInstance(this.feedType);
|
|
}
|
|
|
|
protected virtual SyndicationItem ReadItem(XmlReader reader, SyndicationFeed feed)
|
|
{
|
|
if (feed == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
|
|
}
|
|
if (reader == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
|
|
}
|
|
SyndicationItem item = CreateItem(feed);
|
|
TraceItemReadBegin();
|
|
ReadItemFrom(reader, item, feed.BaseUri);
|
|
TraceItemReadEnd();
|
|
return item;
|
|
}
|
|
|
|
[SuppressMessage("Microsoft.Design", "CA1021:AvoidOutParameters", MessageId = "2#", Justification = "The out parameter is needed to enable implementations that read in items from the stream on demand")]
|
|
protected virtual IEnumerable<SyndicationItem> ReadItems(XmlReader reader, SyndicationFeed feed, out bool areAllItemsRead)
|
|
{
|
|
if (feed == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("feed");
|
|
}
|
|
if (reader == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
|
|
}
|
|
NullNotAllowedCollection<SyndicationItem> items = new NullNotAllowedCollection<SyndicationItem>();
|
|
while (reader.IsStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
items.Add(ReadItem(reader, feed));
|
|
}
|
|
areAllItemsRead = true;
|
|
return items;
|
|
}
|
|
|
|
protected virtual void WriteItem(XmlWriter writer, SyndicationItem item, Uri feedBaseUri)
|
|
{
|
|
TraceItemWriteBegin();
|
|
writer.WriteStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace);
|
|
WriteItemContents(writer, item, feedBaseUri);
|
|
writer.WriteEndElement();
|
|
TraceItemWriteEnd();
|
|
}
|
|
|
|
protected virtual void WriteItems(XmlWriter writer, IEnumerable<SyndicationItem> items, Uri feedBaseUri)
|
|
{
|
|
if (items == null)
|
|
{
|
|
return;
|
|
}
|
|
foreach (SyndicationItem item in items)
|
|
{
|
|
this.WriteItem(writer, item, feedBaseUri);
|
|
}
|
|
}
|
|
|
|
static TextSyndicationContent ReadTextContentFromHelper(XmlReader reader, string type, string context, bool preserveAttributeExtensions)
|
|
{
|
|
if (string.IsNullOrEmpty(type))
|
|
{
|
|
type = Atom10Constants.PlaintextType;
|
|
}
|
|
|
|
TextSyndicationContentKind kind;
|
|
switch (type)
|
|
{
|
|
case Atom10Constants.PlaintextType:
|
|
kind = TextSyndicationContentKind.Plaintext;
|
|
break;
|
|
case Atom10Constants.HtmlType:
|
|
kind = TextSyndicationContentKind.Html;
|
|
break;
|
|
case Atom10Constants.XHtmlType:
|
|
kind = TextSyndicationContentKind.XHtml;
|
|
break;
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.GetString(SR.Atom10SpecRequiresTextConstruct, context, type))));
|
|
}
|
|
|
|
Dictionary<XmlQualifiedName, string> attrs = null;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (reader.LocalName == Atom10Constants.TypeTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
continue;
|
|
}
|
|
string ns = reader.NamespaceURI;
|
|
string name = reader.LocalName;
|
|
if (FeedUtils.IsXmlns(name, ns))
|
|
{
|
|
continue;
|
|
}
|
|
if (preserveAttributeExtensions)
|
|
{
|
|
string value = reader.Value;
|
|
if (attrs == null)
|
|
{
|
|
attrs = new Dictionary<XmlQualifiedName, string>();
|
|
}
|
|
attrs.Add(new XmlQualifiedName(name, ns), value);
|
|
}
|
|
else
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
reader.MoveToElement();
|
|
string val = (kind == TextSyndicationContentKind.XHtml) ? reader.ReadInnerXml() : reader.ReadElementString();
|
|
TextSyndicationContent result = new TextSyndicationContent(val, kind);
|
|
if (attrs != null)
|
|
{
|
|
foreach (XmlQualifiedName attr in attrs.Keys)
|
|
{
|
|
if (!FeedUtils.IsXmlns(attr.Name, attr.Namespace))
|
|
{
|
|
result.AttributeExtensions.Add(attr, attrs[attr]);
|
|
}
|
|
}
|
|
}
|
|
return result;
|
|
}
|
|
|
|
string AsString(DateTimeOffset dateTime)
|
|
{
|
|
if (dateTime.Offset == zeroOffset)
|
|
{
|
|
return dateTime.ToUniversalTime().ToString(Rfc3339UTCDateTimeFormat, CultureInfo.InvariantCulture);
|
|
}
|
|
else
|
|
{
|
|
return dateTime.ToString(Rfc3339LocalDateTimeFormat, CultureInfo.InvariantCulture);
|
|
}
|
|
}
|
|
|
|
DateTimeOffset DateFromString(string dateTimeString, XmlReader reader)
|
|
{
|
|
dateTimeString = dateTimeString.Trim();
|
|
if (dateTimeString.Length < 20)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new XmlException(FeedUtils.AddLineInfo(reader,
|
|
SR.ErrorParsingDateTime)));
|
|
}
|
|
if (dateTimeString[19] == '.')
|
|
{
|
|
// remove any fractional seconds, we choose to ignore them
|
|
int i = 20;
|
|
while (dateTimeString.Length > i && char.IsDigit(dateTimeString[i]))
|
|
{
|
|
++i;
|
|
}
|
|
dateTimeString = dateTimeString.Substring(0, 19) + dateTimeString.Substring(i);
|
|
}
|
|
DateTimeOffset localTime;
|
|
if (DateTimeOffset.TryParseExact(dateTimeString, Rfc3339LocalDateTimeFormat,
|
|
CultureInfo.InvariantCulture.DateTimeFormat,
|
|
DateTimeStyles.None, out localTime))
|
|
{
|
|
return localTime;
|
|
}
|
|
DateTimeOffset utcTime;
|
|
if (DateTimeOffset.TryParseExact(dateTimeString, Rfc3339UTCDateTimeFormat,
|
|
CultureInfo.InvariantCulture.DateTimeFormat,
|
|
DateTimeStyles.AssumeUniversal | DateTimeStyles.AdjustToUniversal, out utcTime))
|
|
{
|
|
return utcTime;
|
|
}
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(
|
|
new XmlException(FeedUtils.AddLineInfo(reader,
|
|
SR.ErrorParsingDateTime)));
|
|
}
|
|
|
|
void ReadCategory(XmlReader reader, SyndicationCategory category)
|
|
{
|
|
ReadCategory(reader, category, this.Version, this.PreserveAttributeExtensions, this.PreserveElementExtensions, this.maxExtensionSize);
|
|
}
|
|
|
|
SyndicationCategory ReadCategoryFrom(XmlReader reader, SyndicationFeed feed)
|
|
{
|
|
SyndicationCategory result = CreateCategory(feed);
|
|
ReadCategory(reader, result);
|
|
return result;
|
|
}
|
|
|
|
SyndicationCategory ReadCategoryFrom(XmlReader reader, SyndicationItem item)
|
|
{
|
|
SyndicationCategory result = CreateCategory(item);
|
|
ReadCategory(reader, result);
|
|
return result;
|
|
}
|
|
|
|
SyndicationContent ReadContentFrom(XmlReader reader, SyndicationItem item)
|
|
{
|
|
MoveToStartElement(reader);
|
|
string type = reader.GetAttribute(Atom10Constants.TypeTag, string.Empty);
|
|
|
|
SyndicationContent result;
|
|
if (TryParseContent(reader, item, type, this.Version, out result))
|
|
{
|
|
return result;
|
|
}
|
|
|
|
if (string.IsNullOrEmpty(type))
|
|
{
|
|
type = Atom10Constants.PlaintextType;
|
|
}
|
|
string src = reader.GetAttribute(Atom10Constants.SourceTag, string.Empty);
|
|
|
|
if (string.IsNullOrEmpty(src) && type != Atom10Constants.PlaintextType && type != Atom10Constants.HtmlType && type != Atom10Constants.XHtmlType)
|
|
{
|
|
return new XmlSyndicationContent(reader);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(src))
|
|
{
|
|
result = new UrlSyndicationContent(new Uri(src, UriKind.RelativeOrAbsolute), type);
|
|
bool isEmpty = reader.IsEmptyElement;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (reader.LocalName == Atom10Constants.TypeTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
continue;
|
|
}
|
|
else if (reader.LocalName == Atom10Constants.SourceTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
continue;
|
|
}
|
|
else if (!FeedUtils.IsXmlns(reader.LocalName, reader.NamespaceURI))
|
|
{
|
|
if (this.preserveAttributeExtensions)
|
|
{
|
|
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
|
|
}
|
|
else
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
reader.ReadStartElement();
|
|
if (!isEmpty)
|
|
{
|
|
reader.ReadEndElement();
|
|
}
|
|
return result;
|
|
}
|
|
else
|
|
{
|
|
return ReadTextContentFromHelper(reader, type, "//atom:feed/atom:entry/atom:content[@type]", this.preserveAttributeExtensions);
|
|
}
|
|
}
|
|
|
|
void ReadFeed(XmlReader reader)
|
|
{
|
|
SetFeed(CreateFeedInstance());
|
|
ReadFeedFrom(reader, this.Feed, false);
|
|
}
|
|
|
|
SyndicationFeed ReadFeedFrom(XmlReader reader, SyndicationFeed result, bool isSourceFeed)
|
|
{
|
|
reader.MoveToContent();
|
|
try
|
|
{
|
|
bool elementIsEmpty = false;
|
|
if (!isSourceFeed)
|
|
{
|
|
MoveToStartElement(reader);
|
|
elementIsEmpty = reader.IsEmptyElement;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (reader.LocalName == "lang" && reader.NamespaceURI == XmlNs)
|
|
{
|
|
result.Language = reader.Value;
|
|
}
|
|
else if (reader.LocalName == "base" && reader.NamespaceURI == XmlNs)
|
|
{
|
|
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
|
|
}
|
|
else
|
|
{
|
|
string ns = reader.NamespaceURI;
|
|
string name = reader.LocalName;
|
|
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
|
|
{
|
|
continue;
|
|
}
|
|
string val = reader.Value;
|
|
if (!TryParseAttribute(name, ns, val, result, this.Version))
|
|
{
|
|
if (this.preserveAttributeExtensions)
|
|
{
|
|
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
|
|
}
|
|
else
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
reader.ReadStartElement();
|
|
}
|
|
|
|
XmlBuffer buffer = null;
|
|
XmlDictionaryWriter extWriter = null;
|
|
bool areAllItemsRead = true;
|
|
bool readItemsAtLeastOnce = false;
|
|
|
|
if (!elementIsEmpty)
|
|
{
|
|
try
|
|
{
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (TryParseFeedElementFrom(reader, result))
|
|
{
|
|
// nothing, we parsed something, great
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.EntryTag, Atom10Constants.Atom10Namespace) && !isSourceFeed)
|
|
{
|
|
if (readItemsAtLeastOnce)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperWarning(new InvalidOperationException(SR.GetString(SR.FeedHasNonContiguousItems, this.GetType().ToString())));
|
|
}
|
|
result.Items = ReadItems(reader, result, out areAllItemsRead);
|
|
readItemsAtLeastOnce = true;
|
|
// if the derived class is reading the items lazily, then stop reading from the stream
|
|
if (!areAllItemsRead)
|
|
{
|
|
break;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (!TryParseElement(reader, result, this.Version))
|
|
{
|
|
if (this.preserveElementExtensions)
|
|
{
|
|
CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
|
|
}
|
|
else
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
reader.Skip();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
LoadElementExtensions(buffer, extWriter, result);
|
|
}
|
|
finally
|
|
{
|
|
if (extWriter != null)
|
|
{
|
|
((IDisposable)extWriter).Dispose();
|
|
}
|
|
}
|
|
}
|
|
if (!isSourceFeed && areAllItemsRead)
|
|
{
|
|
reader.ReadEndElement(); // feed
|
|
}
|
|
}
|
|
catch (FormatException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingFeed), e));
|
|
}
|
|
catch (ArgumentException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingFeed), e));
|
|
}
|
|
return result;
|
|
}
|
|
|
|
void ReadItemFrom(XmlReader reader, SyndicationItem result, Uri feedBaseUri)
|
|
{
|
|
try
|
|
{
|
|
result.BaseUri = feedBaseUri;
|
|
MoveToStartElement(reader);
|
|
bool isEmpty = reader.IsEmptyElement;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
string ns = reader.NamespaceURI;
|
|
string name = reader.LocalName;
|
|
if (name == "base" && ns == XmlNs)
|
|
{
|
|
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
|
|
continue;
|
|
}
|
|
if (FeedUtils.IsXmlns(name, ns) || FeedUtils.IsXmlSchemaType(name, ns))
|
|
{
|
|
continue;
|
|
}
|
|
string val = reader.Value;
|
|
if (!TryParseAttribute(name, ns, val, result, this.Version))
|
|
{
|
|
if (this.preserveAttributeExtensions)
|
|
{
|
|
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
|
|
}
|
|
else
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
reader.ReadStartElement();
|
|
if (!isEmpty)
|
|
{
|
|
XmlBuffer buffer = null;
|
|
XmlDictionaryWriter extWriter = null;
|
|
try
|
|
{
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (TryParseItemElementFrom(reader, result))
|
|
{
|
|
// nothing, we parsed something, great
|
|
}
|
|
else
|
|
{
|
|
if (!TryParseElement(reader, result, this.Version))
|
|
{
|
|
if (this.preserveElementExtensions)
|
|
{
|
|
CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
|
|
}
|
|
else
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
reader.Skip();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
LoadElementExtensions(buffer, extWriter, result);
|
|
}
|
|
finally
|
|
{
|
|
if (extWriter != null)
|
|
{
|
|
((IDisposable) extWriter).Dispose();
|
|
}
|
|
}
|
|
reader.ReadEndElement(); // item
|
|
}
|
|
}
|
|
catch (FormatException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingItem), e));
|
|
}
|
|
catch (ArgumentException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingItem), e));
|
|
}
|
|
}
|
|
|
|
void ReadLink(XmlReader reader, SyndicationLink link, Uri baseUri)
|
|
{
|
|
bool isEmpty = reader.IsEmptyElement;
|
|
string mediaType = null;
|
|
string relationship = null;
|
|
string title = null;
|
|
string lengthStr = null;
|
|
string val = null;
|
|
link.BaseUri = baseUri;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (reader.LocalName == "base" && reader.NamespaceURI == XmlNs)
|
|
{
|
|
link.BaseUri = FeedUtils.CombineXmlBase(link.BaseUri, reader.Value);
|
|
}
|
|
else if (reader.LocalName == Atom10Constants.TypeTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
mediaType = reader.Value;
|
|
}
|
|
else if (reader.LocalName == Atom10Constants.RelativeTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
relationship = reader.Value;
|
|
}
|
|
else if (reader.LocalName == Atom10Constants.TitleTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
title = reader.Value;
|
|
}
|
|
else if (reader.LocalName == Atom10Constants.LengthTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
lengthStr = reader.Value;
|
|
}
|
|
else if (reader.LocalName == Atom10Constants.HrefTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
val = reader.Value;
|
|
}
|
|
else if (!FeedUtils.IsXmlns(reader.LocalName, reader.NamespaceURI))
|
|
{
|
|
if (this.preserveAttributeExtensions)
|
|
{
|
|
link.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
|
|
}
|
|
else
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
long length = 0;
|
|
if (!string.IsNullOrEmpty(lengthStr))
|
|
{
|
|
length = Convert.ToInt64(lengthStr, CultureInfo.InvariantCulture.NumberFormat);
|
|
}
|
|
reader.ReadStartElement();
|
|
if (!isEmpty)
|
|
{
|
|
XmlBuffer buffer = null;
|
|
XmlDictionaryWriter extWriter = null;
|
|
try
|
|
{
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (TryParseElement(reader, link, this.Version))
|
|
{
|
|
continue;
|
|
}
|
|
else if (!this.preserveElementExtensions)
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
reader.Skip();
|
|
}
|
|
else
|
|
{
|
|
CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
|
|
}
|
|
}
|
|
LoadElementExtensions(buffer, extWriter, link);
|
|
}
|
|
finally
|
|
{
|
|
if (extWriter != null)
|
|
{
|
|
((IDisposable) extWriter).Dispose();
|
|
}
|
|
}
|
|
reader.ReadEndElement();
|
|
}
|
|
link.Length = length;
|
|
link.MediaType = mediaType;
|
|
link.RelationshipType = relationship;
|
|
link.Title = title;
|
|
link.Uri = (val != null) ? new Uri(val, UriKind.RelativeOrAbsolute) : null;
|
|
}
|
|
|
|
SyndicationLink ReadLinkFrom(XmlReader reader, SyndicationFeed feed)
|
|
{
|
|
SyndicationLink result = CreateLink(feed);
|
|
ReadLink(reader, result, feed.BaseUri);
|
|
return result;
|
|
}
|
|
|
|
SyndicationLink ReadLinkFrom(XmlReader reader, SyndicationItem item)
|
|
{
|
|
SyndicationLink result = CreateLink(item);
|
|
ReadLink(reader, result, item.BaseUri);
|
|
return result;
|
|
}
|
|
|
|
SyndicationPerson ReadPersonFrom(XmlReader reader, SyndicationFeed feed)
|
|
{
|
|
SyndicationPerson result = CreatePerson(feed);
|
|
ReadPersonFrom(reader, result);
|
|
return result;
|
|
}
|
|
|
|
SyndicationPerson ReadPersonFrom(XmlReader reader, SyndicationItem item)
|
|
{
|
|
SyndicationPerson result = CreatePerson(item);
|
|
ReadPersonFrom(reader, result);
|
|
return result;
|
|
}
|
|
|
|
void ReadPersonFrom(XmlReader reader, SyndicationPerson result)
|
|
{
|
|
bool isEmpty = reader.IsEmptyElement;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
string ns = reader.NamespaceURI;
|
|
string name = reader.LocalName;
|
|
if (FeedUtils.IsXmlns(name, ns))
|
|
{
|
|
continue;
|
|
}
|
|
string val = reader.Value;
|
|
if (!TryParseAttribute(name, ns, val, result, this.Version))
|
|
{
|
|
if (this.preserveAttributeExtensions)
|
|
{
|
|
result.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
|
|
}
|
|
else
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
reader.ReadStartElement();
|
|
if (!isEmpty)
|
|
{
|
|
XmlBuffer buffer = null;
|
|
XmlDictionaryWriter extWriter = null;
|
|
try
|
|
{
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (reader.IsStartElement(Atom10Constants.NameTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Name = reader.ReadElementString();
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.UriTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Uri = reader.ReadElementString();
|
|
}
|
|
else if (reader.IsStartElement(Atom10Constants.EmailTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Email = reader.ReadElementString();
|
|
}
|
|
else
|
|
{
|
|
if (!TryParseElement(reader, result, this.Version))
|
|
{
|
|
if (this.preserveElementExtensions)
|
|
{
|
|
CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
|
|
}
|
|
else
|
|
{
|
|
TraceSyndicationElementIgnoredOnRead(reader);
|
|
reader.Skip();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
LoadElementExtensions(buffer, extWriter, result);
|
|
}
|
|
finally
|
|
{
|
|
if (extWriter != null)
|
|
{
|
|
((IDisposable) extWriter).Dispose();
|
|
}
|
|
}
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
|
|
TextSyndicationContent ReadTextContentFrom(XmlReader reader, string context)
|
|
{
|
|
return ReadTextContentFrom(reader, context, this.PreserveAttributeExtensions);
|
|
}
|
|
|
|
void WriteCategoriesTo(XmlWriter writer, Collection<SyndicationCategory> categories)
|
|
{
|
|
for (int i = 0; i < categories.Count; ++i)
|
|
{
|
|
WriteCategory(writer, categories[i], this.Version);
|
|
}
|
|
}
|
|
|
|
void WriteFeed(XmlWriter writer)
|
|
{
|
|
if (this.Feed == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.FeedFormatterDoesNotHaveFeed)));
|
|
}
|
|
WriteFeedTo(writer, this.Feed, false); // isSourceFeed
|
|
}
|
|
|
|
void WriteFeedTo(XmlWriter writer, SyndicationFeed feed, bool isSourceFeed)
|
|
{
|
|
if (!isSourceFeed)
|
|
{
|
|
if (!string.IsNullOrEmpty(feed.Language))
|
|
{
|
|
writer.WriteAttributeString("xml", "lang", XmlNs, feed.Language);
|
|
}
|
|
if (feed.BaseUri != null)
|
|
{
|
|
writer.WriteAttributeString("xml", "base", XmlNs, FeedUtils.GetUriString(feed.BaseUri));
|
|
}
|
|
WriteAttributeExtensions(writer, feed, this.Version);
|
|
}
|
|
bool isElementRequired = !isSourceFeed;
|
|
TextSyndicationContent title = feed.Title;
|
|
if (isElementRequired)
|
|
{
|
|
title = title ?? new TextSyndicationContent(string.Empty);
|
|
}
|
|
WriteContentTo(writer, Atom10Constants.TitleTag, title);
|
|
WriteContentTo(writer, Atom10Constants.SubtitleTag, feed.Description);
|
|
string id = feed.Id;
|
|
if (isElementRequired)
|
|
{
|
|
id = id ?? idGenerator.Next();
|
|
}
|
|
WriteElement(writer, Atom10Constants.IdTag, id);
|
|
WriteContentTo(writer, Atom10Constants.RightsTag, feed.Copyright);
|
|
WriteFeedLastUpdatedTimeTo(writer, feed.LastUpdatedTime, isElementRequired);
|
|
WriteCategoriesTo(writer, feed.Categories);
|
|
if (feed.ImageUrl != null)
|
|
{
|
|
WriteElement(writer, Atom10Constants.LogoTag, feed.ImageUrl.ToString());
|
|
}
|
|
WriteFeedAuthorsTo(writer, feed.Authors);
|
|
WriteFeedContributorsTo(writer, feed.Contributors);
|
|
WriteElement(writer, Atom10Constants.GeneratorTag, feed.Generator);
|
|
|
|
for (int i = 0; i < feed.Links.Count; ++i)
|
|
{
|
|
WriteLink(writer, feed.Links[i], feed.BaseUri);
|
|
}
|
|
|
|
WriteElementExtensions(writer, feed, this.Version);
|
|
|
|
if (!isSourceFeed)
|
|
{
|
|
WriteItems(writer, feed.Items, feed.BaseUri);
|
|
}
|
|
}
|
|
|
|
void WriteItemContents(XmlWriter dictWriter, SyndicationItem item, Uri feedBaseUri)
|
|
{
|
|
Uri baseUriToWrite = FeedUtils.GetBaseUriToWrite(feedBaseUri, item.BaseUri);
|
|
if (baseUriToWrite != null)
|
|
{
|
|
dictWriter.WriteAttributeString("xml", "base", XmlNs, FeedUtils.GetUriString(baseUriToWrite));
|
|
}
|
|
WriteAttributeExtensions(dictWriter, item, this.Version);
|
|
|
|
string id = item.Id ?? idGenerator.Next();
|
|
WriteElement(dictWriter, Atom10Constants.IdTag, id);
|
|
|
|
TextSyndicationContent title = item.Title ?? new TextSyndicationContent(string.Empty);
|
|
WriteContentTo(dictWriter, Atom10Constants.TitleTag, title);
|
|
WriteContentTo(dictWriter, Atom10Constants.SummaryTag, item.Summary);
|
|
if (item.PublishDate != DateTimeOffset.MinValue)
|
|
{
|
|
dictWriter.WriteElementString(Atom10Constants.PublishedTag,
|
|
Atom10Constants.Atom10Namespace,
|
|
AsString(item.PublishDate));
|
|
}
|
|
WriteItemLastUpdatedTimeTo(dictWriter, item.LastUpdatedTime);
|
|
WriteItemAuthorsTo(dictWriter, item.Authors);
|
|
WriteItemContributorsTo(dictWriter, item.Contributors);
|
|
for (int i = 0; i < item.Links.Count; ++i)
|
|
{
|
|
WriteLink(dictWriter, item.Links[i], item.BaseUri);
|
|
}
|
|
WriteCategoriesTo(dictWriter, item.Categories);
|
|
WriteContentTo(dictWriter, Atom10Constants.ContentTag, item.Content);
|
|
WriteContentTo(dictWriter, Atom10Constants.RightsTag, item.Copyright);
|
|
if (item.SourceFeed != null)
|
|
{
|
|
dictWriter.WriteStartElement(Atom10Constants.SourceFeedTag, Atom10Constants.Atom10Namespace);
|
|
WriteFeedTo(dictWriter, item.SourceFeed, true); // isSourceFeed
|
|
dictWriter.WriteEndElement();
|
|
}
|
|
WriteElementExtensions(dictWriter, item, this.Version);
|
|
}
|
|
|
|
void WritePersonTo(XmlWriter writer, SyndicationPerson p, string elementName)
|
|
{
|
|
writer.WriteStartElement(elementName, Atom10Constants.Atom10Namespace);
|
|
WriteAttributeExtensions(writer, p, this.Version);
|
|
WriteElement(writer, Atom10Constants.NameTag, p.Name);
|
|
if (!string.IsNullOrEmpty(p.Uri))
|
|
{
|
|
writer.WriteElementString(Atom10Constants.UriTag, Atom10Constants.Atom10Namespace, p.Uri);
|
|
}
|
|
if (!string.IsNullOrEmpty(p.Email))
|
|
{
|
|
writer.WriteElementString(Atom10Constants.EmailTag, Atom10Constants.Atom10Namespace, p.Email);
|
|
}
|
|
WriteElementExtensions(writer, p, this.Version);
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
[TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
|
|
[XmlRoot(ElementName = Atom10Constants.FeedTag, Namespace = Atom10Constants.Atom10Namespace)]
|
|
public class Atom10FeedFormatter<TSyndicationFeed> : Atom10FeedFormatter
|
|
where TSyndicationFeed : SyndicationFeed, new ()
|
|
{
|
|
// constructors
|
|
public Atom10FeedFormatter()
|
|
: base(typeof(TSyndicationFeed))
|
|
{
|
|
}
|
|
public Atom10FeedFormatter(TSyndicationFeed feedToWrite)
|
|
: base(feedToWrite)
|
|
{
|
|
}
|
|
|
|
protected override SyndicationFeed CreateFeedInstance()
|
|
{
|
|
return new TSyndicationFeed();
|
|
}
|
|
}
|
|
}
|