FastStringBuffer

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

All Implemented Interfaces:

java.lang.CharSequence, AppendableCharSequence
```
public final class FastStringBuffer
extends java.lang.Object
implements AppendableCharSequence
```
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.)

Field Summary

Fields
Modifier and Type Field and Description

static int C1024

static int C16

static int C256

static int C64

Fields
Modifier and Type	Field and Description
`static int`	`C1024`
`static int`	`C16`
`static int`	`C256`
`static int`	`C64`

Constructor Summary

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

Method Summary

All Methods Static Methods Instance Methods Concrete 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(java.lang.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(java.lang.String s)` Append the contents of a String to the buffer
`void`	`append(java.lang.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.
`FastStringBuffer`	`condense()` Remove surplus space from the array.
`static java.lang.String`	`diagnosticPrint(java.lang.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(java.lang.Object other)` Compare equality
`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
`boolean`	`isEmpty()` Ask whether the string buffer is empty
`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(java.lang.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.
`java.lang.CharSequence`	`subSequence(int start, int end)` Returns a new `CharSequence` that is a subsequence of this sequence.
`char[]`	`toCharArray()` Get a char[] array containing the characters.
`java.lang.String`	`toString()` Convert contents of the FastStringBuffer to a string
`void`	`write(java.io.Writer writer)` Write the value to a writer

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface java.lang.CharSequence
chars, codePoints

- Field Detail
  - C16
```
public static final int C16
```
    See Also:
    
    Constant Field Values
  - C64
```
public static final int C64
```
    See Also:
    
    Constant Field Values
  - C256
```
public static final int C256
```
    See Also:
    
    Constant Field Values
  - C1024
```
public static final int C1024
```
    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(java.lang.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(java.lang.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(java.lang.StringBuffer s)
```
    Append the contents of a StringBuffer to the buffer
    
    Parameters:
    
    s - the StringBuffer to be appended
  - append
```
public void append(java.lang.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 chars in the sequence.
    
    Specified by:
    
    length in interface java.lang.CharSequence
    
    Returns:
    
    the number of chars in this sequence
  - isEmpty
```
public boolean isEmpty()
```
    Ask whether the string buffer is empty
    
    Returns:
    
    true if the buffer is empty (length()==0)
  - 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 java.lang.CharSequence
    
    Parameters:
    
    index - the index of the char value to be returned
    
    Returns:
    
    the specified char value
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the index argument is negative or not less than length()
  - subSequence
```
public java.lang.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 chars) of the returned sequence is end - start, so if start == end then an empty sequence is returned.
    
    Specified by:
    
    subSequence in interface java.lang.CharSequence
    
    Parameters:
    
    start - the start index, inclusive
    
    end - the end index, exclusive
    
    Returns:
    
    the specified subsequence
    
    Throws:
    
    java.lang.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:
    java.lang.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 java.lang.String toString()
```
    Convert contents of the FastStringBuffer to a string
    
    Specified by:
    
    toString in interface java.lang.CharSequence
    
    Overrides:
    
    toString in class java.lang.Object
  - equals
```
public boolean equals(java.lang.Object other)
```
    Compare equality
    
    Overrides:
    
    equals in class java.lang.Object
  - hashCode
```
public int hashCode()
```
    Generate a hash code
    
    Overrides:
    
    hashCode in class java.lang.Object
  - toCharArray
```
public char[] toCharArray()
```
    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:
    
    java.lang.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:
    
    java.lang.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:
    
    java.lang.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:
    
    java.lang.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(java.lang.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 FastStringBuffer 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(java.io.Writer writer)
           throws java.io.IOException
```
    Write the value to a writer
    
    Parameters:
    
    writer - the writer to which the content is to be written
    
    Throws:
    
    java.io.IOException
  - diagnosticPrint
```
public static java.lang.String diagnosticPrint(java.lang.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

Class FastStringBuffer

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

Field Detail

C16

C64

C256

C1024

Constructor Detail

FastStringBuffer

FastStringBuffer

Method Detail

append

append

append

append

append

append

append

append

appendWideChar

append

prependWideChar

length

isEmpty

charAt

subSequence

getChars

indexOf

toString

equals

hashCode

toCharArray

setCharAt

insert

insertWideChar

removeCharAt

prepend

prepend

prependRepeated

setLength

ensureCapacity

condense

write

diagnosticPrint