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