|
//------------------------------------------------------------
// 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();
}
}
}
|