## 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
`CompressedWhitespace(long compressedValue)`

Method Summary
`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

  Throws:
    `IOException`

### writeEscape

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

  Write the value to a Writer with escaping of special characters

  Throws:
    `IOException`

### 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`

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