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
813 lines
35 KiB
C#
813 lines
35 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.ServiceModel.Syndication
|
|
{
|
|
using System.Collections.ObjectModel;
|
|
using System.Runtime.Serialization;
|
|
using System.Xml.Serialization;
|
|
using System.Collections.Generic;
|
|
using System.Xml;
|
|
using System.Xml.Schema;
|
|
using System.ServiceModel.Channels;
|
|
using System.Diagnostics;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Runtime.CompilerServices;
|
|
|
|
internal delegate InlineCategoriesDocument CreateInlineCategoriesDelegate();
|
|
internal delegate ReferencedCategoriesDocument CreateReferencedCategoriesDelegate();
|
|
|
|
[TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
|
|
[XmlRoot(ElementName = App10Constants.Service, Namespace = App10Constants.Namespace)]
|
|
public class AtomPub10ServiceDocumentFormatter : ServiceDocumentFormatter, IXmlSerializable
|
|
{
|
|
Type documentType;
|
|
int maxExtensionSize;
|
|
bool preserveAttributeExtensions;
|
|
bool preserveElementExtensions;
|
|
|
|
public AtomPub10ServiceDocumentFormatter()
|
|
: this(typeof(ServiceDocument))
|
|
{
|
|
}
|
|
|
|
public AtomPub10ServiceDocumentFormatter(Type documentTypeToCreate)
|
|
: base()
|
|
{
|
|
if (documentTypeToCreate == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("documentTypeToCreate");
|
|
}
|
|
if (!typeof(ServiceDocument).IsAssignableFrom(documentTypeToCreate))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument("documentTypeToCreate",
|
|
SR.GetString(SR.InvalidObjectTypePassed, "documentTypeToCreate", "ServiceDocument"));
|
|
}
|
|
this.maxExtensionSize = int.MaxValue;
|
|
this.preserveAttributeExtensions = true;
|
|
this.preserveElementExtensions = true;
|
|
this.documentType = documentTypeToCreate;
|
|
}
|
|
|
|
public AtomPub10ServiceDocumentFormatter(ServiceDocument documentToWrite)
|
|
: base(documentToWrite)
|
|
{
|
|
// 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 = true;
|
|
preserveElementExtensions = true;
|
|
this.documentType = documentToWrite.GetType();
|
|
}
|
|
|
|
public override string Version
|
|
{
|
|
get { return App10Constants.Namespace; }
|
|
}
|
|
|
|
public override bool CanRead(XmlReader reader)
|
|
{
|
|
if (reader == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
|
|
}
|
|
return reader.IsStartElement(App10Constants.Service, App10Constants.Namespace);
|
|
}
|
|
|
|
[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");
|
|
}
|
|
TraceServiceDocumentReadBegin();
|
|
ReadDocument(reader);
|
|
TraceServiceDocumentReadEnd();
|
|
}
|
|
|
|
[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");
|
|
}
|
|
if (this.Document == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.DocumentFormatterDoesNotHaveDocument)));
|
|
}
|
|
TraceServiceDocumentWriteBegin();
|
|
WriteDocument(writer);
|
|
TraceServiceDocumentWriteEnd();
|
|
}
|
|
|
|
public override void ReadFrom(XmlReader reader)
|
|
{
|
|
if (reader == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("reader");
|
|
}
|
|
reader.MoveToContent();
|
|
if (!CanRead(reader))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(SR.GetString(SR.UnknownDocumentXml, reader.LocalName, reader.NamespaceURI)));
|
|
}
|
|
TraceServiceDocumentReadBegin();
|
|
ReadDocument(reader);
|
|
TraceServiceDocumentReadEnd();
|
|
}
|
|
|
|
public override void WriteTo(XmlWriter writer)
|
|
{
|
|
if (writer == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("writer");
|
|
}
|
|
if (this.Document == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.DocumentFormatterDoesNotHaveDocument)));
|
|
}
|
|
TraceServiceDocumentWriteBegin();
|
|
writer.WriteStartElement(App10Constants.Prefix, App10Constants.Service, App10Constants.Namespace);
|
|
WriteDocument(writer);
|
|
writer.WriteEndElement();
|
|
TraceServiceDocumentWriteEnd();
|
|
}
|
|
|
|
internal static CategoriesDocument ReadCategories(XmlReader reader, Uri baseUri, CreateInlineCategoriesDelegate inlineCategoriesFactory, CreateReferencedCategoriesDelegate referencedCategoriesFactory, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int maxExtensionSize)
|
|
{
|
|
string link = reader.GetAttribute(App10Constants.Href, string.Empty);
|
|
if (string.IsNullOrEmpty(link))
|
|
{
|
|
InlineCategoriesDocument inlineCategories = inlineCategoriesFactory();
|
|
ReadInlineCategories(reader, inlineCategories, baseUri, version, preserveElementExtensions, preserveAttributeExtensions, maxExtensionSize);
|
|
return inlineCategories;
|
|
}
|
|
else
|
|
{
|
|
ReferencedCategoriesDocument referencedCategories = referencedCategoriesFactory();
|
|
ReadReferencedCategories(reader, referencedCategories, baseUri, new Uri(link, UriKind.RelativeOrAbsolute), version, preserveElementExtensions, preserveAttributeExtensions, maxExtensionSize);
|
|
return referencedCategories;
|
|
}
|
|
}
|
|
|
|
internal static void TraceServiceDocumentReadBegin()
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationReadServiceDocumentBegin, SR.GetString(SR.TraceCodeSyndicationReadServiceDocumentBegin));
|
|
}
|
|
}
|
|
|
|
internal static void TraceServiceDocumentReadEnd()
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationReadServiceDocumentEnd, SR.GetString(SR.TraceCodeSyndicationReadServiceDocumentEnd));
|
|
}
|
|
}
|
|
|
|
internal static void TraceServiceDocumentWriteBegin()
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationWriteServiceDocumentBegin, SR.GetString(SR.TraceCodeSyndicationWriteServiceDocumentBegin));
|
|
}
|
|
}
|
|
|
|
internal static void TraceServiceDocumentWriteEnd()
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.SyndicationWriteServiceDocumentEnd, SR.GetString(SR.TraceCodeSyndicationWriteServiceDocumentEnd));
|
|
}
|
|
}
|
|
|
|
internal static void WriteCategoriesInnerXml(XmlWriter writer, CategoriesDocument categories, Uri baseUri, string version)
|
|
{
|
|
Uri baseUriToWrite = FeedUtils.GetBaseUriToWrite(baseUri, categories.BaseUri);
|
|
if (baseUriToWrite != null)
|
|
{
|
|
WriteXmlBase(writer, baseUriToWrite);
|
|
}
|
|
if (!string.IsNullOrEmpty(categories.Language))
|
|
{
|
|
WriteXmlLang(writer, categories.Language);
|
|
}
|
|
if (categories.IsInline)
|
|
{
|
|
WriteInlineCategoriesContent(writer, (InlineCategoriesDocument)categories, version);
|
|
}
|
|
else
|
|
{
|
|
WriteReferencedCategoriesContent(writer, (ReferencedCategoriesDocument)categories, version);
|
|
}
|
|
}
|
|
|
|
protected override ServiceDocument CreateDocumentInstance()
|
|
{
|
|
if (this.documentType == typeof(ServiceDocument))
|
|
{
|
|
return new ServiceDocument();
|
|
}
|
|
else
|
|
{
|
|
return (ServiceDocument)Activator.CreateInstance(this.documentType);
|
|
}
|
|
}
|
|
|
|
static void ReadInlineCategories(XmlReader reader, InlineCategoriesDocument inlineCategories, Uri baseUri, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int maxExtensionSize)
|
|
{
|
|
inlineCategories.BaseUri = baseUri;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
|
|
{
|
|
inlineCategories.BaseUri = FeedUtils.CombineXmlBase(inlineCategories.BaseUri, reader.Value);
|
|
}
|
|
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
|
|
{
|
|
inlineCategories.Language = reader.Value;
|
|
}
|
|
else if (reader.LocalName == App10Constants.Fixed && reader.NamespaceURI == string.Empty)
|
|
{
|
|
inlineCategories.IsFixed = (reader.Value == "yes");
|
|
}
|
|
else if (reader.LocalName == Atom10Constants.SchemeTag && reader.NamespaceURI == string.Empty)
|
|
{
|
|
inlineCategories.Scheme = 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, inlineCategories, version))
|
|
{
|
|
if (preserveAttributeExtensions)
|
|
{
|
|
inlineCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
|
|
}
|
|
else
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
SyndicationFeedFormatter.MoveToStartElement(reader);
|
|
bool isEmptyElement = reader.IsEmptyElement;
|
|
reader.ReadStartElement();
|
|
if (!isEmptyElement)
|
|
{
|
|
XmlBuffer buffer = null;
|
|
XmlDictionaryWriter extWriter = null;
|
|
try
|
|
{
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (reader.IsStartElement(Atom10Constants.CategoryTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
SyndicationCategory category = CreateCategory(inlineCategories);
|
|
Atom10FeedFormatter.ReadCategory(reader, category, version, preserveAttributeExtensions, preserveElementExtensions, maxExtensionSize);
|
|
if (category.Scheme == null)
|
|
{
|
|
category.Scheme = inlineCategories.Scheme;
|
|
}
|
|
inlineCategories.Categories.Add(category);
|
|
}
|
|
else if (!TryParseElement(reader, inlineCategories, version))
|
|
{
|
|
if (preserveElementExtensions)
|
|
{
|
|
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
|
|
}
|
|
else
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
reader.Skip();
|
|
}
|
|
}
|
|
}
|
|
LoadElementExtensions(buffer, extWriter, inlineCategories);
|
|
}
|
|
finally
|
|
{
|
|
if (extWriter != null)
|
|
{
|
|
extWriter.Close();
|
|
}
|
|
}
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
|
|
static void ReadReferencedCategories(XmlReader reader, ReferencedCategoriesDocument referencedCategories, Uri baseUri, Uri link, string version, bool preserveElementExtensions, bool preserveAttributeExtensions, int maxExtensionSize)
|
|
{
|
|
referencedCategories.BaseUri = baseUri;
|
|
referencedCategories.Link = link;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
|
|
{
|
|
referencedCategories.BaseUri = FeedUtils.CombineXmlBase(referencedCategories.BaseUri, reader.Value);
|
|
}
|
|
else if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
|
|
{
|
|
referencedCategories.Language = reader.Value;
|
|
}
|
|
else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
|
|
{
|
|
continue;
|
|
}
|
|
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, referencedCategories, version))
|
|
{
|
|
if (preserveAttributeExtensions)
|
|
{
|
|
referencedCategories.AttributeExtensions.Add(new XmlQualifiedName(reader.LocalName, reader.NamespaceURI), reader.Value);
|
|
}
|
|
else
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
reader.MoveToElement();
|
|
bool isEmptyElement = reader.IsEmptyElement;
|
|
reader.ReadStartElement();
|
|
if (!isEmptyElement)
|
|
{
|
|
XmlBuffer buffer = null;
|
|
XmlDictionaryWriter extWriter = null;
|
|
try
|
|
{
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (!TryParseElement(reader, referencedCategories, version))
|
|
{
|
|
if (preserveElementExtensions)
|
|
{
|
|
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, maxExtensionSize);
|
|
}
|
|
else
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
reader.Skip();
|
|
}
|
|
}
|
|
}
|
|
LoadElementExtensions(buffer, extWriter, referencedCategories);
|
|
}
|
|
finally
|
|
{
|
|
if (extWriter != null)
|
|
{
|
|
extWriter.Close();
|
|
}
|
|
}
|
|
reader.ReadEndElement();
|
|
}
|
|
}
|
|
|
|
static void WriteCategories(XmlWriter writer, CategoriesDocument categories, Uri baseUri, string version)
|
|
{
|
|
writer.WriteStartElement(App10Constants.Prefix, App10Constants.Categories, App10Constants.Namespace);
|
|
WriteCategoriesInnerXml(writer, categories, baseUri, version);
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
static void WriteInlineCategoriesContent(XmlWriter writer, InlineCategoriesDocument categories, string version)
|
|
{
|
|
if (!string.IsNullOrEmpty(categories.Scheme))
|
|
{
|
|
writer.WriteAttributeString(Atom10Constants.SchemeTag, categories.Scheme);
|
|
}
|
|
// by default, categories are not fixed
|
|
if (categories.IsFixed)
|
|
{
|
|
writer.WriteAttributeString(App10Constants.Fixed, "yes");
|
|
}
|
|
WriteAttributeExtensions(writer, categories, version);
|
|
for (int i = 0; i < categories.Categories.Count; ++i)
|
|
{
|
|
Atom10FeedFormatter.WriteCategory(writer, categories.Categories[i], version);
|
|
}
|
|
WriteElementExtensions(writer, categories, version);
|
|
}
|
|
|
|
static void WriteReferencedCategoriesContent(XmlWriter writer, ReferencedCategoriesDocument categories, string version)
|
|
{
|
|
if (categories.Link != null)
|
|
{
|
|
writer.WriteAttributeString(App10Constants.Href, FeedUtils.GetUriString(categories.Link));
|
|
}
|
|
WriteAttributeExtensions(writer, categories, version);
|
|
WriteElementExtensions(writer, categories, version);
|
|
}
|
|
|
|
static void WriteXmlBase(XmlWriter writer, Uri baseUri)
|
|
{
|
|
writer.WriteAttributeString("xml", "base", Atom10FeedFormatter.XmlNs, FeedUtils.GetUriString(baseUri));
|
|
}
|
|
|
|
static void WriteXmlLang(XmlWriter writer, string lang)
|
|
{
|
|
writer.WriteAttributeString("xml", "lang", Atom10FeedFormatter.XmlNs, lang);
|
|
|
|
}
|
|
|
|
ResourceCollectionInfo ReadCollection(XmlReader reader, Workspace workspace)
|
|
{
|
|
ResourceCollectionInfo result = CreateCollection(workspace);
|
|
result.BaseUri = workspace.BaseUri;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
|
|
{
|
|
result.BaseUri = FeedUtils.CombineXmlBase(result.BaseUri, reader.Value);
|
|
}
|
|
else if (reader.LocalName == App10Constants.Href && reader.NamespaceURI == string.Empty)
|
|
{
|
|
result.Link = new Uri(reader.Value, UriKind.RelativeOrAbsolute);
|
|
}
|
|
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
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
XmlBuffer buffer = null;
|
|
XmlDictionaryWriter extWriter = null;
|
|
|
|
reader.ReadStartElement();
|
|
try
|
|
{
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/app:collection/atom:title[@type]", this.preserveAttributeExtensions);
|
|
}
|
|
else if (reader.IsStartElement(App10Constants.Categories, App10Constants.Namespace))
|
|
{
|
|
result.Categories.Add(ReadCategories(reader,
|
|
result.BaseUri,
|
|
delegate()
|
|
{
|
|
return CreateInlineCategories(result);
|
|
},
|
|
|
|
delegate()
|
|
{
|
|
return CreateReferencedCategories(result);
|
|
},
|
|
this.Version,
|
|
this.preserveElementExtensions,
|
|
this.preserveAttributeExtensions,
|
|
this.maxExtensionSize));
|
|
}
|
|
else if (reader.IsStartElement(App10Constants.Accept, App10Constants.Namespace))
|
|
{
|
|
result.Accepts.Add(reader.ReadElementString());
|
|
}
|
|
else if (!TryParseElement(reader, result, this.Version))
|
|
{
|
|
if (this.preserveElementExtensions)
|
|
{
|
|
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
|
|
}
|
|
else
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
reader.Skip();
|
|
}
|
|
}
|
|
}
|
|
LoadElementExtensions(buffer, extWriter, result);
|
|
}
|
|
finally
|
|
{
|
|
if (extWriter != null)
|
|
{
|
|
extWriter.Close();
|
|
}
|
|
}
|
|
reader.ReadEndElement();
|
|
return result;
|
|
}
|
|
|
|
void ReadDocument(XmlReader reader)
|
|
{
|
|
ServiceDocument result = CreateDocumentInstance();
|
|
try
|
|
{
|
|
SyndicationFeedFormatter.MoveToStartElement(reader);
|
|
bool elementIsEmpty = reader.IsEmptyElement;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (reader.LocalName == "lang" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
|
|
{
|
|
result.Language = reader.Value;
|
|
}
|
|
else if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.XmlNs)
|
|
{
|
|
result.BaseUri = new Uri(reader.Value, UriKind.RelativeOrAbsolute);
|
|
}
|
|
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
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
XmlBuffer buffer = null;
|
|
XmlDictionaryWriter extWriter = null;
|
|
|
|
reader.ReadStartElement();
|
|
if (!elementIsEmpty)
|
|
{
|
|
try
|
|
{
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (reader.IsStartElement(App10Constants.Workspace, App10Constants.Namespace))
|
|
{
|
|
result.Workspaces.Add(ReadWorkspace(reader, result));
|
|
}
|
|
else if (!TryParseElement(reader, result, this.Version))
|
|
{
|
|
if (this.preserveElementExtensions)
|
|
{
|
|
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
|
|
}
|
|
else
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
reader.Skip();
|
|
}
|
|
}
|
|
}
|
|
LoadElementExtensions(buffer, extWriter, result);
|
|
}
|
|
finally
|
|
{
|
|
if (extWriter != null)
|
|
{
|
|
extWriter.Close();
|
|
}
|
|
}
|
|
}
|
|
reader.ReadEndElement();
|
|
}
|
|
catch (FormatException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e));
|
|
}
|
|
catch (ArgumentException e)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new XmlException(FeedUtils.AddLineInfo(reader, SR.ErrorParsingDocument), e));
|
|
}
|
|
SetDocument(result);
|
|
}
|
|
|
|
Workspace ReadWorkspace(XmlReader reader, ServiceDocument document)
|
|
{
|
|
Workspace result = CreateWorkspace(document);
|
|
result.BaseUri = document.BaseUri;
|
|
if (reader.HasAttributes)
|
|
{
|
|
while (reader.MoveToNextAttribute())
|
|
{
|
|
if (reader.LocalName == "base" && reader.NamespaceURI == Atom10FeedFormatter.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
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
XmlBuffer buffer = null;
|
|
XmlDictionaryWriter extWriter = null;
|
|
|
|
reader.ReadStartElement();
|
|
try
|
|
{
|
|
while (reader.IsStartElement())
|
|
{
|
|
if (reader.IsStartElement(Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace))
|
|
{
|
|
result.Title = Atom10FeedFormatter.ReadTextContentFrom(reader, "//app:service/app:workspace/atom:title[@type]", this.preserveAttributeExtensions);
|
|
}
|
|
else if (reader.IsStartElement(App10Constants.Collection, App10Constants.Namespace))
|
|
{
|
|
result.Collections.Add(ReadCollection(reader, result));
|
|
}
|
|
else if (!TryParseElement(reader, result, this.Version))
|
|
{
|
|
if (this.preserveElementExtensions)
|
|
{
|
|
SyndicationFeedFormatter.CreateBufferIfRequiredAndWriteNode(ref buffer, ref extWriter, reader, this.maxExtensionSize);
|
|
}
|
|
else
|
|
{
|
|
SyndicationFeedFormatter.TraceSyndicationElementIgnoredOnRead(reader);
|
|
reader.Skip();
|
|
}
|
|
}
|
|
}
|
|
LoadElementExtensions(buffer, extWriter, result);
|
|
}
|
|
finally
|
|
{
|
|
if (extWriter != null)
|
|
{
|
|
extWriter.Close();
|
|
}
|
|
}
|
|
reader.ReadEndElement();
|
|
return result;
|
|
}
|
|
|
|
void WriteCollection(XmlWriter writer, ResourceCollectionInfo collection, Uri baseUri)
|
|
{
|
|
writer.WriteStartElement(App10Constants.Prefix, App10Constants.Collection, App10Constants.Namespace);
|
|
Uri baseUriToWrite = FeedUtils.GetBaseUriToWrite(baseUri, collection.BaseUri);
|
|
if (baseUriToWrite != null)
|
|
{
|
|
baseUri = collection.BaseUri;
|
|
WriteXmlBase(writer, baseUriToWrite);
|
|
}
|
|
if (collection.Link != null)
|
|
{
|
|
writer.WriteAttributeString(App10Constants.Href, FeedUtils.GetUriString(collection.Link));
|
|
}
|
|
WriteAttributeExtensions(writer, collection, this.Version);
|
|
if (collection.Title != null)
|
|
{
|
|
collection.Title.WriteTo(writer, Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace);
|
|
}
|
|
for (int i = 0; i < collection.Accepts.Count; ++i)
|
|
{
|
|
writer.WriteElementString(App10Constants.Prefix, App10Constants.Accept, App10Constants.Namespace, collection.Accepts[i]);
|
|
}
|
|
for (int i = 0; i < collection.Categories.Count; ++i)
|
|
{
|
|
WriteCategories(writer, collection.Categories[i], baseUri, this.Version);
|
|
}
|
|
WriteElementExtensions(writer, collection, this.Version);
|
|
writer.WriteEndElement();
|
|
}
|
|
|
|
void WriteDocument(XmlWriter writer)
|
|
{
|
|
// declare the atom10 namespace upfront for compactness
|
|
writer.WriteAttributeString(Atom10Constants.Atom10Prefix, Atom10FeedFormatter.XmlNsNs, Atom10Constants.Atom10Namespace);
|
|
if (!string.IsNullOrEmpty(this.Document.Language))
|
|
{
|
|
WriteXmlLang(writer, this.Document.Language);
|
|
}
|
|
Uri baseUri = this.Document.BaseUri;
|
|
if (baseUri != null)
|
|
{
|
|
WriteXmlBase(writer, baseUri);
|
|
}
|
|
WriteAttributeExtensions(writer, this.Document, this.Version);
|
|
|
|
for (int i = 0; i < this.Document.Workspaces.Count; ++i)
|
|
{
|
|
WriteWorkspace(writer, this.Document.Workspaces[i], baseUri);
|
|
}
|
|
WriteElementExtensions(writer, this.Document, this.Version);
|
|
}
|
|
|
|
void WriteWorkspace(XmlWriter writer, Workspace workspace, Uri baseUri)
|
|
{
|
|
writer.WriteStartElement(App10Constants.Prefix, App10Constants.Workspace, App10Constants.Namespace);
|
|
Uri baseUriToWrite = FeedUtils.GetBaseUriToWrite(baseUri, workspace.BaseUri);
|
|
if (baseUriToWrite != null)
|
|
{
|
|
baseUri = workspace.BaseUri;
|
|
WriteXmlBase(writer, baseUriToWrite);
|
|
}
|
|
WriteAttributeExtensions(writer, workspace, this.Version);
|
|
if (workspace.Title != null)
|
|
{
|
|
workspace.Title.WriteTo(writer, Atom10Constants.TitleTag, Atom10Constants.Atom10Namespace);
|
|
}
|
|
for (int i = 0; i < workspace.Collections.Count; ++i)
|
|
{
|
|
WriteCollection(writer, workspace.Collections[i], baseUri);
|
|
}
|
|
WriteElementExtensions(writer, workspace, this.Version);
|
|
writer.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
[TypeForwardedFrom("System.ServiceModel.Web, Version=3.5.0.0, Culture=neutral, PublicKeyToken=31bf3856ad364e35")]
|
|
[XmlRoot(ElementName = App10Constants.Service, Namespace = App10Constants.Namespace)]
|
|
public class AtomPub10ServiceDocumentFormatter<TServiceDocument> : AtomPub10ServiceDocumentFormatter
|
|
where TServiceDocument : ServiceDocument, new()
|
|
{
|
|
public AtomPub10ServiceDocumentFormatter() :
|
|
base(typeof(TServiceDocument))
|
|
{
|
|
}
|
|
|
|
public AtomPub10ServiceDocumentFormatter(TServiceDocument documentToWrite)
|
|
: base(documentToWrite)
|
|
{
|
|
}
|
|
|
|
protected override ServiceDocument CreateDocumentInstance()
|
|
{
|
|
return new TServiceDocument();
|
|
}
|
|
}
|
|
}
|