The Labs \ Source Viewer \ SSCLI \ System.Xml \ XmlWrappingWriter

  1. //------------------------------------------------------------------------------
  2. // <copyright file="XmlWrapingWriter.cs" company="Microsoft">
  3. //
  4. // Copyright (c) 2006 Microsoft Corporation. All rights reserved.
  5. //
  6. // The use and distribution terms for this software are contained in the file
  7. // named license.txt, which can be found in the root of this distribution.
  8. // By using this software in any fashion, you are agreeing to be bound by the
  9. // terms of this license.
  10. //
  11. // You must not remove this notice, or any other, from this software.
  12. //
  13. // </copyright>
  14. //------------------------------------------------------------------------------
  15. using System;
  16. using System.IO;
  17. using System.Xml.XPath;
  18. using System.Xml.Schema;
  19. using System.Collections;
  20. using System.Diagnostics;
  21. namespace System.Xml
  22. {
  23.    
  24.     internal class XmlWrappingWriter : XmlWriter
  25.     {
  26.         //
  27.         // Fields
  28.         //
  29.         protected XmlWriter writer;
  30.        
  31.         //
  32.         // Constructor
  33.         //
  34.         internal XmlWrappingWriter(XmlWriter baseWriter)
  35.         {
  36.             Debug.Assert(baseWriter != null);
  37.             Writer = baseWriter;
  38.         }
  39.        
  40.         //
  41.         // XmlWriter implementation
  42.         //
  43.         public override XmlWriterSettings Settings {
  44.             get { return writer.Settings; }
  45.         }
  46.         public override WriteState WriteState {
  47.             get { return writer.WriteState; }
  48.         }
  49.         public override XmlSpace XmlSpace {
  50.             get { return writer.XmlSpace; }
  51.         }
  52.         public override string XmlLang {
  53.             get { return writer.XmlLang; }
  54.         }
  55.        
  56.         public override void WriteStartDocument()
  57.         {
  58.             writer.WriteStartDocument();
  59.         }
  60.        
  61.         public override void WriteStartDocument(bool standalone)
  62.         {
  63.             writer.WriteStartDocument(standalone);
  64.         }
  65.        
  66.         public override void WriteEndDocument()
  67.         {
  68.             writer.WriteEndDocument();
  69.         }
  70.        
  71.         public override void WriteDocType(string name, string pubid, string sysid, string subset)
  72.         {
  73.             writer.WriteDocType(name, pubid, sysid, subset);
  74.         }
  75.        
  76.         public override void WriteStartElement(string prefix, string localName, string ns)
  77.         {
  78.             writer.WriteStartElement(prefix, localName, ns);
  79.         }
  80.        
  81.         public override void WriteEndElement()
  82.         {
  83.             writer.WriteEndElement();
  84.         }
  85.        
  86.         public override void WriteFullEndElement()
  87.         {
  88.             writer.WriteFullEndElement();
  89.         }
  90.        
  91.         public override void WriteStartAttribute(string prefix, string localName, string ns)
  92.         {
  93.             writer.WriteStartAttribute(prefix, localName, ns);
  94.         }
  95.        
  96.         public override void WriteEndAttribute()
  97.         {
  98.             writer.WriteEndAttribute();
  99.         }
  100.        
  101.         public override void WriteCData(string text)
  102.         {
  103.             writer.WriteCData(text);
  104.         }
  105.        
  106.         public override void WriteComment(string text)
  107.         {
  108.             writer.WriteComment(text);
  109.         }
  110.        
  111.         public override void WriteProcessingInstruction(string name, string text)
  112.         {
  113.             writer.WriteProcessingInstruction(name, text);
  114.         }
  115.        
  116.         public override void WriteEntityRef(string name)
  117.         {
  118.             writer.WriteEntityRef(name);
  119.         }
  120.        
  121.         public override void WriteCharEntity(char ch)
  122.         {
  123.             writer.WriteCharEntity(ch);
  124.         }
  125.        
  126.         public override void WriteWhitespace(string ws)
  127.         {
  128.             writer.WriteWhitespace(ws);
  129.         }
  130.        
  131.         public override void WriteString(string text)
  132.         {
  133.             writer.WriteString(text);
  134.         }
  135.        
  136.         public override void WriteSurrogateCharEntity(char lowChar, char highChar)
  137.         {
  138.             writer.WriteSurrogateCharEntity(lowChar, highChar);
  139.         }
  140.        
  141.         public override void WriteChars(char[] buffer, int index, int count)
  142.         {
  143.             writer.WriteChars(buffer, index, count);
  144.         }
  145.        
  146.         public override void WriteRaw(char[] buffer, int index, int count)
  147.         {
  148.             writer.WriteRaw(buffer, index, count);
  149.         }
  150.        
  151.         public override void WriteRaw(string data)
  152.         {
  153.             writer.WriteRaw(data);
  154.         }
  155.        
  156.         public override void WriteBase64(byte[] buffer, int index, int count)
  157.         {
  158.             writer.WriteBase64(buffer, index, count);
  159.         }
  160.        
  161.         public override void Close()
  162.         {
  163.             writer.Close();
  164.         }
  165.        
  166.         public override void Flush()
  167.         {
  168.             writer.Flush();
  169.         }
  170.        
  171.         public override string LookupPrefix(string ns)
  172.         {
  173.             return writer.LookupPrefix(ns);
  174.         }
  175.        
  176.         public override void WriteValue(object value)
  177.         {
  178.             writer.WriteValue(value);
  179.         }
  180.        
  181.         public override void WriteValue(string value)
  182.         {
  183.             writer.WriteValue(value);
  184.         }
  185.        
  186.         public override void WriteValue(bool value)
  187.         {
  188.             writer.WriteValue(value);
  189.         }
  190.        
  191.         public override void WriteValue(DateTime value)
  192.         {
  193.             writer.WriteValue(value);
  194.         }
  195.        
  196.         public override void WriteValue(double value)
  197.         {
  198.             writer.WriteValue(value);
  199.         }
  200.        
  201.         public override void WriteValue(float value)
  202.         {
  203.             writer.WriteValue(value);
  204.         }
  205.        
  206.         public override void WriteValue(decimal value)
  207.         {
  208.             writer.WriteValue(value);
  209.         }
  210.        
  211.         public override void WriteValue(int value)
  212.         {
  213.             writer.WriteValue(value);
  214.         }
  215.        
  216.         public override void WriteValue(long value)
  217.         {
  218.             writer.WriteValue(value);
  219.         }
  220.        
  221.         protected override void Dispose(bool disposing)
  222.         {
  223.             ((IDisposable)writer).Dispose();
  224.         }
  225.        
  226.         //
  227.         // Protected methods
  228.         //
  229.         protected XmlWriter Writer {
  230.             get { return writer; }
  231.             set { writer = value; }
  232.         }
  233.     }
  234. }

Developer Fusion