Overview | Package | Class | Deprecated | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## net.sf.saxon.tinytree
Class LargeStringBuffer

    java.lang.Object
      net.sf.saxon.tinytree.LargeStringBuffer

All Implemented Interfaces:
  Serializable, CharSequence

    public final class LargeStringBuffer

extends Object
implements CharSequence, Serializable

This is an implementation of the JDK 1.4 CharSequence interface: it implements a CharSequence as a list of arrays of characters (the individual arrays are known as segments). When characters are appended, a new segment is started if the previous array would otherwise overflow a threshold size (the maxAllocation size).

This is more efficient than a buffer backed by a contiguous array of characters in cases where the size is likely to grow very large, and where substring operations are rare. As used within the TinyTree, the value of each text node is contiguous within one segment, so extraction of the value of a text node is efficient.

See Also:
  Serialized Form

Constructor Summary
`LargeStringBuffer()` Create an empty LargeStringBuffer with default space allocation
`LargeStringBuffer(int minAllocation, int maxAllocation)` Create an empty LargeStringBuffer

Method Summary
`void` | `append(CharSequence data)` Append a CharSequence to this LargeStringBuffer
`char` | `charAt(int index)` Returns the character at the specified index.
`boolean` | `equals(Object other)` Compare equality
`int` | `hashCode()` Generate a hash code
`int` | `length()` Returns the length of this character sequence.
`CharSequence` | `subSequence(int start, int end)` Returns a new character sequence that is a subsequence of this sequence.
`String` | `substring(int start, int end)` Returns a new character sequence that is a subsequence of this sequence.
`String` | `toString()` Convert to a string
`void` | `write(Writer writer)` Write the value to a writer

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

Constructor Detail

### LargeStringBuffer

    public LargeStringBuffer()

  Create an empty LargeStringBuffer with default space allocation

### LargeStringBuffer

    public LargeStringBuffer(int minAllocation,
                             int maxAllocation)

  Create an empty LargeStringBuffer

  Parameters:
    `minAllocation` - initial allocation size for each segment (including the first). If minAllocation exceeds maxAllocation, it is rounded down to the value of maxAllocation
    `maxAllocation` - maximum allocation size for each segment. When a segment reaches this size, a new segment is created rather than appending more characters to the existing segment.

Method Detail

### append

    public void append(CharSequence data)

  Append a CharSequence to this LargeStringBuffer

### length

    public int length()

  Returns the length of this character sequence. The length is the number of 16-bit UTF-16 characters in the sequence.

  Specified by:
    `length` in interface `CharSequence`
  Returns:
    the number of characters in this sequence

### charAt

    public char charAt(int index)

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

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

### subSequence

    public CharSequence subSequence(int start,
                                    int end)

  Returns a new character sequence that is a subsequence of this sequence. The subsequence starts with the character at the specified index and ends with the character at index `end - 1`. The length 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`

### toString

    public String toString()

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

### substring

    public String substring(int start,
                            int end)

  Returns a new character sequence that is a subsequence of this sequence. Unlike subSequence, this is guaranteed to return a String.

### write

    public void write(Writer writer)
               throws IOException

  Write the value to a writer

  Throws:
    `IOException`

Overview | Package | Class | Deprecated | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright (C) Michael H. Kay. All rights reserved.