BasedSequenceImpl (flexmark-java utilities 0.18.9 API)

java.lang.Object
- com.vladsch.flexmark.util.sequence.BasedSequenceImpl

All Implemented Interfaces:

BasedSequence, CharSequence, Comparable<CharSequence>

Direct Known Subclasses:

BasedSequence.EmptyBasedSequence, CharSubSequence, MappedSequence, PrefixedSubSequence, SegmentedSequence, SubSequence
```
public abstract class BasedSequenceImpl
extends Object
implements BasedSequence
```
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/interfaces inherited from interface com.vladsch.flexmark.util.sequence.BasedSequence
  BasedSequence.EmptyBasedSequence

Field Summary
- Fields inherited from interface com.vladsch.flexmark.util.sequence.BasedSequence
  EMPTY_ARRAY, EMPTY_LIST, EOL, EOL_CHAR, EOL_CHAR1, EOL_CHAR2, EOL_CHARS, NULL, 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

BasedSequenceImpl()

Constructors
Constructor and Description
`BasedSequenceImpl()`

Method Summary

All Methods Static Methods Instance Methods Concrete 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)`
`static int`	`columnsToNextTabStop(int column)`
`int`	`compareTo(CharSequence other)`
`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 fromIndex)`
`int`	`countChars(char c, int fromIndex, int endIndex)`
`int`	`countChars(CharSequence chars)`
`int`	`countChars(CharSequence chars, int fromIndex)`
`int`	`countChars(CharSequence chars, int fromIndex, int endIndex)`
`int`	`countCharsReversed(char c)`
`int`	`countCharsReversed(char c, int fromIndex)`
`int`	`countCharsReversed(char c, int startIndex, int fromIndex)`
`int`	`countCharsReversed(CharSequence chars)`
`int`	`countCharsReversed(CharSequence chars, int fromIndex)`
`int`	`countCharsReversed(CharSequence chars, int startIndex, int fromIndex)`
`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(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`	`countNotChars(char c)`
`int`	`countNotChars(char c, int fromIndex)`
`int`	`countNotChars(char c, int fromIndex, int endIndex)`
`int`	`countNotChars(CharSequence chars)`
`int`	`countNotChars(CharSequence chars, int fromIndex)`
`int`	`countNotChars(CharSequence chars, int fromIndex, int endIndex)`
`int`	`countNotCharsReversed(char c)`
`int`	`countNotCharsReversed(char c, int fromIndex)`
`int`	`countNotCharsReversed(char c, int startIndex, int fromIndex)`
`int`	`countNotCharsReversed(CharSequence chars)`
`int`	`countNotCharsReversed(CharSequence chars, int fromIndex)`
`int`	`countNotCharsReversed(CharSequence chars, int startIndex, int fromIndex)`
`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(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)`
`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`	`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()`
`static BasedSequence`	`firstNonNull(BasedSequence... sequences)`
`Range`	`getIndexRange(int startOffset, int endOffset)` Get the range of indices that map into `BasedSequence.getBaseSequence()` with startOffset and endOffset
`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)`
`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)`
`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.
`static BasedSequence`	`of(CharSequence charSequence)`
`static BasedSequence`	`of(CharSequence charSequence, int start)`
`static BasedSequence`	`of(CharSequence charSequence, int start, int end)`
`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)`
`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(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)`
`String`	`toString()`
`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
`static int[]`	`truncateTo(int[] indices, int length)`
`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 class java.lang.Object
clone, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

Methods inherited from interface com.vladsch.flexmark.util.sequence.BasedSequence
baseSubSequence, getBase, getBaseSequence, getEndOffset, getIndexOffset, getSourceRange, getStartOffset, subSequence

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

- Constructor Detail
  - BasedSequenceImpl
```
public BasedSequenceImpl()
```
- Method Detail
  - firstNonNull
```
public static BasedSequence firstNonNull(BasedSequence... sequences)
```
  - getIndexRange
```
public Range getIndexRange(int startOffset,
                           int endOffset)
```
    Description copied from interface: BasedSequence
    
    Get the range of indices that map into BasedSequence.getBaseSequence() with startOffset and endOffset
    
    Specified by:
    
    getIndexRange in interface BasedSequence
    
    Parameters:
    
    startOffset - start offset into base sequence
    
    endOffset - end offset into base sequence
    
    Returns:
    
    range into this sequence that spans start and end offset.
  - endSequence
```
public BasedSequence endSequence(int start,
                                 int end)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    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 BasedSequence endSequence(int start)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    Parameters:
    
    start - offset from end of sequence [ 0..length() )
    
    Returns:
    
    selected portion spanning length() - start to length() of this sequence
  - endCharAt
```
public char endCharAt(int index)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    Parameters:
    
    index - offset from end of sequence
    
    Returns:
    
    character located at length() - index in this sequence
  - midSequence
```
public BasedSequence midSequence(int start,
                                 int end)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    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 BasedSequence midSequence(int start)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    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 char midCharAt(int index)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    Parameters:
    
    index - of character to get
    
    Returns:
    
    character at index or \0 if index is outside valid range for this sequence
  - lastChar
```
public char lastChar()
```
    Specified by:
    
    lastChar in interface BasedSequence
    
    Returns:
    
    the last character of the sequence or '\0' if empty
  - firstChar
```
public char firstChar()
```
    Specified by:
    
    firstChar in interface BasedSequence
    
    Returns:
    
    the first character of the sequence or '\0' if empty
  - indexOf
```
public int indexOf(CharSequence s)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    Parameters:
    
    s - character sequence whose occurrence to find
    
    Returns:
    
    index where found or -1
  - indexOf
```
public int indexOf(CharSequence s,
                   int fromIndex)
```
    Specified by:
    
    indexOf in interface BasedSequence
  - indexOf
```
public int indexOf(CharSequence s,
                   int fromIndex,
                   int endIndex)
```
    Specified by:
    
    indexOf in interface BasedSequence
  - indexOf
```
public int indexOf(char c)
```
    Specified by:
    
    indexOf in interface BasedSequence
  - indexOfAny
```
public int indexOfAny(char c1,
                      char c2)
```
    Specified by:
    
    indexOfAny in interface BasedSequence
  - indexOfAny
```
public int indexOfAny(char c1,
                      char c2,
                      char c3)
```
    Specified by:
    
    indexOfAny in interface BasedSequence
  - indexOfAny
```
public int indexOfAny(CharSequence s)
```
    Specified by:
    
    indexOfAny in interface BasedSequence
  - indexOf
```
public int indexOf(char c,
                   int fromIndex)
```
    Specified by:
    
    indexOf in interface BasedSequence
  - indexOfAny
```
public int indexOfAny(char c1,
                      char c2,
                      int fromIndex)
```
    Specified by:
    
    indexOfAny in interface BasedSequence
  - indexOfAny
```
public int indexOfAny(char c1,
                      char c2,
                      char c3,
                      int fromIndex)
```
    Specified by:
    
    indexOfAny in interface BasedSequence
  - indexOfAny
```
public int indexOfAny(CharSequence s,
                      int index)
```
    Specified by:
    
    indexOfAny in interface BasedSequence
  - indexOf
```
public int indexOf(char c,
                   int fromIndex,
                   int endIndex)
```
    Specified by:
    
    indexOf in interface BasedSequence
  - indexOfAny
```
public int indexOfAny(char c1,
                      char c2,
                      int fromIndex,
                      int endIndex)
```
    Specified by:
    
    indexOfAny in interface BasedSequence
  - indexOfAny
```
public int indexOfAny(char c1,
                      char c2,
                      char c3,
                      int fromIndex,
                      int endIndex)
```
    Specified by:
    
    indexOfAny in interface BasedSequence
  - indexOfAny
```
public int indexOfAny(CharSequence s,
                      int fromIndex,
                      int endIndex)
```
    Specified by:
    
    indexOfAny in interface BasedSequence
  - indexOfNot
```
public int indexOfNot(char c)
```
    Specified by:
    
    indexOfNot in interface BasedSequence
  - indexOfAnyNot
```
public int indexOfAnyNot(char c1,
                         char c2)
```
    Specified by:
    
    indexOfAnyNot in interface BasedSequence
  - indexOfAnyNot
```
public int indexOfAnyNot(char c1,
                         char c2,
                         char c3)
```
    Specified by:
    
    indexOfAnyNot in interface BasedSequence
  - indexOfAnyNot
```
public int indexOfAnyNot(CharSequence s)
```
    Specified by:
    
    indexOfAnyNot in interface BasedSequence
  - indexOfNot
```
public int indexOfNot(char c,
                      int fromIndex)
```
    Specified by:
    
    indexOfNot in interface BasedSequence
  - indexOfAnyNot
```
public int indexOfAnyNot(char c1,
                         char c2,
                         int fromIndex)
```
    Specified by:
    
    indexOfAnyNot in interface BasedSequence
  - indexOfAnyNot
```
public int indexOfAnyNot(char c1,
                         char c2,
                         char c3,
                         int fromIndex)
```
    Specified by:
    
    indexOfAnyNot in interface BasedSequence
  - indexOfAnyNot
```
public int indexOfAnyNot(CharSequence s,
                         int fromIndex)
```
    Specified by:
    
    indexOfAnyNot in interface BasedSequence
  - indexOfNot
```
public int indexOfNot(char c,
                      int fromIndex,
                      int endIndex)
```
    Specified by:
    
    indexOfNot in interface BasedSequence
  - indexOfAnyNot
```
public int indexOfAnyNot(char c1,
                         char c2,
                         int fromIndex,
                         int endIndex)
```
    Specified by:
    
    indexOfAnyNot in interface BasedSequence
  - indexOfAnyNot
```
public int indexOfAnyNot(char c1,
                         char c2,
                         char c3,
                         int fromIndex,
                         int endIndex)
```
    Specified by:
    
    indexOfAnyNot in interface BasedSequence
  - indexOfAnyNot
```
public int indexOfAnyNot(CharSequence s,
                         int fromIndex,
                         int endIndex)
```
    Specified by:
    
    indexOfAnyNot in interface BasedSequence
  - lastIndexOf
```
public int lastIndexOf(CharSequence s)
```
    Specified by:
    
    lastIndexOf in interface BasedSequence
  - lastIndexOf
```
public int lastIndexOf(CharSequence s,
                       int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface BasedSequence
  - lastIndexOf
```
public int lastIndexOf(CharSequence s,
                       int startIndex,
                       int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface BasedSequence
  - lastIndexOf
```
public int lastIndexOf(char c)
```
    Specified by:
    
    lastIndexOf in interface BasedSequence
  - lastIndexOfAny
```
public int lastIndexOfAny(char c1,
                          char c2)
```
    Specified by:
    
    lastIndexOfAny in interface BasedSequence
  - lastIndexOfAny
```
public int lastIndexOfAny(char c1,
                          char c2,
                          char c3)
```
    Specified by:
    
    lastIndexOfAny in interface BasedSequence
  - lastIndexOfAny
```
public int lastIndexOfAny(CharSequence s)
```
    Specified by:
    
    lastIndexOfAny in interface BasedSequence
  - lastIndexOf
```
public int lastIndexOf(char c,
                       int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface BasedSequence
  - lastIndexOfAny
```
public int lastIndexOfAny(char c1,
                          char c2,
                          int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface BasedSequence
  - lastIndexOfAny
```
public int lastIndexOfAny(char c1,
                          char c2,
                          char c3,
                          int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface BasedSequence
  - lastIndexOfAny
```
public int lastIndexOfAny(CharSequence s,
                          int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface BasedSequence
  - lastIndexOf
```
public int lastIndexOf(char c,
                       int startIndex,
                       int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface BasedSequence
  - lastIndexOfAny
```
public int lastIndexOfAny(char c1,
                          char c2,
                          int startIndex,
                          int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface BasedSequence
  - lastIndexOfAny
```
public int lastIndexOfAny(char c1,
                          char c2,
                          char c3,
                          int startIndex,
                          int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface BasedSequence
  - lastIndexOfAny
```
public int lastIndexOfAny(CharSequence s,
                          int startIndex,
                          int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface BasedSequence
  - lastIndexOfNot
```
public int lastIndexOfNot(char c)
```
    Specified by:
    
    lastIndexOfNot in interface BasedSequence
  - lastIndexOfAnyNot
```
public int lastIndexOfAnyNot(char c1,
                             char c2)
```
    Specified by:
    
    lastIndexOfAnyNot in interface BasedSequence
  - lastIndexOfAnyNot
```
public int lastIndexOfAnyNot(char c1,
                             char c2,
                             char c3)
```
    Specified by:
    
    lastIndexOfAnyNot in interface BasedSequence
  - lastIndexOfAnyNot
```
public int lastIndexOfAnyNot(CharSequence s)
```
    Specified by:
    
    lastIndexOfAnyNot in interface BasedSequence
  - lastIndexOfNot
```
public int lastIndexOfNot(char c,
                          int fromIndex)
```
    Specified by:
    
    lastIndexOfNot in interface BasedSequence
  - lastIndexOfAnyNot
```
public int lastIndexOfAnyNot(char c1,
                             char c2,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface BasedSequence
  - lastIndexOfAnyNot
```
public int lastIndexOfAnyNot(char c1,
                             char c2,
                             char c3,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface BasedSequence
  - lastIndexOfAnyNot
```
public int lastIndexOfAnyNot(CharSequence s,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface BasedSequence
  - lastIndexOfNot
```
public int lastIndexOfNot(char c,
                          int startIndex,
                          int fromIndex)
```
    Specified by:
    
    lastIndexOfNot in interface BasedSequence
  - lastIndexOfAnyNot
```
public int lastIndexOfAnyNot(char c1,
                             char c2,
                             int startIndex,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface BasedSequence
  - lastIndexOfAnyNot
```
public int lastIndexOfAnyNot(char c1,
                             char c2,
                             char c3,
                             int startIndex,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface BasedSequence
  - lastIndexOfAnyNot
```
public int lastIndexOfAnyNot(CharSequence s,
                             int startIndex,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface BasedSequence
  - startOfDelimitedBy
```
public int startOfDelimitedBy(CharSequence s,
                              int index)
```
    Specified by:
    
    startOfDelimitedBy in interface BasedSequence
  - startOfDelimitedByAny
```
public int startOfDelimitedByAny(CharSequence s,
                                 int index)
```
    Specified by:
    
    startOfDelimitedByAny in interface BasedSequence
  - startOfDelimitedByAnyNot
```
public int startOfDelimitedByAnyNot(CharSequence s,
                                    int index)
```
    Specified by:
    
    startOfDelimitedByAnyNot in interface BasedSequence
  - endOfDelimitedBy
```
public int endOfDelimitedBy(CharSequence s,
                            int index)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    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 int endOfDelimitedByAny(CharSequence s,
                               int index)
```
    Specified by:
    
    endOfDelimitedByAny in interface BasedSequence
  - endOfDelimitedByAnyNot
```
public int endOfDelimitedByAnyNot(CharSequence s,
                                  int index)
```
    Specified by:
    
    endOfDelimitedByAnyNot in interface BasedSequence
  - endOfLine
```
public int endOfLine(int index)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    Parameters:
    
    index - index where to start searching for end of line
    
    Returns:
    
    index of end of line delimited by \n
  - endOfLineAnyEOL
```
public int endOfLineAnyEOL(int index)
```
    Specified by:
    
    endOfLineAnyEOL in interface BasedSequence
  - startOfLine
```
public int startOfLine(int index)
```
    Specified by:
    
    startOfLine in interface BasedSequence
  - startOfLineAnyEOL
```
public int startOfLineAnyEOL(int index)
```
    Specified by:
    
    startOfLineAnyEOL in interface BasedSequence
  - lineAt
```
public BasedSequence lineAt(int index)
```
    Description copied from interface: BasedSequence
    
    Get the line characters at given index, line delimited by \n
    
    Specified by:
    
    lineAt in interface BasedSequence
    
    Parameters:
    
    index - index at which to get the line
    
    Returns:
    
    sub-sequence for the line containing index
  - lineAtAnyEOL
```
public BasedSequence lineAtAnyEOL(int index)
```
    Description copied from interface: BasedSequence
    
    Get the line characters at given index, line delimited by \n, \r or \r\n
    
    Specified by:
    
    lineAtAnyEOL in interface BasedSequence
    
    Parameters:
    
    index - index at which to get the line
    
    Returns:
    
    sub-sequence for the line containing index
  - countLeading
```
public int countLeading(char c)
```
    Specified by:
    
    countLeading in interface BasedSequence
  - countLeadingNot
```
public int countLeadingNot(char c)
```
    Specified by:
    
    countLeadingNot in interface BasedSequence
  - countLeading
```
public int countLeading(char c,
                        int fromIndex)
```
    Specified by:
    
    countLeading in interface BasedSequence
  - countLeadingNot
```
public int countLeadingNot(char c,
                           int fromIndex)
```
    Specified by:
    
    countLeadingNot in interface BasedSequence
  - countLeading
```
public int countLeading(char c,
                        int fromIndex,
                        int endIndex)
```
    Specified by:
    
    countLeading in interface BasedSequence
  - countLeadingNot
```
public int countLeadingNot(char c,
                           int fromIndex,
                           int endIndex)
```
    Specified by:
    
    countLeadingNot in interface BasedSequence
  - countTrailing
```
public int countTrailing(char c)
```
    Specified by:
    
    countTrailing in interface BasedSequence
  - countTrailingNot
```
public int countTrailingNot(char c)
```
    Specified by:
    
    countTrailingNot in interface BasedSequence
  - countTrailing
```
public int countTrailing(char c,
                         int fromIndex)
```
    Specified by:
    
    countTrailing in interface BasedSequence
  - countTrailingNot
```
public int countTrailingNot(char c,
                            int fromIndex)
```
    Specified by:
    
    countTrailingNot in interface BasedSequence
  - countTrailing
```
public int countTrailing(char c,
                         int startIndex,
                         int fromIndex)
```
    Specified by:
    
    countTrailing in interface BasedSequence
  - countTrailingNot
```
public int countTrailingNot(char c,
                            int startIndex,
                            int fromIndex)
```
    Specified by:
    
    countTrailingNot in interface BasedSequence
  - countChars
```
public int countChars(char c)
```
    Specified by:
    
    countChars in interface BasedSequence
  - countNotChars
```
public int countNotChars(char c)
```
    Specified by:
    
    countNotChars in interface BasedSequence
  - countChars
```
public int countChars(char c,
                      int fromIndex)
```
    Specified by:
    
    countChars in interface BasedSequence
  - countNotChars
```
public int countNotChars(char c,
                         int fromIndex)
```
    Specified by:
    
    countNotChars in interface BasedSequence
  - countCharsReversed
```
public int countCharsReversed(char c)
```
    Specified by:
    
    countCharsReversed in interface BasedSequence
  - countNotCharsReversed
```
public int countNotCharsReversed(char c)
```
    Specified by:
    
    countNotCharsReversed in interface BasedSequence
  - countCharsReversed
```
public int countCharsReversed(char c,
                              int fromIndex)
```
    Specified by:
    
    countCharsReversed in interface BasedSequence
  - countNotCharsReversed
```
public int countNotCharsReversed(char c,
                                 int fromIndex)
```
    Specified by:
    
    countNotCharsReversed in interface BasedSequence
  - countChars
```
public int countChars(char c,
                      int fromIndex,
                      int endIndex)
```
    Specified by:
    
    countChars in interface BasedSequence
  - countCharsReversed
```
public int countCharsReversed(char c,
                              int startIndex,
                              int fromIndex)
```
    Specified by:
    
    countCharsReversed in interface BasedSequence
  - countNotChars
```
public int countNotChars(char c,
                         int fromIndex,
                         int endIndex)
```
    Specified by:
    
    countNotChars in interface BasedSequence
  - countNotCharsReversed
```
public int countNotCharsReversed(char c,
                                 int startIndex,
                                 int fromIndex)
```
    Specified by:
    
    countNotCharsReversed in interface BasedSequence
  - countLeading
```
public int countLeading(CharSequence chars)
```
    Description copied from interface: BasedSequence
    
    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
    
    Specified by:
    
    countLeading in interface BasedSequence
    
    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 int countLeadingNot(CharSequence chars)
```
    Specified by:
    
    countLeadingNot in interface BasedSequence
  - countLeading
```
public int countLeading(CharSequence chars,
                        int fromIndex)
```
    Specified by:
    
    countLeading in interface BasedSequence
  - countLeadingNot
```
public int countLeadingNot(CharSequence chars,
                           int fromIndex)
```
    Specified by:
    
    countLeadingNot in interface BasedSequence
  - countLeading
```
public int countLeading(CharSequence chars,
                        int fromIndex,
                        int endIndex)
```
    Specified by:
    
    countLeading in interface BasedSequence
  - countLeadingNot
```
public int countLeadingNot(CharSequence chars,
                           int fromIndex,
                           int endIndex)
```
    Specified by:
    
    countLeadingNot in interface BasedSequence
  - countTrailing
```
public int countTrailing(CharSequence chars)
```
    Specified by:
    
    countTrailing in interface BasedSequence
  - countTrailingNot
```
public int countTrailingNot(CharSequence chars)
```
    Specified by:
    
    countTrailingNot in interface BasedSequence
  - countTrailing
```
public int countTrailing(CharSequence chars,
                         int fromIndex)
```
    Specified by:
    
    countTrailing in interface BasedSequence
  - countTrailingNot
```
public int countTrailingNot(CharSequence chars,
                            int fromIndex)
```
    Specified by:
    
    countTrailingNot in interface BasedSequence
  - countTrailing
```
public int countTrailing(CharSequence chars,
                         int startIndex,
                         int fromIndex)
```
    Specified by:
    
    countTrailing in interface BasedSequence
  - countTrailingNot
```
public int countTrailingNot(CharSequence chars,
                            int startIndex,
                            int fromIndex)
```
    Specified by:
    
    countTrailingNot in interface BasedSequence
  - countChars
```
public int countChars(CharSequence chars)
```
    Specified by:
    
    countChars in interface BasedSequence
  - countNotChars
```
public int countNotChars(CharSequence chars)
```
    Specified by:
    
    countNotChars in interface BasedSequence
  - countChars
```
public int countChars(CharSequence chars,
                      int fromIndex)
```
    Specified by:
    
    countChars in interface BasedSequence
  - countNotChars
```
public int countNotChars(CharSequence chars,
                         int fromIndex)
```
    Specified by:
    
    countNotChars in interface BasedSequence
  - countCharsReversed
```
public int countCharsReversed(CharSequence chars)
```
    Specified by:
    
    countCharsReversed in interface BasedSequence
  - countNotCharsReversed
```
public int countNotCharsReversed(CharSequence chars)
```
    Specified by:
    
    countNotCharsReversed in interface BasedSequence
  - countCharsReversed
```
public int countCharsReversed(CharSequence chars,
                              int fromIndex)
```
    Specified by:
    
    countCharsReversed in interface BasedSequence
  - countNotCharsReversed
```
public int countNotCharsReversed(CharSequence chars,
                                 int fromIndex)
```
    Specified by:
    
    countNotCharsReversed in interface BasedSequence
  - countChars
```
public int countChars(CharSequence chars,
                      int fromIndex,
                      int endIndex)
```
    Specified by:
    
    countChars in interface BasedSequence
  - columnsToNextTabStop
```
public static int columnsToNextTabStop(int column)
```
  - countLeadingColumns
```
public int countLeadingColumns(int startColumn,
                               CharSequence chars)
```
    Specified by:
    
    countLeadingColumns in interface BasedSequence
  - countCharsReversed
```
public int countCharsReversed(CharSequence chars,
                              int startIndex,
                              int fromIndex)
```
    Specified by:
    
    countCharsReversed in interface BasedSequence
  - countNotChars
```
public int countNotChars(CharSequence chars,
                         int fromIndex,
                         int endIndex)
```
    Specified by:
    
    countNotChars in interface BasedSequence
  - countNotCharsReversed
```
public int countNotCharsReversed(CharSequence chars,
                                 int startIndex,
                                 int fromIndex)
```
    Specified by:
    
    countNotCharsReversed in interface BasedSequence
  - trimStart
```
public BasedSequence trimStart(CharSequence chars)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence.WHITESPACE_CHARS are assumed.
    
    Specified by:
    
    trimStart in interface BasedSequence
    
    Parameters:
    
    chars - set of characters to trim from start of line
    
    Returns:
    
    sequence after it is trimmed
  - trimmedStart
```
public BasedSequence trimmedStart(CharSequence chars)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    Parameters:
    
    chars - set of characters to trim from start of line
    
    Returns:
    
    part of the sequence that was trimmed from the start
  - trimEnd
```
public BasedSequence trimEnd(CharSequence chars)
```
    Specified by:
    
    trimEnd in interface BasedSequence
  - trimmedEnd
```
public BasedSequence trimmedEnd(CharSequence chars)
```
    Specified by:
    
    trimmedEnd in interface BasedSequence
  - trim
```
public BasedSequence trim(CharSequence chars)
```
    Specified by:
    
    trim in interface BasedSequence
  - trimStart
```
public BasedSequence trimStart()
```
    Specified by:
    
    trimStart in interface BasedSequence
  - trimmedStart
```
public BasedSequence trimmedStart()
```
    Specified by:
    
    trimmedStart in interface BasedSequence
  - trimEnd
```
public BasedSequence trimEnd()
```
    Specified by:
    
    trimEnd in interface BasedSequence
  - trimmedEnd
```
public BasedSequence trimmedEnd()
```
    Specified by:
    
    trimmedEnd in interface BasedSequence
  - eolLength
```
public int eolLength()
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    Returns:
    
    0, 1, or 2 depending on the EOL suffix of this sequence
  - eolLength
```
public int eolLength(int eolStart)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    Returns:
    
    0, 1, or 2 depending on the EOL suffix of this sequence
  - trimEOL
```
public BasedSequence trimEOL()
```
    Specified by:
    
    trimEOL in interface BasedSequence
  - trimmedEOL
```
public BasedSequence trimmedEOL()
```
    Specified by:
    
    trimmedEOL in interface BasedSequence
  - trim
```
public BasedSequence trim()
```
    Specified by:
    
    trim in interface BasedSequence
  - ifNull
```
public BasedSequence ifNull(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    If this sequence is the BasedSequence.NULL instance then returns other, otherwise returns this sequence.
    
    Specified by:
    
    ifNull in interface BasedSequence
    
    Parameters:
    
    other - based sequence to return if this is BasedSequence.NULL
    
    Returns:
    
    this or other
  - ifNullEmptyAfter
```
public BasedSequence ifNullEmptyAfter(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    Parameters:
    
    other - based sequence from which to take the empty sequence
    
    Returns:
    
    this or other.subSequence(other.length(), other.length())
  - ifNullEmptyBefore
```
public BasedSequence ifNullEmptyBefore(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    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 BasedSequence
    
    Parameters:
    
    other - based sequence from which to take the empty sequence
    
    Returns:
    
    this or other.subSequence(0, 0)
  - nullIfEmpty
```
public BasedSequence nullIfEmpty()
```
    Description copied from interface: BasedSequence
    
    If this sequence is empty return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfEmpty in interface BasedSequence
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfBlank
```
public BasedSequence nullIfBlank()
```
    Description copied from interface: BasedSequence
    
    If this sequence is blank return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfBlank in interface BasedSequence
    
    Returns:
    
    this or SubSequence.NULL
  - nullIf
```
public BasedSequence nullIf(boolean condition)
```
    Description copied from interface: BasedSequence
    
    If condition is true return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIf in interface BasedSequence
    
    Parameters:
    
    condition - when true return NULL else this
    
    Returns:
    
    this or SubSequence.NULL
  - nullIf
```
public BasedSequence nullIf(CharSequence... matches)
```
    Description copied from interface: BasedSequence
    
    If this sequence matches one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIf in interface BasedSequence
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfNot
```
public BasedSequence nullIfNot(CharSequence... matches)
```
    Description copied from interface: BasedSequence
    
    If this sequence does not match one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfNot in interface BasedSequence
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfStartsWith
```
public BasedSequence nullIfStartsWith(CharSequence... matches)
```
    Description copied from interface: BasedSequence
    
    If this sequence starts with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfStartsWith in interface BasedSequence
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfStartsWithNot
```
public BasedSequence nullIfStartsWithNot(CharSequence... matches)
```
    Description copied from interface: BasedSequence
    
    If this sequence does not start with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfStartsWithNot in interface BasedSequence
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfEndsWith
```
public BasedSequence nullIfEndsWith(CharSequence... matches)
```
    Description copied from interface: BasedSequence
    
    If this sequence ends with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfEndsWith in interface BasedSequence
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - nullIfEndsWithNot
```
public BasedSequence nullIfEndsWithNot(CharSequence... matches)
```
    Description copied from interface: BasedSequence
    
    If this sequence does not end with one of given sequences return BasedSequence.NULL otherwise returns this sequence.
    
    Specified by:
    
    nullIfEndsWithNot in interface BasedSequence
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or SubSequence.NULL
  - isEmpty
```
public boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface BasedSequence
  - isBlank
```
public boolean isBlank()
```
    Specified by:
    
    isBlank in interface BasedSequence
  - isNull
```
public boolean isNull()
```
    Specified by:
    
    isNull in interface BasedSequence
  - isNotNull
```
public boolean isNotNull()
```
    Specified by:
    
    isNotNull in interface BasedSequence
  - endsWith
```
public boolean endsWith(CharSequence suffix)
```
    Description copied from interface: BasedSequence
    
    test if this sequence ends with given characters
    
    Specified by:
    
    endsWith in interface BasedSequence
    
    Parameters:
    
    suffix - characters to test
    
    Returns:
    
    true if ends with suffix
  - startsWith
```
public boolean startsWith(CharSequence prefix)
```
    Description copied from interface: BasedSequence
    
    test if this sequence starts with given characters
    
    Specified by:
    
    startsWith in interface BasedSequence
    
    Parameters:
    
    prefix - characters to test
    
    Returns:
    
    true if starts with prefix
  - removeSuffix
```
public BasedSequence removeSuffix(CharSequence suffix)
```
    Description copied from interface: BasedSequence
    
    Remove suffix if present
    
    Specified by:
    
    removeSuffix in interface BasedSequence
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removePrefix
```
public BasedSequence removePrefix(CharSequence prefix)
```
    Description copied from interface: BasedSequence
    
    Remove prefix if present
    
    Specified by:
    
    removePrefix in interface BasedSequence
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperSuffix
```
public BasedSequence removeProperSuffix(CharSequence suffix)
```
    Description copied from interface: BasedSequence
    
    Remove suffix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperSuffix in interface BasedSequence
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperPrefix
```
public BasedSequence removeProperPrefix(CharSequence prefix)
```
    Description copied from interface: BasedSequence
    
    Remove prefix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperPrefix in interface BasedSequence
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - endsWithIgnoreCase
```
public boolean endsWithIgnoreCase(CharSequence suffix)
```
    Description copied from interface: BasedSequence
    
    test if this sequence ends with given characters, ignoring case differences
    
    Specified by:
    
    endsWithIgnoreCase in interface BasedSequence
    
    Parameters:
    
    suffix - characters to test
    
    Returns:
    
    true if ends with suffix
  - startsWithIgnoreCase
```
public boolean startsWithIgnoreCase(CharSequence prefix)
```
    Description copied from interface: BasedSequence
    
    test if this sequence starts with given characters, ignoring case differences
    
    Specified by:
    
    startsWithIgnoreCase in interface BasedSequence
    
    Parameters:
    
    prefix - characters to test
    
    Returns:
    
    true if starts with prefix
  - removeSuffixIgnoreCase
```
public BasedSequence removeSuffixIgnoreCase(CharSequence suffix)
```
    Description copied from interface: BasedSequence
    
    Remove suffix if present, ignoring case differences
    
    Specified by:
    
    removeSuffixIgnoreCase in interface BasedSequence
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removePrefixIgnoreCase
```
public BasedSequence removePrefixIgnoreCase(CharSequence prefix)
```
    Description copied from interface: BasedSequence
    
    Remove prefix if present, ignoring case differences
    
    Specified by:
    
    removePrefixIgnoreCase in interface BasedSequence
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperSuffixIgnoreCase
```
public BasedSequence removeProperSuffixIgnoreCase(CharSequence suffix)
```
    Description copied from interface: BasedSequence
    
    Remove suffix if present but only if this sequence is longer than the suffix, ignoring case differences
    
    Specified by:
    
    removeProperSuffixIgnoreCase in interface BasedSequence
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperPrefixIgnoreCase
```
public BasedSequence removeProperPrefixIgnoreCase(CharSequence prefix)
```
    Description copied from interface: BasedSequence
    
    Remove prefix if present but only if this sequence is longer than the suffix, ignoring case differences
    
    Specified by:
    
    removeProperPrefixIgnoreCase in interface BasedSequence
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - endsWith
```
public boolean endsWith(CharSequence suffix,
                        boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    test if this sequence ends with given characters
    
    Specified by:
    
    endsWith in interface BasedSequence
    
    Parameters:
    
    suffix - characters to test
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if ends with suffix
  - startsWith
```
public boolean startsWith(CharSequence prefix,
                          boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    test if this sequence starts with given characters
    
    Specified by:
    
    startsWith in interface BasedSequence
    
    Parameters:
    
    prefix - characters to test
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if starts with prefix
  - removeSuffix
```
public BasedSequence removeSuffix(CharSequence suffix,
                                  boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    Remove suffix if present
    
    Specified by:
    
    removeSuffix in interface BasedSequence
    
    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 BasedSequence removePrefix(CharSequence prefix,
                                  boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    Remove prefix if present
    
    Specified by:
    
    removePrefix in interface BasedSequence
    
    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 BasedSequence removeProperSuffix(CharSequence suffix,
                                        boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    Remove suffix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperSuffix in interface BasedSequence
    
    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 BasedSequence removeProperPrefix(CharSequence prefix,
                                        boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    Remove prefix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperPrefix in interface BasedSequence
    
    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 MappedSequence toLowerCase()
```
    Description copied from interface: BasedSequence
    
    Map characters of this sequence to: Uppercase, Lowercase or use custom mapping
    
    Specified by:
    
    toLowerCase in interface BasedSequence
    
    Returns:
    
    lowercase version of sequence
  - toUpperCase
```
public MappedSequence toUpperCase()
```
    Specified by:
    
    toUpperCase in interface BasedSequence
  - toLowerCase
```
public MappedSequence toLowerCase(Locale locale)
```
    Specified by:
    
    toLowerCase in interface BasedSequence
  - toUpperCase
```
public MappedSequence toUpperCase(Locale locale)
```
    Specified by:
    
    toUpperCase in interface BasedSequence
  - toMapped
```
public final MappedSequence toMapped(CharMapper mapper)
```
    Specified by:
    
    toMapped in interface BasedSequence
  - matches
```
public boolean matches(CharSequence chars)
```
    Description copied from interface: BasedSequence
    
    Test the sequence for a match to another CharSequence
    
    Specified by:
    
    matches in interface BasedSequence
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if match
  - matchesIgnoreCase
```
public boolean matchesIgnoreCase(CharSequence chars)
```
    Description copied from interface: BasedSequence
    
    Test the sequence for a match to another CharSequence, ignoring case differences
    
    Specified by:
    
    matchesIgnoreCase in interface BasedSequence
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if match
  - matches
```
public boolean matches(CharSequence chars,
                       boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    Test the sequence for a match to another CharSequence
    
    Specified by:
    
    matches in interface BasedSequence
    
    Parameters:
    
    chars - characters to match against
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if match
  - matchChars
```
public boolean matchChars(CharSequence chars)
```
    Description copied from interface: BasedSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchChars in interface BasedSequence
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if characters at the start of this sequence match
  - matchCharsIgnoreCase
```
public boolean matchCharsIgnoreCase(CharSequence chars)
```
    Description copied from interface: BasedSequence
    
    Test the sequence portion for a match to another CharSequence, ignoring case differences
    
    Specified by:
    
    matchCharsIgnoreCase in interface BasedSequence
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if characters at the start of this sequence match
  - matchChars
```
public boolean matchChars(CharSequence chars,
                          boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchChars in interface BasedSequence
    
    Parameters:
    
    chars - characters to match against
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if characters at the start of this sequence match
  - matchChars
```
public boolean matchChars(CharSequence chars,
                          int startIndex)
```
    Description copied from interface: BasedSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchChars in interface BasedSequence
    
    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 boolean matchCharsIgnoreCase(CharSequence chars,
                                    int startIndex)
```
    Description copied from interface: BasedSequence
    
    Test the sequence portion for a match to another CharSequence, ignoring case differences
    
    Specified by:
    
    matchCharsIgnoreCase in interface BasedSequence
    
    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 boolean matchChars(CharSequence chars,
                          int startIndex,
                          boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchChars in interface BasedSequence
    
    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 boolean matchCharsReversed(CharSequence chars,
                                  int endIndex)
```
    Description copied from interface: BasedSequence
    
    Test the sequence portion for a match to another CharSequence, reverse order
    
    Specified by:
    
    matchCharsReversed in interface BasedSequence
    
    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 boolean matchCharsReversedIgnoreCase(CharSequence chars,
                                            int endIndex)
```
    Description copied from interface: BasedSequence
    
    Test the sequence portion for a match to another CharSequence, reverse order, ignoring case differences
    
    Specified by:
    
    matchCharsReversedIgnoreCase in interface BasedSequence
    
    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 boolean matchCharsReversed(CharSequence chars,
                                  int endIndex,
                                  boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    Test the sequence portion for a match to another CharSequence, reverse order
    
    Specified by:
    
    matchCharsReversed in interface BasedSequence
    
    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 BasedSequence subSequence(Range range)
```
    Description copied from interface: BasedSequence
    
    Get a portion of this sequence
    
    Specified by:
    
    subSequence in interface BasedSequence
    
    Parameters:
    
    range - range to get, coordinates offset form start of this sequence
    
    Returns:
    
    based sequence whose contents reflect the selected portion
  - subSequence
```
public BasedSequence subSequence(int start)
```
    Description copied from interface: BasedSequence
    
    Get a portion of this sequence starting from a given offset to end of the sequence
    
    Specified by:
    
    subSequence in interface BasedSequence
    
    Parameters:
    
    start - offset from start of this sequence
    
    Returns:
    
    based sequence whose contents reflect the selected portion
  - trimTailBlankLines
```
public BasedSequence trimTailBlankLines()
```
    Description copied from interface: BasedSequence
    
    Trim leading trailing blank lines in this sequence
    
    Specified by:
    
    trimTailBlankLines in interface BasedSequence
    
    Returns:
    
    return sequence with trailing blank lines trimmed off
  - trimLeadBlankLines
```
public BasedSequence trimLeadBlankLines()
```
    Specified by:
    
    trimLeadBlankLines in interface BasedSequence
  - toString
```
public String toString()
```
    Specified by:
    
    toString in interface CharSequence
    
    Overrides:
    
    toString in class Object
  - unescape
```
public String unescape()
```
    Description copied from interface: BasedSequence
    
    Get the unescaped string of this sequence content
    
    Specified by:
    
    unescape in interface BasedSequence
    
    Returns:
    
    unescaped text
  - unescapeNoEntities
```
public String unescapeNoEntities()
```
    Description copied from interface: BasedSequence
    
    Get the unescaped string of this sequence content without unescaping entities
    
    Specified by:
    
    unescapeNoEntities in interface BasedSequence
    
    Returns:
    
    unescaped text
  - unescape
```
public BasedSequence unescape(ReplacedTextMapper textMapper)
```
    Description copied from interface: BasedSequence
    
    Get the unescaped string of this sequence content
    
    Specified by:
    
    unescape in interface BasedSequence
    
    Parameters:
    
    textMapper - replaced text mapper which will be uses to map unescaped index to original source index
    
    Returns:
    
    unescaped text in based sequence
  - normalizeEOL
```
public String normalizeEOL()
```
    Description copied from interface: BasedSequence
    
    replace any \r\n and \r by \n
    
    Specified by:
    
    normalizeEOL in interface BasedSequence
    
    Returns:
    
    string with only \n for line separators
  - normalizeEOL
```
public BasedSequence normalizeEOL(ReplacedTextMapper textMapper)
```
    Description copied from interface: BasedSequence
    
    replace any \r\n and \r by \n
    
    Specified by:
    
    normalizeEOL in interface BasedSequence
    
    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
```
public String normalizeEndWithEOL()
```
    Description copied from interface: BasedSequence
    
    replace any \r\n and \r by \n, append terminating EOL if one is not present
    
    Specified by:
    
    normalizeEndWithEOL in interface BasedSequence
    
    Returns:
    
    string with only \n for line separators and terminated by \n
  - normalizeEndWithEOL
```
public BasedSequence normalizeEndWithEOL(ReplacedTextMapper textMapper)
```
    Description copied from interface: BasedSequence
    
    replace any \r\n and \r by \n, append terminating EOL if one is not present
    
    Specified by:
    
    normalizeEndWithEOL in interface BasedSequence
    
    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
  - toVisibleWhitespaceString
```
public String toVisibleWhitespaceString()
```
    Specified by:
    
    toVisibleWhitespaceString in interface BasedSequence
  - isContinuedBy
```
public boolean isContinuedBy(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    Test if the given sequence is a continuation of this sequence in original source text
    
    Specified by:
    
    isContinuedBy in interface BasedSequence
    
    Parameters:
    
    other - sequence to test
    
    Returns:
    
    true if the given sequence is a continuation of this one in the original text
  - isContinuationOf
```
public boolean isContinuationOf(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    Test if this sequence is a continuation of the given sequence in original source text
    
    Specified by:
    
    isContinuationOf in interface BasedSequence
    
    Parameters:
    
    other - sequence to test
    
    Returns:
    
    true if this sequence is a continuation of the given sequence in original source text
  - spliceAtEnd
```
public BasedSequence spliceAtEnd(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    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
    
    Specified by:
    
    spliceAtEnd in interface BasedSequence
    
    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
```
public boolean containsAllOf(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    start/end offset based containment, not textual
    
    Specified by:
    
    containsAllOf in interface BasedSequence
    
    Parameters:
    
    other - based sequence from the same base
    
    Returns:
    
    true if other is contained in this
  - containsSomeOf
```
public boolean containsSomeOf(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    start/end offset based containment, not textual
    
    Specified by:
    
    containsSomeOf in interface BasedSequence
    
    Parameters:
    
    other - based sequence from the same base
    
    Returns:
    
    true if other is contained in this
  - intersect
```
public BasedSequence intersect(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    start/end offset based intersection, not textual
    
    Specified by:
    
    intersect in interface BasedSequence
    
    Parameters:
    
    other - based sequence from the same parent
    
    Returns:
    
    sequence which is the intersection of the range of this and other
  - prefixOf
```
public BasedSequence prefixOf(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    Get the prefix part of this from other, start/end offset based containment, not textual
    
    Specified by:
    
    prefixOf in interface BasedSequence
    
    Parameters:
    
    other - based sequence from the same base
    
    Returns:
    
    prefix part of this as compared to other, start/end offset based, not content
  - suffixOf
```
public BasedSequence suffixOf(BasedSequence other)
```
    Description copied from interface: BasedSequence
    
    Get the suffix part of this from other, start/end offset based containment, not textual
    
    Specified by:
    
    suffixOf in interface BasedSequence
    
    Parameters:
    
    other - based sequence from the same base
    
    Returns:
    
    suffix part of this as compared to other, start/end offset based, not content
  - split
```
public BasedSequence[] split(char delimiter)
```
    Specified by:
    
    split in interface BasedSequence
  - split
```
public BasedSequence[] split(char delimiter,
                             int limit)
```
    Specified by:
    
    split in interface BasedSequence
  - split
```
public BasedSequence[] split(char delimiter,
                             int limit,
                             int flags)
```
    Specified by:
    
    split in interface BasedSequence
  - split
```
public BasedSequence[] split(CharSequence delimiter)
```
    Specified by:
    
    split in interface BasedSequence
  - split
```
public BasedSequence[] split(CharSequence delimiter,
                             int limit)
```
    Specified by:
    
    split in interface BasedSequence
  - split
```
public BasedSequence[] split(CharSequence delimiter,
                             int limit,
                             int flags)
```
    Specified by:
    
    split in interface BasedSequence
  - split
```
public BasedSequence[] split(char delimiter,
                             int limit,
                             int flags,
                             String trimChars)
```
    Description copied from interface: BasedSequence
    
    Split helpers based on delimiter character sets contained in CharSequence
    
    Specified by:
    
    split in interface BasedSequence
    
    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 BasedSequence[] split(CharSequence delimiter,
                             int limit,
                             int flags,
                             String trimChars)
```
    Specified by:
    
    split in interface BasedSequence
  - appendTo
```
public BasedSequence appendTo(StringBuilder out)
```
    Specified by:
    
    appendTo in interface BasedSequence
  - appendTo
```
public BasedSequence appendTo(StringBuilder out,
                              int start)
```
    Specified by:
    
    appendTo in interface BasedSequence
  - appendTo
```
public BasedSequence appendTo(StringBuilder out,
                              int start,
                              int end)
```
    Specified by:
    
    appendTo in interface BasedSequence
  - expandTo
```
public static int[] expandTo(int[] indices,
                             int length,
                             int step)
```
  - truncateTo
```
public static int[] truncateTo(int[] indices,
                               int length)
```
  - indexOfAll
```
public int[] indexOfAll(CharSequence s)
```
    Specified by:
    
    indexOfAll in interface BasedSequence
  - replace
```
public BasedSequence replace(CharSequence find,
                             CharSequence replace)
```
    Specified by:
    
    replace in interface BasedSequence
  - append
```
public BasedSequence append(CharSequence... others)
```
    Specified by:
    
    append in interface BasedSequence
  - equals
```
public boolean equals(Object other)
```
    Overrides:
    
    equals in class Object
  - equalsIgnoreCase
```
public boolean equalsIgnoreCase(CharSequence other)
```
    Description copied from interface: BasedSequence
    
    Test the sequence for a match to another CharSequence, ignoring case differences
    
    Specified by:
    
    equalsIgnoreCase in interface BasedSequence
    
    Parameters:
    
    other - characters to match against
    
    Returns:
    
    true if match
  - equals
```
public boolean equals(Object other,
                      boolean ignoreCase)
```
    Description copied from interface: BasedSequence
    
    Test the sequence for a match to another CharSequence
    
    Specified by:
    
    equals in interface BasedSequence
    
    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>
  - of
```
public static BasedSequence of(CharSequence charSequence)
```
  - of
```
public static BasedSequence of(CharSequence charSequence,
                               int start)
```
  - of
```
public static BasedSequence of(CharSequence charSequence,
                               int start,
                               int end)
```

Class BasedSequenceImpl

Nested Class Summary

Nested classes/interfaces inherited from interface com.vladsch.flexmark.util.sequence.BasedSequence

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Methods inherited from interface java.lang.CharSequence

Constructor Detail

BasedSequenceImpl

Method Detail

firstNonNull

getIndexRange

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

startOfDelimitedBy

startOfDelimitedByAny

startOfDelimitedByAnyNot