net.sf.saxon.tree.tiny

## Class CharSlice

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

- All Implemented Interfaces:
    Serializable, CharSequence

      public final class CharSlice
      extends Object
      implements CharSequence, Serializable

  This is an implementation of the JDK 1.4 CharSequence interface: it implements a CharSequence as a view of an array. The implementation relies on the array being immutable: as a minimum, the caller is required to ensure that the array contents will not change so long as the CharSlice remains in existence. This class should be more efficient than String because it avoids copying the characters unnecessarily. The methods in the class don't check their arguments. Incorrect arguments will generally result in exceptions from lower-level classes.
  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `CharSlice(char[] array)` Create a CharSlice that maps to the whole of a char[] array
    `CharSlice(char[] array, int start, int length)` Create a CharSlice that maps to a section of a char[] array

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `char` | `charAt(int index)` Returns the character at the specified index.
    `void` | `copyTo(char[] destination, int destOffset)` Append the contents to another array at a given offset.
    `boolean` | `equals(Object other)` Compare equality
    `void` | `getChars(int start, int end, char[] destination, int destOffset)` Append the contents to another array at a given offset.
    `int` | `hashCode()` Generate a hash code
    `int` | `indexOf(char c)` Get the index of a specific character in the sequence.
    `int` | `length()` Returns the length of this character sequence.
    `void` | `setLength(int length)` Set the length of this character sequence, without changing the array and start offset to which it is bound
    `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

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

- - ### Constructor Detail

    - #### CharSlice

          public CharSlice(char[] array)

      Create a CharSlice that maps to the whole of a char[] array
      Parameters:
        `array` - the char[] array

    - #### CharSlice

          public CharSlice(char[] array,
                   int start,
                   int length)

      Create a CharSlice that maps to a section of a char[] array
      Parameters:
        `array` - the char[] array
        `start` - position of the first character to be included
        `length` - number of characters to be included

  - ### Method Detail

    - #### length

          public int length()

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

    - #### setLength

          public void setLength(int length)

      Set the length of this character sequence, without changing the array and start offset to which it is bound
      Parameters:
        `length` - the new length of the CharSlice (which must be less than the existing length, though this is not enforced)

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

    - #### indexOf

          public int indexOf(char c)

      Get the index of a specific character in the sequence. Returns -1 if not found. This method mimics `String.indexOf(int)`
      Parameters:
        `c` - the character to be found
      Returns:
        the position of the first occurrence of that character, or -1 if not found.

    - #### 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.
      Parameters:
        `start` - position of the first character to be included (relative to the start of the CharSlice, not the underlying array)
        `end` - position of the first character not to be included (relative to the start of the CharSlice)
      Returns:
        the substring, as a String object

    - #### copyTo

          public void copyTo(char[] destination,
                    int destOffset)

      Append the contents to another array at a given offset. The caller is responsible for ensuring that sufficient space is available.
      Parameters:
        `destination` - the array to which the characters will be copied
        `destOffset` - the offset in the target array where the copy will start

    - #### getChars

          public void getChars(int start,
                      int end,
                      char[] destination,
                      int destOffset)

      Append the contents to another array at a given offset. The caller is responsible for ensuring that sufficient space is available. Otherwise this behaves like String.getChars()
      Parameters:
        `start` - offset of first character to be copied
        `end` - offset of the first character that is not copied
        `destination` - the array to which the characters will be copied
        `destOffset` - the offset in the target array where the copy will start

    - #### write

          public void write(Writer writer)
                     throws IOException

      Write the value to a writer
      Parameters:
        `writer` - the writer to be written to
      Throws:
        `IOException` - if writing fails

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