Package: groovy.text.markup

## [Java] Class DelegatingIndentWriter

- groovy.text.markup.DelegatingIndentWriter

-     public class DelegatingIndentWriter
      extends Writer

  A writer which delegates to another writer and supports an additional indenting level.

- - ### Field Summary

    Fields
    Modifiers | Name | Description
    --- | --- | ---
    `static String` | `SPACES` | Four-space indentation unit.
    `static String` | `TAB` | Tab indentation unit.

  - ### Constructor Summary

    Constructors
    Constructor and description
    `DelegatingIndentWriter(Writer delegate)` Creates an indenting writer that uses SPACES for each indentation level.
    `DelegatingIndentWriter(Writer delegate, String indentString)` Creates an indenting writer that delegates output to another writer.

  - ### Methods Summary

    Methods
    Type Params | Return Type | Name and description
    --- | --- | ---
    `` | `public Writer` | `append(CharSequence csq)` Appends the specified character sequence to this writer. An invocation of this method of the form `out.append(csq)` behaves in exactly the same way as the invocation
            out.write(csq.toString())
    Depending on the specification of `toString` for the character sequence `csq`, the entire sequence may not be appended. For instance, invoking the `toString` method of a character buffer will return a subsequence whose content depends upon the buffer's position and limit. throws: IOException If an I/O error occurs Parameters: `csq` - The character sequence to append. If `csq` is `null`, then the four characters `"null"` are appended to this writer. Returns: This writer Since: 1.5
    `` | `public Writer` | `append(CharSequence csq, int start, int end)` Appends a subsequence of the specified character sequence to this writer. `Appendable`. An invocation of this method of the form `out.append(csq, start, end)` when `csq` is not `null` behaves in exactly the same way as the invocation
        out.write(csq.subSequence(start, end).toString())
    throws: IndexOutOfBoundsException If `start` or `end` are negative, `start` is greater than `end`, or `end` is greater than `csq.length()` throws: IOException If an I/O error occurs Parameters: `csq` - The character sequence from which a subsequence will be appended. If `csq` is `null`, then characters will be appended as if `csq` contained the four characters `"null"`. `start` - The index of the first character in the subsequence `end` - The index of the character following the last character in the subsequence Returns: This writer Since: 1.5
    `` | `public Writer` | `append(char c)` Appends the specified character to this writer. An invocation of this method of the form `out.append(c)` behaves in exactly the same way as the invocation
            out.write(c)
    throws: IOException If an I/O error occurs Parameters: `c` - The 16-bit character to append Returns: This writer Since: 1.5
    `` | `public void` | `close()` Closes the stream, flushing it first. Once the stream has been closed, further write() or flush() invocations will cause an IOException to be thrown. Closing a previously closed stream has no effect. throws: IOException If an I/O error occurs
    `` | `public void` | `flush()` Flushes the stream. If the stream has saved any characters from the various write() methods in a buffer, write them immediately to their intended destination. Then, if that destination is another character or byte stream, flush it. Thus one flush() invocation will flush all the buffers in a chain of Writers and OutputStreams. If the intended destination of this stream is an abstraction provided by the underlying operating system, for example a file, then flushing the stream guarantees only that bytes previously written to the stream are passed to the operating system for writing; it does not guarantee that they are actually written to a physical device such as a disk drive. throws: IOException If an I/O error occurs
    `` | `public int` | `next()` Increases the current indentation level.
    `` | `public int` | `previous()` Decreases the current indentation level.
    `` | `public void` | `write(int c)` Writes a single character. The character to be written is contained in the 16 low-order bits of the given integer value; the 16 high-order bits are ignored. Subclasses that intend to support efficient single-character output should override this method. throws: IOException If an I/O error occurs Parameters: `c` - int specifying a character to be written
    `` | `public void` | `write(char[] cbuf)` Writes an array of characters. throws: IOException If an I/O error occurs Parameters: `cbuf` - Array of characters to be written
    `` | `public void` | `write(char[] cbuf, int off, int len)` Writes a portion of an array of characters. throws: IndexOutOfBoundsException Implementations should throw this exception if `off` is negative, or `len` is negative, or `off + len` is negative or greater than the length of the given array throws: IOException If an I/O error occurs Parameters: `cbuf` - Array of characters `off` - Offset from which to start writing characters `len` - Number of characters to write
    `` | `public void` | `write(String str)` Writes a string. throws: IOException If an I/O error occurs Parameters: `str` - String to be written
    `` | `public void` | `write(String str, int off, int len)` Writes a portion of a string. throws: IndexOutOfBoundsException Implementations should throw this exception if `off` is negative, or `len` is negative, or `off + len` is negative or greater than the length of the given string throws: IOException If an I/O error occurs Implementation Requirements: The implementation in this class throws an `IndexOutOfBoundsException` for the indicated conditions; overriding methods may choose to do otherwise. Parameters: `str` - A String `off` - Offset from which to start writing characters `len` - Number of characters to write
    `` | `public void` | `writeIndent()` Writes the current indentation prefix to the delegate writer.

  - ### Inherited Methods Summary

    Inherited Methods
    Methods inherited from class | Name
    --- | ---
    `class Writer` | `append, append, append, append, append, append, close, equals, flush, getClass, hashCode, notify, notifyAll, nullWriter, toString, wait, wait, wait, write, write, write, write, write`

- - ### Field Detail

    - #### public static final String SPACES

      Four-space indentation unit.

    - #### public static final String TAB

      Tab indentation unit.

  - ### Constructor Detail

    - #### public DelegatingIndentWriter(Writer delegate)

      Creates an indenting writer that uses SPACES for each indentation level.

      Parameters:
        `delegate` - writer that receives the rendered output

    - #### public DelegatingIndentWriter(Writer delegate, String indentString)

      Creates an indenting writer that delegates output to another writer.

      Parameters:
        `delegate` - writer that receives the rendered output
        `indentString` - indentation unit written for each nesting level

  - ### Method Detail

    - #### public Writer append(CharSequence csq)

      Appends the specified character sequence to this writer.

      An invocation of this method of the form `out.append(csq)` behaves in exactly the same way as the invocation

              out.write(csq.toString())

      Depending on the specification of `toString` for the character sequence `csq`, the entire sequence may not be appended. For instance, invoking the `toString` method of a character buffer will return a subsequence whose content depends upon the buffer's position and limit.

      throws:
        IOException If an I/O error occurs
      Parameters:
        `csq` - The character sequence to append. If `csq` is `null`, then the four characters `"null"` are appended to this writer.
      Returns:
        This writer
      Since:
        1.5

    - #### public Writer append(CharSequence csq, int start, int end)

      Appends a subsequence of the specified character sequence to this writer. `Appendable`.

      An invocation of this method of the form `out.append(csq, start, end)` when `csq` is not `null` behaves in exactly the same way as the invocation

          out.write(csq.subSequence(start, end).toString())

      throws:
        IndexOutOfBoundsException If `start` or `end` are negative, `start` is greater than `end`, or `end` is greater than `csq.length()`
      throws:
        IOException If an I/O error occurs
      Parameters:
        `csq` - The character sequence from which a subsequence will be appended. If `csq` is `null`, then characters will be appended as if `csq` contained the four characters `"null"`.
        `start` - The index of the first character in the subsequence
        `end` - The index of the character following the last character in the subsequence
      Returns:
        This writer
      Since:
        1.5

    - #### public Writer append(char c)

      Appends the specified character to this writer.

      An invocation of this method of the form `out.append(c)` behaves in exactly the same way as the invocation

              out.write(c)

      throws:
        IOException If an I/O error occurs
      Parameters:
        `c` - The 16-bit character to append
      Returns:
        This writer
      Since:
        1.5

    - #### public void close()

      Closes the stream, flushing it first. Once the stream has been closed, further write() or flush() invocations will cause an IOException to be thrown. Closing a previously closed stream has no effect.

      throws:
        IOException If an I/O error occurs

    - #### public void flush()

      Flushes the stream. If the stream has saved any characters from the various write() methods in a buffer, write them immediately to their intended destination. Then, if that destination is another character or byte stream, flush it. Thus one flush() invocation will flush all the buffers in a chain of Writers and OutputStreams.

      If the intended destination of this stream is an abstraction provided by the underlying operating system, for example a file, then flushing the stream guarantees only that bytes previously written to the stream are passed to the operating system for writing; it does not guarantee that they are actually written to a physical device such as a disk drive.

      throws:
        IOException If an I/O error occurs

    - #### public int next()

      Increases the current indentation level.

      Returns:
        the new indentation level

    - #### public int previous()

      Decreases the current indentation level.

      Returns:
        the new indentation level

    - #### public void write(int c)

      Writes a single character. The character to be written is contained in the 16 low-order bits of the given integer value; the 16 high-order bits are ignored.

      Subclasses that intend to support efficient single-character output should override this method.

      throws:
        IOException If an I/O error occurs
      Parameters:
        `c` - int specifying a character to be written

    - #### public void write(char[] cbuf)

      Writes an array of characters.

      throws:
        IOException If an I/O error occurs
      Parameters:
        `cbuf` - Array of characters to be written

    - #### public void write(char[] cbuf, int off, int len)

      Writes a portion of an array of characters.

      throws:
        IndexOutOfBoundsException Implementations should throw this exception if `off` is negative, or `len` is negative, or `off + len` is negative or greater than the length of the given array
      throws:
        IOException If an I/O error occurs
      Parameters:
        `cbuf` - Array of characters
        `off` - Offset from which to start writing characters
        `len` - Number of characters to write

    - #### public void write(String str)

      Writes a string.

      throws:
        IOException If an I/O error occurs
      Parameters:
        `str` - String to be written

    - #### public void write(String str, int off, int len)

      Writes a portion of a string.

      throws:
        IndexOutOfBoundsException Implementations should throw this exception if `off` is negative, or `len` is negative, or `off + len` is negative or greater than the length of the given string
      throws:
        IOException If an I/O error occurs
      Implementation Requirements:
        The implementation in this class throws an `IndexOutOfBoundsException` for the indicated conditions; overriding methods may choose to do otherwise.
      Parameters:
        `str` - A String
        `off` - Offset from which to start writing characters
        `len` - Number of characters to write

    - #### public void writeIndent()

      Writes the current indentation prefix to the delegate writer.

      throws:
        IOException if writing the indentation fails