net.sf.saxon.tree.util

## Class FastStringBuffer

- java.lang.Object
- - net.sf.saxon.tree.util.FastStringBuffer

- All Implemented Interfaces:
    Serializable, CharSequence, AppendableCharSequence

      public final class FastStringBuffer
      extends Object
      implements AppendableCharSequence, Serializable

  A simple implementation of a class similar to StringBuffer. Unlike StringBuffer it is not synchronized. It also offers the capability to remove unused space. (This class could possibly be replaced by StringBuilder in JDK 1.5, but using our own class gives more control.)
  See Also:
    Serialized Form

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static int` | `LARGE`
    `static int` | `MEDIUM`
    `static int` | `SMALL`
    `static int` | `TINY`

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `FastStringBuffer(CharSequence cs)` Create a FastStringBuffer with initial content
    `FastStringBuffer(int initialSize)` Create a FastStringBuffer with a given initial capacity

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `append(char ch)` Append a character to the buffer
    `void` | `append(char[] srcArray)` Append the entire contents of a character array to the buffer
    `void` | `append(char[] srcArray, int start, int length)` Append the contents of a character array to the buffer
    `void` | `append(CharSequence s)` Append the contents of a general CharSequence to the buffer
    `void` | `append(CharSlice s)` Append the contents of a CharSlice to the buffer
    `void` | `append(FastStringBuffer s)` Append the contents of a FastStringBuffer to the buffer
    `void` | `append(String s)` Append the contents of a String to the buffer
    `void` | `append(StringBuffer s)` Append the contents of a StringBuffer to the buffer
    `void` | `append(UnicodeString str)` Append a UnicodeString to the buffer (using surrogate pairs if necessary)
    `void` | `appendWideChar(int ch)` Append a wide character to the buffer (as a surrogate pair if necessary)
    `char` | `charAt(int index)` Returns the `char` value at the specified index.
    `CharSequence` | `condense()` Remove surplus space from the array.
    `static String` | `diagnosticPrint(CharSequence in)` Diagnostic print of the contents of a CharSequence.
    `void` | `ensureCapacity(int extra)` Expand the character array if necessary to ensure capacity for appended data
    `boolean` | `equals(Object other)` Compare equality
    `char[]` | `getCharArray()` Get a char[] array containing the characters.
    `void` | `getChars(int srcBegin, int srcEnd, char[] dst, int dstBegin)` Copies characters from this FastStringBuffer into the destination character array.
    `int` | `hashCode()` Generate a hash code
    `int` | `indexOf(char ch)` Get the index of the first character equal to a given value
    `void` | `insert(int index, char ch)` Insert a character at a particular offset
    `void` | `insertWideChar(int index, int ch)` Insert wide character at a particular offset
    `int` | `length()` Returns the length of this character sequence.
    `void` | `prepend(char ch)` Insert a given character at the start of the buffer
    `void` | `prepend(CharSequence str)` Insert a given string at the start of the buffer
    `void` | `prependRepeated(char ch, int repeat)` Insert a given character N times at the start of the buffer
    `void` | `prependWideChar(int ch)` Prepend a wide character to the buffer (as a surrogate pair if necessary)
    `void` | `removeCharAt(int index)` Remove a character at a particular offset
    `void` | `setCharAt(int index, char ch)` Set the character at a particular offset
    `void` | `setLength(int length)` Set the length.
    `CharSequence` | `subSequence(int start, int end)` Returns a new `CharSequence` that is a subsequence of this sequence.
    `String` | `toString()` Convert contents of the FastStringBuffer to a string
    `void` | `write(Writer writer)` Write the value to a writer

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

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

- - ### Field Detail

    - #### TINY

          public static final int TINY

      See Also:
        Constant Field Values

    - #### SMALL

          public static final int SMALL

      See Also:
        Constant Field Values

    - #### MEDIUM

          public static final int MEDIUM

      See Also:
        Constant Field Values

    - #### LARGE

          public static final int LARGE

      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### FastStringBuffer

          public FastStringBuffer(int initialSize)

      Create a FastStringBuffer with a given initial capacity
      Parameters:
        `initialSize` - the initial capacity

    - #### FastStringBuffer

          public FastStringBuffer(CharSequence cs)

      Create a FastStringBuffer with initial content
      Parameters:
        `cs` - the initial content. The buffer is created with just enough capacity for this content (it will be expanded if more content is added later).

  - ### Method Detail

    - #### append

          public void append(String s)

      Append the contents of a String to the buffer
      Parameters:
        `s` - the String to be appended

    - #### append

          public void append(CharSlice s)

      Append the contents of a CharSlice to the buffer
      Parameters:
        `s` - the String to be appended

    - #### append

          public void append(FastStringBuffer s)

      Append the contents of a FastStringBuffer to the buffer
      Parameters:
        `s` - the FastStringBuffer to be appended

    - #### append

          public void append(StringBuffer s)

      Append the contents of a StringBuffer to the buffer
      Parameters:
        `s` - the StringBuffer to be appended

    - #### append

          public void append(CharSequence s)

      Append the contents of a general CharSequence to the buffer
      Specified by:
        `append` in interface `AppendableCharSequence`
      Parameters:
        `s` - the CharSequence to be appended

    - #### append

          public void append(char[] srcArray,
                    int start,
                    int length)

      Append the contents of a character array to the buffer
      Parameters:
        `srcArray` - the array whose contents are to be added
        `start` - the offset of the first character in the array to be copied
        `length` - the number of characters to be copied

    - #### append

          public void append(char[] srcArray)

      Append the entire contents of a character array to the buffer
      Parameters:
        `srcArray` - the array whose contents are to be added

    - #### append

          public void append(char ch)

      Append a character to the buffer
      Parameters:
        `ch` - the character to be added

    - #### appendWideChar

          public void appendWideChar(int ch)

      Append a wide character to the buffer (as a surrogate pair if necessary)
      Parameters:
        `ch` - the character, as a 32-bit Unicode codepoint

    - #### append

          public void append(UnicodeString str)

      Append a UnicodeString to the buffer (using surrogate pairs if necessary)
      Parameters:
        `str` - the UnicodeString

    - #### prependWideChar

          public void prependWideChar(int ch)

      Prepend a wide character to the buffer (as a surrogate pair if necessary)
      Parameters:
        `ch` - the character, as a 32-bit Unicode codepoint

    - #### length

          public int length()

      Returns the length of this character sequence. The length is the number of 16-bit `char`s in the sequence.
      Specified by:
        `length` in interface `CharSequence`
      Returns:
        the number of `char`s in this sequence

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

    - #### getChars

          public void getChars(int srcBegin,
                      int srcEnd,
                      char[] dst,
                      int dstBegin)

      Copies characters from this FastStringBuffer into the destination character array.

      The first character to be copied is at index `srcBegin`; the last character to be copied is at index `srcEnd-1` (thus the total number of characters to be copied is `srcEnd-srcBegin`). The characters are copied into the subarray of `dst` starting at index `dstBegin` and ending at index:

      >          dstbegin + (srcEnd-srcBegin) - 1

      Parameters:
        `srcBegin` - index of the first character in the string to copy.
        `srcEnd` - index after the last character in the string to copy.
        `dst` - the destination array.
        `dstBegin` - the start offset in the destination array.
      Throws:
        `IndexOutOfBoundsException` - If any of the following is true:
        - `srcBegin` is negative.
        - `srcBegin` is greater than `srcEnd`
        - `srcEnd` is greater than the length of this string
        - `dstBegin` is negative
        - `dstBegin+(srcEnd-srcBegin)` is larger than `dst.length`

    - #### indexOf

          public int indexOf(char ch)

      Get the index of the first character equal to a given value
      Parameters:
        `ch` - the character to search for
      Returns:
        the position of the first occurrence, or -1 if not found

    - #### toString

          public String toString()

      Convert contents of the FastStringBuffer to a string
      Specified by:
        `toString` in interface `CharSequence`
      Overrides:
        `toString` in class `Object`

    - #### equals

          public boolean equals(Object other)

      Compare equality
      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Generate a hash code
      Overrides:
        `hashCode` in class `Object`

    - #### getCharArray

          public char[] getCharArray()

      Get a char[] array containing the characters. The caller should not modify the array.
      Returns:
        a char[] array containing the characters

    - #### setCharAt

          public void setCharAt(int index,
                       char ch)

      Set the character at a particular offset
      Parameters:
        `index` - the index of the character to be set
        `ch` - the new character to overwrite the existing character at that location
      Throws:
        `IndexOutOfBoundsException` - if int<0 or int>=length()

    - #### insert

          public void insert(int index,
                    char ch)

      Insert a character at a particular offset
      Parameters:
        `index` - the index of the character to be set
        `ch` - the new character to insert at that location
      Throws:
        `IndexOutOfBoundsException` - if int<0 or int>=length()

    - #### insertWideChar

          public void insertWideChar(int index,
                            int ch)

      Insert wide character at a particular offset
      Parameters:
        `index` - the index of the character to be set
        `ch` - the character, as a 32-bit Unicode codepoint
      Throws:
        `IndexOutOfBoundsException` - if int<0 or int>=length()

    - #### removeCharAt

          public void removeCharAt(int index)

      Remove a character at a particular offset
      Parameters:
        `index` - the index of the character to be set
      Throws:
        `IndexOutOfBoundsException` - if int<0 or int>=length()

    - #### prepend

          public void prepend(char ch)

      Insert a given character at the start of the buffer
      Parameters:
        `ch` - the character to insert

    - #### prepend

          public void prepend(CharSequence str)

      Insert a given string at the start of the buffer
      Parameters:
        `str` - the string to insert

    - #### prependRepeated

          public void prependRepeated(char ch,
                             int repeat)

      Insert a given character N times at the start of the buffer
      Parameters:
        `ch` - the character to insert
        `repeat` - the number of occurrences required. Supplying 0 or a negative number is OK, and is treated as a no-op.

    - #### setLength

          public void setLength(int length)

      Set the length. If this exceeds the current length, this method is a no-op. If this is less than the current length, characters beyond the specified point are deleted.
      Specified by:
        `setLength` in interface `AppendableCharSequence`
      Parameters:
        `length` - the new length

    - #### ensureCapacity

          public void ensureCapacity(int extra)

      Expand the character array if necessary to ensure capacity for appended data
      Parameters:
        `extra` - the amount of additional capacity needed, in characters

    - #### condense

          public CharSequence condense()

      Remove surplus space from the array. This doesn't reduce the array to the minimum possible size; it only reclaims space if it seems worth doing. Specifically, it contracts the array if the amount of wasted space is more than 256 characters, or more than half the allocated size and more than 20 chars.
      Returns:
        the buffer after removing unused space

    - #### write

          public void write(Writer writer)
                     throws IOException

      Write the value to a writer
      Parameters:
        `writer` - the writer to which the content is to be written
      Throws:
        `IOException`

    - #### diagnosticPrint

          public static String diagnosticPrint(CharSequence in)

      Diagnostic print of the contents of a CharSequence. Ordinary printable ASCII characters are displayed as themselves; anything else is displayed as a \\uNNNN escape sequence
      Parameters:
        `in` - the CharSequence whose contents are to be displayed.
      Returns:
        the diagnostic output

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