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

All Implemented Interfaces:

IRichSequence<T>, SequenceUtils, java.lang.CharSequence, java.lang.Comparable<java.lang.CharSequence>

Direct Known Subclasses:

BasedSequenceImpl, MappedRichSequence, RichSequenceImpl
```
public abstract class IRichSequenceBase<T extends IRichSequence<T>>
extends java.lang.Object
implements IRichSequence<T>
```
An abstract base for RichSequence which implements most of the methods allowing subclasses to implement RichSequence with minimal support methods

Field Summary
- Fields inherited from interface com.vladsch.flexmark.util.sequence.SequenceUtils
  ANY_EOL, ANY_EOL_SET, BACKSLASH_SET, DECIMAL_DIGITS, EMPTY_INDICES, ENC_NUL, EOL, EOL_CHAR, EOL_CHAR1, EOL_CHAR2, EOL_CHARS, EOL_SET, HASH_SET, HEXADECIMAL_DIGITS, LINE_SEP, LS, LSEP, NBSP, NBSP_CHARS, NUL, OCTAL_DIGITS, SPACE, SPACE_EOL, SPACE_EOL_SET, SPACE_SET, SPACE_TAB, SPACE_TAB_EOL_SET, SPACE_TAB_NBSP_SET, SPACE_TAB_SET, SPC, SPLIT_INCLUDE_DELIM_PARTS, SPLIT_INCLUDE_DELIMS, SPLIT_SKIP_EMPTY, SPLIT_TRIM_PARTS, SPLIT_TRIM_SKIP_EMPTY, TAB_SET, US, US_CHARS, US_SET, visibleSpacesMap, WHITESPACE, WHITESPACE_CHARS, WHITESPACE_NBSP, WHITESPACE_NBSP_CHARS, WHITESPACE_NBSP_SET, WHITESPACE_NO_EOL_CHARS, WHITESPACE_SET

Constructor Summary

Constructors
Constructor Description

IRichSequenceBase(int hash)
Constructor with pre-computed hash if available, 0 for lazy computation if length() not 0

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method	Description
`T`	`append(java.lang.CharSequence... sequences)`	Concatenate this sequence and list of others, returning sequence of result
`T`	`append(java.lang.Iterable<? extends java.lang.CharSequence> sequences)`
`T`	`appendEOL()`
`T`	`appendRangesTo(java.lang.StringBuilder out, CharMapper charMapper, Range... ranges)`	Append given ranges of this sequence to string builder
`T`	`appendRangesTo(java.lang.StringBuilder out, CharMapper charMapper, java.lang.Iterable<? extends Range> ranges)`
`T`	`appendRangesTo(java.lang.StringBuilder out, Range... ranges)`
`T`	`appendRangesTo(java.lang.StringBuilder out, java.lang.Iterable<? extends Range> ranges)`
`T`	`appendSpace()`
`T`	`appendSpaces(int count)`
`T`	`appendTo(java.lang.StringBuilder out)`
`T`	`appendTo(java.lang.StringBuilder out, int startIndex)`
`T`	`appendTo(java.lang.StringBuilder out, int startIndex, int endIndex)`
`T`	`appendTo(java.lang.StringBuilder out, CharMapper charMapper)`
`T`	`appendTo(java.lang.StringBuilder out, CharMapper charMapper, int startIndex)`
`T`	`appendTo(java.lang.StringBuilder out, CharMapper charMapper, int startIndex, int endIndex)`	Append helpers
`java.util.List<Range>`	`blankLinesRemovedRanges()`
`java.util.List<Range>`	`blankLinesRemovedRanges(int fromIndex)`
`java.util.List<Range>`	`blankLinesRemovedRanges(int fromIndex, int endIndex)`
`java.util.List<Range>`	`blankLinesRemovedRanges(CharPredicate eolChars, int fromIndex, int endIndex)`
`int`	`columnAtIndex(int index)`
`int`	`compareTo(java.lang.CharSequence o)`
`int`	`countLeading(CharPredicate chars)`	Count leading/trailing characters of this sequence
`int`	`countLeading(CharPredicate chars, int fromIndex)`
`int`	`countLeading(CharPredicate chars, int fromIndex, int endIndex)`
`int`	`countLeadingColumns(int startColumn, CharPredicate chars)`	Count column of indent given by chars in the set in this sequence, expanding tabs to 4th column
`int`	`countLeadingNot(CharPredicate chars)`
`int`	`countLeadingNot(CharPredicate chars, int fromIndex)`
`int`	`countLeadingNot(CharPredicate chars, int startIndex, int endIndex)`
`int`	`countLeadingNotSpace()`
`int`	`countLeadingNotSpace(int startIndex)`
`int`	`countLeadingNotSpace(int startIndex, int endIndex)`
`int`	`countLeadingNotSpaceTab()`
`int`	`countLeadingNotSpaceTab(int startIndex)`
`int`	`countLeadingNotSpaceTab(int startIndex, int endIndex)`
`int`	`countLeadingNotWhitespace()`
`int`	`countLeadingNotWhitespace(int startIndex)`
`int`	`countLeadingNotWhitespace(int startIndex, int endIndex)`
`int`	`countLeadingSpace()`
`int`	`countLeadingSpace(int startIndex)`
`int`	`countLeadingSpace(int startIndex, int endIndex)`
`int`	`countLeadingSpaceTab()`
`int`	`countLeadingSpaceTab(int startIndex)`
`int`	`countLeadingSpaceTab(int startIndex, int endIndex)`
`int`	`countLeadingWhitespace()`
`int`	`countLeadingWhitespace(int startIndex)`
`int`	`countLeadingWhitespace(int startIndex, int endIndex)`
`int`	`countOfAny(CharPredicate chars)`
`int`	`countOfAny(CharPredicate chars, int fromIndex)`
`int`	`countOfAny(CharPredicate s, int fromIndex, int endIndex)`
`int`	`countOfAnyNot(CharPredicate chars)`
`int`	`countOfAnyNot(CharPredicate chars, int fromIndex)`
`int`	`countOfAnyNot(CharPredicate chars, int startIndex, int endIndex)`
`int`	`countOfNotSpaceTab()`
`int`	`countOfNotWhitespace()`
`int`	`countOfSpaceTab()`
`int`	`countOfWhitespace()`
`int`	`countTrailing(CharPredicate chars)`
`int`	`countTrailing(CharPredicate chars, int fromIndex)`
`int`	`countTrailing(CharPredicate chars, int startIndex, int fromIndex)`
`int`	`countTrailingNot(CharPredicate chars)`
`int`	`countTrailingNot(CharPredicate chars, int fromIndex)`
`int`	`countTrailingNot(CharPredicate chars, int startIndex, int endIndex)`
`int`	`countTrailingNotSpace()`
`int`	`countTrailingNotSpace(int fromIndex)`
`int`	`countTrailingNotSpace(int startIndex, int fromIndex)`
`int`	`countTrailingNotSpaceTab()`
`int`	`countTrailingNotSpaceTab(int fromIndex)`
`int`	`countTrailingNotSpaceTab(int startIndex, int fromIndex)`
`int`	`countTrailingNotWhitespace()`
`int`	`countTrailingNotWhitespace(int fromIndex)`
`int`	`countTrailingNotWhitespace(int startIndex, int fromIndex)`
`int`	`countTrailingSpace()`
`int`	`countTrailingSpace(int fromIndex)`
`int`	`countTrailingSpace(int startIndex, int fromIndex)`
`int`	`countTrailingSpaceTab()`
`int`	`countTrailingSpaceTab(int fromIndex)`
`int`	`countTrailingSpaceTab(int startIndex, int fromIndex)`
`int`	`countTrailingWhitespace()`
`int`	`countTrailingWhitespace(int fromIndex)`
`int`	`countTrailingWhitespace(int startIndex, int fromIndex)`
`T`	`delete(int startIndex, int endIndex)`	Delete range in sequence
`char`	`endCharAt(int index)`	Convenience method to get characters offset from end of sequence.
`int`	`endOfDelimitedBy(java.lang.CharSequence s, int index)`	Find start/end region in this sequence delimited by any characters in argument or the CharSequence
`int`	`endOfDelimitedByAny(CharPredicate s, int index)`
`int`	`endOfDelimitedByAnyNot(CharPredicate s, int index)`
`int`	`endOfLine(int index)`	Get the offset of the end of line at given index, end of line delimited by \n
`int`	`endOfLineAnyEOL(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.
`T`	`endSequence(int startIndex)`	Convenience method to get characters offset from endIndex of sequence.
`T`	`endSequence(int startIndex, int endIndex)`	Convenience method to get characters offset from endIndex of sequence.
`boolean`	`endsWith(CharPredicate chars)`
`boolean`	`endsWith(java.lang.CharSequence suffix)`	test if this sequence ends with given characters
`boolean`	`endsWith(java.lang.CharSequence suffix, boolean ignoreCase)`	test if this sequence ends with given characters
`boolean`	`endsWithAnyEOL()`
`boolean`	`endsWithEOL()`
`boolean`	`endsWithIgnoreCase(java.lang.CharSequence suffix)`	test if this sequence ends with given characters, ignoring case differences
`boolean`	`endsWithSpace()`
`boolean`	`endsWithSpaceTab()`
`boolean`	`endsWithWhitespace()`
`int`	`eolEndLength()`	Get the length of EOL character at the end of this sequence, if present.
`int`	`eolEndLength(int eolEnd)`	Get the length of EOL character at the given index of this sequence, if present.
`Range`	`eolEndRange(int eolEnd)`	Return Range of eol at given index
`int`	`eolStartLength(int eolStart)`	Get the length of EOL character at the given index of this sequence, if present.
`Range`	`eolStartRange(int eolStart)`	Return Range of eol at given index
`boolean`	`equals(java.lang.Object o)`	Equality comparison based on character content of this sequence, with quick fail resorting to content comparison only if length and hashCodes are equal
`boolean`	`equals(java.lang.Object other, boolean ignoreCase)`	Test the sequence for a match to another CharSequence
`boolean`	`equalsIgnoreCase(java.lang.Object other)`	Test the sequence for a match to another CharSequence, ignoring case differences
`T`	`extractRanges(Range... ranges)`	Build a sequence of ranges in this sequence
`T`	`extractRanges(java.lang.Iterable<Range> ranges)`
`char`	`firstChar()`
`int`	`hashCode()`	String hash code computation
`T`	`ifNull(T other)`	If this sequence is the nullSequence() instance then returns other, otherwise returns this sequence.
`T`	`ifNullEmptyAfter(T other)`	If this sequence is the nullSequence() instance then returns an empty subSequence from the end of other, otherwise returns this sequence.
`T`	`ifNullEmptyBefore(T other)`	If this sequence is the nullSequence() 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(java.lang.CharSequence s)`	All index methods return the position or -1 if not found of the given character, characters or string.
`int`	`indexOf(java.lang.CharSequence s, int fromIndex)`
`int`	`indexOf(java.lang.CharSequence s, int fromIndex, int endIndex)`
`int[]`	`indexOfAll(java.lang.CharSequence s)`	Get indices of all occurrences of a sequence
`int`	`indexOfAny(CharPredicate s)`
`int`	`indexOfAny(CharPredicate s, int index)`
`int`	`indexOfAny(CharPredicate s, int fromIndex, int endIndex)`
`int`	`indexOfAnyNot(CharPredicate s)`
`int`	`indexOfAnyNot(CharPredicate s, int fromIndex)`
`int`	`indexOfAnyNot(CharPredicate s, int fromIndex, int endIndex)`
`int`	`indexOfNot(char c)`
`int`	`indexOfNot(char c, int fromIndex)`
`int`	`indexOfNot(char c, int fromIndex, int endIndex)`
`T`	`insert(int index, java.lang.CharSequence chars)`	Insert char sequence at given index
`boolean`	`isBlank()`
`boolean`	`isCharAt(int index, CharPredicate predicate)`	Safe, if index out of range returns '\0'
`boolean`	`isEmpty()`
`boolean`	`isIn(java.lang.String[] texts)`
`boolean`	`isIn(java.util.Collection<? extends java.lang.CharSequence> texts)`
`boolean`	`isNotBlank()`
`boolean`	`isNotEmpty()`
`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(java.lang.CharSequence s)`
`int`	`lastIndexOf(java.lang.CharSequence s, int fromIndex)`
`int`	`lastIndexOf(java.lang.CharSequence s, int startIndex, int fromIndex)`
`int`	`lastIndexOfAny(CharPredicate s)`
`int`	`lastIndexOfAny(CharPredicate s, int fromIndex)`
`int`	`lastIndexOfAny(CharPredicate s, int startIndex, int fromIndex)`
`int`	`lastIndexOfAnyNot(CharPredicate s)`
`int`	`lastIndexOfAnyNot(CharPredicate s, int fromIndex)`
`int`	`lastIndexOfAnyNot(CharPredicate s, int startIndex, int fromIndex)`
`int`	`lastIndexOfNot(char c)`
`int`	`lastIndexOfNot(char c, int fromIndex)`
`int`	`lastIndexOfNot(char c, int startIndex, int fromIndex)`
`Range`	`leadingBlankLinesRange()`
`Range`	`leadingBlankLinesRange(int startIndex)`
`Range`	`leadingBlankLinesRange(int fromIndex, int endIndex)`
`Range`	`leadingBlankLinesRange(CharPredicate eolChars, int fromIndex, int endIndex)`	Get Range of leading blank lines at given index offsets in sequence
`T`	`lineAt(int index)`	Get the line characters at given index, line delimited by \n
`T`	`lineAtAnyEOL(int index)`	Get the line characters at given index, line delimited by \n, \r or \r\n
`Pair<java.lang.Integer,java.lang.Integer>`	`lineColumnAtIndex(int index)`	Get the line and column information from index into sequence
`Range`	`lineRangeAt(int index)`	Get the line characters at given index, line delimited by \n
`Range`	`lineRangeAtAnyEOL(int index)`	Get the line characters at given index, line delimited by \n, \r or \r\n
`boolean`	`matchChars(java.lang.CharSequence chars)`	Test the sequence portion for a match to another CharSequence
`boolean`	`matchChars(java.lang.CharSequence chars, boolean ignoreCase)`
`boolean`	`matchChars(java.lang.CharSequence chars, int startIndex)`
`boolean`	`matchChars(java.lang.CharSequence chars, int startIndex, boolean ignoreCase)`	Test the sequence portion for a match to another CharSequence
`boolean`	`matchCharsIgnoreCase(java.lang.CharSequence chars)`
`boolean`	`matchCharsIgnoreCase(java.lang.CharSequence chars, int startIndex)`
`boolean`	`matchCharsReversed(java.lang.CharSequence chars, int endIndex)`
`boolean`	`matchCharsReversed(java.lang.CharSequence chars, int endIndex, boolean ignoreCase)`	Test the sequence portion for a match to another CharSequence, reverse order
`boolean`	`matchCharsReversedIgnoreCase(java.lang.CharSequence chars, int endIndex)`
`int`	`matchedCharCount(java.lang.CharSequence chars, int startIndex)`
`int`	`matchedCharCount(java.lang.CharSequence chars, int startIndex, boolean ignoreCase)`
`int`	`matchedCharCount(java.lang.CharSequence chars, int startIndex, int endIndex)`
`int`	`matchedCharCount(java.lang.CharSequence chars, int startIndex, int endIndex, boolean ignoreCase)`
`int`	`matchedCharCount(java.lang.CharSequence chars, int startIndex, int endIndex, boolean fullMatchOnly, boolean ignoreCase)`	Test the sequence portion for a match to another CharSequence
`int`	`matchedCharCountIgnoreCase(java.lang.CharSequence chars, int startIndex)`
`int`	`matchedCharCountIgnoreCase(java.lang.CharSequence chars, int startIndex, int endIndex)`
`int`	`matchedCharCountReversed(java.lang.CharSequence chars, int fromIndex)`
`int`	`matchedCharCountReversed(java.lang.CharSequence chars, int fromIndex, boolean ignoreCase)`
`int`	`matchedCharCountReversed(java.lang.CharSequence chars, int startIndex, int fromIndex)`
`int`	`matchedCharCountReversed(java.lang.CharSequence chars, int startIndex, int fromIndex, boolean ignoreCase)`	Test the sequence portion for a match to another CharSequence, equivalent to taking this.subSequence(startIndex, fromIndex) and then count matching chars going from end of both sequences
`int`	`matchedCharCountReversedIgnoreCase(java.lang.CharSequence chars, int fromIndex)`
`int`	`matchedCharCountReversedIgnoreCase(java.lang.CharSequence chars, int startIndex, int fromIndex)`
`boolean`	`matches(java.lang.CharSequence chars)`	Test the sequence for a match to another CharSequence
`boolean`	`matches(java.lang.CharSequence chars, boolean ignoreCase)`
`boolean`	`matchesIgnoreCase(java.lang.CharSequence chars)`
`char`	`midCharAt(int index)`	Convenience method to get characters offset from start or end of sequence.
`T`	`midSequence(int startIndex)`	Convenience method to get characters offset from start or end of sequence.
`T`	`midSequence(int startIndex, int endIndex)`	Convenience method to get characters offset from start or end of sequence.
`java.lang.String`	`normalizeEndWithEOL()`	replace any \r\n and \r by \n, append terminating EOL if one is not present
`java.lang.String`	`normalizeEOL()`	replace any \r\n and \r by \n
`T`	`nullIf(boolean condition)`	If condition is true return nullSequence() otherwise returns this sequence.
`T`	`nullIf(java.lang.CharSequence... matches)`	If this sequence matches one of given sequences return nullSequence() otherwise returns this sequence.
`T`	`nullIf(java.util.function.BiPredicate<? super T,? super java.lang.CharSequence> predicate, java.lang.CharSequence... matches)`	If predicate returns true for this sequence and one of given sequences return nullSequence() otherwise returns this sequence.
`T`	`nullIf(java.util.function.Predicate<? super java.lang.CharSequence> predicate, java.lang.CharSequence... matches)`	If predicate returns true for one of given sequences return nullSequence() otherwise returns this sequence.
`T`	`nullIfBlank()`	If this sequence is blank return nullSequence() otherwise returns this sequence.
`T`	`nullIfEmpty()`	If this sequence is empty return nullSequence() otherwise returns this sequence.
`T`	`nullIfEndsWith(boolean ignoreCase, java.lang.CharSequence... matches)`
`T`	`nullIfEndsWith(java.lang.CharSequence... matches)`
`T`	`nullIfEndsWithIgnoreCase(java.lang.CharSequence... matches)`
`T`	`nullIfNot(java.lang.CharSequence... matches)`
`T`	`nullIfNot(java.util.function.BiPredicate<? super T,? super java.lang.CharSequence> predicate, java.lang.CharSequence... matches)`
`T`	`nullIfNot(java.util.function.Predicate<? super java.lang.CharSequence> predicate, java.lang.CharSequence... matches)`
`T`	`nullIfNotEndsWith(boolean ignoreCase, java.lang.CharSequence... matches)`
`T`	`nullIfNotEndsWith(java.lang.CharSequence... matches)`
`T`	`nullIfNotEndsWithIgnoreCase(java.lang.CharSequence... matches)`
`T`	`nullIfNotStartsWith(boolean ignoreCase, java.lang.CharSequence... matches)`
`T`	`nullIfNotStartsWith(java.lang.CharSequence... matches)`
`T`	`nullIfNotStartsWithIgnoreCase(java.lang.CharSequence... matches)`
`T`	`nullIfStartsWith(boolean ignoreCase, java.lang.CharSequence... matches)`
`T`	`nullIfStartsWith(java.lang.CharSequence... matches)`
`T`	`nullIfStartsWithIgnoreCase(java.lang.CharSequence... matches)`
`T`	`padding(int length)`
`T`	`padding(int length, char pad)`	Get the chars needed for padding to length
`T`	`padEnd(int length)`
`T`	`padEnd(int length, char pad)`
`T`	`padStart(int length)`
`T`	`padStart(int length, char pad)`	Pad this sequence to given length
`T`	`prefixOnceWith(java.lang.CharSequence prefix)`	Prefix this sequence with a char sequence if not already starting with prefix
`T`	`prefixOnceWithEOL()`
`T`	`prefixOnceWithSpace()`
`T`	`prefixWith(java.lang.CharSequence prefix)`	Prefix this sequence with a char sequence
`T`	`prefixWithEOL()`
`T`	`prefixWithSpace()`
`T`	`prefixWithSpaces(int count)`
`T`	`removePrefix(java.lang.CharSequence prefix)`	Remove prefix if present
`T`	`removePrefix(java.lang.CharSequence prefix, boolean ignoreCase)`	Remove prefix if present
`T`	`removePrefixIgnoreCase(java.lang.CharSequence prefix)`	Remove prefix if present, ignoring case differences
`T`	`removeProperPrefix(java.lang.CharSequence prefix)`	Remove prefix if present but only if this sequence is longer than the suffix
`T`	`removeProperPrefix(java.lang.CharSequence prefix, boolean ignoreCase)`	Remove prefix if present but only if this sequence is longer than the suffix
`T`	`removeProperPrefixIgnoreCase(java.lang.CharSequence prefix)`	Remove prefix if present but only if this sequence is longer than the suffix, ignoring case differences
`T`	`removeProperSuffix(java.lang.CharSequence suffix)`	Remove suffix if present but only if this sequence is longer than the suffix
`T`	`removeProperSuffix(java.lang.CharSequence suffix, boolean ignoreCase)`	Remove suffix if present but only if this sequence is longer than the suffix
`T`	`removeProperSuffixIgnoreCase(java.lang.CharSequence suffix)`	Remove suffix if present but only if this sequence is longer than the suffix, ignoring case differences
`T`	`removeSuffix(java.lang.CharSequence suffix)`	Remove suffix if present
`T`	`removeSuffix(java.lang.CharSequence suffix, boolean ignoreCase)`	Remove suffix if present
`T`	`removeSuffixIgnoreCase(java.lang.CharSequence suffix)`	Remove suffix if present, ignoring case differences
`T`	`replace(int startIndex, int endIndex, java.lang.CharSequence replacement)`	Replace part of the sequence with a char sequence
`T`	`replace(java.lang.CharSequence find, java.lang.CharSequence replace)`	Replace all occurrences of one sequence with another
`char`	`safeCharAt(int index)`	return char at index or '\0' if index <0 or >=length()
`T`	`safeSubSequence(int startIndex)`	Get a portion of this sequence, if index < 0 use 0, if > length() use length
`T`	`safeSubSequence(int startIndex, int endIndex)`	Get a portion of this sequence, if index < 0 use 0, if > length() use length
`T`	`sequenceOf(java.lang.CharSequence charSequence)`	Factory function
`T`	`sequenceOf(java.lang.CharSequence charSequence, int startIndex)`	Factory function
`T[]`	`split(java.lang.CharSequence delimiter)`
`T[]`	`split(java.lang.CharSequence delimiter, boolean includeDelims, CharPredicate trimChars)`
`T[]`	`split(java.lang.CharSequence delimiter, int limit, boolean includeDelims, CharPredicate trimChars)`
`T[]`	`split(java.lang.CharSequence delimiter, int limit, int flags)`
`T[]`	`split(java.lang.CharSequence delimiter, int limit, int flags, CharPredicate trimChars)`
`T[]`	`splitEOL()`
`T[]`	`splitEOL(boolean includeDelims)`
`java.util.List<T>`	`splitList(java.lang.CharSequence delimiter)`
`java.util.List<T>`	`splitList(java.lang.CharSequence delimiter, boolean includeDelims, CharPredicate trimChars)`
`java.util.List<T>`	`splitList(java.lang.CharSequence delimiter, int limit, boolean includeDelims, CharPredicate trimChars)`	Split helpers based on delimiter character sets contained in CharPredicate
`java.util.List<T>`	`splitList(java.lang.CharSequence delimiter, int limit, int flags)`
`java.util.List<T>`	`splitList(java.lang.CharSequence delimiter, int limit, int flags, CharPredicate trimChars)`	Split helpers based on delimiter character sets contained in CharSequence
`java.util.List<T>`	`splitListEOL()`
`java.util.List<T>`	`splitListEOL(boolean includeDelims)`
`java.util.List<T>`	`splitListEOL(boolean includeDelims, CharPredicate trimChars)`
`int`	`startOfDelimitedBy(java.lang.CharSequence s, int index)`
`int`	`startOfDelimitedByAny(CharPredicate s, int index)`
`int`	`startOfDelimitedByAnyNot(CharPredicate s, int index)`
`int`	`startOfLine(int index)`	Get the offset of the start of line at given index, start of line delimited by \n
`int`	`startOfLineAnyEOL(int index)`	Get the offset of the start of line at given index, start of line delimited by \n or any of \n \r \r\n for Any methods.
`boolean`	`startsWith(CharPredicate chars)`
`boolean`	`startsWith(java.lang.CharSequence prefix)`	test if this sequence starts with given characters
`boolean`	`startsWith(java.lang.CharSequence prefix, boolean ignoreCase)`	test if this sequence starts with given characters
`boolean`	`startsWithAnyEOL()`
`boolean`	`startsWithEOL()`
`boolean`	`startsWithIgnoreCase(java.lang.CharSequence prefix)`	test if this sequence starts with given characters, ignoring case differences
`boolean`	`startsWithSpace()`
`boolean`	`startsWithSpaceTab()`
`boolean`	`startsWithWhitespace()`
`T`	`subSequence(int startIndex)`	Get a portion of this sequence starting from a given offset to endIndex of the sequence
`T`	`subSequence(Range range)`	Get a portion of this sequence selected by range
`T`	`subSequenceAfter(Range range)`	Get a portion of this sequence after one selected by range
`T`	`subSequenceBefore(Range range)`	Get a portion of this sequence before one selected by range
`Pair<T,T>`	`subSequenceBeforeAfter(Range range)`	Get a portions of this sequence before and after one selected by range
`T`	`suffixOnceWith(java.lang.CharSequence suffix)`	Suffix this sequence with a char sequence if not already ending with suffix
`T`	`suffixOnceWithEOL()`
`T`	`suffixOnceWithSpace()`
`T`	`suffixWith(java.lang.CharSequence suffix)`	Prefix this sequence with a char sequence
`T`	`suffixWithEOL()`
`T`	`suffixWithSpace()`
`T`	`suffixWithSpaces(int count)`
`T`	`toLowerCase()`	Map characters of this sequence to: Uppercase, Lowercase or use custom mapping
`T`	`toNbSp()`	Map spaces to non break spaces
`T`	`toSpc()`	Map non break spaces to spaces
`java.lang.String`	`toString()`
`java.lang.String`	`toStringOrNull()`	Return string or null if BaseSequence.NULL
`T`	`toUpperCase()`
`java.lang.String`	`toVisibleWhitespaceString()`
`Range`	`trailingBlankLinesRange()`
`Range`	`trailingBlankLinesRange(int fromIndex)`
`Range`	`trailingBlankLinesRange(int startIndex, int fromIndex)`
`Range`	`trailingBlankLinesRange(CharPredicate eolChars, int startIndex, int fromIndex)`	Get Range of trailing blank lines at given index offsets in sequence
`T`	`trim()`
`T`	`trim(int keep)`
`T`	`trim(int keep, CharPredicate chars)`
`T`	`trim(CharPredicate chars)`
`T`	`trimEnd()`
`T`	`trimEnd(int keep)`
`T`	`trimEnd(int keep, CharPredicate chars)`
`T`	`trimEnd(CharPredicate chars)`
`Range`	`trimEndRange()`
`Range`	`trimEndRange(int keep)`
`Range`	`trimEndRange(int keep, CharPredicate chars)`
`Range`	`trimEndRange(CharPredicate chars)`
`T`	`trimEOL()`	Trim last eol at the end of this sequence,
`T`	`trimLeadBlankLines()`
`Pair<T,T>`	`trimmed()`
`Pair<T,T>`	`trimmed(int keep)`
`Pair<T,T>`	`trimmed(int keep, CharPredicate chars)`
`Pair<T,T>`	`trimmed(CharPredicate chars)`
`T`	`trimmedEnd()`
`T`	`trimmedEnd(int keep)`
`T`	`trimmedEnd(int keep, CharPredicate chars)`
`T`	`trimmedEnd(CharPredicate chars)`
`T`	`trimmedEOL()`	Get Trimmed part by `IRichSequence.trimEOL()`
`T`	`trimmedStart()`
`T`	`trimmedStart(int keep)`
`T`	`trimmedStart(int keep, CharPredicate chars)`	Get the characters Trimmed, Trimmed from start/end of this sequence, characters to trim are passed in the sequence argument
`T`	`trimmedStart(CharPredicate chars)`
`Range`	`trimRange()`
`Range`	`trimRange(int keep)`
`Range`	`trimRange(int keep, CharPredicate chars)`
`Range`	`trimRange(CharPredicate chars)`
`T`	`trimStart()`
`T`	`trimStart(int keep)`
`T`	`trimStart(int keep, CharPredicate chars)`	Trim, Trim start/end of this sequence, characters to trim are passed in the sequence argument
`T`	`trimStart(CharPredicate chars)`
`Range`	`trimStartRange()`
`Range`	`trimStartRange(int keep)`
`Range`	`trimStartRange(int keep, CharPredicate chars)`	Range of kept sequence when trim start/end of this sequence is performed, characters to trim are passed in the sequence argument
`Range`	`trimStartRange(CharPredicate chars)`
`T`	`trimTailBlankLines()`	Trim leading trailing blank lines in this sequence
`T`	`trimToEndOfLine()`
`T`	`trimToEndOfLine(boolean includeEol)`
`T`	`trimToEndOfLine(boolean includeEol, int index)`
`T`	`trimToEndOfLine(int index)`
`T`	`trimToEndOfLine(CharPredicate eolChars, boolean includeEol, int index)`	Trim end to end of line containing index
`T`	`trimToStartOfLine()`
`T`	`trimToStartOfLine(boolean includeEol)`
`T`	`trimToStartOfLine(boolean includeEol, int index)`
`T`	`trimToStartOfLine(int index)`
`T`	`trimToStartOfLine(CharPredicate eolChars, boolean includeEol, int index)`	Trim start to start of line containing index
`void`	`validateIndex(int index)`
`void`	`validateIndexInclusiveEnd(int index)`
`void`	`validateStartEnd(int startIndex, int endIndex)`

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

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

Methods inherited from interface com.vladsch.flexmark.util.sequence.IRichSequence
countLeading, countLeading, countOf, countTrailing, emptyArray, eolLength, eolStartLength, getBuilder, getColumnAtIndex, getLineColumnAtIndex, insert, nullIfEndsWithNot, nullIfStartsWithNot, nullSequence, sequenceOf, split, split, split, subSequence, toMapped

- Constructor Detail
  - IRichSequenceBase
```
public IRichSequenceBase(int hash)
```
    Constructor with pre-computed hash if available, 0 for lazy computation if length() not 0
    NOTE: the hash code computed for this class is equivalent to the string hash of the same characters to ensure that equals can use the hash code for quick failure. CharSequence hash code is not specified therefore when in doubt about how it is computed then 0 should be passed to this constructor to compute one that is equal to the string content.
    
    Parameters:
    
    hash - hash code for the char sequence.
- Method Detail
  - equals
```
@Contract(pure=true,
          value="null -> false")
public final boolean equals(java.lang.Object o)
```
    Equality comparison based on character content of this sequence, with quick fail resorting to content comparison only if length and hashCodes are equal
    
    Specified by:
    
    equals in interface IRichSequence<T extends IRichSequence<T>>
    
    Overrides:
    
    equals in class java.lang.Object
    
    Parameters:
    
    o - any char sequence
    
    Returns:
    
    true if character contents are equal
  - hashCode
```
@Contract(pure=true)
public final int hashCode()
```
    String hash code computation
    
    Specified by:
    
    hashCode in interface IRichSequence<T extends IRichSequence<T>>
    
    Overrides:
    
    hashCode in class java.lang.Object
    
    Returns:
    
    hash code of equivalent string
  - equalsIgnoreCase
```
@Contract(pure=true,
          value="null -> false")
public final boolean equalsIgnoreCase(@Nullable
                                      java.lang.Object other)
```
    Description copied from interface: IRichSequence
    
    Test the sequence for a match to another CharSequence, ignoring case differences
    
    Specified by:
    
    equalsIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    other - characters to match against
    
    Returns:
    
    true if match
  - equals
```
@Contract(pure=true,
          value="null, _ ->false")
public final boolean equals(@Nullable
                            java.lang.Object other,
                            boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    Test the sequence for a match to another CharSequence
    
    Specified by:
    
    equals in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    other - characters to match against
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if match
  - compareTo
```
public int compareTo(@NotNull
                     java.lang.CharSequence o)
```
    Specified by:
    
    compareTo in interface java.lang.Comparable<T extends IRichSequence<T>>
  - sequenceOf
```
@NotNull
public final T sequenceOf(@Nullable
                          java.lang.CharSequence charSequence)
```
    Description copied from interface: IRichSequence
    
    Factory function
    
    Specified by:
    
    sequenceOf in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    charSequence - char sequence from which to construct a rich char sequence
    
    Returns:
    
    rich char sequence from given inputs
  - sequenceOf
```
@NotNull
public final T sequenceOf(@Nullable
                          java.lang.CharSequence charSequence,
                          int startIndex)
```
    Description copied from interface: IRichSequence
    
    Factory function
    
    Specified by:
    
    sequenceOf in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    charSequence - char sequence from which to construct a rich char sequence
    
    startIndex - start index of the sequence to use
    
    Returns:
    
    rich char sequence from given inputs
  - subSequence
```
@NotNull
public final T subSequence(int startIndex)
```
    Description copied from interface: IRichSequence
    
    Get a portion of this sequence starting from a given offset to endIndex of the sequence
    
    Specified by:
    
    subSequence in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    startIndex - offset from startIndex of this sequence
    
    Returns:
    
    based sequence whose contents reflect the selected portion
  - subSequence
```
@NotNull
public final T subSequence(@NotNull
                           Range range)
```
    Get a portion of this sequence selected by range
    
    Specified by:
    
    subSequence in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    range - range to get, coordinates offset form start of this sequence
    
    Returns:
    
    sequence whose contents reflect the selected portion, if range.isNull() then this is returned
  - subSequenceBefore
```
@NotNull
public final T subSequenceBefore(@NotNull
                                 Range range)
```
    Get a portion of this sequence before one selected by range
    
    Specified by:
    
    subSequenceBefore in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    range - range to get, coordinates offset form start of this sequence
    
    Returns:
    
    sequence whose contents come before the selected range, if range.isNull() then IRichSequence.nullSequence()
  - subSequenceAfter
```
@NotNull
public final T subSequenceAfter(@NotNull
                                Range range)
```
    Get a portion of this sequence after one selected by range
    
    Specified by:
    
    subSequenceAfter in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    range - range to get, coordinates offset form start of this sequence
    
    Returns:
    
    sequence whose contents come after the selected range, if range.isNull() then IRichSequence.nullSequence()
  - subSequenceBeforeAfter
```
public final Pair<T,T> subSequenceBeforeAfter(Range range)
```
    Get a portions of this sequence before and after one selected by range
    
    Parameters:
    
    range - range to get, coordinates offset form start of this sequence
    
    Returns:
    
    sequence whose contents come before and after the selected range, if range.isNull() then IRichSequence.nullSequence()
  - endSequence
```
@NotNull
public final T endSequence(int startIndex,
                           int endIndex)
```
    Description copied from interface: IRichSequence
    
    Convenience method to get characters offset from endIndex of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Specified by:
    
    endSequence in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    startIndex - offset from endIndex of sequence [ 0..length() )
    
    endIndex - offset from endIndex of sequence [ 0..length() )
    
    Returns:
    
    selected portion spanning length() - startIndex to length() - endIndex of this sequence
  - endSequence
```
@NotNull
public final T endSequence(int startIndex)
```
    Description copied from interface: IRichSequence
    
    Convenience method to get characters offset from endIndex of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions
    
    Specified by:
    
    endSequence in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    startIndex - offset from endIndex of sequence [ 0..length() )
    
    Returns:
    
    selected portion spanning length() - startIndex to length() of this sequence
  - endCharAt
```
public final char endCharAt(int index)
```
    Description copied from interface: IRichSequence
    
    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 IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - offset from end of sequence
    
    Returns:
    
    character located at length() - index in this sequence
  - midSequence
```
@NotNull
public final T midSequence(int startIndex,
                           int endIndex)
```
    Description copied from interface: IRichSequence
    
    Convenience method to get characters offset from start or end of sequence. when offset >=0 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 IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    startIndex - offset into this sequence
    
    endIndex - offset into this sequence
    
    Returns:
    
    selected portion spanning startIndex to endIndex of this sequence. If offset is <0 then it is taken as relative to length()
  - midSequence
```
@NotNull
public final T midSequence(int startIndex)
```
    Description copied from interface: IRichSequence
    
    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 IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    startIndex - offset into this sequence
    
    Returns:
    
    selected portion spanning startIndex to length() of this sequence. If offset is <0 then it is taken as relative to length()
  - midCharAt
```
public final char midCharAt(int index)
```
    Description copied from interface: IRichSequence
    
    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 IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - of character to get
    
    Returns:
    
    character at index or \0 if index is outside valid range for this sequence
  - lastChar
```
public final char lastChar()
```
    Specified by:
    
    lastChar in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    the last character of the sequence or '\0' if empty
  - firstChar
```
public final char firstChar()
```
    Specified by:
    
    firstChar in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    the first character of the sequence or '\0' if empty
  - validateIndex
```
public final void validateIndex(int index)
```
  - validateIndexInclusiveEnd
```
public final void validateIndexInclusiveEnd(int index)
```
  - validateStartEnd
```
public final void validateStartEnd(int startIndex,
                                   int endIndex)
```
  - safeCharAt
```
public char safeCharAt(int index)
```
    Description copied from interface: IRichSequence
    
    return char at index or '\0' if index <0 or >=length()
    
    Specified by:
    
    safeCharAt in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index
    
    Returns:
    
    char or '\0'
  - safeSubSequence
```
@NotNull
public T safeSubSequence(int startIndex,
                         int endIndex)
```
    Description copied from interface: IRichSequence
    
    Get a portion of this sequence, if index < 0 use 0, if > length() use length
    NOTE: the returned value should only depend on start/end indices. If a subsequence of this sequence with matching start/end should equal (using equals()) all such subsequences of this sequence.
    
    Specified by:
    
    safeSubSequence in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    startIndex - offset from startIndex of this sequence
    
    endIndex - offset from startIndex of this sequence
    
    Returns:
    
    based sequence whose contents reflect the selected portion
  - safeSubSequence
```
@NotNull
public T safeSubSequence(int startIndex)
```
    Description copied from interface: IRichSequence
    
    Get a portion of this sequence, if index < 0 use 0, if > length() use length
    NOTE: the returned value should only depend on start/end indices. If a subsequence of this sequence with matching start/end should equal (using equals()) all such subsequences of this sequence.
    
    Specified by:
    
    safeSubSequence in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    startIndex - offset from startIndex of this sequence
    
    Returns:
    
    based sequence whose contents reflect the selected portion
  - isCharAt
```
public boolean isCharAt(int index,
                        @NotNull
                        CharPredicate predicate)
```
    Description copied from interface: IRichSequence
    
    Safe, if index out of range returns '\0'
    
    Specified by:
    
    isCharAt in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index in string
    
    predicate - character set predicate
    
    Returns:
    
    true if character at index tests true
  - toStringOrNull
```
@Nullable
public java.lang.String toStringOrNull()
```
    Description copied from interface: IRichSequence
    
    Return string or null if BaseSequence.NULL
    
    Specified by:
    
    toStringOrNull in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    string or null if BaseSequence.NULL
  - indexOf
```
public final int indexOf(@NotNull
                         java.lang.CharSequence s)
```
    Description copied from interface: IRichSequence
    
    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.
    
    Specified by:
    
    indexOf in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    s - character pre whose occurrence to find
    
    Returns:
    
    index where found or -1
  - indexOf
```
public final int indexOf(@NotNull
                         java.lang.CharSequence s,
                         int fromIndex)
```
    Specified by:
    
    indexOf in interface IRichSequence<T extends IRichSequence<T>>
  - indexOf
```
public final int indexOf(@NotNull
                         java.lang.CharSequence s,
                         int fromIndex,
                         int endIndex)
```
    Specified by:
    
    indexOf in interface IRichSequence<T extends IRichSequence<T>>
  - indexOf
```
public final int indexOf(char c)
```
    Specified by:
    
    indexOf in interface IRichSequence<T extends IRichSequence<T>>
  - indexOf
```
public final int indexOf(char c,
                         int fromIndex)
```
    Specified by:
    
    indexOf in interface IRichSequence<T extends IRichSequence<T>>
  - indexOfAny
```
public final int indexOfAny(@NotNull
                            CharPredicate s)
```
    Specified by:
    
    indexOfAny in interface IRichSequence<T extends IRichSequence<T>>
  - indexOfAny
```
public final int indexOfAny(@NotNull
                            CharPredicate s,
                            int index)
```
    Specified by:
    
    indexOfAny in interface IRichSequence<T extends IRichSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(@NotNull
                               CharPredicate s)
```
    Specified by:
    
    indexOfAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(@NotNull
                               CharPredicate s,
                               int fromIndex)
```
    Specified by:
    
    indexOfAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - indexOfAnyNot
```
public final int indexOfAnyNot(@NotNull
                               CharPredicate s,
                               int fromIndex,
                               int endIndex)
```
    Specified by:
    
    indexOfAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - indexOfNot
```
public final int indexOfNot(char c)
```
    Specified by:
    
    indexOfNot in interface IRichSequence<T extends IRichSequence<T>>
  - indexOfNot
```
public final int indexOfNot(char c,
                            int fromIndex)
```
    Specified by:
    
    indexOfNot in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(char c)
```
    Specified by:
    
    lastIndexOf in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(char c,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOfNot
```
public final int lastIndexOfNot(char c)
```
    Specified by:
    
    lastIndexOfNot in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOfNot
```
public final int lastIndexOfNot(char c,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfNot in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(@NotNull
                             java.lang.CharSequence s)
```
    Specified by:
    
    lastIndexOf in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(@NotNull
                             java.lang.CharSequence s,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(@NotNull
                                CharPredicate s,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(@NotNull
                                CharPredicate s)
```
    Specified by:
    
    lastIndexOfAny in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(@NotNull
                                   CharPredicate s)
```
    Specified by:
    
    lastIndexOfAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(@NotNull
                                   CharPredicate s,
                                   int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOfAnyNot
```
public final int lastIndexOfAnyNot(@NotNull
                                   CharPredicate s,
                                   int startIndex,
                                   int fromIndex)
```
    Specified by:
    
    lastIndexOfAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - indexOf
```
public final int indexOf(char c,
                         int fromIndex,
                         int endIndex)
```
    Specified by:
    
    indexOf in interface IRichSequence<T extends IRichSequence<T>>
  - indexOfNot
```
public final int indexOfNot(char c,
                            int fromIndex,
                            int endIndex)
```
    Specified by:
    
    indexOfNot in interface IRichSequence<T extends IRichSequence<T>>
  - indexOfAny
```
public final int indexOfAny(@NotNull
                            CharPredicate s,
                            int fromIndex,
                            int endIndex)
```
    Specified by:
    
    indexOfAny in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(@NotNull
                             java.lang.CharSequence s,
                             int startIndex,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOf
```
public final int lastIndexOf(char c,
                             int startIndex,
                             int fromIndex)
```
    Specified by:
    
    lastIndexOf in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOfNot
```
public final int lastIndexOfNot(char c,
                                int startIndex,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfNot in interface IRichSequence<T extends IRichSequence<T>>
  - lastIndexOfAny
```
public final int lastIndexOfAny(@NotNull
                                CharPredicate s,
                                int startIndex,
                                int fromIndex)
```
    Specified by:
    
    lastIndexOfAny in interface IRichSequence<T extends IRichSequence<T>>
  - countOfSpaceTab
```
public final int countOfSpaceTab()
```
    Specified by:
    
    countOfSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countOfNotSpaceTab
```
public final int countOfNotSpaceTab()
```
    Specified by:
    
    countOfNotSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countOfWhitespace
```
public final int countOfWhitespace()
```
    Specified by:
    
    countOfWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countOfNotWhitespace
```
public final int countOfNotWhitespace()
```
    Specified by:
    
    countOfNotWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countOfAny
```
public final int countOfAny(@NotNull
                            CharPredicate chars,
                            int fromIndex)
```
    Specified by:
    
    countOfAny in interface IRichSequence<T extends IRichSequence<T>>
  - countOfAny
```
public final int countOfAny(@NotNull
                            CharPredicate chars)
```
    Specified by:
    
    countOfAny in interface IRichSequence<T extends IRichSequence<T>>
  - countOfAnyNot
```
public final int countOfAnyNot(@NotNull
                               CharPredicate chars,
                               int fromIndex)
```
    Specified by:
    
    countOfAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - countOfAnyNot
```
public final int countOfAnyNot(@NotNull
                               CharPredicate chars)
```
    Specified by:
    
    countOfAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - countOfAny
```
public final int countOfAny(@NotNull
                            CharPredicate s,
                            int fromIndex,
                            int endIndex)
```
    Specified by:
    
    countOfAny in interface IRichSequence<T extends IRichSequence<T>>
  - countOfAnyNot
```
public final int countOfAnyNot(@NotNull
                               CharPredicate chars,
                               int startIndex,
                               int endIndex)
```
    Specified by:
    
    countOfAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - countLeading
```
public final int countLeading(@NotNull
                              CharPredicate chars)
```
    Description copied from interface: IRichSequence
    
    Count leading/trailing characters of this sequence
    Parameters can be CharPredicate, counts any contiguous leading/trailing characters in the sequence which are contained in the given char set.
    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(CharPredicate): count contiguous leading characters from set in this sequence countLeadingNot(CharPredicate): count contiguous leading characters not from set in this sequence countTrailing(CharPredicate): count contiguous leading characters from set in this sequence countTrailingNot(CharPredicate): count contiguous leading characters not from set in this sequence
    
    Specified by:
    
    countLeading in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    chars - predicate for set of contiguous characters which should be counted
    
    Returns:
    
    number of chars in contiguous span at start of sequence
  - countLeading
```
public final int countLeading(@NotNull
                              CharPredicate chars,
                              int fromIndex)
```
    Specified by:
    
    countLeading in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNot
```
public final int countLeadingNot(@NotNull
                                 CharPredicate chars)
```
    Specified by:
    
    countLeadingNot in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNot
```
public final int countLeadingNot(@NotNull
                                 CharPredicate chars,
                                 int fromIndex)
```
    Specified by:
    
    countLeadingNot in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailing
```
public final int countTrailing(@NotNull
                               CharPredicate chars)
```
    Specified by:
    
    countTrailing in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailing
```
public final int countTrailing(@NotNull
                               CharPredicate chars,
                               int fromIndex)
```
    Specified by:
    
    countTrailing in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNot
```
public final int countTrailingNot(@NotNull
                                  CharPredicate chars)
```
    Specified by:
    
    countTrailingNot in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNot
```
public final int countTrailingNot(@NotNull
                                  CharPredicate chars,
                                  int fromIndex)
```
    Specified by:
    
    countTrailingNot in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNot
```
public final int countLeadingNot(@NotNull
                                 CharPredicate chars,
                                 int startIndex,
                                 int endIndex)
```
    Specified by:
    
    countLeadingNot in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNot
```
public final int countTrailingNot(@NotNull
                                  CharPredicate chars,
                                  int startIndex,
                                  int endIndex)
```
    Specified by:
    
    countTrailingNot in interface IRichSequence<T extends IRichSequence<T>>
  - countLeading
```
public final int countLeading(@NotNull
                              CharPredicate chars,
                              int fromIndex,
                              int endIndex)
```
    Specified by:
    
    countLeading in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingColumns
```
public final int countLeadingColumns(int startColumn,
                                     @NotNull
                                     CharPredicate chars)
```
    Description copied from interface: IRichSequence
    
    Count column of indent given by chars in the set in this sequence, expanding tabs to 4th column
    
    Specified by:
    
    countLeadingColumns in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    startColumn - column of where this sequence starts
    
    chars - whitespace characters
    
    Returns:
    
    column of first non-whitespace as given by chars
  - countTrailing
```
public final int countTrailing(@NotNull
                               CharPredicate chars,
                               int startIndex,
                               int fromIndex)
```
    Specified by:
    
    countTrailing in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingSpace
```
public final int countLeadingSpace()
```
    Specified by:
    
    countLeadingSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNotSpace
```
public final int countLeadingNotSpace()
```
    Specified by:
    
    countLeadingNotSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingSpace
```
public final int countLeadingSpace(int startIndex)
```
    Specified by:
    
    countLeadingSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNotSpace
```
public final int countLeadingNotSpace(int startIndex)
```
    Specified by:
    
    countLeadingNotSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingSpace
```
public final int countLeadingSpace(int startIndex,
                                   int endIndex)
```
    Specified by:
    
    countLeadingSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNotSpace
```
public final int countLeadingNotSpace(int startIndex,
                                      int endIndex)
```
    Specified by:
    
    countLeadingNotSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingSpace
```
public final int countTrailingSpace()
```
    Specified by:
    
    countTrailingSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNotSpace
```
public final int countTrailingNotSpace()
```
    Specified by:
    
    countTrailingNotSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingSpace
```
public final int countTrailingSpace(int fromIndex)
```
    Specified by:
    
    countTrailingSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNotSpace
```
public final int countTrailingNotSpace(int fromIndex)
```
    Specified by:
    
    countTrailingNotSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingSpace
```
public final int countTrailingSpace(int startIndex,
                                    int fromIndex)
```
    Specified by:
    
    countTrailingSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNotSpace
```
public final int countTrailingNotSpace(int startIndex,
                                       int fromIndex)
```
    Specified by:
    
    countTrailingNotSpace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingSpaceTab
```
public final int countLeadingSpaceTab()
```
    Specified by:
    
    countLeadingSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNotSpaceTab
```
public final int countLeadingNotSpaceTab()
```
    Specified by:
    
    countLeadingNotSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingSpaceTab
```
public final int countLeadingSpaceTab(int startIndex)
```
    Specified by:
    
    countLeadingSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNotSpaceTab
```
public final int countLeadingNotSpaceTab(int startIndex)
```
    Specified by:
    
    countLeadingNotSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingSpaceTab
```
public final int countLeadingSpaceTab(int startIndex,
                                      int endIndex)
```
    Specified by:
    
    countLeadingSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNotSpaceTab
```
public final int countLeadingNotSpaceTab(int startIndex,
                                         int endIndex)
```
    Specified by:
    
    countLeadingNotSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingSpaceTab
```
public final int countTrailingSpaceTab()
```
    Specified by:
    
    countTrailingSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNotSpaceTab
```
public final int countTrailingNotSpaceTab()
```
    Specified by:
    
    countTrailingNotSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingSpaceTab
```
public final int countTrailingSpaceTab(int fromIndex)
```
    Specified by:
    
    countTrailingSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNotSpaceTab
```
public final int countTrailingNotSpaceTab(int fromIndex)
```
    Specified by:
    
    countTrailingNotSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingSpaceTab
```
public final int countTrailingSpaceTab(int startIndex,
                                       int fromIndex)
```
    Specified by:
    
    countTrailingSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNotSpaceTab
```
public final int countTrailingNotSpaceTab(int startIndex,
                                          int fromIndex)
```
    Specified by:
    
    countTrailingNotSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingWhitespace
```
public final int countLeadingWhitespace()
```
    Specified by:
    
    countLeadingWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNotWhitespace
```
public final int countLeadingNotWhitespace()
```
    Specified by:
    
    countLeadingNotWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingWhitespace
```
public final int countLeadingWhitespace(int startIndex)
```
    Specified by:
    
    countLeadingWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNotWhitespace
```
public final int countLeadingNotWhitespace(int startIndex)
```
    Specified by:
    
    countLeadingNotWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingWhitespace
```
public final int countLeadingWhitespace(int startIndex,
                                        int endIndex)
```
    Specified by:
    
    countLeadingWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countLeadingNotWhitespace
```
public final int countLeadingNotWhitespace(int startIndex,
                                           int endIndex)
```
    Specified by:
    
    countLeadingNotWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingWhitespace
```
public final int countTrailingWhitespace()
```
    Specified by:
    
    countTrailingWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNotWhitespace
```
public final int countTrailingNotWhitespace()
```
    Specified by:
    
    countTrailingNotWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingWhitespace
```
public final int countTrailingWhitespace(int fromIndex)
```
    Specified by:
    
    countTrailingWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNotWhitespace
```
public final int countTrailingNotWhitespace(int fromIndex)
```
    Specified by:
    
    countTrailingNotWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingWhitespace
```
public final int countTrailingWhitespace(int startIndex,
                                         int fromIndex)
```
    Specified by:
    
    countTrailingWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - countTrailingNotWhitespace
```
public final int countTrailingNotWhitespace(int startIndex,
                                            int fromIndex)
```
    Specified by:
    
    countTrailingNotWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - trimStart
```
@NotNull
public final T trimStart(@NotNull
                         CharPredicate chars)
```
    Specified by:
    
    trimStart in interface IRichSequence<T extends IRichSequence<T>>
  - trimmedStart
```
@NotNull
public final T trimmedStart(@NotNull
                            CharPredicate chars)
```
    Specified by:
    
    trimmedStart in interface IRichSequence<T extends IRichSequence<T>>
  - trimEnd
```
@NotNull
public final T trimEnd(@NotNull
                       CharPredicate chars)
```
    Specified by:
    
    trimEnd in interface IRichSequence<T extends IRichSequence<T>>
  - trimmedEnd
```
@NotNull
public final T trimmedEnd(@NotNull
                          CharPredicate chars)
```
    Specified by:
    
    trimmedEnd in interface IRichSequence<T extends IRichSequence<T>>
  - trim
```
@NotNull
public final T trim(@NotNull
                    CharPredicate chars)
```
    Specified by:
    
    trim in interface IRichSequence<T extends IRichSequence<T>>
  - trimmed
```
@NotNull
public final Pair<T,T> trimmed(@NotNull
                                     CharPredicate chars)
```
    Specified by:
    
    trimmed in interface IRichSequence<T extends IRichSequence<T>>
  - trimStart
```
@NotNull
public final T trimStart(int keep)
```
    Specified by:
    
    trimStart in interface IRichSequence<T extends IRichSequence<T>>
  - trimmedStart
```
@NotNull
public final T trimmedStart(int keep)
```
    Specified by:
    
    trimmedStart in interface IRichSequence<T extends IRichSequence<T>>
  - trimEnd
```
@NotNull
public final T trimEnd(int keep)
```
    Specified by:
    
    trimEnd in interface IRichSequence<T extends IRichSequence<T>>
  - trimmedEnd
```
@NotNull
public final T trimmedEnd(int keep)
```
    Specified by:
    
    trimmedEnd in interface IRichSequence<T extends IRichSequence<T>>
  - trim
```
@NotNull
public final T trim(int keep)
```
    Specified by:
    
    trim in interface IRichSequence<T extends IRichSequence<T>>
  - trimmed
```
@NotNull
public final Pair<T,T> trimmed(int keep)
```
    Specified by:
    
    trimmed in interface IRichSequence<T extends IRichSequence<T>>
  - trimStart
```
@NotNull
public final T trimStart()
```
    Specified by:
    
    trimStart in interface IRichSequence<T extends IRichSequence<T>>
  - trimmedStart
```
@NotNull
public final T trimmedStart()
```
    Specified by:
    
    trimmedStart in interface IRichSequence<T extends IRichSequence<T>>
  - trimEnd
```
@NotNull
public final T trimEnd()
```
    Specified by:
    
    trimEnd in interface IRichSequence<T extends IRichSequence<T>>
  - trimmedEnd
```
@NotNull
public final T trimmedEnd()
```
    Specified by:
    
    trimmedEnd in interface IRichSequence<T extends IRichSequence<T>>
  - trim
```
@NotNull
public final T trim()
```
    Specified by:
    
    trim in interface IRichSequence<T extends IRichSequence<T>>
  - trimmed
```
@NotNull
public final Pair<T,T> trimmed()
```
    Specified by:
    
    trimmed in interface IRichSequence<T extends IRichSequence<T>>
  - trimStart
```
@NotNull
public final T trimStart(int keep,
                         @NotNull
                         CharPredicate chars)
```
    Description copied from interface: IRichSequence
    
    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 SequenceUtils.WHITESPACE are assumed.
    
    Specified by:
    
    trimStart in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    keep - minimum length of would be trimmed characters to keep. ie. keep 4, will leave 0..4 as is but remove any >4
    
    chars - set of characters to trim from start of line
    
    Returns:
    
    sequence after it is trimmed
  - trimmedStart
```
@NotNull
public final T trimmedStart(int keep,
                            @NotNull
                            CharPredicate chars)
```
    Description copied from interface: IRichSequence
    
    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
    The pair returning functions return before and after sequence
    
    Specified by:
    
    trimmedStart in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    keep - minimum length of would be trimmed characters to keep. ie. keep 4, will leave 0..4 as is but remove any >4
    
    chars - set of characters to trim from start of line
    
    Returns:
    
    part of the sequence that was trimmed from the start
  - trimEnd
```
@NotNull
public final T trimEnd(int keep,
                       @NotNull
                       CharPredicate chars)
```
    Specified by:
    
    trimEnd in interface IRichSequence<T extends IRichSequence<T>>
  - trimmedEnd
```
@NotNull
public final T trimmedEnd(int keep,
                          @NotNull
                          CharPredicate chars)
```
    Specified by:
    
    trimmedEnd in interface IRichSequence<T extends IRichSequence<T>>
  - trim
```
@NotNull
public final T trim(int keep,
                    @NotNull
                    CharPredicate chars)
```
    Specified by:
    
    trim in interface IRichSequence<T extends IRichSequence<T>>
  - trimmed
```
@NotNull
public final Pair<T,T> trimmed(int keep,
                                     @NotNull
                                     CharPredicate chars)
```
    Specified by:
    
    trimmed in interface IRichSequence<T extends IRichSequence<T>>
  - trimStartRange
```
@NotNull
public final Range trimStartRange(int keep,
                                  @NotNull
                                  CharPredicate chars)
```
    Description copied from interface: IRichSequence
    
    Range of kept sequence when trim start/end of this sequence is performed, characters to trim are passed in the sequence argument
    returns range of kept sequence or if nothing matched then Range.NULL is returned, meaning keep all
    If character set in the form of character sequence is not passed in the SequenceUtils.WHITESPACE are assumed.
    
    Specified by:
    
    trimStartRange in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    keep - minimum length of would be trimmed characters to keep. ie. keep 4, will leave 0..4 as is but remove any >4
    
    chars - set of characters to trim from start of line
    
    Returns:
    
    range in this sequence to keep or Range.NULL if to keep all
  - trimEndRange
```
@NotNull
public final Range trimEndRange(int keep,
                                @NotNull
                                CharPredicate chars)
```
    Specified by:
    
    trimEndRange in interface IRichSequence<T extends IRichSequence<T>>
  - trimRange
```
@NotNull
public final Range trimRange(int keep,
                             @NotNull
                             CharPredicate chars)
```
    Specified by:
    
    trimRange in interface IRichSequence<T extends IRichSequence<T>>
  - trimStartRange
```
@NotNull
public final Range trimStartRange(@NotNull
                                  CharPredicate chars)
```
    Specified by:
    
    trimStartRange in interface IRichSequence<T extends IRichSequence<T>>
  - trimEndRange
```
@NotNull
public final Range trimEndRange(@NotNull
                                CharPredicate chars)
```
    Specified by:
    
    trimEndRange in interface IRichSequence<T extends IRichSequence<T>>
  - trimRange
```
@NotNull
public final Range trimRange(@NotNull
                             CharPredicate chars)
```
    Specified by:
    
    trimRange in interface IRichSequence<T extends IRichSequence<T>>
  - trimStartRange
```
@NotNull
public final Range trimStartRange(int keep)
```
    Specified by:
    
    trimStartRange in interface IRichSequence<T extends IRichSequence<T>>
  - trimEndRange
```
@NotNull
public final Range trimEndRange(int keep)
```
    Specified by:
    
    trimEndRange in interface IRichSequence<T extends IRichSequence<T>>
  - trimRange
```
@NotNull
public final Range trimRange(int keep)
```
    Specified by:
    
    trimRange in interface IRichSequence<T extends IRichSequence<T>>
  - trimStartRange
```
@NotNull
public final Range trimStartRange()
```
    Specified by:
    
    trimStartRange in interface IRichSequence<T extends IRichSequence<T>>
  - trimEndRange
```
@NotNull
public final Range trimEndRange()
```
    Specified by:
    
    trimEndRange in interface IRichSequence<T extends IRichSequence<T>>
  - trimRange
```
@NotNull
public final Range trimRange()
```
    Specified by:
    
    trimRange in interface IRichSequence<T extends IRichSequence<T>>
  - padding
```
@NotNull
public final T padding(int length,
                       char pad)
```
    Description copied from interface: IRichSequence
    
    Get the chars needed for padding to length
    
    Specified by:
    
    padding in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    length - length
    
    pad - char to use for padding
    
    Returns:
    
    padding chars
  - padding
```
@NotNull
public final T padding(int length)
```
    Specified by:
    
    padding in interface IRichSequence<T extends IRichSequence<T>>
  - padStart
```
@NotNull
public T padStart(int length,
                  char pad)
```
    Description copied from interface: IRichSequence
    
    Pad this sequence to given length
    
    Specified by:
    
    padStart in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    length - length to pad
    
    pad - char to use for padding
    
    Returns:
    
    sequence padded
  - padEnd
```
@NotNull
public T padEnd(int length,
                char pad)
```
    Specified by:
    
    padEnd in interface IRichSequence<T extends IRichSequence<T>>
  - padStart
```
@NotNull
public T padStart(int length)
```
    Specified by:
    
    padStart in interface IRichSequence<T extends IRichSequence<T>>
  - padEnd
```
@NotNull
public T padEnd(int length)
```
    Specified by:
    
    padEnd in interface IRichSequence<T extends IRichSequence<T>>
  - eolEndLength
```
public final int eolEndLength()
```
    Description copied from interface: IRichSequence
    
    Get the length of EOL character at the end of this sequence, if present.
    \n - 1 \r - 1 \r\n - 2
    
    Specified by:
    
    eolEndLength in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    0 if no EOL, 1, or 2 depending on the EOL suffix of this sequence
  - eolEndLength
```
public final int eolEndLength(int eolEnd)
```
    Description copied from interface: IRichSequence
    
    Get the length of EOL character at the given index of this sequence, if present.
    \n - 1 \r - 1 \r\n - 2
    
    Specified by:
    
    eolEndLength in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    eolEnd - index where the EOL ends, if any, any value can be passed for this argument. If > length of this sequence then it is the same as passing length(), if 0 or less then 0 is returned.
    
    Returns:
    
    0 if no EOL, 1, or 2 depending on the EOL suffix of this sequence
  - eolStartLength
```
public final int eolStartLength(int eolStart)
```
    Description copied from interface: IRichSequence
    
    Get the length of EOL character at the given index of this sequence, if present.
    \n - 1 \r - 1 \r\n - 2
    
    Specified by:
    
    eolStartLength in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    eolStart - index where the EOL starts, if any, any value can be passed for this argument. If >= length of this sequence then 0 is returned if 0 or less then it is the same as 0
    
    Returns:
    
    0 if no EOL, 1, or 2 depending on the EOL suffix of this sequence
  - endOfLine
```
public final int endOfLine(int index)
```
    Description copied from interface: IRichSequence
    
    Get the offset of the end of line at given index, end of line delimited by \n
    
    Specified by:
    
    endOfLine in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index where to start searching for end of line
    
    Returns:
    
    index of end of line delimited by \n
  - endOfLineAnyEOL
```
public final int endOfLineAnyEOL(int index)
```
    Description copied from interface: IRichSequence
    
    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:
    
    endOfLineAnyEOL in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index where to start searching for end of line
    
    Returns:
    
    index of end of line delimited by \n
  - startOfLine
```
public final int startOfLine(int index)
```
    Description copied from interface: IRichSequence
    
    Get the offset of the start of line at given index, start of line delimited by \n
    
    Specified by:
    
    startOfLine in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index where to start searching for end of line
    
    Returns:
    
    index of end of line delimited by \n
  - startOfLineAnyEOL
```
public final int startOfLineAnyEOL(int index)
```
    Description copied from interface: IRichSequence
    
    Get the offset of the start of line at given index, start of line delimited by \n or any of \n \r \r\n for Any methods.
    
    Specified by:
    
    startOfLineAnyEOL in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index where to start searching for end of line
    
    Returns:
    
    index of end of line delimited by \n
  - startOfDelimitedByAnyNot
```
public final int startOfDelimitedByAnyNot(@NotNull
                                          CharPredicate s,
                                          int index)
```
    Specified by:
    
    startOfDelimitedByAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - endOfDelimitedByAnyNot
```
public final int endOfDelimitedByAnyNot(@NotNull
                                        CharPredicate s,
                                        int index)
```
    Specified by:
    
    endOfDelimitedByAnyNot in interface IRichSequence<T extends IRichSequence<T>>
  - startOfDelimitedBy
```
public final int startOfDelimitedBy(@NotNull
                                    java.lang.CharSequence s,
                                    int index)
```
    Specified by:
    
    startOfDelimitedBy in interface IRichSequence<T extends IRichSequence<T>>
  - startOfDelimitedByAny
```
public final int startOfDelimitedByAny(@NotNull
                                       CharPredicate s,
                                       int index)
```
    Specified by:
    
    startOfDelimitedByAny in interface IRichSequence<T extends IRichSequence<T>>
  - endOfDelimitedBy
```
public final int endOfDelimitedBy(@NotNull
                                  java.lang.CharSequence s,
                                  int index)
```
    Description copied from interface: IRichSequence
    
    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 IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    s - character sequence delimiting the region
    
    index - from which to start looking for end of region
    
    Returns:
    
    index of end of region delimited by s
  - endOfDelimitedByAny
```
public final int endOfDelimitedByAny(@NotNull
                                     CharPredicate s,
                                     int index)
```
    Specified by:
    
    endOfDelimitedByAny in interface IRichSequence<T extends IRichSequence<T>>
  - lineRangeAt
```
@NotNull
public final Range lineRangeAt(int index)
```
    Description copied from interface: IRichSequence
    
    Get the line characters at given index, line delimited by \n
    
    Specified by:
    
    lineRangeAt in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index at which to get the line
    
    Returns:
    
    range in sequence for the line delimited by '\n', containing index
  - lineRangeAtAnyEOL
```
@NotNull
public final Range lineRangeAtAnyEOL(int index)
```
    Description copied from interface: IRichSequence
    
    Get the line characters at given index, line delimited by \n, \r or \r\n
    
    Specified by:
    
    lineRangeAtAnyEOL in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index at which to get the line
    
    Returns:
    
    range in sequence for the line delimited by end of line, containing index
  - lineAt
```
@NotNull
public final T lineAt(int index)
```
    Description copied from interface: IRichSequence
    
    Get the line characters at given index, line delimited by \n
    
    Specified by:
    
    lineAt in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index at which to get the line
    
    Returns:
    
    sub-sequence for the line containing index
  - lineAtAnyEOL
```
@NotNull
public final T lineAtAnyEOL(int index)
```
    Description copied from interface: IRichSequence
    
    Get the line characters at given index, line delimited by \n, \r or \r\n
    
    Specified by:
    
    lineAtAnyEOL in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index at which to get the line
    
    Returns:
    
    sub-sequence for the line containing index
  - eolEndRange
```
@NotNull
public final Range eolEndRange(int eolEnd)
```
    Description copied from interface: IRichSequence
    
    Return Range of eol at given index
    
    Specified by:
    
    eolEndRange in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    eolEnd - index where the EOL ends, if any, any value can be passed for this argument. If > length of this sequence then it is the same as passing length(), if 0 or less then 0 is returned.
    
    Returns:
    
    range of eol given by index of its end or Range.NULL if no eol ends at index
  - eolStartRange
```
@NotNull
public Range eolStartRange(int eolStart)
```
    Description copied from interface: IRichSequence
    
    Return Range of eol at given index
    
    Specified by:
    
    eolStartRange in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    eolStart - index where the EOL starts, if any, any value can be passed for this argument. If >= length of this sequence then 0 is returned if 0 or less then it is the same as 0
    
    Returns:
    
    range of eol given by index of its end or Range.NULL if no eol starts at index
  - trimEOL
```
@NotNull
public final T trimEOL()
```
    Description copied from interface: IRichSequence
    
    Trim last eol at the end of this sequence,
    
    Specified by:
    
    trimEOL in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    sequence with one EOL trimmed off if it had one
  - trimmedEOL
```
@NotNull
public final T trimmedEOL()
```
    Description copied from interface: IRichSequence
    
    Get Trimmed part by IRichSequence.trimEOL()
    
    Specified by:
    
    trimmedEOL in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    trimmed off EOL if sequence had one or IRichSequence.nullSequence()
  - trimTailBlankLines
```
@NotNull
public final T trimTailBlankLines()
```
    Description copied from interface: IRichSequence
    
    Trim leading trailing blank lines in this sequence
    
    Specified by:
    
    trimTailBlankLines in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    return sequence with trailing blank lines trimmed off
  - trimLeadBlankLines
```
@NotNull
public final T trimLeadBlankLines()
```
    Specified by:
    
    trimLeadBlankLines in interface IRichSequence<T extends IRichSequence<T>>
  - leadingBlankLinesRange
```
@NotNull
public final Range leadingBlankLinesRange()
```
    Specified by:
    
    leadingBlankLinesRange in interface IRichSequence<T extends IRichSequence<T>>
  - leadingBlankLinesRange
```
@NotNull
public final Range leadingBlankLinesRange(int startIndex)
```
    Specified by:
    
    leadingBlankLinesRange in interface IRichSequence<T extends IRichSequence<T>>
  - leadingBlankLinesRange
```
@NotNull
public final Range leadingBlankLinesRange(int fromIndex,
                                          int endIndex)
```
    Specified by:
    
    leadingBlankLinesRange in interface IRichSequence<T extends IRichSequence<T>>
  - trailingBlankLinesRange
```
@NotNull
public final Range trailingBlankLinesRange()
```
    Specified by:
    
    trailingBlankLinesRange in interface IRichSequence<T extends IRichSequence<T>>
  - trailingBlankLinesRange
```
@NotNull
public final Range trailingBlankLinesRange(int fromIndex)
```
    Specified by:
    
    trailingBlankLinesRange in interface IRichSequence<T extends IRichSequence<T>>
  - trailingBlankLinesRange
```
@NotNull
public final Range trailingBlankLinesRange(int startIndex,
                                           int fromIndex)
```
    Specified by:
    
    trailingBlankLinesRange in interface IRichSequence<T extends IRichSequence<T>>
  - trailingBlankLinesRange
```
@NotNull
public final Range trailingBlankLinesRange(CharPredicate eolChars,
                                           int startIndex,
                                           int fromIndex)
```
    Description copied from interface: IRichSequence
    
    Get Range of trailing blank lines at given index offsets in sequence
    
    Specified by:
    
    trailingBlankLinesRange in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    eolChars - characters to consider as EOL, note IRichSequence.eolStartLength(int) should report length of EOL found if length > 1
    
    startIndex - index in sequence from which to start blank line search, also maximum index to include in blank lines range can be any value, if less than 0 it is the same as 0, if greater than length() it is the same as length()
    
    fromIndex - maximum index in sequence to check and include in range of blank lines can be any value, if less than 0 it is the same as 0, if greater than length() it is the same as length()
    
    Returns:
    
    range of blank lines at or before fromIndex and ranging to minimum of startIndex if the range in sequence contains only whitespace characters then the whole range will be returned even if contains no EOL characters
  - leadingBlankLinesRange
```
@NotNull
public final Range leadingBlankLinesRange(@NotNull
                                          CharPredicate eolChars,
                                          int fromIndex,
                                          int endIndex)
```
    Description copied from interface: IRichSequence
    
    Get Range of leading blank lines at given index offsets in sequence
    
    Specified by:
    
    leadingBlankLinesRange in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    eolChars - characters to consider as EOL, note IRichSequence.eolStartLength(int) should report length of EOL found if length > 1
    
    fromIndex - minimum index in sequence to check and include in range of blank lines can be any value, if less than 0 it is the same as 0, if greater than length() it is the same as length()
    
    endIndex - index in sequence from which to start blank line search, also maximum index to include in blank lines range can be any value, if less than 0 it is the same as 0, if greater than length() it is the same as length()
    
    Returns:
    
    range of blank lines at or before fromIndex and ranging to minimum of startIndex, Range.NULL if none found if the range in sequence contains only whitespace characters then the whole range will be returned even if contains no EOL characters
  - blankLinesRemovedRanges
```
@NotNull
public final java.util.List<Range> blankLinesRemovedRanges()
```
    Specified by:
    
    blankLinesRemovedRanges in interface IRichSequence<T extends IRichSequence<T>>
  - blankLinesRemovedRanges
```
@NotNull
public final java.util.List<Range> blankLinesRemovedRanges(int fromIndex)
```
    Specified by:
    
    blankLinesRemovedRanges in interface IRichSequence<T extends IRichSequence<T>>
  - blankLinesRemovedRanges
```
@NotNull
public final java.util.List<Range> blankLinesRemovedRanges(int fromIndex,
                                                           int endIndex)
```
    Specified by:
    
    blankLinesRemovedRanges in interface IRichSequence<T extends IRichSequence<T>>
  - blankLinesRemovedRanges
```
@NotNull
public final java.util.List<Range> blankLinesRemovedRanges(@NotNull
                                                           CharPredicate eolChars,
                                                           int fromIndex,
                                                           int endIndex)
```
    Specified by:
    
    blankLinesRemovedRanges in interface IRichSequence<T extends IRichSequence<T>>
  - trimToEndOfLine
```
@NotNull
public T trimToEndOfLine(boolean includeEol)
```
    Specified by:
    
    trimToEndOfLine in interface IRichSequence<T extends IRichSequence<T>>
  - trimToEndOfLine
```
@NotNull
public T trimToEndOfLine(int index)
```
    Specified by:
    
    trimToEndOfLine in interface IRichSequence<T extends IRichSequence<T>>
  - trimToEndOfLine
```
@NotNull
public T trimToEndOfLine()
```
    Specified by:
    
    trimToEndOfLine in interface IRichSequence<T extends IRichSequence<T>>
  - trimToEndOfLine
```
@NotNull
public T trimToEndOfLine(boolean includeEol,
                         int index)
```
    Specified by:
    
    trimToEndOfLine in interface IRichSequence<T extends IRichSequence<T>>
  - trimToStartOfLine
```
@NotNull
public T trimToStartOfLine(boolean includeEol)
```
    Specified by:
    
    trimToStartOfLine in interface IRichSequence<T extends IRichSequence<T>>
  - trimToStartOfLine
```
@NotNull
public T trimToStartOfLine(int index)
```
    Specified by:
    
    trimToStartOfLine in interface IRichSequence<T extends IRichSequence<T>>
  - trimToStartOfLine
```
@NotNull
public T trimToStartOfLine()
```
    Specified by:
    
    trimToStartOfLine in interface IRichSequence<T extends IRichSequence<T>>
  - trimToStartOfLine
```
@NotNull
public T trimToStartOfLine(boolean includeEol,
                           int index)
```
    Specified by:
    
    trimToStartOfLine in interface IRichSequence<T extends IRichSequence<T>>
  - trimToEndOfLine
```
@NotNull
public T trimToEndOfLine(@NotNull
                         CharPredicate eolChars,
                         boolean includeEol,
                         int index)
```
    Description copied from interface: IRichSequence
    
    Trim end to end of line containing index
    
    Specified by:
    
    trimToEndOfLine in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    eolChars - characters to consider as EOL, note IRichSequence.eolStartLength(int) should report length of EOL found if length > 1
    
    includeEol - true if EOL is to be included in the line
    
    index - index for offset contained by the line can be any value, if less than 0 it is the same as 0, if greater than length() it is the same as length()
    
    Returns:
    
    trimmed version of the sequence to given EOL or the original sequence
  - trimToStartOfLine
```
@NotNull
public T trimToStartOfLine(@NotNull
                           CharPredicate eolChars,
                           boolean includeEol,
                           int index)
```
    Description copied from interface: IRichSequence
    
    Trim start to start of line containing index
    
    Specified by:
    
    trimToStartOfLine in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    eolChars - characters to consider as EOL, note IRichSequence.eolStartLength(int) should report length of EOL found if length > 1
    
    includeEol - true if EOL is to be included in the line
    
    index - index for offset contained by the line can be any value, if less than 0 it is the same as 0, if greater than length() it is the same as length()
    
    Returns:
    
    trimmed version of the sequence to given EOL or the original sequence
  - ifNull
```
@NotNull
public final T ifNull(@NotNull
                      T other)
```
    Description copied from interface: IRichSequence
    
    If this sequence is the nullSequence() instance then returns other, otherwise returns this sequence.
    
    Specified by:
    
    ifNull in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    other - based sequence to return if this is nullSequence()
    
    Returns:
    
    this or other
  - ifNullEmptyAfter
```
@NotNull
public final T ifNullEmptyAfter(@NotNull
                                T other)
```
    Description copied from interface: IRichSequence
    
    If this sequence is the nullSequence() instance then returns an empty subSequence from the end of other, otherwise returns this sequence.
    
    Specified by:
    
    ifNullEmptyAfter in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    other - based sequence from which to take the empty sequence
    
    Returns:
    
    this or other.subSequence(other.length(), other.length())
  - ifNullEmptyBefore
```
@NotNull
public final T ifNullEmptyBefore(@NotNull
                                 T other)
```
    Description copied from interface: IRichSequence
    
    If this sequence is the nullSequence() instance then returns an empty subSequence from the start of other, otherwise returns this sequence.
    
    Specified by:
    
    ifNullEmptyBefore in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    other - based sequence from which to take the empty sequence
    
    Returns:
    
    this or other.subSequence(0, 0)
  - nullIfEmpty
```
@NotNull
public final T nullIfEmpty()
```
    Description copied from interface: IRichSequence
    
    If this sequence is empty return nullSequence() otherwise returns this sequence.
    
    Specified by:
    
    nullIfEmpty in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    this or nullSequence()
  - nullIfBlank
```
@NotNull
public final T nullIfBlank()
```
    Description copied from interface: IRichSequence
    
    If this sequence is blank return nullSequence() otherwise returns this sequence.
    
    Specified by:
    
    nullIfBlank in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    this or nullSequence()
  - nullIf
```
@NotNull
public final T nullIf(boolean condition)
```
    Description copied from interface: IRichSequence
    
    If condition is true return nullSequence() otherwise returns this sequence.
    
    Specified by:
    
    nullIf in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    condition - when true return NULL else this
    
    Returns:
    
    this or nullSequence()
  - nullIfNot
```
@NotNull
public final T nullIfNot(@NotNull
                         java.util.function.BiPredicate<? super T,? super java.lang.CharSequence> predicate,
                         java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfNot in interface IRichSequence<T extends IRichSequence<T>>
  - nullIf
```
@NotNull
public final T nullIf(@NotNull
                      java.util.function.Predicate<? super java.lang.CharSequence> predicate,
                      java.lang.CharSequence... matches)
```
    Description copied from interface: IRichSequence
    
    If predicate returns true for one of given sequences return nullSequence() otherwise returns this sequence.
    
    Specified by:
    
    nullIf in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    predicate - sequence predicate
    
    matches - match sequence list
    
    Returns:
    
    this or nullSequence()
  - nullIfNot
```
@NotNull
public final T nullIfNot(@NotNull
                         java.util.function.Predicate<? super java.lang.CharSequence> predicate,
                         java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfNot in interface IRichSequence<T extends IRichSequence<T>>
  - nullIf
```
@NotNull
public final T nullIf(java.lang.CharSequence... matches)
```
    Description copied from interface: IRichSequence
    
    If this sequence matches one of given sequences return nullSequence() otherwise returns this sequence.
    
    Specified by:
    
    nullIf in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    matches - match sequence list
    
    Returns:
    
    this or nullSequence()
  - nullIfNot
```
@NotNull
public final T nullIfNot(java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfNot in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfStartsWith
```
@NotNull
public final T nullIfStartsWith(java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfStartsWith in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfNotStartsWith
```
@NotNull
public final T nullIfNotStartsWith(java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfNotStartsWith in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfEndsWith
```
@NotNull
public final T nullIfEndsWith(java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfEndsWith in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfNotEndsWith
```
@NotNull
public final T nullIfNotEndsWith(java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfNotEndsWith in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfStartsWithIgnoreCase
```
@NotNull
public final T nullIfStartsWithIgnoreCase(java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfStartsWithIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfNotStartsWithIgnoreCase
```
@NotNull
public final T nullIfNotStartsWithIgnoreCase(java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfNotStartsWithIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfEndsWithIgnoreCase
```
@NotNull
public final T nullIfEndsWithIgnoreCase(java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfEndsWithIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfNotEndsWithIgnoreCase
```
@NotNull
public final T nullIfNotEndsWithIgnoreCase(java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfNotEndsWithIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfStartsWith
```
@NotNull
public final T nullIfStartsWith(boolean ignoreCase,
                                java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfStartsWith in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfNotStartsWith
```
@NotNull
public final T nullIfNotStartsWith(boolean ignoreCase,
                                   java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfNotStartsWith in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfEndsWith
```
@NotNull
public final T nullIfEndsWith(boolean ignoreCase,
                              java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfEndsWith in interface IRichSequence<T extends IRichSequence<T>>
  - nullIfNotEndsWith
```
@NotNull
public final T nullIfNotEndsWith(boolean ignoreCase,
                                 java.lang.CharSequence... matches)
```
    Specified by:
    
    nullIfNotEndsWith in interface IRichSequence<T extends IRichSequence<T>>
  - nullIf
```
@NotNull
public final T nullIf(@NotNull
                      java.util.function.BiPredicate<? super T,? super java.lang.CharSequence> predicate,
                      java.lang.CharSequence... matches)
```
    Description copied from interface: IRichSequence
    
    If predicate returns true for this sequence and one of given sequences return nullSequence() otherwise returns this sequence.
    
    Specified by:
    
    nullIf in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    predicate - bi predicate for test, first argument is always this, second is one of the match sequences
    
    matches - match sequence list
    
    Returns:
    
    this or nullSequence()
  - isNull
```
public final boolean isNull()
```
    Specified by:
    
    isNull in interface IRichSequence<T extends IRichSequence<T>>
  - isNotNull
```
public final boolean isNotNull()
```
    Specified by:
    
    isNotNull in interface IRichSequence<T extends IRichSequence<T>>
  - isEmpty
```
public final boolean isEmpty()
```
    Specified by:
    
    isEmpty in interface IRichSequence<T extends IRichSequence<T>>
  - isBlank
```
public final boolean isBlank()
```
    Specified by:
    
    isBlank in interface IRichSequence<T extends IRichSequence<T>>
  - isNotEmpty
```
public final boolean isNotEmpty()
```
    Specified by:
    
    isNotEmpty in interface IRichSequence<T extends IRichSequence<T>>
  - isNotBlank
```
public final boolean isNotBlank()
```
    Specified by:
    
    isNotBlank in interface IRichSequence<T extends IRichSequence<T>>
  - endsWith
```
public final boolean endsWith(@NotNull
                              java.lang.CharSequence suffix)
```
    Description copied from interface: IRichSequence
    
    test if this sequence ends with given characters
    
    Specified by:
    
    endsWith in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - characters to test
    
    Returns:
    
    true if ends with suffix
  - endsWith
```
public final boolean endsWith(@NotNull
                              java.lang.CharSequence suffix,
                              boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    test if this sequence ends with given characters
    
    Specified by:
    
    endsWith in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - characters to test
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if ends with suffix
  - startsWith
```
public final boolean startsWith(@NotNull
                                java.lang.CharSequence prefix)
```
    Description copied from interface: IRichSequence
    
    test if this sequence starts with given characters
    
    Specified by:
    
    startsWith in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - characters to test
    
    Returns:
    
    true if starts with prefix
  - startsWith
```
public final boolean startsWith(@NotNull
                                java.lang.CharSequence prefix,
                                boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    test if this sequence starts with given characters
    
    Specified by:
    
    startsWith in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - characters to test
    
    ignoreCase - case ignored when true
    
    Returns:
    
    true if starts with prefix
  - endsWith
```
public final boolean endsWith(@NotNull
                              CharPredicate chars)
```
    Specified by:
    
    endsWith in interface IRichSequence<T extends IRichSequence<T>>
  - startsWith
```
public final boolean startsWith(@NotNull
                                CharPredicate chars)
```
    Specified by:
    
    startsWith in interface IRichSequence<T extends IRichSequence<T>>
  - endsWithEOL
```
public final boolean endsWithEOL()
```
    Specified by:
    
    endsWithEOL in interface IRichSequence<T extends IRichSequence<T>>
  - endsWithAnyEOL
```
public final boolean endsWithAnyEOL()
```
    Specified by:
    
    endsWithAnyEOL in interface IRichSequence<T extends IRichSequence<T>>
  - endsWithSpace
```
public final boolean endsWithSpace()
```
    Specified by:
    
    endsWithSpace in interface IRichSequence<T extends IRichSequence<T>>
  - endsWithSpaceTab
```
public final boolean endsWithSpaceTab()
```
    Specified by:
    
    endsWithSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - endsWithWhitespace
```
public final boolean endsWithWhitespace()
```
    Specified by:
    
    endsWithWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - startsWithEOL
```
public final boolean startsWithEOL()
```
    Specified by:
    
    startsWithEOL in interface IRichSequence<T extends IRichSequence<T>>
  - startsWithAnyEOL
```
public final boolean startsWithAnyEOL()
```
    Specified by:
    
    startsWithAnyEOL in interface IRichSequence<T extends IRichSequence<T>>
  - startsWithSpace
```
public final boolean startsWithSpace()
```
    Specified by:
    
    startsWithSpace in interface IRichSequence<T extends IRichSequence<T>>
  - startsWithSpaceTab
```
public final boolean startsWithSpaceTab()
```
    Specified by:
    
    startsWithSpaceTab in interface IRichSequence<T extends IRichSequence<T>>
  - startsWithWhitespace
```
public final boolean startsWithWhitespace()
```
    Specified by:
    
    startsWithWhitespace in interface IRichSequence<T extends IRichSequence<T>>
  - removeSuffix
```
@NotNull
public final T removeSuffix(@NotNull
                            java.lang.CharSequence suffix)
```
    Description copied from interface: IRichSequence
    
    Remove suffix if present
    
    Specified by:
    
    removeSuffix in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removePrefix
```
@NotNull
public final T removePrefix(@NotNull
                            java.lang.CharSequence prefix)
```
    Description copied from interface: IRichSequence
    
    Remove prefix if present
    
    Specified by:
    
    removePrefix in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperSuffix
```
@NotNull
public final T removeProperSuffix(@NotNull
                                  java.lang.CharSequence suffix)
```
    Description copied from interface: IRichSequence
    
    Remove suffix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperSuffix in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperPrefix
```
@NotNull
public final T removeProperPrefix(@NotNull
                                  java.lang.CharSequence prefix)
```
    Description copied from interface: IRichSequence
    
    Remove prefix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperPrefix in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - endsWithIgnoreCase
```
public final boolean endsWithIgnoreCase(@NotNull
                                        java.lang.CharSequence suffix)
```
    Description copied from interface: IRichSequence
    
    test if this sequence ends with given characters, ignoring case differences
    
    Specified by:
    
    endsWithIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - characters to test
    
    Returns:
    
    true if ends with suffix
  - startsWithIgnoreCase
```
public final boolean startsWithIgnoreCase(@NotNull
                                          java.lang.CharSequence prefix)
```
    Description copied from interface: IRichSequence
    
    test if this sequence starts with given characters, ignoring case differences
    
    Specified by:
    
    startsWithIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - characters to test
    
    Returns:
    
    true if starts with prefix
  - removeSuffixIgnoreCase
```
@NotNull
public final T removeSuffixIgnoreCase(@NotNull
                                      java.lang.CharSequence suffix)
```
    Description copied from interface: IRichSequence
    
    Remove suffix if present, ignoring case differences
    
    Specified by:
    
    removeSuffixIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removePrefixIgnoreCase
```
@NotNull
public final T removePrefixIgnoreCase(@NotNull
                                      java.lang.CharSequence prefix)
```
    Description copied from interface: IRichSequence
    
    Remove prefix if present, ignoring case differences
    
    Specified by:
    
    removePrefixIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperSuffixIgnoreCase
```
@NotNull
public final T removeProperSuffixIgnoreCase(@NotNull
                                            java.lang.CharSequence suffix)
```
    Description copied from interface: IRichSequence
    
    Remove suffix if present but only if this sequence is longer than the suffix, ignoring case differences
    
    Specified by:
    
    removeProperSuffixIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperPrefixIgnoreCase
```
@NotNull
public final T removeProperPrefixIgnoreCase(@NotNull
                                            java.lang.CharSequence prefix)
```
    Description copied from interface: IRichSequence
    
    Remove prefix if present but only if this sequence is longer than the suffix, ignoring case differences
    
    Specified by:
    
    removeProperPrefixIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeSuffix
```
@NotNull
public final T removeSuffix(@NotNull
                            java.lang.CharSequence suffix,
                            boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    Remove suffix if present
    
    Specified by:
    
    removeSuffix in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removePrefix
```
@NotNull
public final T removePrefix(@NotNull
                            java.lang.CharSequence prefix,
                            boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    Remove prefix if present
    
    Specified by:
    
    removePrefix in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - removeProperSuffix
```
@NotNull
public final T removeProperSuffix(@NotNull
                                  java.lang.CharSequence suffix,
                                  boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    Remove suffix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperSuffix in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with suffix removed, or same sequence if no suffix was present
  - removeProperPrefix
```
@NotNull
public final T removeProperPrefix(@NotNull
                                  java.lang.CharSequence prefix,
                                  boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    Remove prefix if present but only if this sequence is longer than the suffix
    
    Specified by:
    
    removeProperPrefix in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - characters to remove
    
    ignoreCase - case ignored when true
    
    Returns:
    
    sequence with prefix removed, or same sequence if no prefix was present
  - insert
```
@NotNull
public T insert(int index,
                @NotNull
                java.lang.CharSequence chars)
```
    Description copied from interface: IRichSequence
    
    Insert char sequence at given index
    
    Specified by:
    
    insert in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index of insertion. if >length of this sequence then same as length, if <0 then same as 0
    
    chars - char sequence to insert
    
    Returns:
    
    resulting sequence based sequence implementation may throw an IllegalArgumentException if inserting another based sequence out of order based on offsets
  - delete
```
@NotNull
public T delete(int startIndex,
                int endIndex)
```
    Description copied from interface: IRichSequence
    
    Delete range in sequence
    
    Specified by:
    
    delete in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    startIndex - start index of deletion
    
    endIndex - end index, not inclusive, of insertion
    
    Returns:
    
    resulting sequence
  - toLowerCase
```
@NotNull
public final T toLowerCase()
```
    Description copied from interface: IRichSequence
    
    Map characters of this sequence to: Uppercase, Lowercase or use custom mapping
    
    Specified by:
    
    toLowerCase in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    lowercase version of sequence
  - toUpperCase
```
@NotNull
public final T toUpperCase()
```
    Specified by:
    
    toUpperCase in interface IRichSequence<T extends IRichSequence<T>>
  - toNbSp
```
@NotNull
public final T toNbSp()
```
    Description copied from interface: IRichSequence
    
    Map spaces to non break spaces
    
    Specified by:
    
    toNbSp in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    mapped sequence with spc changed to NbSp
  - toSpc
```
@NotNull
public final T toSpc()
```
    Description copied from interface: IRichSequence
    
    Map non break spaces to spaces
    
    Specified by:
    
    toSpc in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    mapped sequence with NbSp changed to spc
  - matches
```
public final boolean matches(@NotNull
                             java.lang.CharSequence chars,
                             boolean ignoreCase)
```
    Specified by:
    
    matches in interface IRichSequence<T extends IRichSequence<T>>
  - matches
```
public final boolean matches(@NotNull
                             java.lang.CharSequence chars)
```
    Description copied from interface: IRichSequence
    
    Test the sequence for a match to another CharSequence
    
    Specified by:
    
    matches in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if match
  - matchesIgnoreCase
```
public final boolean matchesIgnoreCase(@NotNull
                                       java.lang.CharSequence chars)
```
    Specified by:
    
    matchesIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - matchChars
```
public final boolean matchChars(@NotNull
                                java.lang.CharSequence chars,
                                int startIndex,
                                boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchChars in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    startIndex - index from which to start the match
    
    ignoreCase - if true match ignoring case differences
    
    Returns:
    
    true if characters at the start index of this sequence match
  - matchChars
```
public final boolean matchChars(@NotNull
                                java.lang.CharSequence chars,
                                int startIndex)
```
    Specified by:
    
    matchChars in interface IRichSequence<T extends IRichSequence<T>>
  - matchCharsIgnoreCase
```
public final boolean matchCharsIgnoreCase(@NotNull
                                          java.lang.CharSequence chars,
                                          int startIndex)
```
    Specified by:
    
    matchCharsIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - matchChars
```
public final boolean matchChars(@NotNull
                                java.lang.CharSequence chars,
                                boolean ignoreCase)
```
    Specified by:
    
    matchChars in interface IRichSequence<T extends IRichSequence<T>>
  - matchChars
```
public final boolean matchChars(@NotNull
                                java.lang.CharSequence chars)
```
    Description copied from interface: IRichSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchChars in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    Returns:
    
    true if characters at the start of this sequence match
  - matchCharsIgnoreCase
```
public final boolean matchCharsIgnoreCase(@NotNull
                                          java.lang.CharSequence chars)
```
    Specified by:
    
    matchCharsIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - matchCharsReversed
```
public final boolean matchCharsReversed(@NotNull
                                        java.lang.CharSequence chars,
                                        int endIndex,
                                        boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    Test the sequence portion for a match to another CharSequence, reverse order
    
    Specified by:
    
    matchCharsReversed in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    endIndex - index from which to start the match and proceed to 0
    
    ignoreCase - if true match ignoring case differences
    
    Returns:
    
    true if characters at the start index of this sequence match
  - matchCharsReversed
```
public final boolean matchCharsReversed(@NotNull
                                        java.lang.CharSequence chars,
                                        int endIndex)
```
    Specified by:
    
    matchCharsReversed in interface IRichSequence<T extends IRichSequence<T>>
  - matchCharsReversedIgnoreCase
```
public final boolean matchCharsReversedIgnoreCase(@NotNull
                                                  java.lang.CharSequence chars,
                                                  int endIndex)
```
    Specified by:
    
    matchCharsReversedIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCount
```
public final int matchedCharCount(@NotNull
                                  java.lang.CharSequence chars,
                                  int startIndex,
                                  int endIndex,
                                  boolean ignoreCase)
```
    Specified by:
    
    matchedCharCount in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCount
```
public final int matchedCharCount(@NotNull
                                  java.lang.CharSequence chars,
                                  int startIndex,
                                  boolean ignoreCase)
```
    Specified by:
    
    matchedCharCount in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCount
```
public final int matchedCharCount(@NotNull
                                  java.lang.CharSequence chars,
                                  int startIndex,
                                  int endIndex)
```
    Specified by:
    
    matchedCharCount in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCount
```
public final int matchedCharCount(@NotNull
                                  java.lang.CharSequence chars,
                                  int startIndex)
```
    Specified by:
    
    matchedCharCount in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCountIgnoreCase
```
public final int matchedCharCountIgnoreCase(@NotNull
                                            java.lang.CharSequence chars,
                                            int startIndex)
```
    Specified by:
    
    matchedCharCountIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCountIgnoreCase
```
public final int matchedCharCountIgnoreCase(@NotNull
                                            java.lang.CharSequence chars,
                                            int startIndex,
                                            int endIndex)
```
    Specified by:
    
    matchedCharCountIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCountReversedIgnoreCase
```
public final int matchedCharCountReversedIgnoreCase(@NotNull
                                                    java.lang.CharSequence chars,
                                                    int startIndex,
                                                    int fromIndex)
```
    Specified by:
    
    matchedCharCountReversedIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCountReversed
```
public final int matchedCharCountReversed(@NotNull
                                          java.lang.CharSequence chars,
                                          int startIndex,
                                          int fromIndex)
```
    Specified by:
    
    matchedCharCountReversed in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCountReversed
```
public final int matchedCharCountReversed(@NotNull
                                          java.lang.CharSequence chars,
                                          int fromIndex,
                                          boolean ignoreCase)
```
    Specified by:
    
    matchedCharCountReversed in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCountReversed
```
public final int matchedCharCountReversed(@NotNull
                                          java.lang.CharSequence chars,
                                          int fromIndex)
```
    Specified by:
    
    matchedCharCountReversed in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCountReversedIgnoreCase
```
public final int matchedCharCountReversedIgnoreCase(@NotNull
                                                    java.lang.CharSequence chars,
                                                    int fromIndex)
```
    Specified by:
    
    matchedCharCountReversedIgnoreCase in interface IRichSequence<T extends IRichSequence<T>>
  - matchedCharCount
```
public final int matchedCharCount(@NotNull
                                  java.lang.CharSequence chars,
                                  int startIndex,
                                  int endIndex,
                                  boolean fullMatchOnly,
                                  boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    Test the sequence portion for a match to another CharSequence
    
    Specified by:
    
    matchedCharCount in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    startIndex - index from which to start the match
    
    endIndex - index at which to end the matching
    
    fullMatchOnly - if true will do quick fail if length of chars is longer than characters after startIndex in this sequence
    
    ignoreCase - if true match ignoring case differences
    
    Returns:
    
    count of characters at the start index of this sequence matching corresponding characters in chars
  - matchedCharCountReversed
```
public final int matchedCharCountReversed(@NotNull
                                          java.lang.CharSequence chars,
                                          int startIndex,
                                          int fromIndex,
                                          boolean ignoreCase)
```
    Description copied from interface: IRichSequence
    
    Test the sequence portion for a match to another CharSequence, equivalent to taking this.subSequence(startIndex, fromIndex) and then count matching chars going from end of both sequences
    
    Specified by:
    
    matchedCharCountReversed in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    chars - characters to match against
    
    startIndex - index at which to stop the match
    
    fromIndex - index from which to start the match, not inclusive, matching starts at fromIndex-1 and proceeds towards 0
    
    ignoreCase - if true match ignoring case differences
    
    Returns:
    
    count of characters at the from index of this sequence matching corresponding characters in chars in reverse order
  - toString
```
@NotNull
public java.lang.String toString()
```
    Specified by:
    
    toString in interface java.lang.CharSequence
    
    Overrides:
    
    toString in class java.lang.Object
  - normalizeEOL
```
@NotNull
public final java.lang.String normalizeEOL()
```
    Description copied from interface: IRichSequence
    
    replace any \r\n and \r by \n
    
    Specified by:
    
    normalizeEOL in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    string with only \n for line separators
  - normalizeEndWithEOL
```
@NotNull
public final java.lang.String normalizeEndWithEOL()
```
    Description copied from interface: IRichSequence
    
    replace any \r\n and \r by \n, append terminating EOL if one is not present
    
    Specified by:
    
    normalizeEndWithEOL in interface IRichSequence<T extends IRichSequence<T>>
    
    Returns:
    
    string with only \n for line separators and terminated by \n
  - toVisibleWhitespaceString
```
@NotNull
public final java.lang.String toVisibleWhitespaceString()
```
    Specified by:
    
    toVisibleWhitespaceString in interface IRichSequence<T extends IRichSequence<T>>
  - splitList
```
@NotNull
public final java.util.List<T> splitList(@NotNull
                                         java.lang.CharSequence delimiter)
```
    Specified by:
    
    splitList in interface IRichSequence<T extends IRichSequence<T>>
  - splitList
```
@NotNull
public final java.util.List<T> splitList(@NotNull
                                         java.lang.CharSequence delimiter,
                                         int limit,
                                         boolean includeDelims,
                                         @Nullable
                                         CharPredicate trimChars)
```
    Description copied from interface: IRichSequence
    
    Split helpers based on delimiter character sets contained in CharPredicate
    
    Specified by:
    
    splitList in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    delimiter - sequence of chars on which to split this sequence
    
    limit - max number of segments to split
    
    includeDelims - if true include delimiters as part of split item
    
    trimChars - set of characters that should be used for trimming individual split results
    
    Returns:
    
    List of split results
  - splitList
```
@NotNull
public final java.util.List<T> splitList(@NotNull
                                         java.lang.CharSequence delimiter,
                                         int limit,
                                         int flags)
```
    Specified by:
    
    splitList in interface IRichSequence<T extends IRichSequence<T>>
  - splitList
```
@NotNull
public final java.util.List<T> splitList(@NotNull
                                         java.lang.CharSequence delimiter,
                                         boolean includeDelims,
                                         @Nullable
                                         CharPredicate trimChars)
```
    Specified by:
    
    splitList in interface IRichSequence<T extends IRichSequence<T>>
  - splitListEOL
```
@NotNull
public final java.util.List<T> splitListEOL()
```
    Specified by:
    
    splitListEOL in interface IRichSequence<T extends IRichSequence<T>>
  - splitListEOL
```
@NotNull
public final java.util.List<T> splitListEOL(boolean includeDelims)
```
    Specified by:
    
    splitListEOL in interface IRichSequence<T extends IRichSequence<T>>
  - splitListEOL
```
@NotNull
public final java.util.List<T> splitListEOL(boolean includeDelims,
                                            @Nullable
                                            CharPredicate trimChars)
```
    Specified by:
    
    splitListEOL in interface IRichSequence<T extends IRichSequence<T>>
  - splitList
```
@NotNull
public final java.util.List<T> splitList(@NotNull
                                         java.lang.CharSequence delimiter,
                                         int limit,
                                         int flags,
                                         @Nullable
                                         CharPredicate trimChars)
```
    Description copied from interface: IRichSequence
    
    Split helpers based on delimiter character sets contained in CharSequence
    
    Specified by:
    
    splitList in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    delimiter - delimiter char sequence to use for splitting
    
    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, if trimChars is not null or empty then this flag is turned on automatically 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
  - splitEOL
```
@NotNull
public final T[] splitEOL()
```
    Specified by:
    
    splitEOL in interface IRichSequence<T extends IRichSequence<T>>
  - splitEOL
```
@NotNull
public final T[] splitEOL(boolean includeDelims)
```
    Specified by:
    
    splitEOL in interface IRichSequence<T extends IRichSequence<T>>
  - split
```
@NotNull
public final T[] split(@NotNull
                       java.lang.CharSequence delimiter,
                       boolean includeDelims,
                       @Nullable
                       CharPredicate trimChars)
```
    Specified by:
    
    split in interface IRichSequence<T extends IRichSequence<T>>
  - split
```
@NotNull
public final T[] split(@NotNull
                       java.lang.CharSequence delimiter)
```
    Specified by:
    
    split in interface IRichSequence<T extends IRichSequence<T>>
  - split
```
@NotNull
public final T[] split(@NotNull
                       java.lang.CharSequence delimiter,
                       int limit,
                       boolean includeDelims,
                       @Nullable
                       CharPredicate trimChars)
```
    Specified by:
    
    split in interface IRichSequence<T extends IRichSequence<T>>
  - split
```
@NotNull
public final T[] split(@NotNull
                       java.lang.CharSequence delimiter,
                       int limit,
                       int flags)
```
    Specified by:
    
    split in interface IRichSequence<T extends IRichSequence<T>>
  - split
```
@NotNull
public final T[] split(@NotNull
                       java.lang.CharSequence delimiter,
                       int limit,
                       int flags,
                       @Nullable
                       CharPredicate trimChars)
```
    Specified by:
    
    split in interface IRichSequence<T extends IRichSequence<T>>
  - appendTo
```
@NotNull
public final T appendTo(@NotNull
                        java.lang.StringBuilder out,
                        @Nullable
                        CharMapper charMapper)
```
    Specified by:
    
    appendTo in interface IRichSequence<T extends IRichSequence<T>>
  - appendTo
```
@NotNull
public final T appendTo(@NotNull
                        java.lang.StringBuilder out,
                        @Nullable
                        CharMapper charMapper,
                        int startIndex)
```
    Specified by:
    
    appendTo in interface IRichSequence<T extends IRichSequence<T>>
  - appendTo
```
@NotNull
public final T appendTo(@NotNull
                        java.lang.StringBuilder out)
```
    Specified by:
    
    appendTo in interface IRichSequence<T extends IRichSequence<T>>
  - appendTo
```
@NotNull
public final T appendTo(@NotNull
                        java.lang.StringBuilder out,
                        int startIndex)
```
    Specified by:
    
    appendTo in interface IRichSequence<T extends IRichSequence<T>>
  - appendTo
```
@NotNull
public final T appendTo(@NotNull
                        java.lang.StringBuilder out,
                        int startIndex,
                        int endIndex)
```
    Specified by:
    
    appendTo in interface IRichSequence<T extends IRichSequence<T>>
  - appendTo
```
@NotNull
public final T appendTo(@NotNull
                        java.lang.StringBuilder out,
                        @Nullable
                        CharMapper charMapper,
                        int startIndex,
                        int endIndex)
```
    Description copied from interface: IRichSequence
    
    Append helpers
    
    Specified by:
    
    appendTo in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    out - string builder
    
    charMapper - mapping to use for output or null if none
    
    startIndex - start index
    
    endIndex - end index
    
    Returns:
    
    this
  - appendRangesTo
```
@NotNull
public final T appendRangesTo(@NotNull
                              java.lang.StringBuilder out,
                              @Nullable
                              CharMapper charMapper,
                              Range... ranges)
```
    Description copied from interface: IRichSequence
    
    Append given ranges of this sequence to string builder
    
    Specified by:
    
    appendRangesTo in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    out - string builder to append to
    
    charMapper - mapping to use for output or null if none
    
    ranges - ranges to append, null range or one for which range.isNull() is true ranges are skipped
    
    Returns:
    
    this
  - appendRangesTo
```
@NotNull
public final T appendRangesTo(@NotNull
                              java.lang.StringBuilder out,
                              Range... ranges)
```
    Specified by:
    
    appendRangesTo in interface IRichSequence<T extends IRichSequence<T>>
  - appendRangesTo
```
@NotNull
public final T appendRangesTo(@NotNull
                              java.lang.StringBuilder out,
                              java.lang.Iterable<? extends Range> ranges)
```
    Specified by:
    
    appendRangesTo in interface IRichSequence<T extends IRichSequence<T>>
  - appendRangesTo
```
@NotNull
public final T appendRangesTo(@NotNull
                              java.lang.StringBuilder out,
                              @Nullable
                              CharMapper charMapper,
                              java.lang.Iterable<? extends Range> ranges)
```
    Specified by:
    
    appendRangesTo in interface IRichSequence<T extends IRichSequence<T>>
  - indexOfAll
```
@NotNull
public final int[] indexOfAll(@NotNull
                              java.lang.CharSequence s)
```
    Description copied from interface: IRichSequence
    
    Get indices of all occurrences of a sequence
    
    Specified by:
    
    indexOfAll in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    s - sequence whose indices to find
    
    Returns:
    
    array of indices
  - appendEOL
```
@NotNull
public final T appendEOL()
```
    Specified by:
    
    appendEOL in interface IRichSequence<T extends IRichSequence<T>>
  - suffixWithEOL
```
@NotNull
public final T suffixWithEOL()
```
    Specified by:
    
    suffixWithEOL in interface IRichSequence<T extends IRichSequence<T>>
  - prefixWithEOL
```
@NotNull
public final T prefixWithEOL()
```
    Specified by:
    
    prefixWithEOL in interface IRichSequence<T extends IRichSequence<T>>
  - prefixOnceWithEOL
```
@NotNull
public final T prefixOnceWithEOL()
```
    Specified by:
    
    prefixOnceWithEOL in interface IRichSequence<T extends IRichSequence<T>>
  - suffixOnceWithEOL
```
@NotNull
public final T suffixOnceWithEOL()
```
    Specified by:
    
    suffixOnceWithEOL in interface IRichSequence<T extends IRichSequence<T>>
  - appendSpace
```
@NotNull
public final T appendSpace()
```
    Specified by:
    
    appendSpace in interface IRichSequence<T extends IRichSequence<T>>
  - suffixWithSpace
```
@NotNull
public final T suffixWithSpace()
```
    Specified by:
    
    suffixWithSpace in interface IRichSequence<T extends IRichSequence<T>>
  - prefixWithSpace
```
@NotNull
public final T prefixWithSpace()
```
    Specified by:
    
    prefixWithSpace in interface IRichSequence<T extends IRichSequence<T>>
  - appendSpaces
```
@NotNull
public final T appendSpaces(int count)
```
    Specified by:
    
    appendSpaces in interface IRichSequence<T extends IRichSequence<T>>
  - suffixWithSpaces
```
@NotNull
public final T suffixWithSpaces(int count)
```
    Specified by:
    
    suffixWithSpaces in interface IRichSequence<T extends IRichSequence<T>>
  - prefixWithSpaces
```
@NotNull
public final T prefixWithSpaces(int count)
```
    Specified by:
    
    prefixWithSpaces in interface IRichSequence<T extends IRichSequence<T>>
  - prefixOnceWithSpace
```
@NotNull
public final T prefixOnceWithSpace()
```
    Specified by:
    
    prefixOnceWithSpace in interface IRichSequence<T extends IRichSequence<T>>
  - suffixOnceWithSpace
```
@NotNull
public final T suffixOnceWithSpace()
```
    Specified by:
    
    suffixOnceWithSpace in interface IRichSequence<T extends IRichSequence<T>>
  - prefixWith
```
@NotNull
public T prefixWith(@Nullable
                    java.lang.CharSequence prefix)
```
    Description copied from interface: IRichSequence
    
    Prefix this sequence with a char sequence
    
    Specified by:
    
    prefixWith in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - char sequence
    
    Returns:
    
    resulting sequence
  - suffixWith
```
@NotNull
public T suffixWith(@Nullable
                    java.lang.CharSequence suffix)
```
    Description copied from interface: IRichSequence
    
    Prefix this sequence with a char sequence
    
    Specified by:
    
    suffixWith in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - char sequence
    
    Returns:
    
    resulting sequence
  - prefixOnceWith
```
@NotNull
public final T prefixOnceWith(@Nullable
                              java.lang.CharSequence prefix)
```
    Description copied from interface: IRichSequence
    
    Prefix this sequence with a char sequence if not already starting with prefix
    
    Specified by:
    
    prefixOnceWith in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    prefix - char sequence
    
    Returns:
    
    resulting sequence
  - suffixOnceWith
```
@NotNull
public final T suffixOnceWith(@Nullable
                              java.lang.CharSequence suffix)
```
    Description copied from interface: IRichSequence
    
    Suffix this sequence with a char sequence if not already ending with suffix
    
    Specified by:
    
    suffixOnceWith in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    suffix - char sequence
    
    Returns:
    
    resulting sequence
  - replace
```
@NotNull
public final T replace(int startIndex,
                       int endIndex,
                       @NotNull
                       java.lang.CharSequence replacement)
```
    Description copied from interface: IRichSequence
    
    Replace part of the sequence with a char sequence
    
    Specified by:
    
    replace in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    startIndex - start index of replaced part
    
    endIndex - end index of replaced part
    
    replacement - char sequence
    
    Returns:
    
    resulting sequence
  - replace
```
@NotNull
public final T replace(@NotNull
                       java.lang.CharSequence find,
                       @NotNull
                       java.lang.CharSequence replace)
```
    Description copied from interface: IRichSequence
    
    Replace all occurrences of one sequence with another
    
    Specified by:
    
    replace in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    find - sequence to find
    
    replace - replacement sequence
    
    Returns:
    
    array of indices
  - append
```
@NotNull
public final T append(java.lang.CharSequence... sequences)
```
    Description copied from interface: IRichSequence
    
    Concatenate this sequence and list of others, returning sequence of result
    
    Specified by:
    
    append in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    sequences - list of char sequences to append to this sequence, null sequences are skipped
    
    Returns:
    
    appended sequence
  - append
```
@NotNull
public final T append(java.lang.Iterable<? extends java.lang.CharSequence> sequences)
```
    Specified by:
    
    append in interface IRichSequence<T extends IRichSequence<T>>
  - extractRanges
```
@NotNull
public final T extractRanges(Range... ranges)
```
    Description copied from interface: IRichSequence
    
    Build a sequence of ranges in this sequence
    NOTE: BasedSequence ranges must be non-overlapping and ordered by startOffset or IllegalArgumentException will be thrown
    
    Specified by:
    
    extractRanges in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    ranges - ranges to extract
    
    Returns:
    
    resulting sequence
  - extractRanges
```
@NotNull
public final T extractRanges(java.lang.Iterable<Range> ranges)
```
    Specified by:
    
    extractRanges in interface IRichSequence<T extends IRichSequence<T>>
  - columnAtIndex
```
public final int columnAtIndex(int index)
```
    Specified by:
    
    columnAtIndex in interface IRichSequence<T extends IRichSequence<T>>
  - lineColumnAtIndex
```
@NotNull
public final Pair<java.lang.Integer,java.lang.Integer> lineColumnAtIndex(int index)
```
    Description copied from interface: IRichSequence
    
    Get the line and column information from index into sequence
    
    Specified by:
    
    lineColumnAtIndex in interface IRichSequence<T extends IRichSequence<T>>
    
    Parameters:
    
    index - index for which to get line information
    
    Returns:
    
    Pair(line, column) where line and column are 0 based, throws IllegalArgumentException if index < 0 or > length.
  - isIn
```
public boolean isIn(@NotNull
                    java.lang.String[] texts)
```
    Specified by:
    
    isIn in interface IRichSequence<T extends IRichSequence<T>>
  - isIn
```
public boolean isIn(@NotNull
                    java.util.Collection<? extends java.lang.CharSequence> texts)
```
    Specified by:
    
    isIn in interface IRichSequence<T extends IRichSequence<T>>

Class IRichSequenceBase<T extends IRichSequence<T>>

Field Summary

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface java.lang.CharSequence

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

Constructor Detail

IRichSequenceBase

Method Detail

equals

hashCode

equalsIgnoreCase

equals

compareTo

sequenceOf

sequenceOf

subSequence

subSequence

subSequenceBefore

subSequenceAfter

subSequenceBeforeAfter

endSequence

endSequence

endCharAt

midSequence

midSequence

midCharAt

lastChar

firstChar

validateIndex

validateIndexInclusiveEnd

validateStartEnd

safeCharAt

safeSubSequence

safeSubSequence

isCharAt

toStringOrNull

indexOf

indexOf

indexOf

indexOf

indexOf

indexOfAny

indexOfAny

indexOfAnyNot

indexOfAnyNot

indexOfAnyNot

indexOfNot

indexOfNot

lastIndexOf

lastIndexOf

lastIndexOfNot

lastIndexOfNot

lastIndexOf

lastIndexOf

lastIndexOfAny

lastIndexOfAny

lastIndexOfAnyNot

lastIndexOfAnyNot

lastIndexOfAnyNot

indexOf

indexOfNot

indexOfAny

lastIndexOf

lastIndexOf

lastIndexOfNot

lastIndexOfAny

countOfSpaceTab

countOfNotSpaceTab

countOfWhitespace

countOfNotWhitespace

countOfAny

countOfAny

countOfAnyNot

countOfAnyNot

countOfAny

countOfAnyNot

countLeading