457 lines
17 KiB
C#
457 lines
17 KiB
C#
//------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//------------------------------------------------------------
|
|
|
|
namespace System.IdentityModel
|
|
{
|
|
using System;
|
|
using System.IO;
|
|
using System.Xml;
|
|
|
|
/// <summary>
|
|
/// Class wraps a given writer and delegates all XmlDictionaryWriter calls
|
|
/// to the inner wrapped writer.
|
|
/// </summary>
|
|
public class DelegatingXmlDictionaryWriter : XmlDictionaryWriter
|
|
{
|
|
XmlDictionaryWriter _innerWriter;
|
|
|
|
// this writer is used to echo un-canonicalized bytes
|
|
XmlWriter _tracingWriter;
|
|
|
|
/// <summary>
|
|
/// Initializes a new instance of <see cref="DelegatingXmlDictionaryWriter"/>
|
|
/// </summary>
|
|
protected DelegatingXmlDictionaryWriter()
|
|
{
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes the inner writer that this instance wraps.
|
|
/// </summary>
|
|
/// <param name="innerWriter">XmlDictionaryWriter to wrap.</param>
|
|
protected void InitializeInnerWriter(XmlDictionaryWriter innerWriter)
|
|
{
|
|
if (innerWriter == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgumentNull("innerWriter");
|
|
}
|
|
|
|
_innerWriter = innerWriter;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Initializes a writer that will write the un-canonicalize xml.
|
|
/// If this agrument is not null, all calls will be echoed to this writer.
|
|
/// </summary>
|
|
/// <param name="tracingWriter">XmlTextWriter to echo .</param>
|
|
protected void InitializeTracingWriter(XmlWriter tracingWriter)
|
|
{
|
|
_tracingWriter = tracingWriter;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Gets the wrapped writer.
|
|
/// </summary>
|
|
protected XmlDictionaryWriter InnerWriter
|
|
{
|
|
get
|
|
{
|
|
return _innerWriter;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Closes the underlying stream.
|
|
/// </summary>
|
|
public override void Close()
|
|
{
|
|
_innerWriter.Close();
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.Close();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Flushes the underlying stream.
|
|
/// </summary>
|
|
public override void Flush()
|
|
{
|
|
_innerWriter.Flush();
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.Flush();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Encodes the specified binary bytes as Base64 and writes out the resulting text.
|
|
/// </summary>
|
|
/// <param name="buffer">Byte array to encode.</param>
|
|
/// <param name="index">The position in the buffer indicating the start of the bytes to write.</param>
|
|
/// <param name="count">The number of bytes to write.</param>
|
|
public override void WriteBase64(byte[] buffer, int index, int count)
|
|
{
|
|
_innerWriter.WriteBase64(buffer, index, count);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteBase64(buffer, index, count);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes out a CDATA block containing the specified text.
|
|
/// </summary>
|
|
/// <param name="text">The text to place inside the CDATA block.</param>
|
|
public override void WriteCData(string text)
|
|
{
|
|
_innerWriter.WriteCData(text);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteCData(text);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Forces the generation of a character entity for the specified Unicode character value.
|
|
/// </summary>
|
|
/// <param name="ch">The Unicode character for which to generate a character entity.</param>
|
|
public override void WriteCharEntity(char ch)
|
|
{
|
|
_innerWriter.WriteCharEntity(ch);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteCharEntity(ch);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// When overridden in a derived class, writes text one buffer at a time.
|
|
/// </summary>
|
|
/// <param name="buffer">Character array containing the text to write.</param>
|
|
/// <param name="index">The position in the buffer indicating the start of the text to write.</param>
|
|
/// <param name="count">The number of characters to write.</param>
|
|
public override void WriteChars(char[] buffer, int index, int count)
|
|
{
|
|
_innerWriter.WriteChars(buffer, index, count);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteChars(buffer, index, count);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes out a comment containing the specified text.
|
|
/// </summary>
|
|
/// <param name="text">Text to place inside the comment.</param>
|
|
public override void WriteComment(string text)
|
|
{
|
|
_innerWriter.WriteComment(text);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteComment(text);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the DOCTYPE declaration with the specified name and optional attributes.
|
|
/// </summary>
|
|
/// <param name="name">The name of the DOCTYPE. This must be non-empty.</param>
|
|
/// <param name="pubid">If non-null it also writes PUBLIC "pubid" "sysid" where pubid and sysid are
|
|
/// replaced with the value of the given arguments.</param>
|
|
/// <param name="sysid">If pubid is null and sysid is non-null it writes SYSTEM "sysid" where sysid
|
|
/// is replaced with the value of this argument.</param>
|
|
/// <param name="subset">If non-null it writes [subset] where subset is replaced with the value of
|
|
/// this argument.</param>
|
|
public override void WriteDocType(string name, string pubid, string sysid, string subset)
|
|
{
|
|
_innerWriter.WriteDocType(name, pubid, sysid, subset);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteDocType(name, pubid, sysid, subset);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Closes the previous System.Xml.XmlWriter.WriteStartAttribute(System.String,System.String) call.
|
|
/// </summary>
|
|
public override void WriteEndAttribute()
|
|
{
|
|
_innerWriter.WriteEndAttribute();
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteEndAttribute();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Closes any open elements or attributes and puts the writer back in the Start state.
|
|
/// </summary>
|
|
public override void WriteEndDocument()
|
|
{
|
|
_innerWriter.WriteEndDocument();
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteEndDocument();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Closes one element and pops the corresponding namespace scope.
|
|
/// </summary>
|
|
public override void WriteEndElement()
|
|
{
|
|
_innerWriter.WriteEndElement();
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteEndElement();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes out an entity reference as name.
|
|
/// </summary>
|
|
/// <param name="name">The name of the entity reference.</param>
|
|
public override void WriteEntityRef(string name)
|
|
{
|
|
_innerWriter.WriteEntityRef(name);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteEntityRef(name);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Closes one element and pops the corresponding namespace scope.
|
|
/// </summary>
|
|
public override void WriteFullEndElement()
|
|
{
|
|
_innerWriter.WriteFullEndElement();
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteFullEndElement();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes out a processing instruction with a space between the name and text as follows: <?name text?>.
|
|
/// </summary>
|
|
/// <param name="name">The name of the processing instruction.</param>
|
|
/// <param name="text">The text to include in the processing instruction.</param>
|
|
public override void WriteProcessingInstruction(string name, string text)
|
|
{
|
|
_innerWriter.WriteProcessingInstruction(name, text);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteProcessingInstruction(name, text);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// When overridden in a derived class, writes raw markup manually from a character buffer.
|
|
/// </summary>
|
|
/// <param name="buffer">Character array containing the text to write.</param>
|
|
/// <param name="index">The position within the buffer indicating the start of the text to write.</param>
|
|
/// <param name="count">The number of characters to write.</param>
|
|
public override void WriteRaw(char[] buffer, int index, int count)
|
|
{
|
|
_innerWriter.WriteRaw(buffer, index, count);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteRaw(buffer, index, count);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes raw markup manually from a string.
|
|
/// </summary>
|
|
/// <param name="data">String containing the text to write.</param>
|
|
public override void WriteRaw(string data)
|
|
{
|
|
_innerWriter.WriteRaw(data);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteRaw(data);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the start of an attribute with the specified local name and namespace URI.
|
|
/// </summary>
|
|
/// <param name="prefix">The namespace prefix of the attribute.</param>
|
|
/// <param name="localName">The local name of the attribute.</param>
|
|
/// <param name="ns">The namespace URI for the attribute.</param>
|
|
public override void WriteStartAttribute(string prefix, string localName, string ns)
|
|
{
|
|
_innerWriter.WriteStartAttribute(prefix, localName, ns);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteStartAttribute(prefix, localName, ns);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// When overridden in a derived class, writes the XML declaration with the version "1.0".
|
|
/// </summary>
|
|
public override void WriteStartDocument()
|
|
{
|
|
_innerWriter.WriteStartDocument();
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteStartDocument();
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// When overridden in a derived class, writes the XML declaration with the version
|
|
/// "1.0" and the standalone attribute.
|
|
/// </summary>
|
|
/// <param name="standalone">If true, it writes "standalone=yes"; if false, it writes "standalone=no".</param>
|
|
public override void WriteStartDocument(bool standalone)
|
|
{
|
|
_innerWriter.WriteStartDocument(standalone);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteStartDocument(standalone);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// When overridden in a derived class, writes the specified start tag and associates
|
|
/// it with the given namespace and prefix.
|
|
/// </summary>
|
|
/// <param name="prefix">The namespace prefix of the element.</param>
|
|
/// <param name="localName">The local name of the element.</param>
|
|
/// <param name="ns">The namespace URI to associate with the element.</param>
|
|
public override void WriteStartElement(string prefix, string localName, string ns)
|
|
{
|
|
_innerWriter.WriteStartElement(prefix, localName, ns);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteStartElement(prefix, localName, ns);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// When overridden in a derived class, gets the state of the writer.
|
|
/// </summary>
|
|
public override WriteState WriteState
|
|
{
|
|
get { return _innerWriter.WriteState; }
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes the given text content.
|
|
/// </summary>
|
|
/// <param name="text">The text to write.</param>
|
|
public override void WriteString(string text)
|
|
{
|
|
_innerWriter.WriteString(text);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteString(text);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Generates and writes the surrogate character entity for the surrogate character pair.
|
|
/// </summary>
|
|
/// <param name="lowChar">The low surrogate. This must be a value between 0xDC00 and 0xDFFF.</param>
|
|
/// <param name="highChar">The high surrogate. This must be a value between 0xD800 and 0xDBFF.</param>
|
|
public override void WriteSurrogateCharEntity(char lowChar, char highChar)
|
|
{
|
|
_innerWriter.WriteSurrogateCharEntity(lowChar, highChar);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteSurrogateCharEntity(lowChar, highChar);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes out the given white space.
|
|
/// </summary>
|
|
/// <param name="ws">The string of white space characters.</param>
|
|
public override void WriteWhitespace(string ws)
|
|
{
|
|
_innerWriter.WriteWhitespace(ws);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteWhitespace(ws);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes an attribute as a xml attribute with the prefix 'xml:'.
|
|
/// </summary>
|
|
/// <param name="localName">Localname of the attribute.</param>
|
|
/// <param name="value">Attribute value.</param>
|
|
public override void WriteXmlAttribute(string localName, string value)
|
|
{
|
|
_innerWriter.WriteXmlAttribute(localName, value);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteAttributeString(localName, value);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Writes an xmlns namespace declaration.
|
|
/// </summary>
|
|
/// <param name="prefix">The prefix of the namespace declaration.</param>
|
|
/// <param name="namespaceUri">The namespace Uri itself.</param>
|
|
public override void WriteXmlnsAttribute(string prefix, string namespaceUri)
|
|
{
|
|
_innerWriter.WriteXmlnsAttribute(prefix, namespaceUri);
|
|
if (_tracingWriter != null)
|
|
{
|
|
_tracingWriter.WriteAttributeString(prefix, String.Empty, namespaceUri, String.Empty);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns the closest prefix defined in the current namespace scope for the namespace URI.
|
|
/// </summary>
|
|
/// <param name="ns">The namespace URI whose prefix you want to find.</param>
|
|
/// <returns>The matching prefix or null if no matching namespace URI is found in the
|
|
/// current scope.</returns>
|
|
public override string LookupPrefix(string ns)
|
|
{
|
|
return _innerWriter.LookupPrefix(ns);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Returns a value indicating if the reader is capable of Canonicalization.
|
|
/// </summary>
|
|
public override bool CanCanonicalize
|
|
{
|
|
get
|
|
{
|
|
return _innerWriter.CanCanonicalize;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Indicates the start of Canonicalization. Any write operatation following this will canonicalize the data
|
|
/// and will wirte it to the given stream.
|
|
/// </summary>
|
|
/// <param name="stream">Stream to which the canonical stream should be written.</param>
|
|
/// <param name="includeComments">The value indicates if comments written should be canonicalized as well.</param>
|
|
/// <param name="inclusivePrefixes">Set of prefixes that needs to be included into the canonical stream. The prefixes are defined at
|
|
/// the first element that is written to the canonical stream.</param>
|
|
public override void StartCanonicalization(Stream stream, bool includeComments, string[] inclusivePrefixes)
|
|
{
|
|
_innerWriter.StartCanonicalization(stream, includeComments, inclusivePrefixes);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Closes a previous Start canonicalization operation. The stream given to the StartCanonicalization is flushed
|
|
/// and any data written after this call will not be written to the canonical stream.
|
|
/// </summary>
|
|
public override void EndCanonicalization()
|
|
{
|
|
_innerWriter.EndCanonicalization();
|
|
}
|
|
}
|
|
}
|