RichCharSequenceBase (flexmark-java utilities 0.50.42 API)

java.lang.Object
- com.vladsch.flexmark.util.sequence.RichCharSequenceBase<T>

All Implemented Interfaces:

RichCharSequence<T>, CharSequence, Comparable<CharSequence>

Direct Known Subclasses:

BasedSequenceImpl, RichCharSequenceImpl
```
public abstract class RichCharSequenceBase<T extends RichCharSequence<T>>
extends Object
implements RichCharSequence<T>
```
A CharSequence that wraps original char sequence and maps '\0' to '�' and adds rich set of string manipulation and test functions.

Field Summary
- Fields inherited from interface com.vladsch.flexmark.util.sequence.RichCharSequence
  EOL, EOL_CHAR, EOL_CHAR1, EOL_CHAR2, EOL_CHARS, SPACE, SPLIT_INCLUDE_DELIM_PARTS, SPLIT_INCLUDE_DELIMS, SPLIT_SKIP_EMPTY, SPLIT_TRIM_PARTS, SPLIT_TRIM_SKIP_EMPTY, WHITESPACE_CHARS, WHITESPACE_NBSP_CHARS, WHITESPACE_NO_EOL_CHARS

Constructor Summary

Constructors
Constructor and Description

RichCharSequenceBase()

Constructors
Constructor and Description
`RichCharSequenceBase()`

Method Summary

All Methods Static Methods Instance Methods Concrete 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)`
`static int`	`columnsToNextTabStop(int column)`
`int`	`compareTo(CharSequence other)`
`int`	`countLeading()`
`int`	`countLeading(char c)`
`int`	`countLeading(char c, int fromIndex)`
`int`	`countLeading(char c, int fromIndex, int endIndex)`
`int`	`countLeading(CharSequence chars)` Count leading/trailing characters of this sequence
`int`	`countLeading(CharSequence chars, int fromIndex)`
`int`	`countLeading(CharSequence chars, int fromIndex, int endIndex)`
`int`	`countLeadingColumns(int startColumn, CharSequence chars)`
`int`	`countLeadingNot()`
`int`	`countLeadingNot(char c)`
`int`	`countLeadingNot(char c, int fromIndex)`
`int`	`countLeadingNot(char c, int fromIndex, int endIndex)`
`int`	`countLeadingNot(CharSequence chars)`
`int`	`countLeadingNot(CharSequence chars, int fromIndex)`
`int`	`countLeadingNot(CharSequence chars, int fromIndex, int endIndex)`
`int`	`countOf()`
`int`	`countOf(char c)`
`int`	`countOf(char c, int fromIndex)`
`int`	`countOf(char c1, int startIndex, int fromIndex)`
`int`	`countOfAny(CharSequence chars)`
`int`	`countOfAny(CharSequence chars, int fromIndex)`
`int`	`countOfAny(CharSequence s, int fromIndex, int endIndex)`
`int`	`countOfAnyNot(CharSequence chars)`
`int`	`countOfAnyNot(CharSequence chars, int fromIndex)`
`int`	`countOfAnyNot(CharSequence s, int fromIndex, int endIndex)`
`int`	`countOfNot()`
`int`	`countOfNot(char c)`
`int`	`countOfNot(char c, int fromIndex)`
`int`	`countOfNot(char c1, int startIndex, int fromIndex)`
`int`	`countTrailing()`
`int`	`countTrailing(char c)`
`int`	`countTrailing(char c, int fromIndex)`
`int`	`countTrailing(char c, int startIndex, int fromIndex)`
`int`	`countTrailing(CharSequence chars)`
`int`	`countTrailing(CharSequence chars, int fromIndex)`
`int`	`countTrailing(CharSequence chars, int startIndex, int fromIndex)`
`int`	`countTrailingNot()`
`int`	`countTrailingNot(char c)`
`int`	`countTrailingNot(char c, int fromIndex)`
`int`	`countTrailingNot(char c, int startIndex, int fromIndex)`
`int`	`countTrailingNot(CharSequence chars)`
`int`	`countTrailingNot(CharSequence chars, int fromIndex)`
`int`	`countTrailingNot(CharSequence chars, int startIndex, int fromIndex)`
`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`	`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
`static int[]`	`expandTo(int[] indices, int length, int step)`
`char`	`firstChar()`
`<S extends RichCharSequence<S>> S`	`firstNonNull(S... sequences)`
`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 index)`
`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`	`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[]`	`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(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)`
`String`	`toString()`
`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
`static int[]`	`truncateTo(int[] indices, int length)`

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

Methods inherited from interface com.vladsch.flexmark.util.sequence.RichCharSequence
emptyArray, nullSequence, sequenceOf, subSequence

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

- Constructor Detail
  - RichCharSequenceBase
```
public RichCharSequenceBase()
```
- Method Detail
  - firstNonNull
```
public <S extends RichCharSequence<S>> S firstNonNull(S... sequences)
```
  - sequenceOf
```
public T sequenceOf(CharSequence charSequence)
```
    Description copied from interface: RichCharSequence
    
    Factory function
    
    Specified by:
    
    sequenceOf in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    charSequence - char sequence from which to construct a rich char sequence
    
    Returns:
    
    rich char sequence from given inputs
  - sequenceOf
```
public final T sequenceOf(CharSequence charSequence,
                          int startIndex)
```
    Factory function
    
    Specified by:
    
    sequenceOf in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
  - endSequence
```
public final T endSequence(int start,
                           int end)
```
    Description copied from interface: RichCharSequence
    
    Convenience method to get characters offset from end of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Specified by:
    
    endSequence in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final T endSequence(int start)
```
    Description copied from interface: RichCharSequence
    
    Convenience method to get characters offset from end of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Specified by:
    
    endSequence in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    start - offset from end of sequence [ 0..length() )
    
    Returns:
    
    selected portion spanning length() - start to length() of this sequence
  - endCharAt
```
public final char endCharAt(int index)
```
    Description copied from interface: RichCharSequence
    
    Convenience method to get characters offset from end of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Specified by:
    
    endCharAt in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    index - offset from end of sequence
    
    Returns:
    
    character located at length() - index in this sequence
  - midSequence
```
public final T midSequence(int start,
                           int end)
```
    Description copied from interface: RichCharSequence
    
    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
    
    Specified by:
    
    midSequence in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final T midSequence(int start)
```
    Description copied from interface: RichCharSequence
    
    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
    
    Specified by:
    
    midSequence in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final char midCharAt(int index)
```
    Description copied from interface: RichCharSequence
    
    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
    
    Specified by:
    
    midCharAt in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    index - of character to get
    
    Returns:
    
    character at index or \0 if index is outside valid range for this sequence
  - lastChar
```
public final char lastChar()
```
    Specified by:
    
    lastChar in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Returns:
    
    the last character of the sequence or '\0' if empty
  - firstChar
```
public final char firstChar()
```
    Specified by:
    
    firstChar in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Returns:
    
    the first character of the sequence or '\0' if empty
  - indexOf
```
public final int indexOf(CharSequence s)
```
    Description copied from interface: RichCharSequence
    
    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
    
    Specified by:
    
    indexOf in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    s - character sequence whose occurrence to find
    
    Returns:
    
    index where found or -1
  - indexOf
```
public final int indexOf(CharSequence s,
                         int fromIndex)
```
    Specified by:
    
    indexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOf
```
public final int indexOf(CharSequence s,
                         int fromIndex,
                         int endIndex)
```
    Specified by:
    
    indexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOf
```
public final int indexOf(char c)
```
    Specified by:
    
    indexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAny
```
public final int indexOfAny(char c1,
                            char c2)
```
    Specified by:
    
    indexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAny
```
public final int indexOfAny(char c1,
                            char c2,
                            char c3)
```
    Specified by:
    
    indexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAny
```
public final int indexOfAny(CharSequence s)
```
    Specified by:
    
    indexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOf
```
public final int indexOf(char c,
                         int fromIndex)
```
    Specified by:
    
    indexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAny
```
public final int indexOfAny(char c1,
                            char c2,
                            int fromIndex)
```
    Specified by:
    
    indexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAny
```
public final int indexOfAny(char c1,
                            char c2,
                            char c3,
                            int fromIndex)
```
    Specified by:
    
    indexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAny
```
public final int indexOfAny(CharSequence s,
                            int index)
```
    Specified by:
    
    indexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOf
```
public final int indexOf(char c,
                         int fromIndex,
                         int endIndex)
```
    Specified by:
    
    indexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAny
```
public final int indexOfAny(char c1,
                            char c2,
                            int fromIndex,
                            int endIndex)
```
    Specified by:
    
    indexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAny
```
public final int indexOfAny(char c1,
                            char c2,
                            char c3,
                            int fromIndex,
                            int endIndex)
```
    Specified by:
    
    indexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAny
```
public final int indexOfAny(CharSequence s,
                            int fromIndex,
                            int endIndex)
```
    Specified by:
    
    indexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfNot
```
public final int indexOfNot(char c)
```
    Specified by:
    
    indexOfNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(char c1,
                               char c2)
```
    Specified by:
    
    indexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(char c1,
                               char c2,
                               char c3)
```
    Specified by:
    
    indexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(CharSequence s)
```
    Specified by:
    
    indexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfNot
```
public final int indexOfNot(char c,
                            int fromIndex)
```
    Specified by:
    
    indexOfNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(char c1,
                               char c2,
                               int fromIndex)
```
    Specified by:
    
    indexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(char c1,
                               char c2,
                               char c3,
                               int fromIndex)
```
    Specified by:
    
    indexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(CharSequence s,
                               int fromIndex)
```
    Specified by:
    
    indexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfNot
```
public final int indexOfNot(char c,
                            int fromIndex,
                            int endIndex)
```
    Specified by:
    
    indexOfNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(char c1,
                               char c2,
                               int fromIndex,
                               int endIndex)
```
    Specified by:
    
    indexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(char c1,
                               char c2,
                               char c3,
                               int fromIndex,
                               int endIndex)
```
    Specified by:
    
    indexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(CharSequence s,
                               int fromIndex,
                               int endIndex)
```
    Specified by:
    
    indexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(CharSequence s)
```
    Specified by:
    
    lastIndexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(CharSequence s,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(CharSequence s,
                             int startIndex,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(char c)
```
    Specified by:
    
    lastIndexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(char c1,
                                char c2)
```
    Specified by:
    
    lastIndexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(char c1,
                                char c2,
                                char c3)
```
    Specified by:
    
    lastIndexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(CharSequence s)
```
    Specified by:
    
    lastIndexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(char c,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(char c1,
                                char c2,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(char c1,
                                char c2,
                                char c3,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(CharSequence s,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(char c,
                             int startIndex,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(char c1,
                                char c2,
                                int startIndex,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(char c1,
                                char c2,
                                char c3,
                                int startIndex,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(CharSequence s,
                                int startIndex,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfNot
```
public final int lastIndexOfNot(char c)
```
    Specified by:
    
    lastIndexOfNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(char c1,
                                   char c2)
```
    Specified by:
    
    lastIndexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(char c1,
                                   char c2,
                                   char c3)
```
    Specified by:
    
    lastIndexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(CharSequence s)
```
    Specified by:
    
    lastIndexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfNot
```
public final int lastIndexOfNot(char c,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(char c1,
                                   char c2,
                                   int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(char c1,
                                   char c2,
                                   char c3,
                                   int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(CharSequence s,
                                   int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfNot
```
public final int lastIndexOfNot(char c,
                                int startIndex,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(char c1,
                                   char c2,
                                   int startIndex,
                                   int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(char c1,
                                   char c2,
                                   char c3,
                                   int startIndex,
                                   int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(CharSequence s,
                                   int startIndex,
                                   int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOf
```
public final int countOf(char c)
```
    Specified by:
    
    countOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOfNot
```
public final int countOfNot(char c)
```
    Specified by:
    
    countOfNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOf
```
public final int countOf(char c,
                         int fromIndex)
```
    Specified by:
    
    countOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOfNot
```
public final int countOfNot(char c,
                            int fromIndex)
```
    Specified by:
    
    countOfNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOf
```
public final int countOf()
```
    Specified by:
    
    countOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOfNot
```
public final int countOfNot()
```
    Specified by:
    
    countOfNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOfAny
```
public final int countOfAny(CharSequence chars)
```
    Specified by:
    
    countOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOfAnyNot
```
public final int countOfAnyNot(CharSequence chars)
```
    Specified by:
    
    countOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOfAny
```
public final int countOfAny(CharSequence chars,
                            int fromIndex)
```
    Specified by:
    
    countOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOfAnyNot
```
public final int countOfAnyNot(CharSequence chars,
                               int fromIndex)
```
    Specified by:
    
    countOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOf
```
public final int countOf(char c1,
                         int startIndex,
                         int fromIndex)
```
    Specified by:
    
    countOf in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOfAny
```
public final int countOfAny(CharSequence s,
                            int fromIndex,
                            int endIndex)
```
    Specified by:
    
    countOfAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOfNot
```
public final int countOfNot(char c1,
                            int startIndex,
                            int fromIndex)
```
    Specified by:
    
    countOfNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countOfAnyNot
```
public final int countOfAnyNot(CharSequence s,
                               int fromIndex,
                               int endIndex)
```
    Specified by:
    
    countOfAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - startOfDelimitedBy
```
public final int startOfDelimitedBy(CharSequence s,
                                    int index)
```
    Specified by:
    
    startOfDelimitedBy in interface RichCharSequence<T extends RichCharSequence<T>>
  - startOfDelimitedByAny
```
public final int startOfDelimitedByAny(CharSequence s,
                                       int index)
```
    Specified by:
    
    startOfDelimitedByAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - startOfDelimitedByAnyNot
```
public final int startOfDelimitedByAnyNot(CharSequence s,
                                          int index)
```
    Specified by:
    
    startOfDelimitedByAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - endOfDelimitedBy
```
public final int endOfDelimitedBy(CharSequence s,
                                  int index)
```
    Description copied from interface: RichCharSequence
    
    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
    
    Specified by:
    
    endOfDelimitedBy in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final int endOfDelimitedByAny(CharSequence s,
                                     int index)
```
    Specified by:
    
    endOfDelimitedByAny in interface RichCharSequence<T extends RichCharSequence<T>>
  - endOfDelimitedByAnyNot
```
public final int endOfDelimitedByAnyNot(CharSequence s,
                                        int index)
```
    Specified by:
    
    endOfDelimitedByAnyNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - endOfLine
```
public final int endOfLine(int index)
```
    Description copied from interface: RichCharSequence
    
    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.
    
    Specified by:
    
    endOfLine in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    index - index where to start searching for end of line
    
    Returns:
    
    index of end of line delimited by \n
  - endOfLineAnyEOL
```
public final int endOfLineAnyEOL(int index)
```
    Specified by:
    
    endOfLineAnyEOL in interface RichCharSequence<T extends RichCharSequence<T>>
  - startOfLine
```
public final int startOfLine(int index)
```
    Specified by:
    
    startOfLine in interface RichCharSequence<T extends RichCharSequence<T>>
  - startOfLineAnyEOL
```
public final int startOfLineAnyEOL(int index)
```
    Specified by:
    
    startOfLineAnyEOL in interface RichCharSequence<T extends RichCharSequence<T>>
  - lineAt
```
public final T lineAt(int index)
```
    Description copied from interface: RichCharSequence
    
    Get the line characters at given index, line delimited by \n
    
    Specified by:
    
    lineAt in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    index - index at which to get the line
    
    Returns:
    
    sub-sequence for the line containing index
  - lineAtAnyEOL
```
public final T lineAtAnyEOL(int index)
```
    Description copied from interface: RichCharSequence
    
    Get the line characters at given index, line delimited by \n, \r or \r\n
    
    Specified by:
    
    lineAtAnyEOL in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    index - index at which to get the line
    
    Returns:
    
    sub-sequence for the line containing index
  - countLeading
```
public final int countLeading(char c)
```
    Specified by:
    
    countLeading in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeadingNot
```
public final int countLeadingNot(char c)
```
    Specified by:
    
    countLeadingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeading
```
public final int countLeading(char c,
                              int fromIndex)
```
    Specified by:
    
    countLeading in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeadingNot
```
public final int countLeadingNot(char c,
                                 int fromIndex)
```
    Specified by:
    
    countLeadingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailing
```
public final int countTrailing(char c)
```
    Specified by:
    
    countTrailing in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailingNot
```
public final int countTrailingNot(char c)
```
    Specified by:
    
    countTrailingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailing
```
public final int countTrailing(char c,
                               int fromIndex)
```
    Specified by:
    
    countTrailing in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailingNot
```
public final int countTrailingNot(char c,
                                  int fromIndex)
```
    Specified by:
    
    countTrailingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeading
```
public final int countLeading(char c,
                              int fromIndex,
                              int endIndex)
```
    Specified by:
    
    countLeading in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailing
```
public final int countTrailing(char c,
                               int startIndex,
                               int fromIndex)
```
    Specified by:
    
    countTrailing in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeadingNot
```
public final int countLeadingNot(char c,
                                 int fromIndex,
                                 int endIndex)
```
    Specified by:
    
    countLeadingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailingNot
```
public final int countTrailingNot(char c,
                                  int startIndex,
                                  int fromIndex)
```
    Specified by:
    
    countTrailingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeading
```
public final int countLeading()
```
    Specified by:
    
    countLeading in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeadingNot
```
public final int countLeadingNot()
```
    Specified by:
    
    countLeadingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailing
```
public final int countTrailing()
```
    Specified by:
    
    countTrailing in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailingNot
```
public final int countTrailingNot()
```
    Specified by:
    
    countTrailingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeading
```
public final int countLeading(CharSequence chars)
```
    Description copied from interface: RichCharSequence
    
    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
    
    Specified by:
    
    countLeading in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final int countLeadingNot(CharSequence chars)
```
    Specified by:
    
    countLeadingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeading
```
public final int countLeading(CharSequence chars,
                              int fromIndex)
```
    Specified by:
    
    countLeading in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeadingNot
```
public final int countLeadingNot(CharSequence chars,
                                 int fromIndex)
```
    Specified by:
    
    countLeadingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailing
```
public final int countTrailing(CharSequence chars)
```
    Specified by:
    
    countTrailing in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailingNot
```
public final int countTrailingNot(CharSequence chars)
```
    Specified by:
    
    countTrailingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailing
```
public final int countTrailing(CharSequence chars,
                               int fromIndex)
```
    Specified by:
    
    countTrailing in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailingNot
```
public final int countTrailingNot(CharSequence chars,
                                  int fromIndex)
```
    Specified by:
    
    countTrailingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeading
```
public final int countLeading(CharSequence chars,
                              int fromIndex,
                              int endIndex)
```
    Specified by:
    
    countLeading in interface RichCharSequence<T extends RichCharSequence<T>>
  - columnsToNextTabStop
```
public static int columnsToNextTabStop(int column)
```
  - countLeadingColumns
```
public final int countLeadingColumns(int startColumn,
                                     CharSequence chars)
```
    Specified by:
    
    countLeadingColumns in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailing
```
public final int countTrailing(CharSequence chars,
                               int startIndex,
                               int fromIndex)
```
    Specified by:
    
    countTrailing in interface RichCharSequence<T extends RichCharSequence<T>>
  - countLeadingNot
```
public final int countLeadingNot(CharSequence chars,
                                 int fromIndex,
                                 int endIndex)
```
    Specified by:
    
    countLeadingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - countTrailingNot
```
public final int countTrailingNot(CharSequence chars,
                                  int startIndex,
                                  int fromIndex)
```
    Specified by:
    
    countTrailingNot in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimStart
```
public final T trimStart(int keepLength,
                         CharSequence chars)
```
    Description copied from interface: RichCharSequence
    
    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 RichCharSequence.WHITESPACE_CHARS are assumed.
    
    Specified by:
    
    trimStart in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    keepLength - minimum length of string to keep
    
    chars - set of characters to trim from start of line
    
    Returns:
    
    sequence after it is trimmed
  - trimmedStart
```
public final T trimmedStart(int keepLength,
                            CharSequence chars)
```
    Description copied from interface: RichCharSequence
    
    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
    
    Specified by:
    
    trimmedStart in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
  - trimEnd
```
public final T trimEnd(int keepLength,
                       CharSequence chars)
```
    Specified by:
    
    trimEnd in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimmedEnd
```
public final T trimmedEnd(int keepLength,
                          CharSequence chars)
```
    Specified by:
    
    trimmedEnd in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimStart
```
public final T trimStart(CharSequence chars)
```
    Specified by:
    
    trimStart in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimmedStart
```
public final T trimmedStart(CharSequence chars)
```
    Specified by:
    
    trimmedStart in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimEnd
```
public final T trimEnd(CharSequence chars)
```
    Specified by:
    
    trimEnd in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimmedEnd
```
public final T trimmedEnd(CharSequence chars)
```
    Specified by:
    
    trimmedEnd in interface RichCharSequence<T extends RichCharSequence<T>>
  - trim
```
public final T trim(CharSequence chars)
```
    Specified by:
    
    trim in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimStart
```
public final T trimStart(int keepLength)
```
    Specified by:
    
    trimStart in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimmedStart
```
public final T trimmedStart(int keepLength)
```
    Specified by:
    
    trimmedStart in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimEnd
```
public final T trimEnd(int keepLength)
```
    Specified by:
    
    trimEnd in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimmedEnd
```
public final T trimmedEnd(int keepLength)
```
    Specified by:
    
    trimmedEnd in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimStart
```
public final T trimStart()
```
    Specified by:
    
    trimStart in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimmedStart
```
public final T trimmedStart()
```
    Specified by:
    
    trimmedStart in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimEnd
```
public final T trimEnd()
```
    Specified by:
    
    trimEnd in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimmedEnd
```
public final T trimmedEnd()
```
    Specified by:
    
    trimmedEnd in interface RichCharSequence<T extends RichCharSequence<T>>
  - padStart
```
public final T padStart(int length,
                        char pad)
```
    Specified by:
    
    padStart in interface RichCharSequence<T extends RichCharSequence<T>>
  - padEnd
```
public final T padEnd(int length,
                      char pad)
```
    Specified by:
    
    padEnd in interface RichCharSequence<T extends RichCharSequence<T>>
  - padStart
```
public final T padStart(int length)
```
    Specified by:
    
    padStart in interface RichCharSequence<T extends RichCharSequence<T>>
  - padEnd
```
public final T padEnd(int length)
```
    Specified by:
    
    padEnd in interface RichCharSequence<T extends RichCharSequence<T>>
  - eolLength
```
public final int eolLength()
```
    Description copied from interface: RichCharSequence
    
    Get the length of EOL character at the end of this sequence, if present.
    \n - 1 \r - 1 \r\n - 2
    
    Specified by:
    
    eolLength in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Returns:
    
    0, 1, or 2 depending on the EOL suffix of this sequence
  - eolLength
```
public final int eolLength(int eolStart)
```
    Description copied from interface: RichCharSequence
    
    Get the length of EOL character at the given index of this sequence, if present.
    \n - 1 \r - 1 \r\n - 2
    
    Specified by:
    
    eolLength in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Returns:
    
    0, 1, or 2 depending on the EOL suffix of this sequence
  - trimEOL
```
public final T trimEOL()
```
    Specified by:
    
    trimEOL in interface RichCharSequence<T extends RichCharSequence<T>>
  - trimmedEOL
```
public final T trimmedEOL()
```
    Specified by:
    
    trimmedEOL in interface RichCharSequence<T extends RichCharSequence<T>>
  - trim
```
public final T trim()
```
    Specified by:
    
    trim in interface RichCharSequence<T extends RichCharSequence<T>>
  - ifNull
```
public final T ifNull(T other)
```
    Description copied from interface: RichCharSequence
    
    If this sequence is the BasedSequence.NULL instance then returns other, otherwise returns this sequence.
    
    Specified by:
    
    ifNull in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    other - based sequence to return if this is BasedSequence.NULL
    
    Returns:
    
    this or other
  - ifNullEmptyAfter
```
public final T ifNullEmptyAfter(T other)
```
    Description copied from interface: RichCharSequence
    
    If this sequence is the BasedSequence.NULL instance then returns an empty subSequence from the end of other, otherwise returns this sequence.
    
    Specified by:
    
    ifNullEmptyAfter in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    other - based sequence from which to take the empty sequence
    
    Returns:
    
    this or other.subSequence(other.length(), other.length())
  - ifNullEmptyBefore
```
public final T ifNullEmptyBefore(T other)
```
    Description copied from interface: RichCharSequence
    
    If this sequence is the BasedSequence.NULL instance then returns an empty subSequence from the start of other, otherwise returns this sequence.
    
    Specified by:
    
    ifNullEmptyBefore in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    other - based sequence from which to take the empty sequence
    
    Returns:
    
    this or other.subSequence(0, 0)
  - nullIfEmpty
```
public final T nullIfEmpty()
```
    Description copied from interface: RichCharSequence
    
    If this sequence is empty return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfEmpty in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfBlank
```
public final T nullIfBlank()
```
    Description copied from interface: RichCharSequence
    
    If this sequence is blank return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfBlank in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Returns:
    
    this or SubSequence.NULL
  - nullIf
```
public final T nullIf(boolean condition)
```
    Description copied from interface: RichCharSequence
    
    If condition is true return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIf in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    condition - when true return NULL else this
    
    Returns:
    
    this or SubSequence.NULL
  - nullIf
```
public final T nullIf(CharSequence... matches)
```
    Description copied from interface: RichCharSequence
    
    If this sequence matches one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIf in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfNot
```
public final T nullIfNot(CharSequence... matches)
```
    Description copied from interface: RichCharSequence
    
    If this sequence does not match one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfNot in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfStartsWith
```
public final T nullIfStartsWith(CharSequence... matches)
```
    Description copied from interface: RichCharSequence
    
    If this sequence starts with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfStartsWith in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfStartsWithNot
```
public final T nullIfStartsWithNot(CharSequence... matches)
```
    Description copied from interface: RichCharSequence
    
    If this sequence does not start with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfStartsWithNot in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfEndsWith
```
public final T nullIfEndsWith(CharSequence... matches)
```
    Description copied from interface: RichCharSequence
    
    If this sequence ends with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfEndsWith in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfEndsWithNot
```
public final T nullIfEndsWithNot(CharSequence... matches)
```
    Description copied from interface: RichCharSequence
    
    If this sequence does not end with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfEndsWithNot in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - isEmpty
```
public final boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface RichCharSequence<T extends RichCharSequence<T>>
  - isBlank
```
public final boolean isBlank()
```
    Specified by:
    
    isBlank in interface RichCharSequence<T extends RichCharSequence<T>>
  - isNull
```
public final boolean isNull()
```
    Specified by:
    
    isNull in interface RichCharSequence<T extends RichCharSequence<T>>
  - isNotNull
```
public final boolean isNotNull()
```
    Specified by:
    
    isNotNull in interface RichCharSequence<T extends RichCharSequence<T>>
  - endsWith
```
public final boolean endsWith(CharSequence suffix)
```
    Description copied from interface: RichCharSequence
    
    test if this sequence ends with given characters
    
    Specified by:
    
    endsWith in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    suffix - characters to test
    
    Returns:
    
    true if ends with suffix
  - startsWith
```
public final boolean startsWith(CharSequence prefix)
```
    Description copied from interface: RichCharSequence
    
    test if this sequence starts with given characters
    
    Specified by:
    
    startsWith in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    prefix - characters to test
    
    Returns:
    
    true if starts with prefix
  - removeSuffix
```
public final T removeSuffix(CharSequence suffix)
```
    Description copied from interface: RichCharSequence
    
    Remove suffix if present
    
    Specified by:
    
    removeSuffix in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removePrefix
```
public final T removePrefix(CharSequence prefix)
```
    Description copied from interface: RichCharSequence
    
    Remove prefix if present
    
    Specified by:
    
    removePrefix in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperSuffix
```
public final T removeProperSuffix(CharSequence suffix)
```
    Description copied from interface: RichCharSequence
    
    Remove suffix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperSuffix in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperPrefix
```
public final T removeProperPrefix(CharSequence prefix)
```
    Description copied from interface: RichCharSequence
    
    Remove prefix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperPrefix in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - endsWithIgnoreCase
```
public final boolean endsWithIgnoreCase(CharSequence suffix)
```
    Description copied from interface: RichCharSequence
    
    test if this sequence ends with given characters, ignoring case differences
    
    Specified by:
    
    endsWithIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    suffix - characters to test
    
    Returns:
    
    true if ends with suffix
  - startsWithIgnoreCase
```
public final boolean startsWithIgnoreCase(CharSequence prefix)
```
    Description copied from interface: RichCharSequence
    
    test if this sequence starts with given characters, ignoring case differences
    
    Specified by:
    
    startsWithIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    prefix - characters to test
    
    Returns:
    
    true if starts with prefix
  - removeSuffixIgnoreCase
```
public final T removeSuffixIgnoreCase(CharSequence suffix)
```
    Description copied from interface: RichCharSequence
    
    Remove suffix if present, ignoring case differences
    
    Specified by:
    
    removeSuffixIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removePrefixIgnoreCase
```
public final T removePrefixIgnoreCase(CharSequence prefix)
```
    Description copied from interface: RichCharSequence
    
    Remove prefix if present, ignoring case differences
    
    Specified by:
    
    removePrefixIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperSuffixIgnoreCase
```
public final T removeProperSuffixIgnoreCase(CharSequence suffix)
```
    Description copied from interface: RichCharSequence
    
    Remove suffix if present but only if this sequence is longer than the suffix, ignoring case differences
    
    Specified by:
    
    removeProperSuffixIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperPrefixIgnoreCase
```
public final T removeProperPrefixIgnoreCase(CharSequence prefix)
```
    Description copied from interface: RichCharSequence
    
    Remove prefix if present but only if this sequence is longer than the suffix, ignoring case differences
    
    Specified by:
    
    removeProperPrefixIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - endsWith
```
public final boolean endsWith(CharSequence suffix,
                              boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    test if this sequence ends with given characters
    
    Specified by:
    
    endsWith in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    suffix - characters to test
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if ends with suffix
  - startsWith
```
public final boolean startsWith(CharSequence prefix,
                                boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    test if this sequence starts with given characters
    
    Specified by:
    
    startsWith in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    prefix - characters to test
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if starts with prefix
  - removeSuffix
```
public final T removeSuffix(CharSequence suffix,
                            boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    Remove suffix if present
    
    Specified by:
    
    removeSuffix in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removePrefix
```
public final T removePrefix(CharSequence prefix,
                            boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    Remove prefix if present
    
    Specified by:
    
    removePrefix in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperSuffix
```
public final T removeProperSuffix(CharSequence suffix,
                                  boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    Remove suffix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperSuffix in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperPrefix
```
public final T removeProperPrefix(CharSequence prefix,
                                  boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    Remove prefix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperPrefix in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - toLowerCase
```
public final T toLowerCase()
```
    Description copied from interface: RichCharSequence
    
    Map characters of this sequence to: Uppercase, Lowercase or use custom mapping
    
    Specified by:
    
    toLowerCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Returns:
    
    lowercase version of sequence
  - toUpperCase
```
public final T toUpperCase()
```
    Specified by:
    
    toUpperCase in interface RichCharSequence<T extends RichCharSequence<T>>
  - toLowerCase
```
public final T toLowerCase(Locale locale)
```
    Specified by:
    
    toLowerCase in interface RichCharSequence<T extends RichCharSequence<T>>
  - toUpperCase
```
public final T toUpperCase(Locale locale)
```
    Specified by:
    
    toUpperCase in interface RichCharSequence<T extends RichCharSequence<T>>
  - toMapped
```
public T toMapped(CharMapper mapper)
```
    Specified by:
    
    toMapped in interface RichCharSequence<T extends RichCharSequence<T>>
  - matches
```
public final boolean matches(CharSequence chars)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence for a match to another CharSequence
    
    Specified by:
    
    matches in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if match
  - matchesIgnoreCase
```
public final boolean matchesIgnoreCase(CharSequence chars)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence for a match to another CharSequence, ignoring case differences
    
    Specified by:
    
    matchesIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if match
  - matches
```
public final boolean matches(CharSequence chars,
                             boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence for a match to another CharSequence
    
    Specified by:
    
    matches in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if match
  - matchChars
```
public final boolean matchChars(CharSequence chars)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchChars in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if characters at the start of this sequence match
  - matchCharsIgnoreCase
```
public final boolean matchCharsIgnoreCase(CharSequence chars)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence portion for a match to another CharSequence, ignoring case differences
    
    Specified by:
    
    matchCharsIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if characters at the start of this sequence match
  - matchChars
```
public final boolean matchChars(CharSequence chars,
                                boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchChars in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if characters at the start of this sequence match
  - matchChars
```
public final boolean matchChars(CharSequence chars,
                                int startIndex)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchChars in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final boolean matchCharsIgnoreCase(CharSequence chars,
                                          int startIndex)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence portion for a match to another CharSequence, ignoring case differences
    
    Specified by:
    
    matchCharsIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final boolean matchChars(CharSequence chars,
                                int startIndex,
                                boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchChars in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final boolean matchCharsReversed(CharSequence chars,
                                        int endIndex)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence portion for a match to another CharSequence, reverse order
    
    Specified by:
    
    matchCharsReversed in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final boolean matchCharsReversedIgnoreCase(CharSequence chars,
                                                  int endIndex)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence portion for a match to another CharSequence, reverse order, ignoring case differences
    
    Specified by:
    
    matchCharsReversedIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final boolean matchCharsReversed(CharSequence chars,
                                        int endIndex,
                                        boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence portion for a match to another CharSequence, reverse order
    
    Specified by:
    
    matchCharsReversed in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
  - subSequence
```
public final T subSequence(Range range)
```
    Description copied from interface: RichCharSequence
    
    Get a portion of this sequence
    
    Specified by:
    
    subSequence in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    range - range to get, coordinates offset form start of this sequence
    
    Returns:
    
    based sequence whose contents reflect the selected portion
  - subSequence
```
public final T subSequence(int start)
```
    Description copied from interface: RichCharSequence
    
    Get a portion of this sequence starting from a given offset to end of the sequence
    
    Specified by:
    
    subSequence in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    start - offset from start of this sequence
    
    Returns:
    
    based sequence whose contents reflect the selected portion
  - trimTailBlankLines
```
public final T trimTailBlankLines()
```
    Description copied from interface: RichCharSequence
    
    Trim leading trailing blank lines in this sequence
    
    Specified by:
    
    trimTailBlankLines in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Returns:
    
    return sequence with trailing blank lines trimmed off
  - trimLeadBlankLines
```
public final T trimLeadBlankLines()
```
    Specified by:
    
    trimLeadBlankLines in interface RichCharSequence<T extends RichCharSequence<T>>
  - toString
```
public String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Overrides:
    
    toString in class Object
  - normalizeEOL
```
public final String normalizeEOL()
```
    Description copied from interface: RichCharSequence
    
    replace any \r\n and \r by \n
    
    Specified by:
    
    normalizeEOL in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Returns:
    
    string with only \n for line separators
  - normalizeEndWithEOL
```
public final String normalizeEndWithEOL()
```
    Description copied from interface: RichCharSequence
    
    replace any \r\n and \r by \n, append terminating EOL if one is not present
    
    Specified by:
    
    normalizeEndWithEOL in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Returns:
    
    string with only \n for line separators and terminated by \n
  - toVisibleWhitespaceString
```
public final String toVisibleWhitespaceString()
```
    Specified by:
    
    toVisibleWhitespaceString in interface RichCharSequence<T extends RichCharSequence<T>>
  - split
```
public final T[] split(char delimiter)
```
    Specified by:
    
    split in interface RichCharSequence<T extends RichCharSequence<T>>
  - split
```
public final T[] split(char delimiter,
                       int limit)
```
    Specified by:
    
    split in interface RichCharSequence<T extends RichCharSequence<T>>
  - split
```
public final T[] split(char delimiter,
                       int limit,
                       int flags)
```
    Specified by:
    
    split in interface RichCharSequence<T extends RichCharSequence<T>>
  - split
```
public final T[] split(CharSequence delimiter)
```
    Specified by:
    
    split in interface RichCharSequence<T extends RichCharSequence<T>>
  - split
```
public final T[] split(CharSequence delimiter,
                       int limit)
```
    Specified by:
    
    split in interface RichCharSequence<T extends RichCharSequence<T>>
  - split
```
public final T[] split(CharSequence delimiter,
                       int limit,
                       int flags)
```
    Specified by:
    
    split in interface RichCharSequence<T extends RichCharSequence<T>>
  - split
```
public final T[] split(char delimiter,
                       int limit,
                       int flags,
                       String trimChars)
```
    Description copied from interface: RichCharSequence
    
    Split helpers based on delimiter character sets contained in CharSequence
    
    Specified by:
    
    split in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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
```
public final T[] split(CharSequence delimiter,
                       int limit,
                       int flags,
                       String trimChars)
```
    Specified by:
    
    split in interface RichCharSequence<T extends RichCharSequence<T>>
  - appendTo
```
public final T appendTo(StringBuilder out)
```
    Specified by:
    
    appendTo in interface RichCharSequence<T extends RichCharSequence<T>>
  - appendTo
```
public final T appendTo(StringBuilder out,
                        int start)
```
    Specified by:
    
    appendTo in interface RichCharSequence<T extends RichCharSequence<T>>
  - appendTo
```
public final T appendTo(StringBuilder out,
                        int start,
                        int end)
```
    Specified by:
    
    appendTo in interface RichCharSequence<T extends RichCharSequence<T>>
  - expandTo
```
public static int[] expandTo(int[] indices,
                             int length,
                             int step)
```
  - truncateTo
```
public static int[] truncateTo(int[] indices,
                               int length)
```
  - indexOfAll
```
public final int[] indexOfAll(CharSequence s)
```
    Description copied from interface: RichCharSequence
    
    Get indices of all occurrences of a sequence
    
    Specified by:
    
    indexOfAll in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    s - sequence whose indices to find
    
    Returns:
    
    array of indices
  - replace
```
public final T replace(CharSequence find,
                       CharSequence replace)
```
    Description copied from interface: RichCharSequence
    
    Replace all occurrences of one sequence with another
    
    Specified by:
    
    replace in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    find - sequence to find
    
    replace - replacement sequence
    
    Returns:
    
    array of indices
  - append
```
public final T append(CharSequence... others)
```
    Specified by:
    
    append in interface RichCharSequence<T extends RichCharSequence<T>>
  - getColumnAtIndex
```
public final int getColumnAtIndex(int index)
```
    Specified by:
    
    getColumnAtIndex in interface RichCharSequence<T extends RichCharSequence<T>>
  - getLineColumnAtIndex
```
public final Pair<Integer,Integer> getLineColumnAtIndex(int index)
```
    Description copied from interface: RichCharSequence
    
    Get the line and column information from index into sequence
    
    Specified by:
    
    getLineColumnAtIndex in interface RichCharSequence<T extends RichCharSequence<T>>
    
    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.
  - equals
```
public boolean equals(Object other)
```
    Overrides:
    
    equals in class Object
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(CharSequence other)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence for a match to another CharSequence, ignoring case differences
    
    Specified by:
    
    equalsIgnoreCase in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    other - characters to match against
    
    Returns:
    
    true if match
  - equals
```
public boolean equals(Object other,
                      boolean ignoreCase)
```
    Description copied from interface: RichCharSequence
    
    Test the sequence for a match to another CharSequence
    
    Specified by:
    
    equals in interface RichCharSequence<T extends RichCharSequence<T>>
    
    Parameters:
    
    other - characters to match against
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if match
  - compareTo
```
public int compareTo(CharSequence other)
```
    Specified by:
    
    compareTo in interface Comparable<CharSequence>

Class RichCharSequenceBase<T extends RichCharSequence<T>>

Field Summary

Fields inherited from interface com.vladsch.flexmark.util.sequence.RichCharSequence

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface com.vladsch.flexmark.util.sequence.RichCharSequence

Methods inherited from interface java.lang.CharSequence

Constructor Detail

RichCharSequenceBase

Method Detail

firstNonNull

sequenceOf

sequenceOf

endSequence

endSequence

endCharAt

midSequence

midSequence

midCharAt

lastChar

firstChar

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

lastIndexOfAnyNot

lastIndexOfAnyNot

lastIndexOfAnyNot

lastIndexOfNot

lastIndexOfAnyNot

lastIndexOfAnyNot

lastIndexOfAnyNot

lastIndexOfNot

lastIndexOfAnyNot

lastIndexOfAnyNot

lastIndexOfAnyNot

countOf

countOfNot

countOf

countOfNot