RichCharSequence (flexmark-java utilities 0.50.42 API)

All Superinterfaces:

CharSequence, Comparable<CharSequence>

All Known Subinterfaces:

BasedSequence

All Known Implementing Classes:

BasedSequence.EmptyBasedSequence, BasedSequenceImpl, CharSubSequence, MappedSequence, PrefixedSubSequence, RichCharSequenceBase, RichCharSequenceImpl, SegmentedSequence, SubSequence
```
public interface RichCharSequence<T extends RichCharSequence>
extends CharSequence, Comparable<CharSequence>
```
A CharSequence that references original char sequence and maps '\0' to '�' a subSequence() returns a sub-sequence from the original base sequence

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`EOL`
`static char`	`EOL_CHAR`
`static char`	`EOL_CHAR1`
`static char`	`EOL_CHAR2`
`static String`	`EOL_CHARS`
`static String`	`SPACE`
`static int`	`SPLIT_INCLUDE_DELIM_PARTS`
`static int`	`SPLIT_INCLUDE_DELIMS`
`static int`	`SPLIT_SKIP_EMPTY`
`static int`	`SPLIT_TRIM_PARTS`
`static int`	`SPLIT_TRIM_SKIP_EMPTY`
`static String`	`WHITESPACE_CHARS`
`static String`	`WHITESPACE_NBSP_CHARS`
`static String`	`WHITESPACE_NO_EOL_CHARS`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`T`	`append(CharSequence... others)`
`T`	`appendTo(StringBuilder out)`
`T`	`appendTo(StringBuilder out, int start)`
`T`	`appendTo(StringBuilder out, int start, int end)`
`int`	`countLeading()`
`int`	`countLeading(char c)`
`int`	`countLeading(char c, int startIndex)`
`int`	`countLeading(char c, int startIndex, int endIndex)`
`int`	`countLeading(CharSequence chars)` Count leading/trailing characters of this sequence
`int`	`countLeading(CharSequence chars, int startIndex)`
`int`	`countLeading(CharSequence chars, int startIndex, int endIndex)`
`int`	`countLeadingColumns(int startColumn, CharSequence chars)`
`int`	`countLeadingNot()`
`int`	`countLeadingNot(char c)`
`int`	`countLeadingNot(char c, int startIndex)`
`int`	`countLeadingNot(char c, int startIndex, int endIndex)`
`int`	`countLeadingNot(CharSequence chars)`
`int`	`countLeadingNot(CharSequence chars, int startIndex)`
`int`	`countLeadingNot(CharSequence chars, int startIndex, int endIndex)`
`int`	`countOf()`
`int`	`countOf(char c)`
`int`	`countOf(char c, int startIndex)`
`int`	`countOf(char c, int startIndex, int endIndex)`
`int`	`countOfAny(CharSequence chars)`
`int`	`countOfAny(CharSequence chars, int startIndex)`
`int`	`countOfAny(CharSequence chars, int startIndex, int endIndex)`
`int`	`countOfAnyNot(CharSequence chars)`
`int`	`countOfAnyNot(CharSequence chars, int startIndex)`
`int`	`countOfAnyNot(CharSequence chars, int startIndex, int endIndex)`
`int`	`countOfNot()`
`int`	`countOfNot(char c)`
`int`	`countOfNot(char c, int startIndex)`
`int`	`countOfNot(char c, int startIndex, int endIndex)`
`int`	`countTrailing()`
`int`	`countTrailing(char c)`
`int`	`countTrailing(char c, int startIndex)`
`int`	`countTrailing(char c, int startIndex, int endIndex)`
`int`	`countTrailing(CharSequence chars)`
`int`	`countTrailing(CharSequence chars, int startIndex)`
`int`	`countTrailing(CharSequence chars, int startIndex, int endIndex)`
`int`	`countTrailingNot()`
`int`	`countTrailingNot(char c)`
`int`	`countTrailingNot(char c, int startIndex)`
`int`	`countTrailingNot(char c, int startIndex, int endIndex)`
`int`	`countTrailingNot(CharSequence chars)`
`int`	`countTrailingNot(CharSequence chars, int startIndex)`
`int`	`countTrailingNot(CharSequence chars, int startIndex, int endIndex)`
`T[]`	`emptyArray()`
`char`	`endCharAt(int index)` Convenience method to get characters offset from end of sequence.
`int`	`endOfDelimitedBy(CharSequence s, int index)` Find start/end region in this sequence delimited by any characters in argument or the CharSequence
`int`	`endOfDelimitedByAny(CharSequence s, int index)`
`int`	`endOfDelimitedByAnyNot(CharSequence s, int index)`
`int`	`endOfLine(int index)` Get the offset of the end of line at given index, end of line delimited by \n or any of \n \r \r\n for Any methods.
`int`	`endOfLineAnyEOL(int index)`
`T`	`endSequence(int start)` Convenience method to get characters offset from end of sequence.
`T`	`endSequence(int start, int end)` Convenience method to get characters offset from end of sequence.
`boolean`	`endsWith(CharSequence suffix)` test if this sequence ends with given characters
`boolean`	`endsWith(CharSequence suffix, boolean ignoreCase)` test if this sequence ends with given characters
`boolean`	`endsWithIgnoreCase(CharSequence suffix)` test if this sequence ends with given characters, ignoring case differences
`int`	`eolLength()` Get the length of EOL character at the end of this sequence, if present.
`int`	`eolLength(int eolStart)` Get the length of EOL character at the given index of this sequence, if present.
`boolean`	`equals(Object other, boolean ignoreCase)` Test the sequence for a match to another CharSequence
`boolean`	`equalsIgnoreCase(CharSequence other)` Test the sequence for a match to another CharSequence, ignoring case differences
`char`	`firstChar()`
`int`	`getColumnAtIndex(int index)`
`Pair<Integer,Integer>`	`getLineColumnAtIndex(int index)` Get the line and column information from index into sequence
`T`	`ifNull(T other)` If this sequence is the BasedSequence.NULL instance then returns other, otherwise returns this sequence.
`T`	`ifNullEmptyAfter(T other)` If this sequence is the BasedSequence.NULL instance then returns an empty subSequence from the end of other, otherwise returns this sequence.
`T`	`ifNullEmptyBefore(T other)` If this sequence is the BasedSequence.NULL instance then returns an empty subSequence from the start of other, otherwise returns this sequence.
`int`	`indexOf(char c)`
`int`	`indexOf(char c, int fromIndex)`
`int`	`indexOf(char c, int fromIndex, int endIndex)`
`int`	`indexOf(CharSequence s)` All index methods return the position or -1 if not found of the given character, characters or string.
`int`	`indexOf(CharSequence s, int fromIndex)`
`int`	`indexOf(CharSequence s, int fromIndex, int endIndex)`
`int[]`	`indexOfAll(CharSequence s)` Get indices of all occurrences of a sequence
`int`	`indexOfAny(char c1, char c2)`
`int`	`indexOfAny(char c1, char c2, char c3)`
`int`	`indexOfAny(char c1, char c2, char c3, int fromIndex)`
`int`	`indexOfAny(char c1, char c2, char c3, int fromIndex, int endIndex)`
`int`	`indexOfAny(char c1, char c2, int fromIndex)`
`int`	`indexOfAny(char c1, char c2, int fromIndex, int endIndex)`
`int`	`indexOfAny(CharSequence s)`
`int`	`indexOfAny(CharSequence s, int fromIndex)`
`int`	`indexOfAny(CharSequence s, int fromIndex, int endIndex)`
`int`	`indexOfAnyNot(char c1, char c2)`
`int`	`indexOfAnyNot(char c1, char c2, char c3)`
`int`	`indexOfAnyNot(char c1, char c2, char c3, int fromIndex)`
`int`	`indexOfAnyNot(char c1, char c2, char c3, int fromIndex, int endIndex)`
`int`	`indexOfAnyNot(char c1, char c2, int fromIndex)`
`int`	`indexOfAnyNot(char c1, char c2, int fromIndex, int endIndex)`
`int`	`indexOfAnyNot(CharSequence s)`
`int`	`indexOfAnyNot(CharSequence s, int fromIndex)`
`int`	`indexOfAnyNot(CharSequence s, int fromIndex, int endIndex)`
`int`	`indexOfNot(char c)`
`int`	`indexOfNot(char c, int fromIndex)`
`int`	`indexOfNot(char c, int fromIndex, int endIndex)`
`boolean`	`isBlank()`
`boolean`	`isEmpty()`
`boolean`	`isNotNull()`
`boolean`	`isNull()`
`char`	`lastChar()`
`int`	`lastIndexOf(char c)`
`int`	`lastIndexOf(char c, int fromIndex)`
`int`	`lastIndexOf(char c, int startIndex, int fromIndex)`
`int`	`lastIndexOf(CharSequence s)`
`int`	`lastIndexOf(CharSequence s, int fromIndex)`
`int`	`lastIndexOf(CharSequence s, int startIndex, int fromIndex)`
`int`	`lastIndexOfAny(char c1, char c2)`
`int`	`lastIndexOfAny(char c1, char c2, char c3)`
`int`	`lastIndexOfAny(char c1, char c2, char c3, int fromIndex)`
`int`	`lastIndexOfAny(char c1, char c2, char c3, int startIndex, int fromIndex)`
`int`	`lastIndexOfAny(char c1, char c2, int fromIndex)`
`int`	`lastIndexOfAny(char c1, char c2, int startIndex, int fromIndex)`
`int`	`lastIndexOfAny(CharSequence s)`
`int`	`lastIndexOfAny(CharSequence s, int fromIndex)`
`int`	`lastIndexOfAny(CharSequence s, int startIndex, int fromIndex)`
`int`	`lastIndexOfAnyNot(char c1, char c2)`
`int`	`lastIndexOfAnyNot(char c1, char c2, char c3)`
`int`	`lastIndexOfAnyNot(char c1, char c2, char c3, int fromIndex)`
`int`	`lastIndexOfAnyNot(char c1, char c2, char c3, int startIndex, int fromIndex)`
`int`	`lastIndexOfAnyNot(char c1, char c2, int fromIndex)`
`int`	`lastIndexOfAnyNot(char c1, char c2, int startIndex, int fromIndex)`
`int`	`lastIndexOfAnyNot(CharSequence s)`
`int`	`lastIndexOfAnyNot(CharSequence s, int fromIndex)`
`int`	`lastIndexOfAnyNot(CharSequence s, int startIndex, int fromIndex)`
`int`	`lastIndexOfNot(char c)`
`int`	`lastIndexOfNot(char c, int fromIndex)`
`int`	`lastIndexOfNot(char c, int startIndex, int fromIndex)`
`T`	`lineAt(int index)` Get the line characters at given index, line delimited by \n
`T`	`lineAtAnyEOL(int index)` Get the line characters at given index, line delimited by \n, \r or \r\n
`boolean`	`matchChars(CharSequence chars)` Test the sequence portion for a match to another CharSequence
`boolean`	`matchChars(CharSequence chars, boolean ignoreCase)` Test the sequence portion for a match to another CharSequence
`boolean`	`matchChars(CharSequence chars, int startIndex)` Test the sequence portion for a match to another CharSequence
`boolean`	`matchChars(CharSequence chars, int startIndex, boolean ignoreCase)` Test the sequence portion for a match to another CharSequence
`boolean`	`matchCharsIgnoreCase(CharSequence chars)` Test the sequence portion for a match to another CharSequence, ignoring case differences
`boolean`	`matchCharsIgnoreCase(CharSequence chars, int startIndex)` Test the sequence portion for a match to another CharSequence, ignoring case differences
`boolean`	`matchCharsReversed(CharSequence chars, int endIndex)` Test the sequence portion for a match to another CharSequence, reverse order
`boolean`	`matchCharsReversed(CharSequence chars, int endIndex, boolean ignoreCase)` Test the sequence portion for a match to another CharSequence, reverse order
`boolean`	`matchCharsReversedIgnoreCase(CharSequence chars, int endIndex)` Test the sequence portion for a match to another CharSequence, reverse order, ignoring case differences
`boolean`	`matches(CharSequence chars)` Test the sequence for a match to another CharSequence
`boolean`	`matches(CharSequence chars, boolean ignoreCase)` Test the sequence for a match to another CharSequence
`boolean`	`matchesIgnoreCase(CharSequence chars)` Test the sequence for a match to another CharSequence, ignoring case differences
`char`	`midCharAt(int index)` Convenience method to get characters offset from start or end of sequence.
`T`	`midSequence(int start)` Convenience method to get characters offset from start or end of sequence.
`T`	`midSequence(int start, int end)` Convenience method to get characters offset from start or end of sequence.
`String`	`normalizeEndWithEOL()` replace any \r\n and \r by \n, append terminating EOL if one is not present
`String`	`normalizeEOL()` replace any \r\n and \r by \n
`T`	`nullIf(boolean condition)` If condition is true return BasedSequence.NULL otherwise returns this sequence.
`T`	`nullIf(CharSequence... matches)` If this sequence matches one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`T`	`nullIfBlank()` If this sequence is blank return BasedSequence.NULL otherwise returns this sequence.
`T`	`nullIfEmpty()` If this sequence is empty return BasedSequence.NULL otherwise returns this sequence.
`T`	`nullIfEndsWith(CharSequence... matches)` If this sequence ends with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`T`	`nullIfEndsWithNot(CharSequence... matches)` If this sequence does not end with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`T`	`nullIfNot(CharSequence... matches)` If this sequence does not match one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`T`	`nullIfStartsWith(CharSequence... matches)` If this sequence starts with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`T`	`nullIfStartsWithNot(CharSequence... matches)` If this sequence does not start with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`T`	`nullSequence()`
`T`	`padEnd(int length)`
`T`	`padEnd(int length, char pad)`
`T`	`padStart(int length)`
`T`	`padStart(int length, char pad)`
`T`	`removePrefix(CharSequence prefix)` Remove prefix if present
`T`	`removePrefix(CharSequence prefix, boolean ignoreCase)` Remove prefix if present
`T`	`removePrefixIgnoreCase(CharSequence prefix)` Remove prefix if present, ignoring case differences
`T`	`removeProperPrefix(CharSequence prefix)` Remove prefix if present but only if this sequence is longer than the suffix
`T`	`removeProperPrefix(CharSequence prefix, boolean ignoreCase)` Remove prefix if present but only if this sequence is longer than the suffix
`T`	`removeProperPrefixIgnoreCase(CharSequence prefix)` Remove prefix if present but only if this sequence is longer than the suffix, ignoring case differences
`T`	`removeProperSuffix(CharSequence suffix)` Remove suffix if present but only if this sequence is longer than the suffix
`T`	`removeProperSuffix(CharSequence suffix, boolean ignoreCase)` Remove suffix if present but only if this sequence is longer than the suffix
`T`	`removeProperSuffixIgnoreCase(CharSequence suffix)` Remove suffix if present but only if this sequence is longer than the suffix, ignoring case differences
`T`	`removeSuffix(CharSequence suffix)` Remove suffix if present
`T`	`removeSuffix(CharSequence suffix, boolean ignoreCase)` Remove suffix if present
`T`	`removeSuffixIgnoreCase(CharSequence suffix)` Remove suffix if present, ignoring case differences
`T`	`replace(CharSequence find, CharSequence replace)` Replace all occurrences of one sequence with another
`T`	`sequenceOf(CharSequence charSequence)` Factory function
`T`	`sequenceOf(CharSequence charSequence, int startIndex)` Factory function
`T`	`sequenceOf(CharSequence charSequence, int startIndex, int endIndex)` Factory function
`T[]`	`split(char delimiter)`
`T[]`	`split(char delimiter, int limit)`
`T[]`	`split(char delimiter, int limit, int flags)`
`T[]`	`split(char delimiter, int limit, int flags, String trimChars)` Split helpers based on delimiter character sets contained in CharSequence
`T[]`	`split(CharSequence delimiter)`
`T[]`	`split(CharSequence delimiter, int limit)`
`T[]`	`split(CharSequence delimiter, int limit, int flags)`
`T[]`	`split(CharSequence delimiter, int limit, int flags, String trimChars)`
`int`	`startOfDelimitedBy(CharSequence s, int index)`
`int`	`startOfDelimitedByAny(CharSequence s, int index)`
`int`	`startOfDelimitedByAnyNot(CharSequence s, int index)`
`int`	`startOfLine(int index)`
`int`	`startOfLineAnyEOL(int index)`
`boolean`	`startsWith(CharSequence prefix)` test if this sequence starts with given characters
`boolean`	`startsWith(CharSequence prefix, boolean ignoreCase)` test if this sequence starts with given characters
`boolean`	`startsWithIgnoreCase(CharSequence prefix)` test if this sequence starts with given characters, ignoring case differences
`T`	`subSequence(int start)` Get a portion of this sequence starting from a given offset to end of the sequence
`T`	`subSequence(int start, int end)` Get a portion of this sequence
`T`	`subSequence(Range range)` Get a portion of this sequence
`T`	`toLowerCase()` Map characters of this sequence to: Uppercase, Lowercase or use custom mapping
`T`	`toLowerCase(Locale locale)`
`T`	`toMapped(CharMapper mapper)`
`T`	`toUpperCase()`
`T`	`toUpperCase(Locale locale)`
`String`	`toVisibleWhitespaceString()`
`T`	`trim()`
`T`	`trim(CharSequence chars)`
`T`	`trimEnd()`
`T`	`trimEnd(CharSequence chars)`
`T`	`trimEnd(int keepLength)`
`T`	`trimEnd(int keepLength, CharSequence chars)`
`T`	`trimEOL()`
`T`	`trimLeadBlankLines()`
`T`	`trimmedEnd()`
`T`	`trimmedEnd(CharSequence chars)`
`T`	`trimmedEnd(int keepLength)`
`T`	`trimmedEnd(int keepLength, CharSequence chars)`
`T`	`trimmedEOL()`
`T`	`trimmedStart()`
`T`	`trimmedStart(CharSequence chars)`
`T`	`trimmedStart(int keepLength)`
`T`	`trimmedStart(int keepLength, CharSequence chars)` Get the characters Trimmed, Trimmed from start/end of this sequence, characters to trim are passed in the sequence argument
`T`	`trimStart()`
`T`	`trimStart(CharSequence chars)`
`T`	`trimStart(int keepLength)`
`T`	`trimStart(int keepLength, CharSequence chars)` Trim, Trim start/end of this sequence, characters to trim are passed in the sequence argument
`T`	`trimTailBlankLines()` Trim leading trailing blank lines in this sequence

Methods inherited from interface java.lang.CharSequence
charAt, chars, codePoints, length, toString

Methods inherited from interface java.lang.Comparable
compareTo

- Field Detail
  - EOL
```
static final String EOL
```
    See Also:
    
    Constant Field Values
  - SPACE
```
static final String SPACE
```
    See Also:
    
    Constant Field Values
  - WHITESPACE_NO_EOL_CHARS
```
static final String WHITESPACE_NO_EOL_CHARS
```
    See Also:
    
    Constant Field Values
  - WHITESPACE_CHARS
```
static final String WHITESPACE_CHARS
```
    See Also:
    
    Constant Field Values
  - WHITESPACE_NBSP_CHARS
```
static final String WHITESPACE_NBSP_CHARS
```
    See Also:
    
    Constant Field Values
  - EOL_CHARS
```
static final String EOL_CHARS
```
    See Also:
    
    Constant Field Values
  - EOL_CHAR
```
static final char EOL_CHAR
```
  - EOL_CHAR1
```
static final char EOL_CHAR1
```
  - EOL_CHAR2
```
static final char EOL_CHAR2
```
  - SPLIT_INCLUDE_DELIMS
```
static final int SPLIT_INCLUDE_DELIMS
```
    See Also:
    
    Constant Field Values
  - SPLIT_TRIM_PARTS
```
static final int SPLIT_TRIM_PARTS
```
    See Also:
    
    Constant Field Values
  - SPLIT_SKIP_EMPTY
```
static final int SPLIT_SKIP_EMPTY
```
    See Also:
    
    Constant Field Values
  - SPLIT_INCLUDE_DELIM_PARTS
```
static final int SPLIT_INCLUDE_DELIM_PARTS
```
    See Also:
    
    Constant Field Values
  - SPLIT_TRIM_SKIP_EMPTY
```
static final int SPLIT_TRIM_SKIP_EMPTY
```
    See Also:
    
    Constant Field Values
- Method Detail
  - emptyArray
```
T[] emptyArray()
```
  - nullSequence
```
T nullSequence()
```
  - lastChar
```
char lastChar()
```
    Returns:
    
    the last character of the sequence or '\0' if empty
  - firstChar
```
char firstChar()
```
    Returns:
    
    the first character of the sequence or '\0' if empty
  - subSequence
```
T subSequence(int start,
              int end)
```
    Get a portion of this sequence
    
    Specified by:
    
    subSequence in interface CharSequence
    
    Parameters:
    
    start - offset from start of this sequence
    
    end - offset from start of this sequence
    
    Returns:
    
    based sequence whose contents reflect the selected portion
  - subSequence
```
T subSequence(Range range)
```
    Get a portion of this sequence
    
    Parameters:
    
    range - range to get, coordinates offset form start of this sequence
    
    Returns:
    
    based sequence whose contents reflect the selected portion
  - subSequence
```
T subSequence(int start)
```
    Get a portion of this sequence starting from a given offset to end of the sequence
    
    Parameters:
    
    start - offset from start of this sequence
    
    Returns:
    
    based sequence whose contents reflect the selected portion
  - endSequence
```
T endSequence(int start,
              int end)
```
    Convenience method to get characters offset from end of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Parameters:
    
    start - offset from end of sequence [ 0..length() )
    
    end - offset from end of sequence [ 0..length() )
    
    Returns:
    
    selected portion spanning length() - start to length() - end of this sequence
  - endSequence
```
T endSequence(int start)
```
    Convenience method to get characters offset from end of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Parameters:
    
    start - offset from end of sequence [ 0..length() )
    
    Returns:
    
    selected portion spanning length() - start to length() of this sequence
  - endCharAt
```
char endCharAt(int index)
```
    Convenience method to get characters offset from end of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Parameters:
    
    index - offset from end of sequence
    
    Returns:
    
    character located at length() - index in this sequence
  - midSequence
```
T midSequence(int start,
              int end)
```
    Convenience method to get characters offset from start or end of sequence. when offset >= then it is offset from the start of the sequence, when <0 then from the end
    no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Parameters:
    
    start - offset into this sequence
    
    end - offset into this sequence
    
    Returns:
    
    selected portion spanning start to end of this sequence. If offset is <0 then it is taken as relative to length()
  - midSequence
```
T midSequence(int start)
```
    Convenience method to get characters offset from start or end of sequence. when offset >= then it is offset from the start of the sequence, when <0 then from the end
    no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Parameters:
    
    start - offset into this sequence
    
    Returns:
    
    selected portion spanning start to length() of this sequence. If offset is <0 then it is taken as relative to length()
  - midCharAt
```
char midCharAt(int index)
```
    Convenience method to get characters offset from start or end of sequence. when index >= then it is offset from the start of the sequence, when <0 then from the end no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Parameters:
    
    index - of character to get
    
    Returns:
    
    character at index or \0 if index is outside valid range for this sequence
  - sequenceOf
```
T sequenceOf(CharSequence charSequence)
```
    Factory function
    
    Parameters:
    
    charSequence - char sequence from which to construct a rich char sequence
    
    Returns:
    
    rich char sequence from given inputs
  - sequenceOf
```
T sequenceOf(CharSequence charSequence,
             int startIndex)
```
    Factory function
    
    Parameters:
    
    charSequence - char sequence from which to construct a rich char sequence
    
    startIndex - start index of the sequence to use
    
    Returns:
    
    rich char sequence from given inputs
  - sequenceOf
```
T sequenceOf(CharSequence charSequence,
             int startIndex,
             int endIndex)
```
    Factory function
    
    Parameters:
    
    charSequence - char sequence from which to construct a rich char sequence
    
    startIndex - start index of the sequence to use
    
    endIndex - end index of the sequence to use
    
    Returns:
    
    rich char sequence from given inputs
  - indexOf
```
int indexOf(CharSequence s)
```
    All index methods return the position or -1 if not found of the given character, characters or string.
    The basic methods have overloads for 1, 2, or 3 characters and CharSequence parameters. If fromIndex is not given then for forward searching methods 0 is taken as the value, for reverse searching methods length() is taken as the value
    For forward searching methods fromIndex is the minimum start position for search and endIndex is the maximum end position, if not given the length() of string is assumed.
    For reverse searching methods fromIndex is the maximum start position for search and startIndex is the minimum end position, if not given then 0 is assumed.
    Variations of arguments are for convenience and speed when 1, 2 or 3 characters are needed to be tested. Methods that take a character set in the form of CharSequence will route their call to character based methods if the CharSequence is only 1, 2 or 3 characters long.
    indexOf(CharSequence): returns the index of the next occurrence of given text in this sequence
    indexOfAny(CharSequence): returns the index of the next occurrence of any of the characters in this sequence indexOfAny(char): returns the index of the next occurrence of any of the characters in this sequence indexOfAny(char,char): returns the index of the next occurrence of any of the characters in this sequence indexOfAny(char,char,char): returns the index of the next occurrence of any of the characters in this sequence
    indexOfAnyNot(CharSequence): returns the index of the next occurrence of any of the characters not in this sequence indexOfAnyNot(char): returns the index of the next occurrence of any of the characters not in this sequence indexOfAnyNot(char,char): returns the index of the next occurrence of any of the characters not in this sequence indexOfAnyNot(char,char,char): returns the index of the next occurrence of any of the characters not in this sequence
    lastIndexOf(CharSequence): returns the index of the previous occurrence of given text in this sequence, reversed search
    lastIndexOfAny(CharSequence): returns the index of the previous occurrence of any of the characters in this sequence, reversed search lastIndexOfAny(char): returns the index of the previous occurrence of any of the characters in this sequence, reversed search lastIndexOfAny(char,char): returns the index of the previous occurrence of any of the characters in this sequence, reversed search lastIndexOfAny(char,char,char): returns the index of the previous occurrence of any of the characters in this sequence, reversed search
    lastIndexOfAnyNot(CharSequence): returns the index of the previous occurrence of any of the characters not in this sequence, reversed search lastIndexOfAnyNot(Char): returns the index of the previous occurrence of any of the characters not in this sequence, reversed search lastIndexOfAnyNot(char,char): returns the index of the previous occurrence of any of the characters not in this sequence, reversed search lastIndexOfAnyNot(char,char,char): returns the index of the previous occurrence of any of the characters not in this sequence, reversed search
    
    Parameters:
    
    s - character sequence whose occurrence to find
    
    Returns:
    
    index where found or -1
  - indexOf
```
int indexOf(CharSequence s,
            int fromIndex)
```
  - indexOf
```
int indexOf(CharSequence s,
            int fromIndex,
            int endIndex)
```
  - indexOf
```
int indexOf(char c)
```
  - indexOfAny
```
int indexOfAny(char c1,
               char c2)
```
  - indexOfAny
```
int indexOfAny(char c1,
               char c2,
               char c3)
```
  - indexOfAny
```
int indexOfAny(CharSequence s)
```
  - indexOf
```
int indexOf(char c,
            int fromIndex)
```
  - indexOfAny
```
int indexOfAny(char c1,
               char c2,
               int fromIndex)
```
  - indexOfAny
```
int indexOfAny(char c1,
               char c2,
               char c3,
               int fromIndex)
```
  - indexOfAny
```
int indexOfAny(CharSequence s,
               int fromIndex)
```
  - indexOf
```
int indexOf(char c,
            int fromIndex,
            int endIndex)
```
  - indexOfAny
```
int indexOfAny(char c1,
               char c2,
               int fromIndex,
               int endIndex)
```
  - indexOfAny
```
int indexOfAny(char c1,
               char c2,
               char c3,
               int fromIndex,
               int endIndex)
```
  - indexOfAny
```
int indexOfAny(CharSequence s,
               int fromIndex,
               int endIndex)
```
  - indexOfNot
```
int indexOfNot(char c)
```
  - indexOfAnyNot
```
int indexOfAnyNot(char c1,
                  char c2)
```
  - indexOfAnyNot
```
int indexOfAnyNot(char c1,
                  char c2,
                  char c3)
```
  - indexOfAnyNot
```
int indexOfAnyNot(CharSequence s)
```
  - indexOfNot
```
int indexOfNot(char c,
               int fromIndex)
```
  - indexOfAnyNot
```
int indexOfAnyNot(char c1,
                  char c2,
                  int fromIndex)
```
  - indexOfAnyNot
```
int indexOfAnyNot(char c1,
                  char c2,
                  char c3,
                  int fromIndex)
```
  - indexOfAnyNot
```
int indexOfAnyNot(CharSequence s,
                  int fromIndex)
```
  - indexOfNot
```
int indexOfNot(char c,
               int fromIndex,
               int endIndex)
```
  - indexOfAnyNot
```
int indexOfAnyNot(char c1,
                  char c2,
                  int fromIndex,
                  int endIndex)
```
  - indexOfAnyNot
```
int indexOfAnyNot(char c1,
                  char c2,
                  char c3,
                  int fromIndex,
                  int endIndex)
```
  - indexOfAnyNot
```
int indexOfAnyNot(CharSequence s,
                  int fromIndex,
                  int endIndex)
```
  - lastIndexOf
```
int lastIndexOf(CharSequence s)
```
  - lastIndexOf
```
int lastIndexOf(CharSequence s,
                int fromIndex)
```
  - lastIndexOf
```
int lastIndexOf(CharSequence s,
                int startIndex,
                int fromIndex)
```
  - lastIndexOf
```
int lastIndexOf(char c)
```
  - lastIndexOfAny
```
int lastIndexOfAny(char c1,
                   char c2)
```
  - lastIndexOfAny
```
int lastIndexOfAny(char c1,
                   char c2,
                   char c3)
```
  - lastIndexOfAny
```
int lastIndexOfAny(CharSequence s)
```
  - lastIndexOf
```
int lastIndexOf(char c,
                int fromIndex)
```
  - lastIndexOfAny
```
int lastIndexOfAny(char c1,
                   char c2,
                   int fromIndex)
```
  - lastIndexOfAny
```
int lastIndexOfAny(char c1,
                   char c2,
                   char c3,
                   int fromIndex)
```
  - lastIndexOfAny
```
int lastIndexOfAny(CharSequence s,
                   int fromIndex)
```
  - lastIndexOf
```
int lastIndexOf(char c,
                int startIndex,
                int fromIndex)
```
  - lastIndexOfAny
```
int lastIndexOfAny(char c1,
                   char c2,
                   int startIndex,
                   int fromIndex)
```
  - lastIndexOfAny
```
int lastIndexOfAny(char c1,
                   char c2,
                   char c3,
                   int startIndex,
                   int fromIndex)
```
  - lastIndexOfAny
```
int lastIndexOfAny(CharSequence s,
                   int startIndex,
                   int fromIndex)
```
  - lastIndexOfNot
```
int lastIndexOfNot(char c)
```
  - lastIndexOfAnyNot
```
int lastIndexOfAnyNot(char c1,
                      char c2)
```
  - lastIndexOfAnyNot
```
int lastIndexOfAnyNot(char c1,
                      char c2,
                      char c3)
```
  - lastIndexOfAnyNot
```
int lastIndexOfAnyNot(CharSequence s)
```
  - lastIndexOfNot
```
int lastIndexOfNot(char c,
                   int fromIndex)
```
  - lastIndexOfAnyNot
```
int lastIndexOfAnyNot(char c1,
                      char c2,
                      int fromIndex)
```
  - lastIndexOfAnyNot
```
int lastIndexOfAnyNot(char c1,
                      char c2,
                      char c3,
                      int fromIndex)
```
  - lastIndexOfAnyNot
```
int lastIndexOfAnyNot(CharSequence s,
                      int fromIndex)
```
  - lastIndexOfNot
```
int lastIndexOfNot(char c,
                   int startIndex,
                   int fromIndex)
```
  - lastIndexOfAnyNot
```
int lastIndexOfAnyNot(char c1,
                      char c2,
                      int startIndex,
                      int fromIndex)
```
  - lastIndexOfAnyNot
```
int lastIndexOfAnyNot(char c1,
                      char c2,
                      char c3,
                      int startIndex,
                      int fromIndex)
```
  - lastIndexOfAnyNot
```
int lastIndexOfAnyNot(CharSequence s,
                      int startIndex,
                      int fromIndex)
```
  - countLeading
```
int countLeading(CharSequence chars)
```
    Count leading/trailing characters of this sequence
    Parameters can be: 1, 2 or 3 characters or CharSequence. For character arguments counts any contiguous leading/trailing characters in the sequence.
    For CharSequence counts counts any contiguous leading/trailing characters in the sequence which are contained in the given char sequence.
    All functions have overloads: with no fromIndex then 0 is taken for leading and length() for trailing methods with fromIndex then this is taken as the start for leading and end for trailing methods with fromIndex and endIndex, counting will start at fromIndex and stop at endIndex
    countLeading(): count contiguous leading space/tab characters in this sequence countLeading(CharSequence): count contiguous leading characters from set in this sequence countLeading(char): count contiguous leading characters from set in this sequence countLeading(char,char): count contiguous leading characters from set in this sequence countLeading(char,char,char): count contiguous leading characters from set in this sequence
    countLeadingNot(): count contiguous leading not space/tabs in this sequence countLeadingNot(CharSequence): count contiguous leading characters not from set in this sequence countLeadingNot(char): count contiguous leading characters not from set in this sequence countLeadingNot(char,char): count contiguous leading characters not from set in this sequence countLeadingNot(char,char,char): count contiguous leading characters not from set in this sequence
    countTrailing(): count contiguous leading space/tab in this sequence countTrailing(CharSequence): count contiguous leading characters from set in this sequence countTrailing(char): count contiguous leading characters from set in this sequence countTrailing(char,char): count contiguous leading characters from set in this sequence countTrailing(char,char,char): count contiguous leading characters from set in this sequence
    countTrailingNot(): count contiguous leading not space/tabs in this sequence countTrailingNot(CharSequence): count contiguous leading characters not from set in this sequence countTrailingNot(char): count contiguous leading characters not from set in this sequence countTrailingNot(char,char): count contiguous leading characters not from set in this sequence countTrailingNot(char,char,char): count contiguous leading characters not from set in this sequence
    
    Parameters:
    
    chars - set of contiguous characters which should be counted at start of sequence
    
    Returns:
    
    number of chars in contiguous span at start of sequence
  - countLeadingNot
```
int countLeadingNot(CharSequence chars)
```
  - countLeading
```
int countLeading(CharSequence chars,
                 int startIndex)
```
  - countLeadingNot
```
int countLeadingNot(CharSequence chars,
                    int startIndex)
```
  - countLeading
```
int countLeading(CharSequence chars,
                 int startIndex,
                 int endIndex)
```
  - countLeadingNot
```
int countLeadingNot(CharSequence chars,
                    int startIndex,
                    int endIndex)
```
  - countTrailing
```
int countTrailing(CharSequence chars)
```
  - countTrailingNot
```
int countTrailingNot(CharSequence chars)
```
  - countTrailing
```
int countTrailing(CharSequence chars,
                  int startIndex)
```
  - countTrailingNot
```
int countTrailingNot(CharSequence chars,
                     int startIndex)
```
  - countTrailing
```
int countTrailing(CharSequence chars,
                  int startIndex,
                  int endIndex)
```
  - countTrailingNot
```
int countTrailingNot(CharSequence chars,
                     int startIndex,
                     int endIndex)
```
  - countLeading
```
int countLeading(char c)
```
  - countLeadingNot
```
int countLeadingNot(char c)
```
  - countLeading
```
int countLeading(char c,
                 int startIndex)
```
  - countLeadingNot
```
int countLeadingNot(char c,
                    int startIndex)
```
  - countLeading
```
int countLeading(char c,
                 int startIndex,
                 int endIndex)
```
  - countLeadingNot
```
int countLeadingNot(char c,
                    int startIndex,
                    int endIndex)
```
  - countTrailing
```
int countTrailing(char c)
```
  - countTrailingNot
```
int countTrailingNot(char c)
```
  - countTrailing
```
int countTrailing(char c,
                  int startIndex)
```
  - countTrailingNot
```
int countTrailingNot(char c,
                     int startIndex)
```
  - countTrailing
```
int countTrailing(char c,
                  int startIndex,
                  int endIndex)
```
  - countTrailingNot
```
int countTrailingNot(char c,
                     int startIndex,
                     int endIndex)
```
  - countLeading
```
int countLeading()
```
  - countLeadingNot
```
int countLeadingNot()
```
  - countTrailing
```
int countTrailing()
```
  - countTrailingNot
```
int countTrailingNot()
```
  - countOf
```
int countOf()
```
  - countOfNot
```
int countOfNot()
```
  - countOf
```
int countOf(char c)
```
  - countOfNot
```
int countOfNot(char c)
```
  - countOf
```
int countOf(char c,
            int startIndex)
```
  - countOfNot
```
int countOfNot(char c,
               int startIndex)
```
  - countOf
```
int countOf(char c,
            int startIndex,
            int endIndex)
```
  - countOfNot
```
int countOfNot(char c,
               int startIndex,
               int endIndex)
```
  - countOfAny
```
int countOfAny(CharSequence chars)
```
  - countOfAnyNot
```
int countOfAnyNot(CharSequence chars)
```
  - countOfAny
```
int countOfAny(CharSequence chars,
               int startIndex)
```
  - countOfAnyNot
```
int countOfAnyNot(CharSequence chars,
                  int startIndex)
```
  - countOfAny
```
int countOfAny(CharSequence chars,
               int startIndex,
               int endIndex)
```
  - countOfAnyNot
```
int countOfAnyNot(CharSequence chars,
                  int startIndex,
                  int endIndex)
```
  - countLeadingColumns
```
int countLeadingColumns(int startColumn,
                        CharSequence chars)
```
  - trimStart
```
T trimStart(int keepLength,
            CharSequence chars)
```
    Trim, Trim start/end of this sequence, characters to trim are passed in the sequence argument
    returns trimmed sequence or if nothing matched the original sequence
    If character set in the form of character sequence is not passed in the WHITESPACE_CHARS are assumed.
    
    Parameters:
    
    keepLength - minimum length of string to keep
    
    chars - set of characters to trim from start of line
    
    Returns:
    
    sequence after it is trimmed
  - trimEnd
```
T trimEnd(int keepLength,
          CharSequence chars)
```
  - trimStart
```
T trimStart(int keepLength)
```
  - trimEnd
```
T trimEnd(int keepLength)
```
  - trimStart
```
T trimStart(CharSequence chars)
```
  - trimEnd
```
T trimEnd(CharSequence chars)
```
  - trim
```
T trim(CharSequence chars)
```
  - trimStart
```
T trimStart()
```
  - trimEnd
```
T trimEnd()
```
  - trim
```
T trim()
```
  - trimEOL
```
T trimEOL()
```
  - padStart
```
T padStart(int length,
           char pad)
```
  - padEnd
```
T padEnd(int length,
         char pad)
```
  - padStart
```
T padStart(int length)
```
  - padEnd
```
T padEnd(int length)
```
  - trimmedStart
```
T trimmedStart(int keepLength,
               CharSequence chars)
```
    Get the characters Trimmed, Trimmed from start/end of this sequence, characters to trim are passed in the sequence argument
    returns trimmed sequence or if nothing matched the original sequence
    
    Parameters:
    
    keepLength - minimum length of string to keep
    
    chars - set of characters to trim from start of line
    
    Returns:
    
    part of the sequence that was trimmed from the start
  - trimmedEnd
```
T trimmedEnd(int keepLength,
             CharSequence chars)
```
  - trimmedStart
```
T trimmedStart(int keepLength)
```
  - trimmedEnd
```
T trimmedEnd(int keepLength)
```
  - trimmedStart
```
T trimmedStart(CharSequence chars)
```
  - trimmedEnd
```
T trimmedEnd(CharSequence chars)
```
  - trimmedStart
```
T trimmedStart()
```
  - trimmedEnd
```
T trimmedEnd()
```
  - trimmedEOL
```
T trimmedEOL()
```
  - eolLength
```
int eolLength()
```
    Get the length of EOL character at the end of this sequence, if present.
    \n - 1 \r - 1 \r\n - 2
    
    Returns:
    
    0, 1, or 2 depending on the EOL suffix of this sequence
  - eolLength
```
int eolLength(int eolStart)
```
    Get the length of EOL character at the given index of this sequence, if present.
    \n - 1 \r - 1 \r\n - 2
    
    Returns:
    
    0, 1, or 2 depending on the EOL suffix of this sequence
  - isEmpty
```
boolean isEmpty()
```
  - isBlank
```
boolean isBlank()
```
  - isNull
```
boolean isNull()
```
  - isNotNull
```
boolean isNotNull()
```
  - ifNull
```
T ifNull(T other)
```
    If this sequence is the BasedSequence.NULL instance then returns other, otherwise returns this sequence.
    
    Parameters:
    
    other - based sequence to return if this is BasedSequence.NULL
    
    Returns:
    
    this or other
  - ifNullEmptyAfter
```
T ifNullEmptyAfter(T other)
```
    If this sequence is the BasedSequence.NULL instance then returns an empty subSequence from the end of other, otherwise returns this sequence.
    
    Parameters:
    
    other - based sequence from which to take the empty sequence
    
    Returns:
    
    this or other.subSequence(other.length(), other.length())
  - ifNullEmptyBefore
```
T ifNullEmptyBefore(T other)
```
    If this sequence is the BasedSequence.NULL instance then returns an empty subSequence from the start of other, otherwise returns this sequence.
    
    Parameters:
    
    other - based sequence from which to take the empty sequence
    
    Returns:
    
    this or other.subSequence(0, 0)
  - nullIfEmpty
```
T nullIfEmpty()
```
    If this sequence is empty return BasedSequence.NULL otherwise returns this sequence.
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfBlank
```
T nullIfBlank()
```
    If this sequence is blank return BasedSequence.NULL otherwise returns this sequence.
    
    Returns:
    
    this or SubSequence.NULL
  - nullIf
```
T nullIf(boolean condition)
```
    If condition is true return BasedSequence.NULL otherwise returns this sequence.
    
    Parameters:
    
    condition - when true return NULL else this
    
    Returns:
    
    this or SubSequence.NULL
  - nullIf
```
T nullIf(CharSequence... matches)
```
    If this sequence matches one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfNot
```
T nullIfNot(CharSequence... matches)
```
    If this sequence does not match one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfStartsWith
```
T nullIfStartsWith(CharSequence... matches)
```
    If this sequence starts with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfStartsWithNot
```
T nullIfStartsWithNot(CharSequence... matches)
```
    If this sequence does not start with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfEndsWith
```
T nullIfEndsWith(CharSequence... matches)
```
    If this sequence ends with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfEndsWithNot
```
T nullIfEndsWithNot(CharSequence... matches)
```
    If this sequence does not end with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - endOfDelimitedBy
```
int endOfDelimitedBy(CharSequence s,
                     int index)
```
    Find start/end region in this sequence delimited by any characters in argument or the CharSequence
    For Any and AnyNot methods uses the CharSequence argument as a character set of possible delimiting characters
    
    Parameters:
    
    s - character sequence delimiting the region
    
    index - from which to start looking for end of region
    
    Returns:
    
    index of end of region delimited by s
  - endOfDelimitedByAny
```
int endOfDelimitedByAny(CharSequence s,
                        int index)
```
  - endOfDelimitedByAnyNot
```
int endOfDelimitedByAnyNot(CharSequence s,
                           int index)
```
  - startOfDelimitedBy
```
int startOfDelimitedBy(CharSequence s,
                       int index)
```
  - startOfDelimitedByAny
```
int startOfDelimitedByAny(CharSequence s,
                          int index)
```
  - startOfDelimitedByAnyNot
```
int startOfDelimitedByAnyNot(CharSequence s,
                             int index)
```
  - endOfLine
```
int endOfLine(int index)
```
    Get the offset of the end of line at given index, end of line delimited by \n or any of \n \r \r\n for Any methods.
    
    Parameters:
    
    index - index where to start searching for end of line
    
    Returns:
    
    index of end of line delimited by \n
  - endOfLineAnyEOL
```
int endOfLineAnyEOL(int index)
```
  - startOfLine
```
int startOfLine(int index)
```
  - startOfLineAnyEOL
```
int startOfLineAnyEOL(int index)
```
  - lineAt
```
T lineAt(int index)
```
    Get the line characters at given index, line delimited by \n
    
    Parameters:
    
    index - index at which to get the line
    
    Returns:
    
    sub-sequence for the line containing index
  - lineAtAnyEOL
```
T lineAtAnyEOL(int index)
```
    Get the line characters at given index, line delimited by \n, \r or \r\n
    
    Parameters:
    
    index - index at which to get the line
    
    Returns:
    
    sub-sequence for the line containing index
  - normalizeEOL
```
String normalizeEOL()
```
    replace any \r\n and \r by \n
    
    Returns:
    
    string with only \n for line separators
  - normalizeEndWithEOL
```
String normalizeEndWithEOL()
```
    replace any \r\n and \r by \n, append terminating EOL if one is not present
    
    Returns:
    
    string with only \n for line separators and terminated by \n
  - matches
```
boolean matches(CharSequence chars)
```
    Test the sequence for a match to another CharSequence
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if match
  - matchesIgnoreCase
```
boolean matchesIgnoreCase(CharSequence chars)
```
    Test the sequence for a match to another CharSequence, ignoring case differences
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if match
  - equalsIgnoreCase
```
boolean equalsIgnoreCase(CharSequence other)
```
    Test the sequence for a match to another CharSequence, ignoring case differences
    
    Parameters:
    
    other - characters to match against
    
    Returns:
    
    true if match
  - matches
```
boolean matches(CharSequence chars,
                boolean ignoreCase)
```
    Test the sequence for a match to another CharSequence
    
    Parameters:
    
    chars - characters to match against
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if match
  - equals
```
boolean equals(Object other,
               boolean ignoreCase)
```
    Test the sequence for a match to another CharSequence
    
    Parameters:
    
    other - characters to match against
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if match
  - matchChars
```
boolean matchChars(CharSequence chars)
```
    Test the sequence portion for a match to another CharSequence
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if characters at the start of this sequence match
  - matchCharsIgnoreCase
```
boolean matchCharsIgnoreCase(CharSequence chars)
```
    Test the sequence portion for a match to another CharSequence, ignoring case differences
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if characters at the start of this sequence match
  - matchChars
```
boolean matchChars(CharSequence chars,
                   boolean ignoreCase)
```
    Test the sequence portion for a match to another CharSequence
    
    Parameters:
    
    chars - characters to match against
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if characters at the start of this sequence match
  - matchChars
```
boolean matchChars(CharSequence chars,
                   int startIndex)
```
    Test the sequence portion for a match to another CharSequence
    
    Parameters:
    
    chars - characters to match against
    
    startIndex - index from which to start the match
    
    Returns:
    
    true if characters at the start index of this sequence match
  - matchCharsIgnoreCase
```
boolean matchCharsIgnoreCase(CharSequence chars,
                             int startIndex)
```
    Test the sequence portion for a match to another CharSequence, ignoring case differences
    
    Parameters:
    
    chars - characters to match against
    
    startIndex - index from which to start the match
    
    Returns:
    
    true if characters at the start index of this sequence match
  - matchChars
```
boolean matchChars(CharSequence chars,
                   int startIndex,
                   boolean ignoreCase)
```
    Test the sequence portion for a match to another CharSequence
    
    Parameters:
    
    chars - characters to match against
    
    startIndex - index from which to start the match
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if characters at the start index of this sequence match
  - matchCharsReversed
```
boolean matchCharsReversed(CharSequence chars,
                           int endIndex)
```
    Test the sequence portion for a match to another CharSequence, reverse order
    
    Parameters:
    
    chars - characters to match against
    
    endIndex - index from which to start the match and proceed to 0
    
    Returns:
    
    true if characters at the start index of this sequence match
  - matchCharsReversedIgnoreCase
```
boolean matchCharsReversedIgnoreCase(CharSequence chars,
                                     int endIndex)
```
    Test the sequence portion for a match to another CharSequence, reverse order, ignoring case differences
    
    Parameters:
    
    chars - characters to match against
    
    endIndex - index from which to start the match and proceed to 0
    
    Returns:
    
    true if characters at the start index of this sequence match
  - matchCharsReversed
```
boolean matchCharsReversed(CharSequence chars,
                           int endIndex,
                           boolean ignoreCase)
```
    Test the sequence portion for a match to another CharSequence, reverse order
    
    Parameters:
    
    chars - characters to match against
    
    endIndex - index from which to start the match and proceed to 0
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if characters at the start index of this sequence match
  - endsWith
```
boolean endsWith(CharSequence suffix)
```
    test if this sequence ends with given characters
    
    Parameters:
    
    suffix - characters to test
    
    Returns:
    
    true if ends with suffix
  - endsWithIgnoreCase
```
boolean endsWithIgnoreCase(CharSequence suffix)
```
    test if this sequence ends with given characters, ignoring case differences
    
    Parameters:
    
    suffix - characters to test
    
    Returns:
    
    true if ends with suffix
  - endsWith
```
boolean endsWith(CharSequence suffix,
                 boolean ignoreCase)
```
    test if this sequence ends with given characters
    
    Parameters:
    
    suffix - characters to test
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if ends with suffix
  - startsWith
```
boolean startsWith(CharSequence prefix)
```
    test if this sequence starts with given characters
    
    Parameters:
    
    prefix - characters to test
    
    Returns:
    
    true if starts with prefix
  - startsWithIgnoreCase
```
boolean startsWithIgnoreCase(CharSequence prefix)
```
    test if this sequence starts with given characters, ignoring case differences
    
    Parameters:
    
    prefix - characters to test
    
    Returns:
    
    true if starts with prefix
  - startsWith
```
boolean startsWith(CharSequence prefix,
                   boolean ignoreCase)
```
    test if this sequence starts with given characters
    
    Parameters:
    
    prefix - characters to test
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if starts with prefix
  - removeSuffix
```
T removeSuffix(CharSequence suffix)
```
    Remove suffix if present
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeSuffixIgnoreCase
```
T removeSuffixIgnoreCase(CharSequence suffix)
```
    Remove suffix if present, ignoring case differences
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeSuffix
```
T removeSuffix(CharSequence suffix,
               boolean ignoreCase)
```
    Remove suffix if present
    
    Parameters:
    
    suffix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removePrefix
```
T removePrefix(CharSequence prefix)
```
    Remove prefix if present
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removePrefixIgnoreCase
```
T removePrefixIgnoreCase(CharSequence prefix)
```
    Remove prefix if present, ignoring case differences
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removePrefix
```
T removePrefix(CharSequence prefix,
               boolean ignoreCase)
```
    Remove prefix if present
    
    Parameters:
    
    prefix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperSuffix
```
T removeProperSuffix(CharSequence suffix)
```
    Remove suffix if present but only if this sequence is longer than the suffix
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperSuffixIgnoreCase
```
T removeProperSuffixIgnoreCase(CharSequence suffix)
```
    Remove suffix if present but only if this sequence is longer than the suffix, ignoring case differences
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperSuffix
```
T removeProperSuffix(CharSequence suffix,
                     boolean ignoreCase)
```
    Remove suffix if present but only if this sequence is longer than the suffix
    
    Parameters:
    
    suffix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperPrefix
```
T removeProperPrefix(CharSequence prefix)
```
    Remove prefix if present but only if this sequence is longer than the suffix
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperPrefixIgnoreCase
```
T removeProperPrefixIgnoreCase(CharSequence prefix)
```
    Remove prefix if present but only if this sequence is longer than the suffix, ignoring case differences
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperPrefix
```
T removeProperPrefix(CharSequence prefix,
                     boolean ignoreCase)
```
    Remove prefix if present but only if this sequence is longer than the suffix
    
    Parameters:
    
    prefix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - toLowerCase
```
T toLowerCase()
```
    Map characters of this sequence to: Uppercase, Lowercase or use custom mapping
    
    Returns:
    
    lowercase version of sequence
  - toUpperCase
```
T toUpperCase()
```
  - toLowerCase
```
T toLowerCase(Locale locale)
```
  - toUpperCase
```
T toUpperCase(Locale locale)
```
  - toMapped
```
T toMapped(CharMapper mapper)
```
  - trimTailBlankLines
```
T trimTailBlankLines()
```
    Trim leading trailing blank lines in this sequence
    
    Returns:
    
    return sequence with trailing blank lines trimmed off
  - trimLeadBlankLines
```
T trimLeadBlankLines()
```
  - toVisibleWhitespaceString
```
String toVisibleWhitespaceString()
```
  - split
```
T[] split(char delimiter,
          int limit,
          int flags,
          String trimChars)
```
    Split helpers based on delimiter character sets contained in CharSequence
    
    Parameters:
    
    delimiter - delimiter char or set of chars in CharSequence to split this sequence on
    
    limit - max number of segments to split
    
    flags - flags for desired options: SPLIT_INCLUDE_DELIMS: include delimiters as part of split item SPLIT_TRIM_PARTS: trim the segments SPLIT_SKIP_EMPTY: skip empty segments (or empty after trimming if enabled) SPLIT_INCLUDE_DELIM_PARTS: include delimiters as separate split item of its own SPLIT_TRIM_SKIP_EMPTY: same as SPLIT_TRIM_PARTS | SPLIT_SKIP_EMPTY
    
    trimChars - set of characters that should be used for trimming individual split results
    
    Returns:
    
    List of split results
  - split
```
T[] split(char delimiter)
```
  - split
```
T[] split(char delimiter,
          int limit)
```
  - split
```
T[] split(char delimiter,
          int limit,
          int flags)
```
  - split
```
T[] split(CharSequence delimiter)
```
  - split
```
T[] split(CharSequence delimiter,
          int limit)
```
  - split
```
T[] split(CharSequence delimiter,
          int limit,
          int flags)
```
  - split
```
T[] split(CharSequence delimiter,
          int limit,
          int flags,
          String trimChars)
```
  - indexOfAll
```
int[] indexOfAll(CharSequence s)
```
    Get indices of all occurrences of a sequence
    
    Parameters:
    
    s - sequence whose indices to find
    
    Returns:
    
    array of indices
  - replace
```
T replace(CharSequence find,
          CharSequence replace)
```
    Replace all occurrences of one sequence with another
    
    Parameters:
    
    find - sequence to find
    
    replace - replacement sequence
    
    Returns:
    
    array of indices
  - appendTo
```
T appendTo(StringBuilder out)
```
  - appendTo
```
T appendTo(StringBuilder out,
           int start)
```
  - appendTo
```
T appendTo(StringBuilder out,
           int start,
           int end)
```
  - append
```
T append(CharSequence... others)
```
  - getLineColumnAtIndex
```
Pair<Integer,Integer> getLineColumnAtIndex(int index)
```
    Get the line and column information from index into sequence
    
    Parameters:
    
    index - index for which to get line information
    
    Returns:
    
    Pair(line, column) where line and column are 0 based, throws IllegalArgumentException if index < 0 or > length.
  - getColumnAtIndex
```
int getColumnAtIndex(int index)
```

Interface RichCharSequence<T extends RichCharSequence>

Field Summary

Method Summary

Methods inherited from interface java.lang.CharSequence

Methods inherited from interface java.lang.Comparable

Field Detail

EOL

SPACE

WHITESPACE_NO_EOL_CHARS

WHITESPACE_CHARS

WHITESPACE_NBSP_CHARS

EOL_CHARS

EOL_CHAR

EOL_CHAR1

EOL_CHAR2

SPLIT_INCLUDE_DELIMS

SPLIT_TRIM_PARTS

SPLIT_SKIP_EMPTY

SPLIT_INCLUDE_DELIM_PARTS

SPLIT_TRIM_SKIP_EMPTY

Method Detail

emptyArray

nullSequence

lastChar

firstChar

subSequence

subSequence

subSequence

endSequence

endSequence

endCharAt

midSequence

midSequence

midCharAt

sequenceOf

sequenceOf

sequenceOf

indexOf

indexOf

indexOf

indexOf

indexOfAny

indexOfAny

indexOfAny

indexOf

indexOfAny

indexOfAny

indexOfAny

indexOf

indexOfAny

indexOfAny

indexOfAny

indexOfNot

indexOfAnyNot

indexOfAnyNot

indexOfAnyNot

indexOfNot

indexOfAnyNot

indexOfAnyNot

indexOfAnyNot

indexOfNot

indexOfAnyNot

indexOfAnyNot

indexOfAnyNot

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOfAny

lastIndexOfAny

lastIndexOfAny

lastIndexOf

lastIndexOfAny

lastIndexOfAny

lastIndexOfAny

lastIndexOf

lastIndexOfAny

lastIndexOfAny

lastIndexOfAny

lastIndexOfNot