BasedSequence (flexmark-java utilities 0.40.4 API)

All Superinterfaces:

CharSequence, Comparable<CharSequence>

All Known Implementing Classes:

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

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static class BasedSequence.EmptyBasedSequence

Nested Classes
Modifier and Type	Interface and Description
`static class`	`BasedSequence.EmptyBasedSequence`

Field Summary

Fields
Modifier and Type	Field and Description
`static BasedSequence[]`	`EMPTY_ARRAY`
`static List<BasedSequence>`	`EMPTY_LIST`
`static BasedSequence[]`	`EMPTY_SEGMENTS`
`static BasedSequence`	`EOL`
`static char`	`EOL_CHAR`
`static char`	`EOL_CHAR1`
`static char`	`EOL_CHAR2`
`static String`	`EOL_CHARS`
`static BasedSequence`	`NULL`
`static BasedSequence`	`SPACE`
`static int`	`SPLIT_INCLUDE_DELIM_PARTS`
`static int`	`SPLIT_INCLUDE_DELIMS`
`static int`	`SPLIT_SKIP_EMPTY`
`static int`	`SPLIT_TRIM_PARTS`
`static int`	`SPLIT_TRIM_SKIP_EMPTY`
`static String`	`WHITESPACE_CHARS`
`static String`	`WHITESPACE_NBSP_CHARS`
`static String`	`WHITESPACE_NO_EOL_CHARS`

Method Summary

All Methods Instance Methods Abstract Methods
Modifier and Type	Method and Description
`BasedSequence`	`append(CharSequence... others)`
`BasedSequence`	`appendTo(StringBuilder out)`
`BasedSequence`	`appendTo(StringBuilder out, int start)`
`BasedSequence`	`appendTo(StringBuilder out, int start, int end)`
`BasedSequence`	`baseSubSequence(int start)` Get a portion of the original sequence that this sequence is based on
`BasedSequence`	`baseSubSequence(int start, int end)` Get a portion of the original sequence that this sequence is based on
`boolean`	`containsAllOf(BasedSequence other)` start/end offset based containment, not textual
`boolean`	`containsSomeOf(BasedSequence other)` start/end offset based containment, not textual
`int`	`countChars(char c)`
`int`	`countChars(char c, int startIndex)`
`int`	`countChars(char c, int startIndex, int endIndex)`
`int`	`countChars(CharSequence chars)`
`int`	`countChars(CharSequence chars, int startIndex)`
`int`	`countChars(CharSequence chars, int startIndex, int endIndex)`
`int`	`countCharsReversed(char c)`
`int`	`countCharsReversed(char c, int startIndex)`
`int`	`countCharsReversed(char c, int startIndex, int endIndex)`
`int`	`countCharsReversed(CharSequence chars)`
`int`	`countCharsReversed(CharSequence chars, int startIndex)`
`int`	`countCharsReversed(CharSequence chars, int startIndex, int endIndex)`
`int`	`countLeading(char c)`
`int`	`countLeading(char c, int startIndex)`
`int`	`countLeading(char c, int startIndex, int endIndex)`
`int`	`countLeading(CharSequence chars)` Count leading/trailing characters of this sequence
`int`	`countLeading(CharSequence chars, int startIndex)`
`int`	`countLeading(CharSequence chars, int startIndex, int endIndex)`
`int`	`countLeadingColumns(int startColumn, CharSequence chars)`
`int`	`countLeadingNot(char c)`
`int`	`countLeadingNot(char c, int startIndex)`
`int`	`countLeadingNot(char c, int startIndex, int endIndex)`
`int`	`countLeadingNot(CharSequence chars)`
`int`	`countLeadingNot(CharSequence chars, int startIndex)`
`int`	`countLeadingNot(CharSequence chars, int startIndex, int endIndex)`
`int`	`countNotChars(char c)`
`int`	`countNotChars(char c, int startIndex)`
`int`	`countNotChars(char c, int startIndex, int endIndex)`
`int`	`countNotChars(CharSequence chars)`
`int`	`countNotChars(CharSequence chars, int startIndex)`
`int`	`countNotChars(CharSequence chars, int startIndex, int endIndex)`
`int`	`countNotCharsReversed(char c)`
`int`	`countNotCharsReversed(char c, int startIndex)`
`int`	`countNotCharsReversed(char c, int startIndex, int endIndex)`
`int`	`countNotCharsReversed(CharSequence chars)`
`int`	`countNotCharsReversed(CharSequence chars, int startIndex)`
`int`	`countNotCharsReversed(CharSequence chars, int startIndex, int endIndex)`
`int`	`countTrailing(char c)`
`int`	`countTrailing(char c, int startIndex)`
`int`	`countTrailing(char c, int startIndex, int endIndex)`
`int`	`countTrailing(CharSequence chars)`
`int`	`countTrailing(CharSequence chars, int startIndex)`
`int`	`countTrailing(CharSequence chars, int startIndex, int endIndex)`
`int`	`countTrailingNot(char c)`
`int`	`countTrailingNot(char c, int startIndex)`
`int`	`countTrailingNot(char c, int startIndex, int endIndex)`
`int`	`countTrailingNot(CharSequence chars)`
`int`	`countTrailingNot(CharSequence chars, int startIndex)`
`int`	`countTrailingNot(CharSequence chars, int startIndex, int endIndex)`
`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)`
`BasedSequence`	`endSequence(int start)` Convenience method to get characters offset from end of sequence.
`BasedSequence`	`endSequence(int start, int end)` Convenience method to get characters offset from end of sequence.
`boolean`	`endsWith(CharSequence suffix)` test if this sequence ends with given characters
`boolean`	`endsWith(CharSequence suffix, boolean ignoreCase)` test if this sequence ends with given characters
`boolean`	`endsWithIgnoreCase(CharSequence suffix)` test if this sequence ends with given characters, ignoring case differences
`int`	`eolLength()` Get the length of EOL character at the end of this sequence, if present.
`int`	`eolLength(int eolStart)` Get the length of EOL character at the given index of this sequence, if present.
`boolean`	`equals(Object other, boolean ignoreCase)` Test the sequence for a match to another CharSequence
`boolean`	`equalsIgnoreCase(CharSequence other)` Test the sequence for a match to another CharSequence, ignoring case differences
`char`	`firstChar()`
`Object`	`getBase()` Get the underlying object on which this sequence contents are based
`BasedSequence`	`getBaseSequence()` Get the base sequence for the text
`int`	`getColumnAtIndex(int index)`
`int`	`getEndOffset()` Get the end offset of this sequence into `getBaseSequence()` and `getBase()` original text source.
`int`	`getIndexOffset(int index)` Get the offset of index in this sequence mapped to offset into `getBaseSequence()` and `getBase()` original text source.
`Range`	`getIndexRange(int startOffset, int endOffset)` Get the range of indices that map into `getBaseSequence()` with startOffset and endOffset
`Pair<Integer,Integer>`	`getLineColumnAtIndex(int index)` Get the line and column information from index into sequence
`Range`	`getSourceRange()` Get the range of this sequence in original `getBaseSequence()` and `getBase()` original text source.
`int`	`getStartOffset()` Get the start offset of this sequence into `getBaseSequence()` and `getBase()` original text source.
`BasedSequence`	`ifNull(BasedSequence other)` If this sequence is the BasedSequence.NULL instance then returns other, otherwise returns this sequence.
`BasedSequence`	`ifNullEmptyAfter(BasedSequence other)` If this sequence is the BasedSequence.NULL instance then returns an empty subSequence from the end of other, otherwise returns this sequence.
`BasedSequence`	`ifNullEmptyBefore(BasedSequence other)` If this sequence is the BasedSequence.NULL instance then returns an empty subSequence from the start of other, otherwise returns this sequence.
`int`	`indexOf(char c)`
`int`	`indexOf(char c, int fromIndex)`
`int`	`indexOf(char c, int fromIndex, int endIndex)`
`int`	`indexOf(CharSequence s)` All index methods return the position or -1 if not found of the given character, characters or string.
`int`	`indexOf(CharSequence s, int fromIndex)`
`int`	`indexOf(CharSequence s, int fromIndex, int endIndex)`
`int[]`	`indexOfAll(CharSequence s)` Get indices of all occurrences of a sequence
`int`	`indexOfAny(char c1, char c2)`
`int`	`indexOfAny(char c1, char c2, char c3)`
`int`	`indexOfAny(char c1, char c2, char c3, int fromIndex)`
`int`	`indexOfAny(char c1, char c2, char c3, int fromIndex, int endIndex)`
`int`	`indexOfAny(char c1, char c2, int fromIndex)`
`int`	`indexOfAny(char c1, char c2, int fromIndex, int endIndex)`
`int`	`indexOfAny(CharSequence s)`
`int`	`indexOfAny(CharSequence s, int fromIndex)`
`int`	`indexOfAny(CharSequence s, int fromIndex, int endIndex)`
`int`	`indexOfAnyNot(char c1, char c2)`
`int`	`indexOfAnyNot(char c1, char c2, char c3)`
`int`	`indexOfAnyNot(char c1, char c2, char c3, int fromIndex)`
`int`	`indexOfAnyNot(char c1, char c2, char c3, int fromIndex, int endIndex)`
`int`	`indexOfAnyNot(char c1, char c2, int fromIndex)`
`int`	`indexOfAnyNot(char c1, char c2, int fromIndex, int endIndex)`
`int`	`indexOfAnyNot(CharSequence s)`
`int`	`indexOfAnyNot(CharSequence s, int fromIndex)`
`int`	`indexOfAnyNot(CharSequence s, int fromIndex, int endIndex)`
`int`	`indexOfNot(char c)`
`int`	`indexOfNot(char c, int fromIndex)`
`int`	`indexOfNot(char c, int fromIndex, int endIndex)`
`BasedSequence`	`intersect(BasedSequence other)` start/end offset based intersection, not textual
`boolean`	`isBlank()`
`boolean`	`isContinuationOf(BasedSequence other)` Test if this sequence is a continuation of the given sequence in original source text
`boolean`	`isContinuedBy(BasedSequence other)` Test if the given sequence is a continuation of this sequence in original source text
`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)`
`BasedSequence`	`lineAt(int index)` Get the line characters at given index, line delimited by \n
`BasedSequence`	`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.
`BasedSequence`	`midSequence(int start)` Convenience method to get characters offset from start or end of sequence.
`BasedSequence`	`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
`BasedSequence`	`normalizeEndWithEOL(ReplacedTextMapper textMapper)` 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
`BasedSequence`	`normalizeEOL(ReplacedTextMapper textMapper)` replace any \r\n and \r by \n
`BasedSequence`	`nullIf(boolean condition)` If condition is true return BasedSequence.NULL otherwise returns this sequence.
`BasedSequence`	`nullIf(CharSequence... matches)` If this sequence matches one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`BasedSequence`	`nullIfBlank()` If this sequence is blank return BasedSequence.NULL otherwise returns this sequence.
`BasedSequence`	`nullIfEmpty()` If this sequence is empty return BasedSequence.NULL otherwise returns this sequence.
`BasedSequence`	`nullIfEndsWith(CharSequence... matches)` If this sequence ends with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`BasedSequence`	`nullIfEndsWithNot(CharSequence... matches)` If this sequence does not end with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`BasedSequence`	`nullIfNot(CharSequence... matches)` If this sequence does not match one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`BasedSequence`	`nullIfStartsWith(CharSequence... matches)` If this sequence starts with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`BasedSequence`	`nullIfStartsWithNot(CharSequence... matches)` If this sequence does not start with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
`BasedSequence`	`prefixOf(BasedSequence other)` Get the prefix part of this from other, start/end offset based containment, not textual
`BasedSequence`	`removePrefix(CharSequence prefix)` Remove prefix if present
`BasedSequence`	`removePrefix(CharSequence prefix, boolean ignoreCase)` Remove prefix if present
`BasedSequence`	`removePrefixIgnoreCase(CharSequence prefix)` Remove prefix if present, ignoring case differences
`BasedSequence`	`removeProperPrefix(CharSequence prefix)` Remove prefix if present but only if this sequence is longer than the suffix
`BasedSequence`	`removeProperPrefix(CharSequence prefix, boolean ignoreCase)` Remove prefix if present but only if this sequence is longer than the suffix
`BasedSequence`	`removeProperPrefixIgnoreCase(CharSequence prefix)` Remove prefix if present but only if this sequence is longer than the suffix, ignoring case differences
`BasedSequence`	`removeProperSuffix(CharSequence suffix)` Remove suffix if present but only if this sequence is longer than the suffix
`BasedSequence`	`removeProperSuffix(CharSequence suffix, boolean ignoreCase)` Remove suffix if present but only if this sequence is longer than the suffix
`BasedSequence`	`removeProperSuffixIgnoreCase(CharSequence suffix)` Remove suffix if present but only if this sequence is longer than the suffix, ignoring case differences
`BasedSequence`	`removeSuffix(CharSequence suffix)` Remove suffix if present
`BasedSequence`	`removeSuffix(CharSequence suffix, boolean ignoreCase)` Remove suffix if present
`BasedSequence`	`removeSuffixIgnoreCase(CharSequence suffix)` Remove suffix if present, ignoring case differences
`BasedSequence`	`replace(CharSequence find, CharSequence replace)` Replace all occurrences of one sequence with another
`BasedSequence`	`spliceAtEnd(BasedSequence other)` Splice the given sequence to the end of this one and return a BasedSequence of the result.
`BasedSequence[]`	`split(char delimiter)`
`BasedSequence[]`	`split(char delimiter, int limit)`
`BasedSequence[]`	`split(char delimiter, int limit, int flags)`
`BasedSequence[]`	`split(char delimiter, int limit, int flags, String trimChars)` Split helpers based on delimiter character sets contained in CharSequence
`BasedSequence[]`	`split(CharSequence delimiter)`
`BasedSequence[]`	`split(CharSequence delimiter, int limit)`
`BasedSequence[]`	`split(CharSequence delimiter, int limit, int flags)`
`BasedSequence[]`	`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
`BasedSequence`	`subSequence(int start)` Get a portion of this sequence starting from a given offset to end of the sequence
`BasedSequence`	`subSequence(int start, int end)` Get a portion of this sequence
`BasedSequence`	`subSequence(Range range)` Get a portion of this sequence
`BasedSequence`	`suffixOf(BasedSequence other)` Get the suffix part of this from other, start/end offset based containment, not textual
`MappedSequence`	`toLowerCase()` Map characters of this sequence to: Uppercase, Lowercase or use custom mapping
`MappedSequence`	`toLowerCase(Locale locale)`
`MappedSequence`	`toMapped(CharMapper mapper)`
`MappedSequence`	`toUpperCase()`
`MappedSequence`	`toUpperCase(Locale locale)`
`String`	`toVisibleWhitespaceString()`
`BasedSequence`	`trim()`
`BasedSequence`	`trim(CharSequence chars)`
`BasedSequence`	`trimEnd()`
`BasedSequence`	`trimEnd(CharSequence chars)`
`BasedSequence`	`trimEOL()`
`BasedSequence`	`trimLeadBlankLines()`
`BasedSequence`	`trimmedEnd()`
`BasedSequence`	`trimmedEnd(CharSequence chars)`
`BasedSequence`	`trimmedEOL()`
`BasedSequence`	`trimmedStart()`
`BasedSequence`	`trimmedStart(CharSequence chars)` Get the characters Trimmed, Trimmed from start/end of this sequence, characters to trim are passed in the sequence argument
`BasedSequence`	`trimStart()`
`BasedSequence`	`trimStart(CharSequence chars)` Trim, Trim start/end of this sequence, characters to trim are passed in the sequence argument
`BasedSequence`	`trimTailBlankLines()` Trim leading trailing blank lines in this sequence
`String`	`unescape()` Get the unescaped string of this sequence content
`BasedSequence`	`unescape(ReplacedTextMapper textMapper)` Get the unescaped string of this sequence content
`String`	`unescapeNoEntities()` Get the unescaped string of this sequence content without unescaping entities

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

Methods inherited from interface java.lang.Comparable
compareTo

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

Interface BasedSequence

Nested Class Summary

Field Summary

Method Summary

Methods inherited from interface java.lang.CharSequence

Methods inherited from interface java.lang.Comparable

Field Detail

NULL

EOL

SPACE

EMPTY_LIST

EMPTY_ARRAY

WHITESPACE_NO_EOL_CHARS

WHITESPACE_CHARS

WHITESPACE_NBSP_CHARS

EOL_CHARS

EOL_CHAR

EOL_CHAR1

EOL_CHAR2

EMPTY_SEGMENTS

SPLIT_INCLUDE_DELIMS

SPLIT_TRIM_PARTS

SPLIT_SKIP_EMPTY

SPLIT_INCLUDE_DELIM_PARTS

SPLIT_TRIM_SKIP_EMPTY

Method Detail

lastChar

firstChar

getBase

getBaseSequence

getStartOffset

getEndOffset

getIndexOffset

getIndexRange

getSourceRange

subSequence

subSequence

subSequence

baseSubSequence

baseSubSequence

endSequence

endSequence

endCharAt

midSequence

midSequence

midCharAt

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