|
//------------------------------------------------------------
// Copyright (c) Microsoft Corporation. All rights reserved.
//------------------------------------------------------------
namespace System.Xml
{
using System.Globalization;
using System.IO;
using System.Runtime;
using System.Runtime.Serialization;
using System.Text;
using System.Threading.Tasks;
abstract class XmlBaseWriter : XmlDictionaryWriter, IFragmentCapableXmlDictionaryWriter
{
XmlNodeWriter writer;
NamespaceManager nsMgr;
Element[] elements;
int depth;
string attributeLocalName;
string attributeValue;
bool isXmlAttribute;
bool isXmlnsAttribute;
WriteState writeState;
DocumentState documentState;
byte[] trailBytes;
int trailByteCount;
XmlStreamNodeWriter nodeWriter;
XmlSigningNodeWriter signingWriter;
XmlUTF8NodeWriter textFragmentWriter;
XmlNodeWriter oldWriter;
Stream oldStream;
int oldNamespaceBoundary;
bool inList;
const string xmlnsNamespace = "http://www.w3.org/2000/xmlns/";
const string xmlNamespace = "http://www.w3.org/XML/1998/namespace";
static BinHexEncoding binhexEncoding;
static string[] prefixes = { "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o", "p", "q", "r", "s", "t", "u", "v", "w", "x", "y", "z" };
XmlBaseWriterNodeWriterAsyncHelper nodeWriterAsyncHelper;
protected XmlBaseWriter()
{
this.nsMgr = new NamespaceManager();
this.writeState = WriteState.Start;
this.documentState = DocumentState.None;
}
protected void SetOutput(XmlStreamNodeWriter writer)
{
this.inList = false;
this.writer = writer;
this.nodeWriter = writer;
this.writeState = WriteState.Start;
this.documentState = DocumentState.None;
this.nsMgr.Clear();
if (this.depth != 0)
{
this.elements = null;
this.depth = 0;
}
this.attributeLocalName = null;
this.attributeValue = null;
this.oldWriter = null;
this.oldStream = null;
}
public override void Flush()
{
if (IsClosed)
ThrowClosed();
writer.Flush();
}
public override void Close()
{
if (IsClosed)
return;
try
{
FinishDocument();
AutoComplete(WriteState.Closed);
writer.Flush();
}
finally
{
nsMgr.Close();
if (depth != 0)
{
elements = null;
depth = 0;
}
attributeValue = null;
attributeLocalName = null;
nodeWriter.Close();
if (signingWriter != null)
{
signingWriter.Close();
}
if (textFragmentWriter != null)
{
textFragmentWriter.Close();
}
oldWriter = null;
oldStream = null;
}
}
protected bool IsClosed
{
get { return writeState == WriteState.Closed; }
}
protected void ThrowClosed()
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlWriterClosed)));
}
static BinHexEncoding BinHexEncoding
{
get
{
if (binhexEncoding == null)
binhexEncoding = new BinHexEncoding();
return binhexEncoding;
}
}
public override string XmlLang
{
get
{
return nsMgr.XmlLang;
}
}
public override XmlSpace XmlSpace
{
get
{
return nsMgr.XmlSpace;
}
}
public override WriteState WriteState
{
get
{
return writeState;
}
}
public override void WriteXmlnsAttribute(string prefix, string ns)
{
if (IsClosed)
ThrowClosed();
if (ns == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("ns");
if (writeState != WriteState.Element)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteXmlnsAttribute", WriteState.ToString())));
if (prefix == null)
{
prefix = nsMgr.LookupPrefix(ns);
if (prefix == null)
{
GeneratePrefix(ns, null);
}
}
else
{
nsMgr.AddNamespaceIfNotDeclared(prefix, ns, null);
}
}
public override void WriteXmlnsAttribute(string prefix, XmlDictionaryString ns)
{
if (IsClosed)
ThrowClosed();
if (ns == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("ns");
if (writeState != WriteState.Element)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteXmlnsAttribute", WriteState.ToString())));
if (prefix == null)
{
prefix = nsMgr.LookupPrefix(ns.Value);
if (prefix == null)
{
GeneratePrefix(ns.Value, ns);
}
}
else
{
nsMgr.AddNamespaceIfNotDeclared(prefix, ns.Value, ns);
}
}
void StartAttribute(ref string prefix, string localName, string ns, XmlDictionaryString xNs)
{
if (IsClosed)
ThrowClosed();
if (writeState == WriteState.Attribute)
WriteEndAttribute();
if (localName == null || (localName.Length == 0 && prefix != "xmlns"))
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("localName"));
if (writeState != WriteState.Element)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteStartAttribute", WriteState.ToString())));
if (prefix == null)
{
if (ns == xmlnsNamespace && localName != "xmlns")
prefix = "xmlns";
else if (ns == xmlNamespace)
prefix = "xml";
else
prefix = string.Empty;
}
// Normalize a (prefix,localName) of (null, "xmlns") to ("xmlns", string.Empty).
if (prefix.Length == 0 && localName == "xmlns")
{
prefix = "xmlns";
localName = string.Empty;
}
isXmlnsAttribute = false;
isXmlAttribute = false;
if (prefix == "xml")
{
if (ns != null && ns != xmlNamespace)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlPrefixBoundToNamespace, "xml", xmlNamespace, ns), "ns"));
isXmlAttribute = true;
attributeValue = string.Empty;
attributeLocalName = localName;
}
else if (prefix == "xmlns")
{
if (ns != null && ns != xmlnsNamespace)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlPrefixBoundToNamespace, "xmlns", xmlnsNamespace, ns), "ns"));
isXmlnsAttribute = true;
attributeValue = string.Empty;
attributeLocalName = localName;
}
else if (ns == null)
{
// A null namespace means the namespace of the given prefix.
if (prefix.Length == 0)
{
// An empty prefix on an attribute means no namespace (not the default namespace)
ns = string.Empty;
}
else
{
ns = nsMgr.LookupNamespace(prefix);
if (ns == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlUndefinedPrefix, prefix), "prefix"));
}
}
else if (ns.Length == 0)
{
// An empty namespace means no namespace; prefix must be empty
if (prefix.Length != 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlEmptyNamespaceRequiresNullPrefix), "prefix"));
}
else if (prefix.Length == 0)
{
// No prefix specified - try to find a prefix corresponding to the given namespace
prefix = nsMgr.LookupAttributePrefix(ns);
// If we didn't find anything with the right namespace, generate one.
if (prefix == null)
{
// Watch for special values
if (ns.Length == xmlnsNamespace.Length && ns == xmlnsNamespace)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlSpecificBindingNamespace, "xmlns", ns)));
if (ns.Length == xmlNamespace.Length && ns == xmlNamespace)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlSpecificBindingNamespace, "xml", ns)));
prefix = GeneratePrefix(ns, xNs);
}
}
else
{
nsMgr.AddNamespaceIfNotDeclared(prefix, ns, xNs);
}
writeState = WriteState.Attribute;
}
public override void WriteStartAttribute(string prefix, string localName, string namespaceUri)
{
StartAttribute(ref prefix, localName, namespaceUri, null);
if (!isXmlnsAttribute)
{
writer.WriteStartAttribute(prefix, localName);
}
}
public override void WriteStartAttribute(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri)
{
StartAttribute(ref prefix, (localName != null ? localName.Value : null), (namespaceUri != null ? namespaceUri.Value : null), namespaceUri);
if (!isXmlnsAttribute)
{
writer.WriteStartAttribute(prefix, localName);
}
}
public override void WriteEndAttribute()
{
if (IsClosed)
ThrowClosed();
if (writeState != WriteState.Attribute)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteEndAttribute", WriteState.ToString())));
FlushBase64();
try
{
if (isXmlAttribute)
{
if (attributeLocalName == "lang")
{
nsMgr.AddLangAttribute(attributeValue);
}
else if (attributeLocalName == "space")
{
if (attributeValue == "preserve")
{
nsMgr.AddSpaceAttribute(XmlSpace.Preserve);
}
else if (attributeValue == "default")
{
nsMgr.AddSpaceAttribute(XmlSpace.Default);
}
else
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlInvalidXmlSpace, attributeValue)));
}
}
else
{
// XmlTextWriter specifically allows for other localNames
}
isXmlAttribute = false;
attributeLocalName = null;
attributeValue = null;
}
if (isXmlnsAttribute)
{
nsMgr.AddNamespaceIfNotDeclared(attributeLocalName, attributeValue, null);
isXmlnsAttribute = false;
attributeLocalName = null;
attributeValue = null;
}
else
{
writer.WriteEndAttribute();
}
}
finally
{
writeState = WriteState.Element;
}
}
public override void WriteComment(string text)
{
if (IsClosed)
ThrowClosed();
if (writeState == WriteState.Attribute)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteComment", WriteState.ToString())));
if (text == null)
{
text = string.Empty;
}
else if (text.IndexOf("--", StringComparison.Ordinal) != -1 || (text.Length > 0 && text[text.Length - 1] == '-'))
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlInvalidCommentChars), "text"));
}
StartComment();
FlushBase64();
writer.WriteComment(text);
EndComment();
}
public override void WriteFullEndElement()
{
if (IsClosed)
ThrowClosed();
if (writeState == WriteState.Attribute)
WriteEndAttribute();
if (writeState != WriteState.Element && writeState != WriteState.Content)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteFullEndElement", WriteState.ToString())));
AutoComplete(WriteState.Content);
WriteEndElement();
}
public override void WriteCData(string text)
{
if (IsClosed)
ThrowClosed();
if (writeState == WriteState.Attribute)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteCData", WriteState.ToString())));
if (text == null)
text = string.Empty;
if (text.Length > 0)
{
StartContent();
FlushBase64();
writer.WriteCData(text);
EndContent();
}
}
public override void WriteDocType(string name, string pubid, string sysid, string subset)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.XmlMethodNotSupported, "WriteDocType")));
}
void StartElement(ref string prefix, string localName, string ns, XmlDictionaryString xNs)
{
if (IsClosed)
ThrowClosed();
if (this.documentState == DocumentState.Epilog)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlOnlyOneRoot)));
if (localName == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("localName"));
if (localName.Length == 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.InvalidLocalNameEmpty), "localName"));
if (writeState == WriteState.Attribute)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteStartElement", WriteState.ToString())));
FlushBase64();
AutoComplete(WriteState.Element);
Element element = EnterScope();
if (ns == null)
{
if (prefix == null)
prefix = string.Empty;
ns = nsMgr.LookupNamespace(prefix);
if (ns == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlUndefinedPrefix, prefix), "prefix"));
}
else if (prefix == null)
{
prefix = nsMgr.LookupPrefix(ns);
if (prefix == null)
{
prefix = string.Empty;
nsMgr.AddNamespace(string.Empty, ns, xNs);
}
}
else
{
nsMgr.AddNamespaceIfNotDeclared(prefix, ns, xNs);
}
element.Prefix = prefix;
element.LocalName = localName;
}
public override void WriteStartElement(string prefix, string localName, string namespaceUri)
{
StartElement(ref prefix, localName, namespaceUri, null);
writer.WriteStartElement(prefix, localName);
}
public override void WriteStartElement(string prefix, XmlDictionaryString localName, XmlDictionaryString namespaceUri)
{
StartElement(ref prefix, (localName != null ? localName.Value : null), (namespaceUri != null ? namespaceUri.Value : null), namespaceUri);
writer.WriteStartElement(prefix, localName);
}
public override void WriteEndElement()
{
if (IsClosed)
ThrowClosed();
if (depth == 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidDepth, "WriteEndElement", depth.ToString(CultureInfo.InvariantCulture))));
if (writeState == WriteState.Attribute)
WriteEndAttribute();
FlushBase64();
if (writeState == WriteState.Element)
{
nsMgr.DeclareNamespaces(writer);
writer.WriteEndStartElement(true);
}
else
{
Element element = elements[depth];
writer.WriteEndElement(element.Prefix, element.LocalName);
}
ExitScope();
writeState = WriteState.Content;
}
Element EnterScope()
{
nsMgr.EnterScope();
depth++;
if (elements == null)
{
elements = new Element[4];
}
else if (elements.Length == depth)
{
Element[] newElementNodes = new Element[depth * 2];
Array.Copy(elements, newElementNodes, depth);
elements = newElementNodes;
}
Element element = elements[depth];
if (element == null)
{
element = new Element();
elements[depth] = element;
}
return element;
}
void ExitScope()
{
elements[depth].Clear();
depth--;
if (depth == 0 && documentState == DocumentState.Document)
this.documentState = DocumentState.Epilog;
nsMgr.ExitScope();
}
protected void FlushElement()
{
if (this.writeState == WriteState.Element)
{
AutoComplete(WriteState.Content);
}
}
protected void StartComment()
{
FlushElement();
}
protected void EndComment()
{
}
protected void StartContent()
{
FlushElement();
if (depth == 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlIllegalOutsideRoot)));
}
protected void StartContent(char ch)
{
FlushElement();
if (depth == 0)
VerifyWhitespace(ch);
}
protected void StartContent(string s)
{
FlushElement();
if (depth == 0)
VerifyWhitespace(s);
}
protected void StartContent(char[] chars, int offset, int count)
{
FlushElement();
if (depth == 0)
VerifyWhitespace(chars, offset, count);
}
void VerifyWhitespace(char ch)
{
if (!IsWhitespace(ch))
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlIllegalOutsideRoot)));
}
void VerifyWhitespace(string s)
{
for (int i = 0; i < s.Length; i++)
if (!IsWhitespace(s[i]))
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlIllegalOutsideRoot)));
}
void VerifyWhitespace(char[] chars, int offset, int count)
{
for (int i = 0; i < count; i++)
if (!IsWhitespace(chars[offset + i]))
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlIllegalOutsideRoot)));
}
bool IsWhitespace(char ch)
{
return (ch == ' ' || ch == '\n' || ch == '\r' || ch == 't');
}
protected void EndContent()
{
}
void AutoComplete(WriteState writeState)
{
if (this.writeState == WriteState.Element)
{
EndStartElement();
}
this.writeState = writeState;
}
void EndStartElement()
{
nsMgr.DeclareNamespaces(writer);
writer.WriteEndStartElement(false);
}
public override string LookupPrefix(string ns)
{
if (ns == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("ns"));
if (IsClosed)
ThrowClosed();
return nsMgr.LookupPrefix(ns);
}
internal string LookupNamespace(string prefix)
{
if (prefix == null)
return null;
return nsMgr.LookupNamespace(prefix);
}
string GetQualifiedNamePrefix(string namespaceUri, XmlDictionaryString xNs)
{
string prefix = nsMgr.LookupPrefix(namespaceUri);
if (prefix == null)
{
if (writeState != WriteState.Attribute)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlNamespaceNotFound, namespaceUri), "namespaceUri"));
prefix = GeneratePrefix(namespaceUri, xNs);
}
return prefix;
}
public override void WriteQualifiedName(string localName, string namespaceUri)
{
if (IsClosed)
ThrowClosed();
if (localName == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("localName"));
if (localName.Length == 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.InvalidLocalNameEmpty), "localName"));
if (namespaceUri == null)
namespaceUri = string.Empty;
string prefix = GetQualifiedNamePrefix(namespaceUri, null);
if (prefix.Length != 0)
{
WriteString(prefix);
WriteString(":");
}
WriteString(localName);
}
public override void WriteQualifiedName(XmlDictionaryString localName, XmlDictionaryString namespaceUri)
{
if (IsClosed)
ThrowClosed();
if (localName == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("localName"));
if (localName.Value.Length == 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.InvalidLocalNameEmpty), "localName"));
if (namespaceUri == null)
namespaceUri = XmlDictionaryString.Empty;
string prefix = GetQualifiedNamePrefix(namespaceUri.Value, namespaceUri);
FlushBase64();
if (attributeValue != null)
WriteAttributeText(string.Concat(prefix, ":", namespaceUri.Value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteQualifiedName(prefix, localName);
EndContent();
}
}
public override void WriteStartDocument()
{
if (IsClosed)
ThrowClosed();
if (writeState != WriteState.Start)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteStartDocument", WriteState.ToString())));
writeState = WriteState.Prolog;
documentState = DocumentState.Document;
writer.WriteDeclaration();
}
public override void WriteStartDocument(bool standalone)
{
if (IsClosed)
ThrowClosed();
WriteStartDocument();
}
public override void WriteProcessingInstruction(string name, string text)
{
if (IsClosed)
ThrowClosed();
if (name != "xml")
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlProcessingInstructionNotSupported), "name"));
if (writeState != WriteState.Start)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidDeclaration)));
// The only thing the text can legitimately contain is version, encoding, and standalone.
// We only support version 1.0, we can only write whatever encoding we were supplied,
// and we don't support DTDs, so whatever values are supplied in the text argument are irrelevant.
writer.WriteDeclaration();
}
void FinishDocument()
{
if (this.writeState == WriteState.Attribute)
{
WriteEndAttribute();
}
while (this.depth > 0)
{
WriteEndElement();
}
}
public override void WriteEndDocument()
{
if (IsClosed)
ThrowClosed();
if (writeState == WriteState.Start || writeState == WriteState.Prolog)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlNoRootElement)));
FinishDocument();
writeState = WriteState.Start;
documentState = DocumentState.End;
}
protected int NamespaceBoundary
{
get
{
return nsMgr.NamespaceBoundary;
}
set
{
nsMgr.NamespaceBoundary = value;
}
}
public override void WriteEntityRef(string name)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.XmlMethodNotSupported, "WriteEntityRef")));
}
public override void WriteName(string name)
{
if (IsClosed)
ThrowClosed();
WriteString(name);
}
public override void WriteNmToken(string name)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR.GetString(SR.XmlMethodNotSupported, "WriteNmToken")));
}
public override void WriteWhitespace(string whitespace)
{
if (IsClosed)
ThrowClosed();
if (whitespace == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("whitespace");
for (int i = 0; i < whitespace.Length; ++i)
{
char c = whitespace[i];
if (c != ' ' &&
c != '\t' &&
c != '\n' &&
c != '\r')
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlOnlyWhitespace), "whitespace"));
}
WriteString(whitespace);
}
public override void WriteString(string value)
{
if (IsClosed)
ThrowClosed();
if (value == null)
value = string.Empty;
if (value.Length > 0 || this.inList)
{
FlushBase64();
if (attributeValue != null)
WriteAttributeText(value);
if (!isXmlnsAttribute)
{
StartContent(value);
writer.WriteEscapedText(value);
EndContent();
}
}
}
public override void WriteString(XmlDictionaryString value)
{
if (IsClosed)
ThrowClosed();
if (value == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
if (value.Value.Length > 0)
{
FlushBase64();
if (attributeValue != null)
WriteAttributeText(value.Value);
if (!isXmlnsAttribute)
{
StartContent(value.Value);
writer.WriteEscapedText(value);
EndContent();
}
}
}
public override void WriteChars(char[] chars, int offset, int count)
{
if (IsClosed)
ThrowClosed();
if (chars == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("chars"));
// Not checking upper bound because it will be caught by "count". This is what XmlTextWriter does.
if (offset < 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.ValueMustBeNonNegative)));
if (count < 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.ValueMustBeNonNegative)));
if (count > chars.Length - offset)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.SizeExceedsRemainingBufferSpace, chars.Length - offset)));
if (count > 0)
{
FlushBase64();
if (attributeValue != null)
WriteAttributeText(new string(chars, offset, count));
if (!isXmlnsAttribute)
{
StartContent(chars, offset, count);
writer.WriteEscapedText(chars, offset, count);
EndContent();
}
}
}
public override void WriteRaw(string value)
{
if (IsClosed)
ThrowClosed();
if (value == null)
value = string.Empty;
if (value.Length > 0)
{
FlushBase64();
if (attributeValue != null)
WriteAttributeText(value);
if (!isXmlnsAttribute)
{
StartContent(value);
writer.WriteText(value);
EndContent();
}
}
}
public override void WriteRaw(char[] chars, int offset, int count)
{
if (IsClosed)
ThrowClosed();
if (chars == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("chars"));
// Not checking upper bound because it will be caught by "count". This is what XmlTextWriter does.
if (offset < 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.ValueMustBeNonNegative)));
if (count < 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.ValueMustBeNonNegative)));
if (count > chars.Length - offset)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.SizeExceedsRemainingBufferSpace, chars.Length - offset)));
if (count > 0)
{
FlushBase64();
if (attributeValue != null)
WriteAttributeText(new string(chars, offset, count));
if (!isXmlnsAttribute)
{
StartContent(chars, offset, count);
writer.WriteText(chars, offset, count);
EndContent();
}
}
}
public override void WriteCharEntity(char ch)
{
if (IsClosed)
ThrowClosed();
if (ch >= 0xd800 && ch <= 0xdfff)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlMissingLowSurrogate), "ch"));
if (attributeValue != null)
WriteAttributeText(ch.ToString());
if (!isXmlnsAttribute)
{
StartContent(ch);
FlushBase64();
writer.WriteCharEntity(ch);
EndContent();
}
}
public override void WriteSurrogateCharEntity(char lowChar, char highChar)
{
if (IsClosed)
ThrowClosed();
SurrogateChar ch = new SurrogateChar(lowChar, highChar);
if (attributeValue != null)
{
char[] chars = new char[2] { highChar, lowChar };
WriteAttributeText(new string(chars));
}
if (!isXmlnsAttribute)
{
StartContent();
FlushBase64();
writer.WriteCharEntity(ch.Char);
EndContent();
}
}
public override void WriteValue(object value)
{
if (IsClosed)
ThrowClosed();
if (value == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("value"));
else if (value is object[])
{
WriteValue((object[])value);
}
else if (value is Array)
{
WriteValue((Array)value);
}
else if (value is IStreamProvider)
{
WriteValue((IStreamProvider)value);
}
else
{
WritePrimitiveValue(value);
}
}
protected void WritePrimitiveValue(object value)
{
if (IsClosed)
ThrowClosed();
if (value == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("value"));
if (value is ulong)
{
WriteValue((ulong)value);
}
else if (value is string)
{
WriteValue((string)value);
}
else if (value is int)
{
WriteValue((int)value);
}
else if (value is long)
{
WriteValue((long)value);
}
else if (value is bool)
{
WriteValue((bool)value);
}
else if (value is double)
{
WriteValue((double)value);
}
else if (value is DateTime)
{
WriteValue((DateTime)value);
}
else if (value is float)
{
WriteValue((float)value);
}
else if (value is decimal)
{
WriteValue((decimal)value);
}
else if (value is XmlDictionaryString)
{
WriteValue((XmlDictionaryString)value);
}
else if (value is UniqueId)
{
WriteValue((UniqueId)value);
}
else if (value is Guid)
{
WriteValue((Guid)value);
}
else if (value is TimeSpan)
{
WriteValue((TimeSpan)value);
}
else if (value.GetType().IsArray)
{
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlNestedArraysNotSupported), "value"));
}
else
{
base.WriteValue(value);
}
}
public override void WriteValue(string value)
{
if (IsClosed)
ThrowClosed();
WriteString(value);
}
public override void WriteValue(int value)
{
if (IsClosed)
ThrowClosed();
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteInt32Text(value);
EndContent();
}
}
public override void WriteValue(long value)
{
if (IsClosed)
ThrowClosed();
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteInt64Text(value);
EndContent();
}
}
void WriteValue(ulong value)
{
if (IsClosed)
ThrowClosed();
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteUInt64Text(value);
EndContent();
}
}
public override void WriteValue(bool value)
{
if (IsClosed)
ThrowClosed();
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteBoolText(value);
EndContent();
}
}
public override void WriteValue(decimal value)
{
if (IsClosed)
ThrowClosed();
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteDecimalText(value);
EndContent();
}
}
public override void WriteValue(float value)
{
if (IsClosed)
ThrowClosed();
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteFloatText(value);
EndContent();
}
}
public override void WriteValue(double value)
{
if (IsClosed)
ThrowClosed();
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteDoubleText(value);
EndContent();
}
}
public override void WriteValue(XmlDictionaryString value)
{
WriteString(value);
}
public override void WriteValue(DateTime value)
{
if (IsClosed)
ThrowClosed();
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteDateTimeText(value);
EndContent();
}
}
public override void WriteValue(UniqueId value)
{
if (IsClosed)
ThrowClosed();
if (value == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("value");
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteUniqueIdText(value);
EndContent();
}
}
public override void WriteValue(Guid value)
{
if (IsClosed)
ThrowClosed();
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteGuidText(value);
EndContent();
}
}
public override void WriteValue(TimeSpan value)
{
if (IsClosed)
ThrowClosed();
FlushBase64();
if (attributeValue != null)
WriteAttributeText(XmlConverter.ToString(value));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteTimeSpanText(value);
EndContent();
}
}
public override void WriteBase64(byte[] buffer, int offset, int count)
{
if (IsClosed)
ThrowClosed();
EnsureBufferBounds(buffer, offset, count);
if (count > 0)
{
if (trailByteCount > 0)
{
while (trailByteCount < 3 && count > 0)
{
trailBytes[trailByteCount++] = buffer[offset++];
count--;
}
}
int totalByteCount = trailByteCount + count;
int actualByteCount = totalByteCount - (totalByteCount % 3);
if (trailBytes == null)
{
trailBytes = new byte[3];
}
if (actualByteCount >= 3)
{
if (attributeValue != null)
{
WriteAttributeText(XmlConverter.Base64Encoding.GetString(trailBytes, 0, trailByteCount));
WriteAttributeText(XmlConverter.Base64Encoding.GetString(buffer, offset, actualByteCount - trailByteCount));
}
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteBase64Text(trailBytes, trailByteCount, buffer, offset, actualByteCount - trailByteCount);
EndContent();
}
trailByteCount = (totalByteCount - actualByteCount);
if (trailByteCount > 0)
{
int trailOffset = offset + count - trailByteCount;
for (int i = 0; i < trailByteCount; i++)
trailBytes[i] = buffer[trailOffset++];
}
}
else
{
Buffer.BlockCopy(buffer, offset, trailBytes, trailByteCount, count);
trailByteCount += count;
}
}
}
internal override IAsyncResult BeginWriteBase64(byte[] buffer, int offset, int count, AsyncCallback callback, object state)
{
if (IsClosed)
ThrowClosed();
EnsureBufferBounds(buffer, offset, count);
return new WriteBase64AsyncResult(buffer, offset, count, this, callback, state);
}
internal override void EndWriteBase64(IAsyncResult result)
{
WriteBase64AsyncResult.End(result);
}
internal override AsyncCompletionResult WriteBase64Async(AsyncEventArgs<XmlWriteBase64AsyncArguments> state)
{
if (this.nodeWriterAsyncHelper == null)
{
this.nodeWriterAsyncHelper = new XmlBaseWriterNodeWriterAsyncHelper(this);
}
this.nodeWriterAsyncHelper.SetArguments(state);
if (this.nodeWriterAsyncHelper.StartAsync() == AsyncCompletionResult.Completed)
{
return AsyncCompletionResult.Completed;
}
return AsyncCompletionResult.Queued;
}
class WriteBase64AsyncResult : AsyncResult
{
static AsyncCompletion onComplete = new AsyncCompletion(OnComplete);
XmlBaseWriter writer;
byte[] buffer;
int offset;
int count;
int actualByteCount;
int totalByteCount;
public WriteBase64AsyncResult(byte[] buffer, int offset, int count, XmlBaseWriter writer, AsyncCallback callback, object state)
: base(callback, state)
{
this.writer = writer;
this.buffer = buffer;
this.offset = offset;
this.count = count;
bool completeSelf = true;
if (this.count > 0)
{
if (writer.trailByteCount > 0)
{
while (writer.trailByteCount < 3 && this.count > 0)
{
writer.trailBytes[writer.trailByteCount++] = buffer[this.offset++];
this.count--;
}
}
this.totalByteCount = writer.trailByteCount + this.count;
this.actualByteCount = totalByteCount - (totalByteCount % 3);
if (writer.trailBytes == null)
{
writer.trailBytes = new byte[3];
}
if (actualByteCount >= 3)
{
if (writer.attributeValue != null)
{
writer.WriteAttributeText(XmlConverter.Base64Encoding.GetString(writer.trailBytes, 0, writer.trailByteCount));
writer.WriteAttributeText(XmlConverter.Base64Encoding.GetString(buffer, this.offset, actualByteCount - writer.trailByteCount));
}
// StartContent/WriteBase64Text/EndContent will be called from HandleWriteBase64 as appropriate
completeSelf = HandleWriteBase64Text(null);
}
else
{
Buffer.BlockCopy(buffer, this.offset, writer.trailBytes, writer.trailByteCount, this.count);
writer.trailByteCount += this.count;
}
}
if (completeSelf)
{
this.Complete(true);
}
}
static bool OnComplete(IAsyncResult result)
{
WriteBase64AsyncResult thisPtr = (WriteBase64AsyncResult)result.AsyncState;
return thisPtr.HandleWriteBase64Text(result);
}
bool HandleWriteBase64Text(IAsyncResult result)
{
// in this code block if count > 0 && actualByteCount >= 3
if (!writer.isXmlnsAttribute)
{
if (result == null)
{
this.writer.StartContent();
result = this.writer.writer.BeginWriteBase64Text(this.writer.trailBytes,
this.writer.trailByteCount,
this.buffer,
this.offset,
this.actualByteCount - this.writer.trailByteCount,
PrepareAsyncCompletion(onComplete),
this);
if (!result.CompletedSynchronously)
{
return false;
}
}
this.writer.writer.EndWriteBase64Text(result);
this.writer.EndContent();
}
this.writer.trailByteCount = (totalByteCount - actualByteCount);
if (this.writer.trailByteCount > 0)
{
int trailOffset = offset + count - this.writer.trailByteCount;
for (int i = 0; i < this.writer.trailByteCount; i++)
this.writer.trailBytes[i] = this.buffer[trailOffset++];
}
return true;
}
public static void End(IAsyncResult result)
{
AsyncResult.End<WriteBase64AsyncResult>(result);
}
}
public override void WriteBinHex(byte[] buffer, int offset, int count)
{
if (IsClosed)
ThrowClosed();
EnsureBufferBounds(buffer, offset, count);
WriteRaw(BinHexEncoding.GetString(buffer, offset, count));
}
public override bool CanCanonicalize
{
get
{
return true;
}
}
protected bool Signing
{
get
{
return writer == signingWriter;
}
}
public override void StartCanonicalization(Stream stream, bool includeComments, string[] inclusivePrefixes)
{
if (IsClosed)
ThrowClosed();
if (Signing)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlCanonicalizationStarted)));
FlushElement();
if (signingWriter == null)
signingWriter = CreateSigningNodeWriter();
signingWriter.SetOutput(writer, stream, includeComments, inclusivePrefixes);
writer = signingWriter;
SignScope(signingWriter.CanonicalWriter);
}
public override void EndCanonicalization()
{
if (IsClosed)
ThrowClosed();
if (!Signing)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlCanonicalizationNotStarted)));
signingWriter.Flush();
writer = signingWriter.NodeWriter;
}
protected abstract XmlSigningNodeWriter CreateSigningNodeWriter();
public virtual bool CanFragment
{
get
{
return true;
}
}
public void StartFragment(Stream stream, bool generateSelfContainedTextFragment)
{
if (!CanFragment)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
if (IsClosed)
ThrowClosed();
if (stream == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("stream"));
if (oldStream != null || oldWriter != null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException());
if (WriteState == WriteState.Attribute)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "StartFragment", WriteState.ToString())));
FlushElement();
writer.Flush();
oldNamespaceBoundary = NamespaceBoundary;
XmlStreamNodeWriter fragmentWriter = null;
if (generateSelfContainedTextFragment)
{
this.NamespaceBoundary = depth + 1;
if (textFragmentWriter == null)
textFragmentWriter = new XmlUTF8NodeWriter();
textFragmentWriter.SetOutput(stream, false, Encoding.UTF8);
fragmentWriter = textFragmentWriter;
}
if (Signing)
{
if (fragmentWriter != null)
{
oldWriter = signingWriter.NodeWriter;
signingWriter.NodeWriter = fragmentWriter;
}
else
{
oldStream = ((XmlStreamNodeWriter)signingWriter.NodeWriter).Stream;
((XmlStreamNodeWriter)signingWriter.NodeWriter).Stream = stream;
}
}
else
{
if (fragmentWriter != null)
{
oldWriter = writer;
writer = fragmentWriter;
}
else
{
oldStream = nodeWriter.Stream;
nodeWriter.Stream = stream;
}
}
}
public void EndFragment()
{
if (IsClosed)
ThrowClosed();
if (oldStream == null && oldWriter == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException());
if (WriteState == WriteState.Attribute)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "EndFragment", WriteState.ToString())));
FlushElement();
writer.Flush();
if (Signing)
{
if (oldWriter != null)
signingWriter.NodeWriter = oldWriter;
else
((XmlStreamNodeWriter)signingWriter.NodeWriter).Stream = oldStream;
}
else
{
if (oldWriter != null)
writer = oldWriter;
else
nodeWriter.Stream = oldStream;
}
NamespaceBoundary = oldNamespaceBoundary;
oldWriter = null;
oldStream = null;
}
public void WriteFragment(byte[] buffer, int offset, int count)
{
if (!CanFragment)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException());
if (IsClosed)
ThrowClosed();
if (buffer == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentNullException("buffer"));
if (offset < 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.ValueMustBeNonNegative)));
if (count < 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.ValueMustBeNonNegative)));
if (count > buffer.Length - offset)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.SizeExceedsRemainingBufferSpace, buffer.Length - offset)));
if (WriteState == WriteState.Attribute)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteFragment", WriteState.ToString())));
if (writer != nodeWriter)
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException());
FlushElement();
FlushBase64();
nodeWriter.Flush();
nodeWriter.Stream.Write(buffer, offset, count);
}
void FlushBase64()
{
if (trailByteCount > 0)
{
FlushTrailBytes();
}
}
void FlushTrailBytes()
{
if (attributeValue != null)
WriteAttributeText(XmlConverter.Base64Encoding.GetString(trailBytes, 0, trailByteCount));
if (!isXmlnsAttribute)
{
StartContent();
writer.WriteBase64Text(trailBytes, trailByteCount, trailBytes, 0, 0);
EndContent();
}
trailByteCount = 0;
}
void WriteValue(object[] array)
{
FlushBase64();
StartContent();
writer.WriteStartListText();
this.inList = true;
for (int i = 0; i < array.Length; i++)
{
if (i != 0)
{
writer.WriteListSeparator();
}
WritePrimitiveValue(array[i]);
}
this.inList = false;
writer.WriteEndListText();
EndContent();
}
void WriteValue(Array array)
{
FlushBase64();
StartContent();
writer.WriteStartListText();
this.inList = true;
for (int i = 0; i < array.Length; i++)
{
if (i != 0)
{
writer.WriteListSeparator();
}
WritePrimitiveValue(array.GetValue(i));
}
this.inList = false;
writer.WriteEndListText();
EndContent();
}
protected void StartArray(int count)
{
FlushBase64();
if (this.documentState == DocumentState.Epilog)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlOnlyOneRoot)));
if (this.documentState == DocumentState.Document && count > 1 && depth == 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlOnlyOneRoot)));
if (writeState == WriteState.Attribute)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidWriteState, "WriteStartElement", WriteState.ToString())));
AutoComplete(WriteState.Content);
}
protected void EndArray()
{
}
void EnsureBufferBounds(byte[] buffer, int offset, int count)
{
if (buffer == null)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("buffer");
// Not checking upper bound because it will be caught by "count". This is what XmlTextWriter does.
if (offset < 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("offset", SR.GetString(SR.ValueMustBeNonNegative)));
if (count < 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.ValueMustBeNonNegative)));
if (count > buffer.Length - offset)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentOutOfRangeException("count", SR.GetString(SR.SizeExceedsRemainingBufferSpace, buffer.Length - offset)));
}
string GeneratePrefix(string ns, XmlDictionaryString xNs)
{
if (writeState != WriteState.Element && writeState != WriteState.Attribute)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR.GetString(SR.XmlInvalidPrefixState, WriteState.ToString())));
string prefix = nsMgr.AddNamespace(ns, xNs);
if (prefix != null)
return prefix;
while (true)
{
int prefixId = elements[depth].PrefixId++;
prefix = string.Concat("d", depth.ToString(CultureInfo.InvariantCulture), "p", prefixId.ToString(CultureInfo.InvariantCulture));
if (nsMgr.LookupNamespace(prefix) == null)
{
nsMgr.AddNamespace(prefix, ns, xNs);
return prefix;
}
}
}
protected void SignScope(XmlCanonicalWriter signingWriter)
{
nsMgr.Sign(signingWriter);
}
void WriteAttributeText(string value)
{
if (attributeValue.Length == 0)
attributeValue = value;
else
attributeValue += value;
}
class Element
{
string prefix;
string localName;
int prefixId;
public string Prefix
{
get
{
return prefix;
}
set
{
prefix = value;
}
}
public string LocalName
{
get
{
return localName;
}
set
{
localName = value;
}
}
public int PrefixId
{
get
{
return prefixId;
}
set
{
prefixId = value;
}
}
public void Clear()
{
this.prefix = null;
this.localName = null;
this.prefixId = 0;
}
}
enum DocumentState : byte
{
None, // Not inside StartDocument/EndDocument - Allows multiple root elemnts
Document, // Inside StartDocument/EndDocument
Epilog, // EndDocument must be called
End // Nothing further to write
}
class NamespaceManager
{
Namespace[] namespaces;
Namespace lastNameSpace;
int nsCount;
int depth;
XmlAttribute[] attributes;
int attributeCount;
XmlSpace space;
string lang;
int namespaceBoundary;
int nsTop;
Namespace defaultNamespace;
public NamespaceManager()
{
defaultNamespace = new Namespace();
defaultNamespace.Depth = 0;
defaultNamespace.Prefix = string.Empty;
defaultNamespace.Uri = string.Empty;
defaultNamespace.UriDictionaryString = null;
}
public string XmlLang
{
get
{
return lang;
}
}
public XmlSpace XmlSpace
{
get
{
return space;
}
}
public void Clear()
{
if (this.namespaces == null)
{
this.namespaces = new Namespace[4];
this.namespaces[0] = defaultNamespace;
}
this.nsCount = 1;
this.nsTop = 0;
this.depth = 0;
this.attributeCount = 0;
this.space = XmlSpace.None;
this.lang = null;
this.lastNameSpace = null;
this.namespaceBoundary = 0;
}
public int NamespaceBoundary
{
get
{
return namespaceBoundary;
}
set
{
int i;
for (i = 0; i < nsCount; i++)
if (namespaces[i].Depth >= value)
break;
nsTop = i;
namespaceBoundary = value;
lastNameSpace = null;
}
}
public void Close()
{
if (depth == 0)
{
if (namespaces != null && namespaces.Length > 32)
namespaces = null;
if (attributes != null && attributes.Length > 4)
attributes = null;
}
else
{
namespaces = null;
attributes = null;
}
lang = null;
}
public void DeclareNamespaces(XmlNodeWriter writer)
{
int i = this.nsCount;
while (i > 0)
{
Namespace nameSpace = namespaces[i - 1];
if (nameSpace.Depth != depth)
break;
i--;
}
while (i < this.nsCount)
{
Namespace nameSpace = namespaces[i];
if (nameSpace.UriDictionaryString != null)
writer.WriteXmlnsAttribute(nameSpace.Prefix, nameSpace.UriDictionaryString);
else
writer.WriteXmlnsAttribute(nameSpace.Prefix, nameSpace.Uri);
i++;
}
}
public void EnterScope()
{
depth++;
}
public void ExitScope()
{
while (nsCount > 0)
{
Namespace nameSpace = namespaces[nsCount - 1];
if (nameSpace.Depth != depth)
break;
if (lastNameSpace == nameSpace)
lastNameSpace = null;
nameSpace.Clear();
nsCount--;
}
while (attributeCount > 0)
{
XmlAttribute attribute = attributes[attributeCount - 1];
if (attribute.Depth != depth)
break;
space = attribute.XmlSpace;
lang = attribute.XmlLang;
attribute.Clear();
attributeCount--;
}
depth--;
}
public void AddLangAttribute(string lang)
{
AddAttribute();
this.lang = lang;
}
public void AddSpaceAttribute(XmlSpace space)
{
AddAttribute();
this.space = space;
}
void AddAttribute()
{
if (attributes == null)
{
attributes = new XmlAttribute[1];
}
else if (attributes.Length == attributeCount)
{
XmlAttribute[] newAttributes = new XmlAttribute[attributeCount * 2];
Array.Copy(attributes, newAttributes, attributeCount);
attributes = newAttributes;
}
XmlAttribute attribute = attributes[attributeCount];
if (attribute == null)
{
attribute = new XmlAttribute();
attributes[attributeCount] = attribute;
}
attribute.XmlLang = this.lang;
attribute.XmlSpace = this.space;
attribute.Depth = depth;
attributeCount++;
}
public string AddNamespace(string uri, XmlDictionaryString uriDictionaryString)
{
if (uri.Length == 0)
{
// Empty namespace can only be bound to the empty prefix
AddNamespaceIfNotDeclared(string.Empty, uri, uriDictionaryString);
return string.Empty;
}
else
{
for (int i = 0; i < prefixes.Length; i++)
{
string prefix = prefixes[i];
bool declared = false;
for (int j = nsCount - 1; j >= nsTop; j--)
{
Namespace nameSpace = namespaces[j];
if (nameSpace.Prefix == prefix)
{
declared = true;
break;
}
}
if (!declared)
{
AddNamespace(prefix, uri, uriDictionaryString);
return prefix;
}
}
}
return null;
}
public void AddNamespaceIfNotDeclared(string prefix, string uri, XmlDictionaryString uriDictionaryString)
{
if (LookupNamespace(prefix) != uri)
{
AddNamespace(prefix, uri, uriDictionaryString);
}
}
public void AddNamespace(string prefix, string uri, XmlDictionaryString uriDictionaryString)
{
if (prefix.Length >= 3)
{
// Upper and lower case letter differ by a bit.
if ((prefix[0] & ~32) == 'X' && (prefix[1] & ~32) == 'M' && (prefix[2] & ~32) == 'L')
{
if (prefix == "xml" && uri == xmlNamespace)
return;
if (prefix == "xmlns" && uri == xmlnsNamespace)
return;
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlReservedPrefix), "prefix"));
}
}
Namespace nameSpace;
for (int i = nsCount - 1; i >= 0; i--)
{
nameSpace = namespaces[i];
if (nameSpace.Depth != depth)
break;
if (nameSpace.Prefix == prefix)
{
if (nameSpace.Uri == uri)
return;
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlPrefixBoundToNamespace, prefix, nameSpace.Uri, uri), "prefix"));
}
}
if (prefix.Length != 0 && uri.Length == 0)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlEmptyNamespaceRequiresNullPrefix), "prefix"));
if (uri.Length == xmlnsNamespace.Length && uri == xmlnsNamespace)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlSpecificBindingNamespace, "xmlns", uri)));
// The addressing namespace and the xmlNamespace are the same length, so add a quick check to try to disambiguate
if (uri.Length == xmlNamespace.Length && uri[18] == 'X' && uri == xmlNamespace)
throw System.Runtime.Serialization.DiagnosticUtility.ExceptionUtility.ThrowHelperError(new ArgumentException(SR.GetString(SR.XmlSpecificBindingNamespace, "xml", uri)));
if (namespaces.Length == nsCount)
{
Namespace[] newNamespaces = new Namespace[nsCount * 2];
Array.Copy(namespaces, newNamespaces, nsCount);
namespaces = newNamespaces;
}
nameSpace = namespaces[nsCount];
if (nameSpace == null)
{
nameSpace = new Namespace();
namespaces[nsCount] = nameSpace;
}
nameSpace.Depth = depth;
nameSpace.Prefix = prefix;
nameSpace.Uri = uri;
nameSpace.UriDictionaryString = uriDictionaryString;
nsCount++;
lastNameSpace = null;
}
public string LookupPrefix(string ns)
{
if (lastNameSpace != null && lastNameSpace.Uri == ns)
return lastNameSpace.Prefix;
int nsCount = this.nsCount;
for (int i = nsCount - 1; i >= nsTop; i--)
{
Namespace nameSpace = namespaces[i];
if (object.ReferenceEquals(nameSpace.Uri, ns))
{
string prefix = nameSpace.Prefix;
// Make sure that the prefix refers to the namespace in scope
bool declared = false;
for (int j = i + 1; j < nsCount; j++)
{
if (namespaces[j].Prefix == prefix)
{
declared = true;
break;
}
}
if (!declared)
{
lastNameSpace = nameSpace;
return prefix;
}
}
}
for (int i = nsCount - 1; i >= nsTop; i--)
{
Namespace nameSpace = namespaces[i];
if (nameSpace.Uri == ns)
{
string prefix = nameSpace.Prefix;
// Make sure that the prefix refers to the namespace in scope
bool declared = false;
for (int j = i + 1; j < nsCount; j++)
{
if (namespaces[j].Prefix == prefix)
{
declared = true;
break;
}
}
if (!declared)
{
lastNameSpace = nameSpace;
return prefix;
}
}
}
if (ns.Length == 0)
{
// Make sure the default binding is still valid
bool emptyPrefixUnassigned = true;
for (int i = nsCount - 1; i >= nsTop; i--)
{
if (namespaces[i].Prefix.Length == 0)
{
emptyPrefixUnassigned = false;
break;
}
}
if (emptyPrefixUnassigned)
return string.Empty;
}
if (ns == xmlnsNamespace)
return "xmlns";
if (ns == xmlNamespace)
return "xml";
return null;
}
public string LookupAttributePrefix(string ns)
{
if (lastNameSpace != null && lastNameSpace.Uri == ns && lastNameSpace.Prefix.Length != 0)
return lastNameSpace.Prefix;
int nsCount = this.nsCount;
for (int i = nsCount - 1; i >= nsTop; i--)
{
Namespace nameSpace = namespaces[i];
if (object.ReferenceEquals(nameSpace.Uri, ns))
{
string prefix = nameSpace.Prefix;
if (prefix.Length != 0)
{
// Make sure that the prefix refers to the namespace in scope
bool declared = false;
for (int j = i + 1; j < nsCount; j++)
{
if (namespaces[j].Prefix == prefix)
{
declared = true;
break;
}
}
if (!declared)
{
lastNameSpace = nameSpace;
return prefix;
}
}
}
}
for (int i = nsCount - 1; i >= nsTop; i--)
{
Namespace nameSpace = namespaces[i];
if (nameSpace.Uri == ns)
{
string prefix = nameSpace.Prefix;
if (prefix.Length != 0)
{
// Make sure that the prefix refers to the namespace in scope
bool declared = false;
for (int j = i + 1; j < nsCount; j++)
{
if (namespaces[j].Prefix == prefix)
{
declared = true;
break;
}
}
if (!declared)
{
lastNameSpace = nameSpace;
return prefix;
}
}
}
}
if (ns.Length == 0)
return string.Empty;
return null;
}
public string LookupNamespace(string prefix)
{
int nsCount = this.nsCount;
if (prefix.Length == 0)
{
for (int i = nsCount - 1; i >= nsTop; i--)
{
Namespace nameSpace = namespaces[i];
if (nameSpace.Prefix.Length == 0)
return nameSpace.Uri;
}
return string.Empty;
}
if (prefix.Length == 1)
{
char prefixChar = prefix[0];
for (int i = nsCount - 1; i >= nsTop; i--)
{
Namespace nameSpace = namespaces[i];
if (nameSpace.PrefixChar == prefixChar)
return nameSpace.Uri;
}
return null;
}
for (int i = nsCount - 1; i >= nsTop; i--)
{
Namespace nameSpace = namespaces[i];
if (nameSpace.Prefix == prefix)
return nameSpace.Uri;
}
if (prefix == "xmlns")
return xmlnsNamespace;
if (prefix == "xml")
return xmlNamespace;
return null;
}
public void Sign(XmlCanonicalWriter signingWriter)
{
int nsCount = this.nsCount;
Fx.Assert(nsCount >= 1 && namespaces[0].Prefix.Length == 0 && namespaces[0].Uri.Length == 0, "");
for (int i = 1; i < nsCount; i++)
{
Namespace nameSpace = namespaces[i];
bool found = false;
for (int j = i + 1; j < nsCount && !found; j++)
{
found = (nameSpace.Prefix == namespaces[j].Prefix);
}
if (!found)
{
signingWriter.WriteXmlnsAttribute(nameSpace.Prefix, nameSpace.Uri);
}
}
}
class XmlAttribute
{
XmlSpace space;
string lang;
int depth;
public XmlAttribute()
{
}
public int Depth
{
get
{
return depth;
}
set
{
depth = value;
}
}
public string XmlLang
{
get
{
return lang;
}
set
{
lang = value;
}
}
public XmlSpace XmlSpace
{
get
{
return space;
}
set
{
space = value;
}
}
public void Clear()
{
this.lang = null;
}
}
class Namespace
{
string prefix;
string ns;
XmlDictionaryString xNs;
int depth;
char prefixChar;
public Namespace()
{
}
public void Clear()
{
this.prefix = null;
this.prefixChar = (char)0;
this.ns = null;
this.xNs = null;
this.depth = 0;
}
public int Depth
{
get
{
return depth;
}
set
{
depth = value;
}
}
public char PrefixChar
{
get
{
return prefixChar;
}
}
public string Prefix
{
get
{
return prefix;
}
set
{
if (value.Length == 1)
prefixChar = value[0];
else
prefixChar = (char)0;
prefix = value;
}
}
public string Uri
{
get
{
return ns;
}
set
{
ns = value;
}
}
public XmlDictionaryString UriDictionaryString
{
get
{
return xNs;
}
set
{
xNs = value;
}
}
}
}
class XmlBaseWriterNodeWriterAsyncHelper
{
static AsyncEventArgsCallback onWriteComplete;
XmlBaseWriter writer;
byte[] buffer;
int offset;
int count;
int actualByteCount;
int totalByteCount;
AsyncEventArgs<XmlNodeWriterWriteBase64TextArgs> nodeWriterAsyncState;
XmlNodeWriterWriteBase64TextArgs nodeWriterArgs;
AsyncEventArgs<XmlWriteBase64AsyncArguments> inputState;
public XmlBaseWriterNodeWriterAsyncHelper(XmlBaseWriter writer)
{
this.writer = writer;
}
public void SetArguments(AsyncEventArgs<XmlWriteBase64AsyncArguments> inputState)
{
Fx.Assert(inputState != null, "InputState cannot be null.");
this.inputState = inputState;
this.buffer = inputState.Arguments.Buffer;
this.offset = inputState.Arguments.Offset;
this.count = inputState.Arguments.Count;
}
public AsyncCompletionResult StartAsync()
{
bool completeSelf = true;
if (this.count > 0)
{
// Bytes that have been already been read.
if (this.writer.trailByteCount > 0)
{
// Copy over up to 3 trailing bytes into the trailBytes buffer.
while (this.writer.trailByteCount < 3 && this.count > 0)
{
this.writer.trailBytes[this.writer.trailByteCount++] = this.buffer[this.offset++];
this.count--;
}
}
this.totalByteCount = this.writer.trailByteCount + this.count;
this.actualByteCount = this.totalByteCount - (this.totalByteCount % 3);
if (this.writer.trailBytes == null)
{
this.writer.trailBytes = new byte[3];
}
if (actualByteCount >= 3)
{
if (this.writer.attributeValue != null)
{
this.writer.WriteAttributeText(XmlConverter.Base64Encoding.GetString(this.writer.trailBytes, 0, this.writer.trailByteCount));
this.writer.WriteAttributeText(XmlConverter.Base64Encoding.GetString(this.buffer, this.offset, actualByteCount - this.writer.trailByteCount));
}
// StartContent/WriteBase64Text/EndContent will be called from HandleWriteBase64 as appropriate
completeSelf = HandleWriteBase64Text(false);
}
else
{
Buffer.BlockCopy(this.buffer, this.offset, this.writer.trailBytes, this.writer.trailByteCount, this.count);
this.writer.trailByteCount += this.count;
}
}
if (completeSelf)
{
this.Clear();
return AsyncCompletionResult.Completed;
}
return AsyncCompletionResult.Queued;
}
static void OnWriteComplete(IAsyncEventArgs asyncEventArgs)
{
bool completeSelf = false;
Exception completionException = null;
XmlBaseWriterNodeWriterAsyncHelper thisPtr = (XmlBaseWriterNodeWriterAsyncHelper)asyncEventArgs.AsyncState;
AsyncEventArgs<XmlWriteBase64AsyncArguments> inputState = thisPtr.inputState;
try
{
if (asyncEventArgs.Exception != null)
{
completionException = asyncEventArgs.Exception;
completeSelf = true;
}
else
{
completeSelf = thisPtr.HandleWriteBase64Text(true);
}
}
catch (Exception exception)
{
if (Fx.IsFatal(exception))
{
throw;
}
completionException = exception;
completeSelf = true;
}
if (completeSelf)
{
thisPtr.Clear();
inputState.Complete(false, completionException);
}
}
bool HandleWriteBase64Text(bool isAsyncCallback)
{
Fx.Assert(this.count > 0 && this.actualByteCount >= 3, "HandleWriteBase64Text cannot be invoked with less than 3 bytes.");
if (!writer.isXmlnsAttribute)
{
if (!isAsyncCallback)
{
if (this.nodeWriterAsyncState == null)
{
this.nodeWriterAsyncState = new AsyncEventArgs<XmlNodeWriterWriteBase64TextArgs>();
this.nodeWriterArgs = new XmlNodeWriterWriteBase64TextArgs();
}
if (onWriteComplete == null)
{
onWriteComplete = new AsyncEventArgsCallback(OnWriteComplete);
}
this.writer.StartContent();
this.nodeWriterArgs.TrailBuffer = this.writer.trailBytes;
this.nodeWriterArgs.TrailCount = this.writer.trailByteCount;
this.nodeWriterArgs.Buffer = this.buffer;
this.nodeWriterArgs.Offset = this.offset;
this.nodeWriterArgs.Count = this.actualByteCount - this.writer.trailByteCount;
this.nodeWriterAsyncState.Set(onWriteComplete, this.nodeWriterArgs, this);
if (this.writer.writer.WriteBase64TextAsync(this.nodeWriterAsyncState) != AsyncCompletionResult.Completed)
{
return false;
}
this.nodeWriterAsyncState.Complete(true);
}
this.writer.EndContent();
}
this.writer.trailByteCount = (this.totalByteCount - this.actualByteCount);
if (this.writer.trailByteCount > 0)
{
int trailOffset = offset + count - this.writer.trailByteCount;
for (int i = 0; i < this.writer.trailByteCount; i++)
this.writer.trailBytes[i] = this.buffer[trailOffset++];
}
return true;
}
void Clear()
{
this.inputState = null;
this.buffer = null;
this.offset = 0;
this.count = 0;
this.actualByteCount = 0;
this.totalByteCount = 0;
}
}
}
}
|