The Labs \ Source Viewer \ SSCLI \ System.CodeDom.Compiler \ Indentation

  1. //------------------------------------------------------------------------------
  2. // <copyright file="IndentTextWriter.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. namespace System.CodeDom.Compiler
  16. {
  17.    
  18.     using System.Diagnostics;
  19.     using System;
  20.     using System.IO;
  21.     using System.Text;
  22.     using System.Security.Permissions;
  23.     using System.Globalization;
  24.    
  25.     /// <devdoc>
  26.     /// <para>Provides a text writer that can indent new lines by a tabString token.</para>
  27.     /// </devdoc>
  28.     [PermissionSet(SecurityAction.LinkDemand, Name = "FullTrust")]
  29.     [PermissionSet(SecurityAction.InheritanceDemand, Name = "FullTrust")]
  30.     public class IndentedTextWriter : TextWriter
  31.     {
  32.         private TextWriter writer;
  33.         private int indentLevel;
  34.         private bool tabsPending;
  35.         private string tabString;
  36.        
  37.         /// <devdoc>
  38.         /// <para>[To be supplied.]</para>
  39.         /// </devdoc>
  40.         public const string DefaultTabString = " ";
  41.        
  42.         /// <devdoc>
  43.         /// <para>
  44.         /// Initializes a new instance of <see cref='System.CodeDom.Compiler.IndentedTextWriter'/> using the specified
  45.         /// text writer and default tab string.
  46.         /// </para>
  47.         /// </devdoc>
  48.         public IndentedTextWriter(TextWriter writer) : this(writer, DefaultTabString)
  49.         {
  50.         }
  51.        
  52.         /// <devdoc>
  53.         /// <para>
  54.         /// Initializes a new instance of <see cref='System.CodeDom.Compiler.IndentedTextWriter'/> using the specified
  55.         /// text writer and tab string.
  56.         /// </para>
  57.         /// </devdoc>
  58.         public IndentedTextWriter(TextWriter writer, string tabString) : base(CultureInfo.InvariantCulture)
  59.         {
  60.             this.writer = writer;
  61.             this.tabString = tabString;
  62.             indentLevel = 0;
  63.             tabsPending = false;
  64.         }
  65.        
  66.         /// <devdoc>
  67.         /// <para>[To be supplied.]</para>
  68.         /// </devdoc>
  69.         public override Encoding Encoding {
  70.             get { return writer.Encoding; }
  71.         }
  72.        
  73.         /// <devdoc>
  74.         /// <para>
  75.         /// Gets or sets the new line character to use.
  76.         /// </para>
  77.         /// </devdoc>
  78.         public override string NewLine {
  79.             get { return writer.NewLine; }
  80.            
  81.             set { writer.NewLine = value; }
  82.         }
  83.        
  84.         /// <devdoc>
  85.         /// <para>
  86.         /// Gets or sets the number of spaces to indent.
  87.         /// </para>
  88.         /// </devdoc>
  89.         public int Indent {
  90.             get { return indentLevel; }
  91.             set {
  92.                 Debug.Assert(value >= 0, "Bogus Indent... probably caused by mismatched Indent++ and Indent--");
  93.                 if (value < 0) {
  94.                     value = 0;
  95.                 }
  96.                 indentLevel = value;
  97.             }
  98.         }
  99.        
  100.         /// <devdoc>
  101.         /// <para>
  102.         /// Gets or sets the TextWriter to use.
  103.         /// </para>
  104.         /// </devdoc>
  105.         public TextWriter InnerWriter {
  106.             get { return writer; }
  107.         }
  108.        
  109.         internal string TabString {
  110.             get { return tabString; }
  111.         }
  112.        
  113.         /// <devdoc>
  114.         /// <para>
  115.         /// Closes the document being written to.
  116.         /// </para>
  117.         /// </devdoc>
  118.         public override void Close()
  119.         {
  120.             writer.Close();
  121.         }
  122.        
  123.         /// <devdoc>
  124.         /// <para>[To be supplied.]</para>
  125.         /// </devdoc>
  126.         public override void Flush()
  127.         {
  128.             writer.Flush();
  129.         }
  130.        
  131.         /// <devdoc>
  132.         /// <para>[To be supplied.]</para>
  133.         /// </devdoc>
  134.         protected virtual void OutputTabs()
  135.         {
  136.             if (tabsPending) {
  137.                 for (int i = 0; i < indentLevel; i++) {
  138.                     writer.Write(tabString);
  139.                 }
  140.                 tabsPending = false;
  141.             }
  142.         }
  143.        
  144.         /// <devdoc>
  145.         /// <para>
  146.         /// Writes a string
  147.         /// to the text stream.
  148.         /// </para>
  149.         /// </devdoc>
  150.         public override void Write(string s)
  151.         {
  152.             OutputTabs();
  153.             writer.Write(s);
  154.         }
  155.        
  156.         /// <devdoc>
  157.         /// <para>
  158.         /// Writes the text representation of a Boolean value to the text stream.
  159.         /// </para>
  160.         /// </devdoc>
  161.         public override void Write(bool value)
  162.         {
  163.             OutputTabs();
  164.             writer.Write(value);
  165.         }
  166.        
  167.         /// <devdoc>
  168.         /// <para>
  169.         /// Writes a character to the text stream.
  170.         /// </para>
  171.         /// </devdoc>
  172.         public override void Write(char value)
  173.         {
  174.             OutputTabs();
  175.             writer.Write(value);
  176.         }
  177.        
  178.         /// <devdoc>
  179.         /// <para>
  180.         /// Writes a
  181.         /// character array to the text stream.
  182.         /// </para>
  183.         /// </devdoc>
  184.         public override void Write(char[] buffer)
  185.         {
  186.             OutputTabs();
  187.             writer.Write(buffer);
  188.         }
  189.        
  190.         /// <devdoc>
  191.         /// <para>
  192.         /// Writes a subarray
  193.         /// of characters to the text stream.
  194.         /// </para>
  195.         /// </devdoc>
  196.         public override void Write(char[] buffer, int index, int count)
  197.         {
  198.             OutputTabs();
  199.             writer.Write(buffer, index, count);
  200.         }
  201.        
  202.         /// <devdoc>
  203.         /// <para>
  204.         /// Writes the text representation of a Double to the text stream.
  205.         /// </para>
  206.         /// </devdoc>
  207.         public override void Write(double value)
  208.         {
  209.             OutputTabs();
  210.             writer.Write(value);
  211.         }
  212.        
  213.         /// <devdoc>
  214.         /// <para>
  215.         /// Writes the text representation of
  216.         /// a Single to the text
  217.         /// stream.
  218.         /// </para>
  219.         /// </devdoc>
  220.         public override void Write(float value)
  221.         {
  222.             OutputTabs();
  223.             writer.Write(value);
  224.         }
  225.        
  226.         /// <devdoc>
  227.         /// <para>
  228.         /// Writes the text representation of an integer to the text stream.
  229.         /// </para>
  230.         /// </devdoc>
  231.         public override void Write(int value)
  232.         {
  233.             OutputTabs();
  234.             writer.Write(value);
  235.         }
  236.        
  237.         /// <devdoc>
  238.         /// <para>
  239.         /// Writes the text representation of an 8-byte integer to the text stream.
  240.         /// </para>
  241.         /// </devdoc>
  242.         public override void Write(long value)
  243.         {
  244.             OutputTabs();
  245.             writer.Write(value);
  246.         }
  247.        
  248.         /// <devdoc>
  249.         /// <para>
  250.         /// Writes the text representation of an object
  251.         /// to the text stream.
  252.         /// </para>
  253.         /// </devdoc>
  254.         public override void Write(object value)
  255.         {
  256.             OutputTabs();
  257.             writer.Write(value);
  258.         }
  259.        
  260.         /// <devdoc>
  261.         /// <para>
  262.         /// Writes out a formatted string, using the same semantics as specified.
  263.         /// </para>
  264.         /// </devdoc>
  265.         public override void Write(string format, object arg0)
  266.         {
  267.             OutputTabs();
  268.             writer.Write(format, arg0);
  269.         }
  270.        
  271.         /// <devdoc>
  272.         /// <para>
  273.         /// Writes out a formatted string,
  274.         /// using the same semantics as specified.
  275.         /// </para>
  276.         /// </devdoc>
  277.         public override void Write(string format, object arg0, object arg1)
  278.         {
  279.             OutputTabs();
  280.             writer.Write(format, arg0, arg1);
  281.         }
  282.        
  283.         /// <devdoc>
  284.         /// <para>
  285.         /// Writes out a formatted string,
  286.         /// using the same semantics as specified.
  287.         /// </para>
  288.         /// </devdoc>
  289.         public override void Write(string format, params object[] arg)
  290.         {
  291.             OutputTabs();
  292.             writer.Write(format, arg);
  293.         }
  294.        
  295.         /// <devdoc>
  296.         /// <para>
  297.         /// Writes the specified
  298.         /// string to a line without tabs.
  299.         /// </para>
  300.         /// </devdoc>
  301.         public void WriteLineNoTabs(string s)
  302.         {
  303.             writer.WriteLine(s);
  304.         }
  305.        
  306.         /// <devdoc>
  307.         /// <para>
  308.         /// Writes the specified string followed by
  309.         /// a line terminator to the text stream.
  310.         /// </para>
  311.         /// </devdoc>
  312.         public override void WriteLine(string s)
  313.         {
  314.             OutputTabs();
  315.             writer.WriteLine(s);
  316.             tabsPending = true;
  317.         }
  318.        
  319.         /// <devdoc>
  320.         /// <para>
  321.         /// Writes a line terminator.
  322.         /// </para>
  323.         /// </devdoc>
  324.         public override void WriteLine()
  325.         {
  326.             OutputTabs();
  327.             writer.WriteLine();
  328.             tabsPending = true;
  329.         }
  330.        
  331.         /// <devdoc>
  332.         /// <para>
  333.         /// Writes the text representation of a Boolean followed by a line terminator to
  334.         /// the text stream.
  335.         /// </para>
  336.         /// </devdoc>
  337.         public override void WriteLine(bool value)
  338.         {
  339.             OutputTabs();
  340.             writer.WriteLine(value);
  341.             tabsPending = true;
  342.         }
  343.        
  344.         /// <devdoc>
  345.         /// <para>[To be supplied.]</para>
  346.         /// </devdoc>
  347.         public override void WriteLine(char value)
  348.         {
  349.             OutputTabs();
  350.             writer.WriteLine(value);
  351.             tabsPending = true;
  352.         }
  353.        
  354.         /// <devdoc>
  355.         /// <para>[To be supplied.]</para>
  356.         /// </devdoc>
  357.         public override void WriteLine(char[] buffer)
  358.         {
  359.             OutputTabs();
  360.             writer.WriteLine(buffer);
  361.             tabsPending = true;
  362.         }
  363.        
  364.         /// <devdoc>
  365.         /// <para>[To be supplied.]</para>
  366.         /// </devdoc>
  367.         public override void WriteLine(char[] buffer, int index, int count)
  368.         {
  369.             OutputTabs();
  370.             writer.WriteLine(buffer, index, count);
  371.             tabsPending = true;
  372.         }
  373.        
  374.         /// <devdoc>
  375.         /// <para>[To be supplied.]</para>
  376.         /// </devdoc>
  377.         public override void WriteLine(double value)
  378.         {
  379.             OutputTabs();
  380.             writer.WriteLine(value);
  381.             tabsPending = true;
  382.         }
  383.        
  384.         /// <devdoc>
  385.         /// <para>[To be supplied.]</para>
  386.         /// </devdoc>
  387.         public override void WriteLine(float value)
  388.         {
  389.             OutputTabs();
  390.             writer.WriteLine(value);
  391.             tabsPending = true;
  392.         }
  393.        
  394.         /// <devdoc>
  395.         /// <para>[To be supplied.]</para>
  396.         /// </devdoc>
  397.         public override void WriteLine(int value)
  398.         {
  399.             OutputTabs();
  400.             writer.WriteLine(value);
  401.             tabsPending = true;
  402.         }
  403.        
  404.         /// <devdoc>
  405.         /// <para>[To be supplied.]</para>
  406.         /// </devdoc>
  407.         public override void WriteLine(long value)
  408.         {
  409.             OutputTabs();
  410.             writer.WriteLine(value);
  411.             tabsPending = true;
  412.         }
  413.        
  414.         /// <devdoc>
  415.         /// <para>[To be supplied.]</para>
  416.         /// </devdoc>
  417.         public override void WriteLine(object value)
  418.         {
  419.             OutputTabs();
  420.             writer.WriteLine(value);
  421.             tabsPending = true;
  422.         }
  423.        
  424.         /// <devdoc>
  425.         /// <para>[To be supplied.]</para>
  426.         /// </devdoc>
  427.         public override void WriteLine(string format, object arg0)
  428.         {
  429.             OutputTabs();
  430.             writer.WriteLine(format, arg0);
  431.             tabsPending = true;
  432.         }
  433.        
  434.         /// <devdoc>
  435.         /// <para>[To be supplied.]</para>
  436.         /// </devdoc>
  437.         public override void WriteLine(string format, object arg0, object arg1)
  438.         {
  439.             OutputTabs();
  440.             writer.WriteLine(format, arg0, arg1);
  441.             tabsPending = true;
  442.         }
  443.        
  444.         /// <devdoc>
  445.         /// <para>[To be supplied.]</para>
  446.         /// </devdoc>
  447.         public override void WriteLine(string format, params object[] arg)
  448.         {
  449.             OutputTabs();
  450.             writer.WriteLine(format, arg);
  451.             tabsPending = true;
  452.         }
  453.        
  454.         /// <devdoc>
  455.         /// <para>[To be supplied.]</para>
  456.         /// </devdoc>
  457.         [CLSCompliant(false)]
  458.         public override void WriteLine(UInt32 value)
  459.         {
  460.             OutputTabs();
  461.             writer.WriteLine(value);
  462.             tabsPending = true;
  463.         }
  464.        
  465.         internal void InternalOutputTabs()
  466.         {
  467.             for (int i = 0; i < indentLevel; i++) {
  468.                 writer.Write(tabString);
  469.             }
  470.         }
  471.     }
  472.    
  473.     internal class Indentation
  474.     {
  475.         private IndentedTextWriter writer;
  476.         private int indent;
  477.         private string s;
  478.        
  479.         internal Indentation(IndentedTextWriter writer, int indent)
  480.         {
  481.             this.writer = writer;
  482.             this.indent = indent;
  483.             s = null;
  484.         }
  485.        
  486.         internal string IndentationString {
  487.             get {
  488.                 if (s == null) {
  489.                     string tabString = writer.TabString;
  490.                     StringBuilder sb = new StringBuilder(indent * tabString.Length);
  491.                     for (int i = 0; i < indent; i++) {
  492.                         sb.Append(tabString);
  493.                     }
  494.                     s = sb.ToString();
  495.                 }
  496.                 return s;
  497.             }
  498.         }
  499.     }
  500. }

Developer Fusion