net.sf.saxon.tree.tiny

## Class CompressedWhitespace

- java.lang.Object
- - net.sf.saxon.tree.tiny.CompressedWhitespace

- All Implemented Interfaces:
    CharSequence

      public class CompressedWhitespace
      extends Object
      implements CharSequence

  This class provides a compressed representation of a sequence of whitespace characters. The representation is a sequence of bytes: in each byte the top two bits indicate which whitespace character is used (x9, xA, xD, or x20) and the bottom six bits indicate the number of such characters. A zero byte is a filler. We don't compress the sequence if it would occupy more than 8 bytes, because that's the space we've got available in the TinyTree arrays.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `CompressedWhitespace(long compressedValue)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `char` | `charAt(int index)` Returns the `char` value at the specified index.
    `static CharSequence` | `compress(CharSequence in)` Attempt to compress a CharSequence
    `boolean` | `equals(Object obj)` Indicates whether some other object is "equal to" this one.
    `long` | `getCompressedValue()`
    `int` | `hashCode()` Returns a hash code value for the object.
    `int` | `length()`
    `CharSequence` | `subSequence(int start, int end)` Returns a new `CharSequence` that is a subsequence of this sequence.
    `String` | `toString()` Returns a string representation of the object.
    `FastStringBuffer` | `uncompress(FastStringBuffer buffer)` Uncompress the whitespace to a FastStringBuffer
    `static void` | `uncompress(long value, FastStringBuffer buffer)`
    `void` | `write(Writer writer)` Write the value to a Writer
    `void` | `writeEscape(boolean[] specialChars, OutputStream stream)` Write the value to a UTF-8 OutputStream with escaping of special characters
    `void` | `writeEscape(boolean[] specialChars, Writer writer)` Write the value to a Writer with escaping of special characters

    - ### Methods inherited from class java.lang.Object

      `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### CompressedWhitespace

          public CompressedWhitespace(long compressedValue)

  - ### Method Detail

    - #### compress

          public static CharSequence compress(CharSequence in)

      Attempt to compress a CharSequence
      Parameters:
        `in` - the CharSequence to be compressed
      Returns:
        the compressed sequence if it can be compressed; or the original CharSequence otherwise

    - #### uncompress

          public FastStringBuffer uncompress(FastStringBuffer buffer)

      Uncompress the whitespace to a FastStringBuffer
      Parameters:
        `buffer` - the buffer to which the whitespace is to be appended. The parameter may be null, in which case a new buffer is created.
      Returns:
        the FastStringBuffer to which the whitespace has been appended. If a buffer was supplied in the argument, this will be the same buffer.

    - #### uncompress

          public static void uncompress(long value,
                        FastStringBuffer buffer)

    - #### getCompressedValue

          public long getCompressedValue()

    - #### length

          public int length()

      Specified by:
        `length` in interface `CharSequence`

    - #### charAt

          public char charAt(int index)

      Returns the `char` value at the specified index. An index ranges from zero to `length() - 1`. The first `char` value of the sequence is at index zero, the next at index one, and so on, as for array indexing.

      If the `char` value specified by the index is a surrogate, the surrogate value is returned.

      Specified by:
        `charAt` in interface `CharSequence`
      Parameters:
        `index` - the index of the `char` value to be returned
      Returns:
        the specified `char` value
      Throws:
        `IndexOutOfBoundsException` - if the `index` argument is negative or not less than `length()`

    - #### subSequence

          public CharSequence subSequence(int start,
                                 int end)

      Returns a new `CharSequence` that is a subsequence of this sequence. The subsequence starts with the `char` value at the specified index and ends with the `char` value at index `end - 1`. The length (in `char`s) of the returned sequence is `end - start`, so if `start == end` then an empty sequence is returned.
      Specified by:
        `subSequence` in interface `CharSequence`
      Parameters:
        `start` - the start index, inclusive
        `end` - the end index, exclusive
      Returns:
        the specified subsequence
      Throws:
        `IndexOutOfBoundsException` - if `start` or `end` are negative, if `end` is greater than `length()`, or if `start` is greater than `end`

    - #### equals

          public boolean equals(Object obj)

      Indicates whether some other object is "equal to" this one.
      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Returns a hash code value for the object.
      Overrides:
        `hashCode` in class `Object`

    - #### toString

          public String toString()

      Returns a string representation of the object.
      Specified by:
        `toString` in interface `CharSequence`
      Overrides:
        `toString` in class `Object`

    - #### write

          public void write(Writer writer)
                     throws IOException

      Write the value to a Writer
      Parameters:
        `writer` - the writer to write to
      Throws:
        `IOException` - if an error occurs downstream

    - #### writeEscape

          public void writeEscape(boolean[] specialChars,
                         Writer writer)
                           throws IOException

      Write the value to a Writer with escaping of special characters
      Parameters:
        `specialChars` - identifies which characters are considered special
        `writer` - the writer to write to
      Throws:
        `IOException` - if an error occurs downstream

    - #### writeEscape

          public void writeEscape(boolean[] specialChars,
                         OutputStream stream)
                           throws IOException

      Write the value to a UTF-8 OutputStream with escaping of special characters
      Parameters:
        `specialChars` - array of booleans indicating which characters need to be XML-escaped
        `stream` - the output stream to write to
      Throws:
        `IOException` - if an error occurs downstream

Copyright (c) 2004-2013 Saxonica Limited. All rights reserved.