IRichSequence (flexmark-java sequence utilities 0.62.2 API)

All Superinterfaces:

CharSequence, Comparable<CharSequence>, SequenceUtils

All Known Subinterfaces:

BasedSequence, ReplacedBasedSequence, RichSequence

All Known Implementing Classes:

BasedSequence.EmptyBasedSequence, BasedSequenceImpl, CharSubSequence, IRichSequenceBase, MappedBasedSequence, MappedRichSequence, PrefixedSubSequence, RichSequenceImpl, SegmentedSequence, SegmentedSequenceFull, SegmentedSequenceTree, SubSequence
```
public interface IRichSequence<T extends IRichSequence<T>>
extends CharSequence, Comparable<CharSequence>, SequenceUtils
```
A CharSequence that provides a rich set of manipulation methods.
NOTE: '\0' changed to '�' use NullEncoder.decodeNull mapper to get original null chars.
safe access methods return '\0' for no char response.

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

Method Summary

All Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`T`	`append(CharSequence... sequences)` Concatenate this sequence and list of others, returning sequence of result
`T`	`append(Iterable<? extends CharSequence> sequences)`
`T`	`appendEOL()`
`T`	`appendRangesTo(@NotNull StringBuilder out, @Nullable CharMapper charMapper, Iterable<? extends Range> ranges)`
`T`	`appendRangesTo(@NotNull StringBuilder out, @Nullable CharMapper charMapper, Range... ranges)` Append given ranges of this sequence to string builder
`T`	`appendRangesTo(@NotNull StringBuilder out, Iterable<? extends Range> ranges)`
`T`	`appendRangesTo(@NotNull StringBuilder out, Range... ranges)`
`T`	`appendSpace()`
`T`	`appendSpaces(int count)`
`T`	`appendTo(@NotNull StringBuilder out)`
`T`	`appendTo(@NotNull StringBuilder out, @Nullable CharMapper charMapper)`
`T`	`appendTo(@NotNull StringBuilder out, @Nullable CharMapper charMapper, int startIndex)`
`T`	`appendTo(@NotNull StringBuilder out, @Nullable CharMapper charMapper, int startIndex, int endIndex)` Append helpers
`T`	`appendTo(@NotNull StringBuilder out, int startIndex)`
`T`	`appendTo(@NotNull StringBuilder out, int startIndex, int endIndex)`
`@NotNull List<Range>`	`blankLinesRemovedRanges()`
`@NotNull List<Range>`	`blankLinesRemovedRanges(@NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars, int fromIndex, int endIndex)`
`@NotNull List<Range>`	`blankLinesRemovedRanges(int fromIndex)`
`@NotNull List<Range>`	`blankLinesRemovedRanges(int fromIndex, int endIndex)`
`int`	`columnAtIndex(int index)`
`default int`	`countLeading()` Deprecated.
`default int`	`countLeading(char c)` Deprecated. consider using built-in sets of characters, ..._SET, or Use CharPredicate.anyOf(...)
`int`	`countLeading(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)` Count leading/trailing characters of this sequence
`int`	`countLeading(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex)`
`int`	`countLeading(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex, int endIndex)`
`int`	`countLeadingColumns(int startColumn, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)` Count column of indent given by chars in the set in this sequence, expanding tabs to 4th column
`int`	`countLeadingNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`int`	`countLeadingNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex)`
`int`	`countLeadingNot(@NotNull com.vladsch.flexmark.util.misc.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)`
`default int`	`countOf(char c)` Deprecated.
`int`	`countOfAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`int`	`countOfAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex)`
`int`	`countOfAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex, int endIndex)`
`int`	`countOfAnyNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`int`	`countOfAnyNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex)`
`int`	`countOfAnyNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex, int endIndex)`
`int`	`countOfNotSpaceTab()`
`int`	`countOfNotWhitespace()`
`int`	`countOfSpaceTab()`
`int`	`countOfWhitespace()`
`default int`	`countTrailing()` Deprecated.
`int`	`countTrailing(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`int`	`countTrailing(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex)`
`int`	`countTrailing(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex, int endIndex)`
`int`	`countTrailingNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`int`	`countTrailingNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex)`
`int`	`countTrailingNot(@NotNull com.vladsch.flexmark.util.misc.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
`T[]`	`emptyArray()`
`char`	`endCharAt(int index)` Convenience method to get characters offset from end of sequence.
`int`	`endOfDelimitedBy(@NotNull CharSequence s, int index)` Find start/end region in this sequence delimited by any characters in argument or the CharSequence
`int`	`endOfDelimitedByAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int index)`
`int`	`endOfDelimitedByAnyNot(@NotNull com.vladsch.flexmark.util.misc.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(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`boolean`	`endsWith(@NotNull CharSequence suffix)` test if this sequence ends with given characters
`boolean`	`endsWith(@NotNull CharSequence suffix, boolean ignoreCase)` test if this sequence ends with given characters
`boolean`	`endsWithAnyEOL()`
`boolean`	`endsWithEOL()`
`boolean`	`endsWithIgnoreCase(@NotNull 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.
`@NotNull Range`	`eolEndRange(int eolEnd)` Return Range of eol at given index
`default int`	`eolLength(int eolStart)` Deprecated.
`default int`	`eolStartLength()` Deprecated.
`int`	`eolStartLength(int eolStart)` Get the length of EOL character at the given index of this sequence, if present.
`@NotNull Range`	`eolStartRange(int eolStart)` Return Range of eol at given index
`boolean`	`equals(@Nullable Object other)` Comparison to another CharSequence should result in a match if their contents are equal regardless of the implementation.
`boolean`	`equals(@Nullable Object other, boolean ignoreCase)` Test the sequence for a match to another CharSequence
`boolean`	`equalsIgnoreCase(@Nullable Object other)` Test the sequence for a match to another CharSequence, ignoring case differences
`T`	`extractRanges(Iterable<Range> ranges)`
`T`	`extractRanges(Range... ranges)` Build a sequence of ranges in this sequence
`char`	`firstChar()`
`<B extends ISequenceBuilder<B,T>> B`	`getBuilder()` Get a sequence builder for this sequence type
`default int`	`getColumnAtIndex(int index)` Deprecated.
`default @NotNull com.vladsch.flexmark.util.misc.Pair<Integer,Integer>`	`getLineColumnAtIndex(int index)` Deprecated.
`int`	`hashCode()` Should return hashCode of the underlying character sequence which is equal to the String value of that sequence
`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(@NotNull CharSequence s)` All index methods return the position or -1 if not found of the given character, characters or string.
`int`	`indexOf(@NotNull CharSequence s, int fromIndex)`
`int`	`indexOf(@NotNull CharSequence s, int fromIndex, int endIndex)`
`@NotNull int[]`	`indexOfAll(@NotNull CharSequence s)` Get indices of all occurrences of a sequence
`int`	`indexOfAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s)`
`int`	`indexOfAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex)`
`int`	`indexOfAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex, int endIndex)`
`int`	`indexOfAnyNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s)`
`int`	`indexOfAnyNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex)`
`int`	`indexOfAnyNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex, int endIndex)`
`int`	`indexOfNot(char c)`
`int`	`indexOfNot(char c, int fromIndex)`
`int`	`indexOfNot(char c, int fromIndex, int endIndex)`
`default T`	`insert(@NotNull CharSequence chars, int index)` Deprecated. use `insert(int, CharSequence)` instead
`T`	`insert(int index, @NotNull CharSequence chars)` Insert char sequence at given index
`boolean`	`isBlank()`
`boolean`	`isCharAt(int index, @NotNull com.vladsch.flexmark.util.misc.CharPredicate predicate)` Safe, if index out of range returns '\0'
`boolean`	`isEmpty()`
`boolean`	`isIn(@NotNull Collection<? extends CharSequence> texts)`
`boolean`	`isIn(@NotNull String[] 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(@NotNull CharSequence s)`
`int`	`lastIndexOf(@NotNull CharSequence s, int fromIndex)`
`int`	`lastIndexOf(@NotNull CharSequence s, int startIndex, int fromIndex)`
`int`	`lastIndexOfAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s)`
`int`	`lastIndexOfAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex)`
`int`	`lastIndexOfAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int startIndex, int fromIndex)`
`int`	`lastIndexOfAnyNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s)`
`int`	`lastIndexOfAnyNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex)`
`int`	`lastIndexOfAnyNot(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int startIndex, int fromIndex)`
`int`	`lastIndexOfNot(char c)`
`int`	`lastIndexOfNot(char c, int fromIndex)`
`int`	`lastIndexOfNot(char c, int startIndex, int fromIndex)`
`@NotNull Range`	`leadingBlankLinesRange()`
`@NotNull Range`	`leadingBlankLinesRange(@NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars, int fromIndex, int endIndex)` Get Range of leading blank lines at given index offsets in sequence
`@NotNull Range`	`leadingBlankLinesRange(int startIndex)`
`@NotNull Range`	`leadingBlankLinesRange(int fromIndex, int endIndex)`
`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
`@NotNull com.vladsch.flexmark.util.misc.Pair<Integer,Integer>`	`lineColumnAtIndex(int index)` Get the line and column information from index into sequence
`@NotNull Range`	`lineRangeAt(int index)` Get the line characters at given index, line delimited by \n
`@NotNull Range`	`lineRangeAtAnyEOL(int index)` Get the line characters at given index, line delimited by \n, \r or \r\n
`boolean`	`matchChars(@NotNull CharSequence chars)` Test the sequence portion for a match to another CharSequence
`boolean`	`matchChars(@NotNull CharSequence chars, boolean ignoreCase)`
`boolean`	`matchChars(@NotNull CharSequence chars, int startIndex)`
`boolean`	`matchChars(@NotNull CharSequence chars, int startIndex, boolean ignoreCase)` Test the sequence portion for a match to another CharSequence
`boolean`	`matchCharsIgnoreCase(@NotNull CharSequence chars)`
`boolean`	`matchCharsIgnoreCase(@NotNull CharSequence chars, int startIndex)`
`boolean`	`matchCharsReversed(@NotNull CharSequence chars, int endIndex)`
`boolean`	`matchCharsReversed(@NotNull CharSequence chars, int endIndex, boolean ignoreCase)` Test the sequence portion for a match to another CharSequence, reverse order
`boolean`	`matchCharsReversedIgnoreCase(@NotNull CharSequence chars, int endIndex)`
`int`	`matchedCharCount(@NotNull CharSequence chars, int startIndex)`
`int`	`matchedCharCount(@NotNull CharSequence chars, int startIndex, boolean ignoreCase)`
`int`	`matchedCharCount(@NotNull CharSequence chars, int startIndex, int endIndex)`
`int`	`matchedCharCount(@NotNull CharSequence chars, int startIndex, int endIndex, boolean ignoreCase)`
`int`	`matchedCharCount(@NotNull CharSequence chars, int startIndex, int endIndex, boolean fullMatchOnly, boolean ignoreCase)` Test the sequence portion for a match to another CharSequence
`int`	`matchedCharCountIgnoreCase(@NotNull CharSequence chars, int startIndex)`
`int`	`matchedCharCountIgnoreCase(@NotNull CharSequence chars, int startIndex, int endIndex)`
`int`	`matchedCharCountReversed(@NotNull CharSequence chars, int fromIndex)`
`int`	`matchedCharCountReversed(@NotNull CharSequence chars, int fromIndex, boolean ignoreCase)`
`int`	`matchedCharCountReversed(@NotNull CharSequence chars, int startIndex, int fromIndex)`
`int`	`matchedCharCountReversed(@NotNull 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(@NotNull CharSequence chars, int fromIndex)`
`int`	`matchedCharCountReversedIgnoreCase(@NotNull CharSequence chars, int startIndex, int fromIndex)`
`boolean`	`matches(@NotNull CharSequence chars)` Test the sequence for a match to another CharSequence
`boolean`	`matches(@NotNull CharSequence chars, boolean ignoreCase)`
`boolean`	`matchesIgnoreCase(@NotNull 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.
`@NotNull String`	`normalizeEndWithEOL()` replace any \r\n and \r by \n, append terminating EOL if one is not present
`@NotNull String`	`normalizeEOL()` replace any \r\n and \r by \n
`T`	`nullIf(@NotNull BiPredicate<? super T,? super CharSequence> predicate, CharSequence... matches)` If predicate returns true for this sequence and one of given sequences return nullSequence() otherwise returns this sequence.
`T`	`nullIf(boolean condition)` If condition is true return nullSequence() otherwise returns this sequence.
`T`	`nullIf(CharSequence... matches)` If this sequence matches one of given sequences return nullSequence() otherwise returns this sequence.
`T`	`nullIf(@NotNull Predicate<? super CharSequence> predicate, 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, CharSequence... matches)`
`T`	`nullIfEndsWith(CharSequence... matches)`
`T`	`nullIfEndsWithIgnoreCase(CharSequence... matches)`
`default T`	`nullIfEndsWithNot(CharSequence... matches)` Deprecated.
`T`	`nullIfNot(@NotNull BiPredicate<? super T,? super CharSequence> predicate, CharSequence... matches)`
`T`	`nullIfNot(CharSequence... matches)`
`T`	`nullIfNot(@NotNull Predicate<? super CharSequence> predicate, CharSequence... matches)`
`T`	`nullIfNotEndsWith(boolean ignoreCase, CharSequence... matches)`
`T`	`nullIfNotEndsWith(CharSequence... matches)`
`T`	`nullIfNotEndsWithIgnoreCase(CharSequence... matches)`
`T`	`nullIfNotStartsWith(boolean ignoreCase, CharSequence... matches)`
`T`	`nullIfNotStartsWith(CharSequence... matches)`
`T`	`nullIfNotStartsWithIgnoreCase(CharSequence... matches)`
`T`	`nullIfStartsWith(boolean ignoreCase, CharSequence... matches)`
`T`	`nullIfStartsWith(CharSequence... matches)`
`T`	`nullIfStartsWithIgnoreCase(CharSequence... matches)`
`default T`	`nullIfStartsWithNot(CharSequence... matches)` Deprecated.
`T`	`nullSequence()`
`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(@Nullable CharSequence prefix)` Prefix this sequence with a char sequence if not already starting with prefix
`T`	`prefixOnceWithEOL()`
`T`	`prefixOnceWithSpace()`
`T`	`prefixWith(@Nullable CharSequence prefix)` Prefix this sequence with a char sequence
`T`	`prefixWithEOL()`
`T`	`prefixWithSpace()`
`T`	`prefixWithSpaces(int count)`
`T`	`removePrefix(@NotNull CharSequence prefix)` Remove prefix if present
`T`	`removePrefix(@NotNull CharSequence prefix, boolean ignoreCase)` Remove prefix if present
`T`	`removePrefixIgnoreCase(@NotNull CharSequence prefix)` Remove prefix if present, ignoring case differences
`T`	`removeProperPrefix(@NotNull CharSequence prefix)` Remove prefix if present but only if this sequence is longer than the suffix
`T`	`removeProperPrefix(@NotNull CharSequence prefix, boolean ignoreCase)` Remove prefix if present but only if this sequence is longer than the suffix
`T`	`removeProperPrefixIgnoreCase(@NotNull CharSequence prefix)` Remove prefix if present but only if this sequence is longer than the suffix, ignoring case differences
`T`	`removeProperSuffix(@NotNull CharSequence suffix)` Remove suffix if present but only if this sequence is longer than the suffix
`T`	`removeProperSuffix(@NotNull CharSequence suffix, boolean ignoreCase)` Remove suffix if present but only if this sequence is longer than the suffix
`T`	`removeProperSuffixIgnoreCase(@NotNull CharSequence suffix)` Remove suffix if present but only if this sequence is longer than the suffix, ignoring case differences
`T`	`removeSuffix(@NotNull CharSequence suffix)` Remove suffix if present
`T`	`removeSuffix(@NotNull CharSequence suffix, boolean ignoreCase)` Remove suffix if present
`T`	`removeSuffixIgnoreCase(@NotNull CharSequence suffix)` Remove suffix if present, ignoring case differences
`T`	`replace(@NotNull CharSequence find, @NotNull CharSequence replace)` Replace all occurrences of one sequence with another
`T`	`replace(int startIndex, int endIndex, @NotNull CharSequence replacement)` Replace part of the sequence with a char sequence
`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(@Nullable CharSequence charSequence)` Factory function
`T`	`sequenceOf(@Nullable CharSequence charSequence, int startIndex)` Factory function
`T`	`sequenceOf(@Nullable CharSequence charSequence, int startIndex, int endIndex)` Factory function
`default T[]`	`split(char delimiter)` Deprecated.
`default T[]`	`split(char delimiter, int limit)` Deprecated.
`default T[]`	`split(char delimiter, int limit, int flags)` Deprecated.
`T[]`	`split(@NotNull CharSequence delimiter)`
`T[]`	`split(@NotNull CharSequence delimiter, boolean includeDelims, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`T[]`	`split(@NotNull CharSequence delimiter, int limit, boolean includeDelims, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`T[]`	`split(@NotNull CharSequence delimiter, int limit, int flags)`
`T[]`	`split(@NotNull CharSequence delimiter, int limit, int flags, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`T[]`	`splitEOL()`
`T[]`	`splitEOL(boolean includeDelims)`
`@NotNull List<T>`	`splitList(@NotNull CharSequence delimiter)`
`@NotNull List<T>`	`splitList(@NotNull CharSequence delimiter, boolean includeDelims, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`@NotNull List<T>`	`splitList(@NotNull CharSequence delimiter, int limit, boolean includeDelims, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)` Split helpers based on delimiter character sets contained in CharPredicate
`@NotNull List<T>`	`splitList(@NotNull CharSequence delimiter, int limit, int flags)`
`@NotNull List<T>`	`splitList(@NotNull CharSequence delimiter, int limit, int flags, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)` Split helpers based on delimiter character sets contained in CharSequence
`@NotNull List<T>`	`splitListEOL()`
`@NotNull List<T>`	`splitListEOL(boolean includeDelims)`
`@NotNull List<T>`	`splitListEOL(boolean includeDelims, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`int`	`startOfDelimitedBy(@NotNull CharSequence s, int index)`
`int`	`startOfDelimitedByAny(@NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int index)`
`int`	`startOfDelimitedByAnyNot(@NotNull com.vladsch.flexmark.util.misc.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(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`boolean`	`startsWith(@NotNull CharSequence prefix)` test if this sequence starts with given characters
`boolean`	`startsWith(@NotNull CharSequence prefix, boolean ignoreCase)` test if this sequence starts with given characters
`boolean`	`startsWithAnyEOL()`
`boolean`	`startsWithEOL()`
`boolean`	`startsWithIgnoreCase(@NotNull 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(int startIndex, int endIndex)` Get a portion of this sequence
`T`	`subSequence(@NotNull Range range)` Get a portion of this sequence selected by range
`T`	`subSequenceAfter(@NotNull Range range)` Get a portion of this sequence after one selected by range
`T`	`subSequenceBefore(@NotNull Range range)` Get a portion of this sequence before one selected by range
`T`	`suffixOnceWith(@Nullable CharSequence suffix)` Suffix this sequence with a char sequence if not already ending with suffix
`T`	`suffixOnceWithEOL()`
`T`	`suffixOnceWithSpace()`
`T`	`suffixWith(@Nullable 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`	`toMapped(CharMapper mapper)`
`T`	`toNbSp()` Map spaces to non break spaces
`T`	`toSpc()` Map non break spaces to spaces
`@Nullable String`	`toStringOrNull()` Return string or null if BaseSequence.NULL
`T`	`toUpperCase()`
`@NotNull String`	`toVisibleWhitespaceString()`
`@NotNull Range`	`trailingBlankLinesRange()`
`@NotNull Range`	`trailingBlankLinesRange(com.vladsch.flexmark.util.misc.CharPredicate eolChars, int startIndex, int fromIndex)` Get Range of trailing blank lines at given index offsets in sequence
`@NotNull Range`	`trailingBlankLinesRange(int fromIndex)`
`@NotNull Range`	`trailingBlankLinesRange(int startIndex, int fromIndex)`
`T`	`trim()`
`T`	`trim(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`T`	`trim(int keep)`
`T`	`trim(int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`T`	`trimEnd()`
`T`	`trimEnd(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`T`	`trimEnd(int keep)`
`T`	`trimEnd(int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`@NotNull Range`	`trimEndRange()`
`@NotNull Range`	`trimEndRange(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`@NotNull Range`	`trimEndRange(int keep)`
`@NotNull Range`	`trimEndRange(int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`T`	`trimEOL()` Trim last eol at the end of this sequence,
`T`	`trimLeadBlankLines()`
`@NotNull com.vladsch.flexmark.util.misc.Pair<T,T>`	`trimmed()`
`@NotNull com.vladsch.flexmark.util.misc.Pair<T,T>`	`trimmed(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`@NotNull com.vladsch.flexmark.util.misc.Pair<T,T>`	`trimmed(int keep)`
`@NotNull com.vladsch.flexmark.util.misc.Pair<T,T>`	`trimmed(int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`T`	`trimmedEnd()`
`T`	`trimmedEnd(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`T`	`trimmedEnd(int keep)`
`T`	`trimmedEnd(int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`T`	`trimmedEOL()` Get Trimmed part by `trimEOL()`
`T`	`trimmedStart()`
`T`	`trimmedStart(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`T`	`trimmedStart(int keep)`
`T`	`trimmedStart(int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)` Get the characters Trimmed, Trimmed from start/end of this sequence, characters to trim are passed in the sequence argument
`@NotNull Range`	`trimRange()`
`@NotNull Range`	`trimRange(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`@NotNull Range`	`trimRange(int keep)`
`@NotNull Range`	`trimRange(int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`T`	`trimStart()`
`T`	`trimStart(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`T`	`trimStart(int keep)`
`T`	`trimStart(int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)` Trim, Trim start/end of this sequence, characters to trim are passed in the sequence argument
`@NotNull Range`	`trimStartRange()`
`@NotNull Range`	`trimStartRange(@NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`@NotNull Range`	`trimStartRange(int keep)`
`@NotNull Range`	`trimStartRange(int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)` Range of kept sequence when trim start/end of this sequence is performed, characters to trim are passed in the sequence argument
`T`	`trimTailBlankLines()` Trim leading trailing blank lines in this sequence
`T`	`trimToEndOfLine()`
`T`	`trimToEndOfLine(boolean includeEol)`
`T`	`trimToEndOfLine(boolean includeEol, int index)`
`T`	`trimToEndOfLine(@NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars, boolean includeEol, int index)` Trim end to end of line containing index
`T`	`trimToEndOfLine(int index)`
`T`	`trimToStartOfLine()`
`T`	`trimToStartOfLine(boolean includeEol)`
`T`	`trimToStartOfLine(boolean includeEol, int index)`
`T`	`trimToStartOfLine(@NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars, boolean includeEol, int index)` Trim start to start of line containing index
`T`	`trimToStartOfLine(int index)`

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

Methods inherited from interface java.lang.Comparable
compareTo

Methods inherited from interface com.vladsch.flexmark.util.sequence.SequenceUtils
blankLinesRemovedRanges, blankLinesRemovedRanges, blankLinesRemovedRanges, blankLinesRemovedRanges, columnAtIndex, columnsToNextTabStop, compare, compare, compare, compareReversed, containedBy, containedBy, containsAny, containsAny, containsAnyNot, containsAnyNot, containsAnyNot, countLeading, countLeading, countLeading, countLeadingColumns, countLeadingNot, countLeadingNot, countLeadingNot, countLeadingNotSpace, countLeadingNotSpace, countLeadingNotSpace, countLeadingNotSpaceTab, countLeadingNotSpaceTab, countLeadingNotSpaceTab, countLeadingNotWhitespace, countLeadingNotWhitespace, countLeadingNotWhitespace, countLeadingSpace, countLeadingSpace, countLeadingSpace, countLeadingSpaceTab, countLeadingSpaceTab, countLeadingSpaceTab, countLeadingWhitespace, countLeadingWhitespace, countLeadingWhitespace, countOfAny, countOfAny, countOfAny, countOfAnyNot, countOfAnyNot, countOfAnyNot, countOfNotSpaceTab, countOfNotWhitespace, countOfSpaceTab, countOfWhitespace, countTrailing, countTrailing, countTrailing, countTrailingNot, countTrailingNot, countTrailingNot, countTrailingNotSpace, countTrailingNotSpace, countTrailingNotSpace, countTrailingNotSpaceTab, countTrailingNotSpaceTab, countTrailingNotSpaceTab, countTrailingNotWhitespace, countTrailingNotWhitespace, countTrailingNotWhitespace, countTrailingSpace, countTrailingSpace, countTrailingSpace, countTrailingSpaceTab, countTrailingSpaceTab, countTrailingSpaceTab, countTrailingWhitespace, countTrailingWhitespace, countTrailingWhitespace, endOfDelimitedBy, endOfDelimitedByAny, endOfDelimitedByAnyNot, endOfLine, endOfLineAnyEOL, endsWith, endsWith, endsWith, endsWithAnyEOL, endsWithEOL, endsWithSpace, endsWithSpaceTab, endsWithWhitespace, eolEndLength, eolEndLength, eolEndRange, eolStartLength, eolStartRange, equals, expandTo, firstChar, getVisibleSpacesMap, hashCode, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOfAll, indexOfAny, indexOfAny, indexOfAny, indexOfAnyNot, indexOfAnyNot, indexOfAnyNot, indexOfNot, indexOfNot, indexOfNot, isBlank, isEmpty, isNotBlank, isNotEmpty, isVisibleWhitespace, lastChar, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOfAny, lastIndexOfAny, lastIndexOfAny, lastIndexOfAnyNot, lastIndexOfAnyNot, lastIndexOfAnyNot, lastIndexOfNot, lastIndexOfNot, lastIndexOfNot, leadingBlankLinesRange, leadingBlankLinesRange, leadingBlankLinesRange, leadingBlankLinesRange, lineColumnAtIndex, lineRangeAt, lineRangeAtAnyEOL, matchChars, matchChars, matchChars, matchChars, matchCharsIgnoreCase, matchCharsIgnoreCase, matchCharsReversed, matchCharsReversed, matchCharsReversedIgnoreCase, matchedCharCount, matchedCharCount, matchedCharCount, matchedCharCount, matchedCharCount, matchedCharCountIgnoreCase, matchedCharCountIgnoreCase, matchedCharCountReversed, matchedCharCountReversed, matchedCharCountReversed, matchedCharCountReversed, matchedCharCountReversedIgnoreCase, matchedCharCountReversedIgnoreCase, matches, matches, matchesIgnoreCase, padEnd, padEnd, padStart, padStart, parseIntOrDefault, parseIntOrDefault, parseIntOrNull, parseIntOrNull, parseLongOrNull, parseLongOrNull, parseNumberOrNull, parseNumberPrefixOrNull, parseUnsignedIntOrDefault, parseUnsignedIntOrDefault, parseUnsignedIntOrNull, parseUnsignedIntOrNull, safeCharAt, split, split, split, split, split, splitEOL, splitEOL, splitList, splitList, splitList, splitList, splitList, splitListEOL, splitListEOL, splitListEOL, startOfDelimitedBy, startOfDelimitedByAny, startOfDelimitedByAnyNot, startOfLine, startOfLineAnyEOL, startsWith, startsWith, startsWith, startsWithAnyEOL, startsWithEOL, startsWithSpace, startsWithSpaceTab, startsWithWhitespace, subSequence, subSequence, subSequenceAfter, subSequenceBefore, subSequenceBeforeAfter, toStringArray, toVisibleWhitespaceString, trailingBlankLinesRange, trailingBlankLinesRange, trailingBlankLinesRange, trailingBlankLinesRange, trim, trim, trim, trim, trimEnd, trimEnd, trimEnd, trimEnd, trimEndRange, trimEndRange, trimEndRange, trimEndRange, trimEOL, trimLeadBlankLines, trimmed, trimmed, trimmed, trimmed, trimmedEnd, trimmedEnd, trimmedEnd, trimmedEnd, trimmedEOL, trimmedStart, trimmedStart, trimmedStart, trimmedStart, trimRange, trimRange, trimRange, trimRange, trimStart, trimStart, trimStart, trimStart, trimStartRange, trimStartRange, trimStartRange, trimStartRange, trimTailBlankLines, truncateTo, validateIndex, validateIndexInclusiveEnd, validateStartEnd

Method Detail

equals
```
boolean equals(@Nullable
               @Nullable Object other)
```
Comparison to another CharSequence should result in a match if their contents are equal regardless of the implementation. Should not resort to content comparison unless

Overrides:

equals in class Object

Parameters:

other - another char sequence

Returns:

true if character sequences are equal

hashCode
```
int hashCode()
```
Should return hashCode of the underlying character sequence which is equal to the String value of that sequence

Overrides:

hashCode in class Object

Returns:

hash code as if it was a string of the sequence content

emptyArray
```
@NotNull
T[] emptyArray()
```

nullSequence
```
@NotNull
T nullSequence()
```

lastChar
```
char lastChar()
```
Returns:

the last character of the sequence or '\0' if empty

firstChar
```
char firstChar()
```
Returns:

the first character of the sequence or '\0' if empty

safeCharAt
```
char safeCharAt(int index)
```
return char at index or '\0' if index <0 or >=length()

Parameters:

index - index

Returns:

char or '\0'

subSequence
```
@NotNull
T subSequence(int startIndex,
                       int endIndex)
```
Get a portion of this sequence
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:

subSequence in interface CharSequence

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
T safeSubSequence(int startIndex,
                           int endIndex)
```
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.

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
T safeSubSequence(int startIndex)
```
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.

Parameters:

startIndex - offset from startIndex of this sequence

Returns:

based sequence whose contents reflect the selected portion

subSequence
```
@NotNull
T subSequence(@NotNull
                       @NotNull Range range)
```
Get a portion of this sequence selected by range

Parameters:

range - range to get, coordinates offset form start of this sequence

Returns:

based sequence whose contents reflect the selected portion, if range.isNull() then nullSequence()

subSequenceBefore
```
@NotNull
T subSequenceBefore(@NotNull
                             @NotNull Range range)
```
Get a portion of this sequence before one selected by range

Parameters:

range - range to get, coordinates offset form start of this sequence

Returns:

based sequence whose contents reflect the selected portion, if range.isNull() then nullSequence()

subSequenceAfter
```
@NotNull
T subSequenceAfter(@NotNull
                            @NotNull Range range)
```
Get a portion of this sequence after one selected by range

Parameters:

range - range to get, coordinates offset form start of this sequence

Returns:

based sequence whose contents reflect the selected portion, if range.isNull() then nullSequence()

subSequence
```
@NotNull
T subSequence(int startIndex)
```
Get a portion of this sequence starting from a given offset to endIndex of the sequence

Parameters:

startIndex - offset from startIndex of this sequence

Returns:

based sequence whose contents reflect the selected portion

endSequence
```
@NotNull
T endSequence(int startIndex,
                       int endIndex)
```
Convenience method to get characters offset from endIndex of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions

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
T endSequence(int startIndex)
```
Convenience method to get characters offset from endIndex of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions

Parameters:

startIndex - offset from endIndex of sequence [ 0..length() )

Returns:

selected portion spanning length() - startIndex to length() of this sequence

endCharAt
```
char endCharAt(int index)
```
Convenience method to get characters offset from end of sequence. no exceptions are thrown, instead a \0 is returned for an invalid index positions

Parameters:

index - offset from end of sequence

Returns:

character located at length() - index in this sequence

midSequence
```
@NotNull
T midSequence(int startIndex,
                       int endIndex)
```
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

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
T midSequence(int startIndex)
```
Convenience method to get characters offset from start or end of sequence. when offset >= then it is offset from the start of the sequence, when <0 then from the end
no exceptions are thrown, instead a \0 is returned for an invalid index positions

Parameters:

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
```
char midCharAt(int index)
```
Convenience method to get characters offset from start or end of sequence. when index >= then it is offset from the start of the sequence, when <0 then from the end no exceptions are thrown, instead a \0 is returned for an invalid index positions

Parameters:

index - of character to get

Returns:

character at index or \0 if index is outside valid range for this sequence

sequenceOf
```
@NotNull
T sequenceOf(@Nullable
                      @Nullable CharSequence charSequence)
```
Factory function

Parameters:

charSequence - char sequence from which to construct a rich char sequence

Returns:

rich char sequence from given inputs

sequenceOf
```
@NotNull
T sequenceOf(@Nullable
                      @Nullable CharSequence charSequence,
                      int startIndex)
```
Factory function

Parameters:

charSequence - char sequence from which to construct a rich char sequence

startIndex - start index of the sequence to use

Returns:

rich char sequence from given inputs

sequenceOf
```
@NotNull
T sequenceOf(@Nullable
                      @Nullable CharSequence charSequence,
                      int startIndex,
                      int endIndex)
```
Factory function

Parameters:

charSequence - char sequence from which to construct a rich char sequence

startIndex - start index of the sequence to use

endIndex - end index of the sequence to use

Returns:

rich char sequence from given inputs

getBuilder
```
@NotNull
<B extends ISequenceBuilder<B,T>> B getBuilder()
```
Get a sequence builder for this sequence type

Type Parameters:

B - type of builder

Returns:

builder which can build this type of sequence

indexOf
```
int indexOf(@NotNull
            @NotNull CharSequence s)
```
All index methods return the position or -1 if not found of the given character, characters or string.
The basic methods have overloads for 1, 2, or 3 characters and CharSequence parameters. If fromIndex is not given then for forward searching methods 0 is taken as the value, for reverse searching methods length() is taken as the value
For forward searching methods fromIndex is the minimum start position for search and endIndex is the maximum end position, if not given the length() of string is assumed.
For reverse searching methods fromIndex is the maximum start position for search and startIndex is the minimum end position, if not given then 0 is assumed.

Parameters:

s - character pre whose occurrence to find

Returns:

index where found or -1

indexOf

int indexOf(@NotNull
            @NotNull CharSequence s,
            int fromIndex)

indexOf

int indexOf(@NotNull
            @NotNull CharSequence s,
            int fromIndex,
            int endIndex)

indexOf

int indexOf(char c,
            int fromIndex,
            int endIndex)

indexOf

int indexOf(char c,
            int fromIndex)

indexOf
```
int indexOf(char c)
```

indexOfAny

int indexOfAny(@NotNull
               @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
               int fromIndex,
               int endIndex)

indexOfAny

int indexOfAny(@NotNull
               @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
               int fromIndex)

indexOfAny

int indexOfAny(@NotNull
               @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)

indexOfNot

int indexOfNot(char c,
               int fromIndex,
               int endIndex)

indexOfNot

int indexOfNot(char c,
               int fromIndex)

indexOfNot
```
int indexOfNot(char c)
```

indexOfAnyNot

int indexOfAnyNot(@NotNull
                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                  int fromIndex,
                  int endIndex)

indexOfAnyNot

int indexOfAnyNot(@NotNull
                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                  int fromIndex)

indexOfAnyNot

int indexOfAnyNot(@NotNull
                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)

lastIndexOf

int lastIndexOf(@NotNull
                @NotNull CharSequence s)

lastIndexOf

int lastIndexOf(@NotNull
                @NotNull CharSequence s,
                int fromIndex)

lastIndexOf

int lastIndexOf(@NotNull
                @NotNull CharSequence s,
                int startIndex,
                int fromIndex)

lastIndexOf

int lastIndexOf(char c,
                int startIndex,
                int fromIndex)

lastIndexOf

int lastIndexOf(char c,
                int fromIndex)

lastIndexOf
```
int lastIndexOf(char c)
```

lastIndexOfAny

int lastIndexOfAny(@NotNull
                   @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                   int startIndex,
                   int fromIndex)

lastIndexOfAny

int lastIndexOfAny(@NotNull
                   @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                   int fromIndex)

lastIndexOfAny

int lastIndexOfAny(@NotNull
                   @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)

lastIndexOfNot
```
int lastIndexOfNot(char c)
```

lastIndexOfNot

int lastIndexOfNot(char c,
                   int fromIndex)

lastIndexOfNot

int lastIndexOfNot(char c,
                   int startIndex,
                   int fromIndex)

lastIndexOfAnyNot

int lastIndexOfAnyNot(@NotNull
                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                      int startIndex,
                      int fromIndex)

lastIndexOfAnyNot

int lastIndexOfAnyNot(@NotNull
                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                      int fromIndex)

lastIndexOfAnyNot

int lastIndexOfAnyNot(@NotNull
                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)

countLeading
```
int countLeading(@NotNull
                 @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)
```
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

Parameters:

chars - predicate for set of contiguous characters which should be counted

Returns:

number of chars in contiguous span at start of sequence

countLeadingNot

int countLeadingNot(@NotNull
                    @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countLeading

int countLeading(@NotNull
                 @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                 int startIndex)

countLeadingNot

int countLeadingNot(@NotNull
                    @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                    int startIndex)

countLeading

int countLeading(@NotNull
                 @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                 int startIndex,
                 int endIndex)

countLeadingNot

int countLeadingNot(@NotNull
                    @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                    int startIndex,
                    int endIndex)

countLeading
```
@Deprecated
default int countLeading(char c)
```
Deprecated. consider using built-in sets of characters, ..._SET, or Use CharPredicate.anyOf(...)

Parameters:

c - char

Returns:

leading count

countTrailing

int countTrailing(@NotNull
                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countTrailingNot

int countTrailingNot(@NotNull
                     @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countTrailing

int countTrailing(@NotNull
                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                  int startIndex)

countTrailingNot

int countTrailingNot(@NotNull
                     @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                     int startIndex)

countTrailing

int countTrailing(@NotNull
                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                  int startIndex,
                  int endIndex)

countTrailingNot

int countTrailingNot(@NotNull
                     @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                     int startIndex,
                     int endIndex)

countLeadingSpace
```
int countLeadingSpace()
```

countLeadingNotSpace
```
int countLeadingNotSpace()
```

countLeadingSpace
```
int countLeadingSpace(int startIndex)
```

countLeadingNotSpace

int countLeadingNotSpace(int startIndex)

countLeadingSpace

int countLeadingSpace(int startIndex,
                      int endIndex)

countLeadingNotSpace

int countLeadingNotSpace(int startIndex,
                         int endIndex)

countTrailingSpace
```
int countTrailingSpace()
```

countTrailingNotSpace
```
int countTrailingNotSpace()
```

countTrailingSpace
```
int countTrailingSpace(int fromIndex)
```

countTrailingNotSpace

int countTrailingNotSpace(int fromIndex)

countTrailingSpace

int countTrailingSpace(int startIndex,
                       int fromIndex)

countTrailingNotSpace

int countTrailingNotSpace(int startIndex,
                          int fromIndex)

countLeadingSpaceTab
```
int countLeadingSpaceTab()
```

countLeadingNotSpaceTab
```
int countLeadingNotSpaceTab()
```

countLeadingSpaceTab

int countLeadingSpaceTab(int startIndex)

countLeadingNotSpaceTab

int countLeadingNotSpaceTab(int startIndex)

countLeadingSpaceTab

int countLeadingSpaceTab(int startIndex,
                         int endIndex)

countLeadingNotSpaceTab

int countLeadingNotSpaceTab(int startIndex,
                            int endIndex)

countTrailingSpaceTab
```
int countTrailingSpaceTab()
```

countTrailingNotSpaceTab
```
int countTrailingNotSpaceTab()
```

countTrailingSpaceTab

int countTrailingSpaceTab(int fromIndex)

countTrailingNotSpaceTab

int countTrailingNotSpaceTab(int fromIndex)

countTrailingSpaceTab

int countTrailingSpaceTab(int startIndex,
                          int fromIndex)

countTrailingNotSpaceTab

int countTrailingNotSpaceTab(int startIndex,
                             int fromIndex)

countLeadingWhitespace
```
int countLeadingWhitespace()
```

countLeadingNotWhitespace
```
int countLeadingNotWhitespace()
```

countLeadingWhitespace

int countLeadingWhitespace(int startIndex)

countLeadingNotWhitespace

int countLeadingNotWhitespace(int startIndex)

countLeadingWhitespace

int countLeadingWhitespace(int startIndex,
                           int endIndex)

countLeadingNotWhitespace

int countLeadingNotWhitespace(int startIndex,
                              int endIndex)

countTrailingWhitespace
```
int countTrailingWhitespace()
```

countTrailingNotWhitespace
```
int countTrailingNotWhitespace()
```

countTrailingWhitespace

int countTrailingWhitespace(int fromIndex)

countTrailingNotWhitespace

int countTrailingNotWhitespace(int fromIndex)

countTrailingWhitespace

int countTrailingWhitespace(int startIndex,
                            int fromIndex)

countTrailingNotWhitespace

int countTrailingNotWhitespace(int startIndex,
                               int fromIndex)

countLeading

@Deprecated
default int countLeading()

Deprecated.

countTrailing

@Deprecated
default int countTrailing()

Deprecated.

countOfSpaceTab
```
int countOfSpaceTab()
```

countOfNotSpaceTab
```
int countOfNotSpaceTab()
```

countOfWhitespace
```
int countOfWhitespace()
```

countOfNotWhitespace
```
int countOfNotWhitespace()
```

countOf

@Deprecated
default int countOf(char c)

Deprecated.

countOfAny

int countOfAny(@NotNull
               @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countOfAnyNot

int countOfAnyNot(@NotNull
                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countOfAny

int countOfAny(@NotNull
               @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
               int startIndex)

countOfAnyNot

int countOfAnyNot(@NotNull
                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                  int startIndex)

countOfAny

int countOfAny(@NotNull
               @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
               int startIndex,
               int endIndex)

countOfAnyNot

int countOfAnyNot(@NotNull
                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                  int startIndex,
                  int endIndex)

countLeadingColumns
```
int countLeadingColumns(int startColumn,
                        @NotNull
                        @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)
```
Count column of indent given by chars in the set in this sequence, expanding tabs to 4th column

Parameters:

startColumn - column of where this sequence starts

chars - whitespace characters

Returns:

column of first non-whitespace as given by chars

trimStartRange
```
@NotNull
@NotNull Range trimStartRange(int keep,
                                       @NotNull
                                       @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)
```
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.

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
@NotNull Range trimEndRange(int keep,
                                     @NotNull
                                     @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimRange

@NotNull
@NotNull Range trimRange(int keep,
                                  @NotNull
                                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimStartRange

@NotNull
@NotNull Range trimStartRange(@NotNull
                                       @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimEndRange

@NotNull
@NotNull Range trimEndRange(@NotNull
                                     @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimRange

@NotNull
@NotNull Range trimRange(@NotNull
                                  @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimStartRange

@NotNull
@NotNull Range trimStartRange(int keep)

trimEndRange

@NotNull
@NotNull Range trimEndRange(int keep)

trimRange

@NotNull
@NotNull Range trimRange(int keep)

trimStartRange

@NotNull
@NotNull Range trimStartRange()

trimEndRange
```
@NotNull
@NotNull Range trimEndRange()
```

trimRange
```
@NotNull
@NotNull Range trimRange()
```

trimStart
```
@NotNull
T trimStart(int keep,
                     @NotNull
                     @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)
```
Trim, Trim start/end of this sequence, characters to trim are passed in the sequence argument
returns trimmed sequence or if nothing matched the original sequence
If character set in the form of character sequence is not passed in the SequenceUtils.WHITESPACE are assumed.

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

trimEnd

@NotNull
T trimEnd(int keep,
                   @NotNull
                   @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trim

@NotNull
T trim(int keep,
                @NotNull
                @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimStart
```
@NotNull
T trimStart(int keep)
```

trimEnd
```
@NotNull
T trimEnd(int keep)
```

trim
```
@NotNull
T trim(int keep)
```

trimStart

@NotNull
T trimStart(@NotNull
                     @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimEnd

@NotNull
T trimEnd(@NotNull
                   @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trim

@NotNull
T trim(@NotNull
                @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimStart
```
@NotNull
T trimStart()
```

trimEnd
```
@NotNull
T trimEnd()
```

trim
```
@NotNull
T trim()
```

trimmedStart
```
@NotNull
T trimmedStart(int keep,
                        @NotNull
                        @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)
```
Get the characters Trimmed, Trimmed from start/end of this sequence, characters to trim are passed in the sequence argument
returns trimmed sequence or if nothing matched the original sequence
The pair returning functions return before and after sequence

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

trimmedEnd

@NotNull
T trimmedEnd(int keep,
                      @NotNull
                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmed

@NotNull
@NotNull com.vladsch.flexmark.util.misc.Pair<T,T> trimmed(int keep,
                                                                   @NotNull
                                                                   @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmedStart
```
@NotNull
T trimmedStart(int keep)
```

trimmedEnd
```
@NotNull
T trimmedEnd(int keep)
```

trimmed

@NotNull
@NotNull com.vladsch.flexmark.util.misc.Pair<T,T> trimmed(int keep)

trimmedStart

@NotNull
T trimmedStart(@NotNull
                        @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmedEnd

@NotNull
T trimmedEnd(@NotNull
                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmed

@NotNull
@NotNull com.vladsch.flexmark.util.misc.Pair<T,T> trimmed(@NotNull
                                                                   @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmedStart
```
@NotNull
T trimmedStart()
```

trimmedEnd
```
@NotNull
T trimmedEnd()
```

trimmed

@NotNull
@NotNull com.vladsch.flexmark.util.misc.Pair<T,T> trimmed()

padding
```
@NotNull
T padding(int length,
                   char pad)
```
Get the chars needed for padding to length

Parameters:

length - length

pad - char to use for padding

Returns:

padding chars

padding
```
@NotNull
T padding(int length)
```

padStart
```
@NotNull
T padStart(int length,
                    char pad)
```
Pad this sequence to given length

Parameters:

length - length to pad

pad - char to use for padding

Returns:

sequence padded

padEnd

@NotNull
T padEnd(int length,
                  char pad)

padStart
```
@NotNull
T padStart(int length)
```

padEnd
```
@NotNull
T padEnd(int length)
```

isEmpty
```
boolean isEmpty()
```

isBlank
```
boolean isBlank()
```

isNotEmpty
```
boolean isNotEmpty()
```

isNotBlank
```
boolean isNotBlank()
```

isNull
```
boolean isNull()
```

isNotNull
```
boolean isNotNull()
```

ifNull
```
@NotNull
T ifNull(@NotNull
                  T other)
```
If this sequence is the nullSequence() instance then returns other, otherwise returns this sequence.

Parameters:

other - based sequence to return if this is nullSequence()

Returns:

this or other

ifNullEmptyAfter
```
@NotNull
T ifNullEmptyAfter(@NotNull
                            T other)
```
If this sequence is the nullSequence() instance then returns an empty subSequence from the end of other, otherwise returns this sequence.

Parameters:

other - based sequence from which to take the empty sequence

Returns:

this or other.subSequence(other.length(), other.length())

ifNullEmptyBefore
```
@NotNull
T ifNullEmptyBefore(@NotNull
                             T other)
```
If this sequence is the nullSequence() instance then returns an empty subSequence from the start of other, otherwise returns this sequence.

Parameters:

other - based sequence from which to take the empty sequence

Returns:

this or other.subSequence(0, 0)

nullIfEmpty
```
@NotNull
T nullIfEmpty()
```
If this sequence is empty return nullSequence() otherwise returns this sequence.

Returns:

this or nullSequence()

nullIfBlank
```
@NotNull
T nullIfBlank()
```
If this sequence is blank return nullSequence() otherwise returns this sequence.

Returns:

this or nullSequence()

nullIf
```
@NotNull
T nullIf(boolean condition)
```
If condition is true return nullSequence() otherwise returns this sequence.

Parameters:

condition - when true return NULL else this

Returns:

this or nullSequence()

nullIf
```
@NotNull
T nullIf(@NotNull
                  @NotNull BiPredicate<? super T,? super CharSequence> predicate,
                  CharSequence... matches)
```
If predicate returns true for this sequence and one of given sequences return nullSequence() otherwise returns this sequence.

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()

nullIfNot

@NotNull
T nullIfNot(@NotNull
                     @NotNull BiPredicate<? super T,? super CharSequence> predicate,
                     CharSequence... matches)

nullIf
```
@NotNull
T nullIf(@NotNull
                  @NotNull Predicate<? super CharSequence> predicate,
                  CharSequence... matches)
```
If predicate returns true for one of given sequences return nullSequence() otherwise returns this sequence.

Parameters:

predicate - sequence predicate

matches - match sequence list

Returns:

this or nullSequence()

nullIfNot

@NotNull
T nullIfNot(@NotNull
                     @NotNull Predicate<? super CharSequence> predicate,
                     CharSequence... matches)

nullIf
```
@NotNull
T nullIf(CharSequence... matches)
```
If this sequence matches one of given sequences return nullSequence() otherwise returns this sequence.

Parameters:

matches - match sequence list

Returns:

this or nullSequence()

nullIfNot

@NotNull
T nullIfNot(CharSequence... matches)

nullIfStartsWith

@NotNull
T nullIfStartsWith(CharSequence... matches)

nullIfNotStartsWith

@NotNull
T nullIfNotStartsWith(CharSequence... matches)

nullIfStartsWithNot

@Deprecated
 @NotNull
default T nullIfStartsWithNot(CharSequence... matches)

Deprecated.

nullIfEndsWith

@NotNull
T nullIfEndsWith(CharSequence... matches)

nullIfNotEndsWith

@NotNull
T nullIfNotEndsWith(CharSequence... matches)

nullIfStartsWithIgnoreCase

@NotNull
T nullIfStartsWithIgnoreCase(CharSequence... matches)

nullIfNotStartsWithIgnoreCase

@NotNull
T nullIfNotStartsWithIgnoreCase(CharSequence... matches)

nullIfEndsWithIgnoreCase

@NotNull
T nullIfEndsWithIgnoreCase(CharSequence... matches)

nullIfNotEndsWithIgnoreCase

@NotNull
T nullIfNotEndsWithIgnoreCase(CharSequence... matches)

nullIfStartsWith

@NotNull
T nullIfStartsWith(boolean ignoreCase,
                            CharSequence... matches)

nullIfNotStartsWith

@NotNull
T nullIfNotStartsWith(boolean ignoreCase,
                               CharSequence... matches)

nullIfEndsWith

@NotNull
T nullIfEndsWith(boolean ignoreCase,
                          CharSequence... matches)

nullIfNotEndsWith

@NotNull
T nullIfNotEndsWith(boolean ignoreCase,
                             CharSequence... matches)

nullIfEndsWithNot

@Deprecated
 @NotNull
default T nullIfEndsWithNot(CharSequence... matches)

Deprecated.

eolEndLength
```
int eolEndLength()
```
Get the length of EOL character at the end of this sequence, if present.
\n - 1 \r - 1 \r\n - 2

Returns:

0 if no EOL, 1, or 2 depending on the EOL suffix of this sequence

eolStartLength

@Deprecated
default int eolStartLength()

Deprecated.

eolEndLength
```
int eolEndLength(int eolEnd)
```
Get the length of EOL character at the given index of this sequence, if present.
\n - 1 \r - 1 \r\n - 2

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
```
int eolStartLength(int eolStart)
```
Get the length of EOL character at the given index of this sequence, if present.
\n - 1 \r - 1 \r\n - 2

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

eolLength

@Deprecated
default int eolLength(int eolStart)

Deprecated.

eolEndRange
```
@NotNull
@NotNull Range eolEndRange(int eolEnd)
```
Return Range of eol at given index

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
@NotNull Range eolStartRange(int eolStart)
```
Return Range of eol at given index

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
T trimEOL()
```
Trim last eol at the end of this sequence,

Returns:

sequence with one EOL trimmed off if it had one

trimmedEOL
```
@NotNull
T trimmedEOL()
```
Get Trimmed part by trimEOL()

Returns:

trimmed off EOL if sequence had one or nullSequence()

endOfDelimitedBy
```
int endOfDelimitedBy(@NotNull
                     @NotNull CharSequence s,
                     int index)
```
Find start/end region in this sequence delimited by any characters in argument or the CharSequence
For Any and AnyNot methods uses the CharSequence argument as a character set of possible delimiting characters

Parameters:

s - character sequence delimiting the region

index - from which to start looking for end of region

Returns:

index of end of region delimited by s

endOfDelimitedByAny

int endOfDelimitedByAny(@NotNull
                        @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                        int index)

endOfDelimitedByAnyNot

int endOfDelimitedByAnyNot(@NotNull
                           @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                           int index)

startOfDelimitedBy

int startOfDelimitedBy(@NotNull
                       @NotNull CharSequence s,
                       int index)

startOfDelimitedByAny

int startOfDelimitedByAny(@NotNull
                          @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                          int index)

startOfDelimitedByAnyNot

int startOfDelimitedByAnyNot(@NotNull
                             @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                             int index)

endOfLine
```
int endOfLine(int index)
```
Get the offset of the end of line at given index, end of line delimited by \n

Parameters:

index - index where to start searching for end of line

Returns:

index of end of line delimited by \n

endOfLineAnyEOL
```
int endOfLineAnyEOL(int index)
```
Get the offset of the end of line at given index, end of line delimited by \n or any of \n \r \r\n for Any methods.

Parameters:

index - index where to start searching for end of line

Returns:

index of end of line delimited by \n

startOfLine
```
int startOfLine(int index)
```
Get the offset of the start of line at given index, start of line delimited by \n

Parameters:

index - index where to start searching for end of line

Returns:

index of end of line delimited by \n

startOfLineAnyEOL
```
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.

Parameters:

index - index where to start searching for end of line

Returns:

index of end of line delimited by \n

lineRangeAt
```
@NotNull
@NotNull Range lineRangeAt(int index)
```
Get the line characters at given index, line delimited by \n

Parameters:

index - index at which to get the line

Returns:

range in sequence for the line delimited by '\n', containing index

lineRangeAtAnyEOL
```
@NotNull
@NotNull Range lineRangeAtAnyEOL(int index)
```
Get the line characters at given index, line delimited by \n, \r or \r\n

Parameters:

index - index at which to get the line

Returns:

range in sequence for the line delimited by end of line, containing index

lineAt
```
@NotNull
T lineAt(int index)
```
Get the line characters at given index, line delimited by \n

Parameters:

index - index at which to get the line

Returns:

sub-sequence for the line containing index

lineAtAnyEOL
```
@NotNull
T lineAtAnyEOL(int index)
```
Get the line characters at given index, line delimited by \n, \r or \r\n

Parameters:

index - index at which to get the line

Returns:

sub-sequence for the line containing index

trimTailBlankLines
```
@NotNull
T trimTailBlankLines()
```
Trim leading trailing blank lines in this sequence

Returns:

return sequence with trailing blank lines trimmed off

trimLeadBlankLines
```
@NotNull
T trimLeadBlankLines()
```

leadingBlankLinesRange
```
@NotNull
@NotNull Range leadingBlankLinesRange(@NotNull
                                               @NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars,
                                               int fromIndex,
                                               int endIndex)
```
Get Range of leading blank lines at given index offsets in sequence

Parameters:

eolChars - characters to consider as EOL, note 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

trailingBlankLinesRange
```
@NotNull
@NotNull Range trailingBlankLinesRange(com.vladsch.flexmark.util.misc.CharPredicate eolChars,
                                                int startIndex,
                                                int fromIndex)
```
Get Range of trailing blank lines at given index offsets in sequence

Parameters:

eolChars - characters to consider as EOL, note 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
@NotNull Range leadingBlankLinesRange()

leadingBlankLinesRange

@NotNull
@NotNull Range leadingBlankLinesRange(int startIndex)

leadingBlankLinesRange

@NotNull
@NotNull Range leadingBlankLinesRange(int fromIndex,
                                               int endIndex)

trailingBlankLinesRange

@NotNull
@NotNull Range trailingBlankLinesRange()

trailingBlankLinesRange

@NotNull
@NotNull Range trailingBlankLinesRange(int fromIndex)

trailingBlankLinesRange

@NotNull
@NotNull Range trailingBlankLinesRange(int startIndex,
                                                int fromIndex)

blankLinesRemovedRanges

@NotNull
@NotNull List<Range> blankLinesRemovedRanges()

blankLinesRemovedRanges

@NotNull
@NotNull List<Range> blankLinesRemovedRanges(int fromIndex)

blankLinesRemovedRanges

@NotNull
@NotNull List<Range> blankLinesRemovedRanges(int fromIndex,
                                                      int endIndex)

blankLinesRemovedRanges

@NotNull
@NotNull List<Range> blankLinesRemovedRanges(@NotNull
                                                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars,
                                                      int fromIndex,
                                                      int endIndex)

trimToEndOfLine
```
@NotNull
T trimToEndOfLine(@NotNull
                           @NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars,
                           boolean includeEol,
                           int index)
```
Trim end to end of line containing index

Parameters:

eolChars - characters to consider as EOL, note 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

trimToEndOfLine

@NotNull
T trimToEndOfLine(boolean includeEol,
                           int index)

trimToEndOfLine

@NotNull
T trimToEndOfLine(boolean includeEol)

trimToEndOfLine
```
@NotNull
T trimToEndOfLine(int index)
```

trimToEndOfLine
```
@NotNull
T trimToEndOfLine()
```

trimToStartOfLine
```
@NotNull
T trimToStartOfLine(@NotNull
                             @NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars,
                             boolean includeEol,
                             int index)
```
Trim start to start of line containing index

Parameters:

eolChars - characters to consider as EOL, note 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
T trimToStartOfLine(boolean includeEol,
                             int index)

trimToStartOfLine

@NotNull
T trimToStartOfLine(boolean includeEol)

trimToStartOfLine

@NotNull
T trimToStartOfLine(int index)

trimToStartOfLine
```
@NotNull
T trimToStartOfLine()
```

normalizeEOL
```
@NotNull
@NotNull String normalizeEOL()
```
replace any \r\n and \r by \n

Returns:

string with only \n for line separators

normalizeEndWithEOL
```
@NotNull
@NotNull String normalizeEndWithEOL()
```
replace any \r\n and \r by \n, append terminating EOL if one is not present

Returns:

string with only \n for line separators and terminated by \n

matches
```
boolean matches(@NotNull
                @NotNull CharSequence chars)
```
Test the sequence for a match to another CharSequence

Parameters:

chars - characters to match against

Returns:

true if match

matchesIgnoreCase

boolean matchesIgnoreCase(@NotNull
                          @NotNull CharSequence chars)

matches

boolean matches(@NotNull
                @NotNull CharSequence chars,
                boolean ignoreCase)

equalsIgnoreCase
```
boolean equalsIgnoreCase(@Nullable
                         @Nullable Object other)
```
Test the sequence for a match to another CharSequence, ignoring case differences

Parameters:

other - characters to match against

Returns:

true if match

equals
```
boolean equals(@Nullable
               @Nullable Object other,
               boolean ignoreCase)
```
Test the sequence for a match to another CharSequence

Parameters:

other - characters to match against

ignoreCase - case ignored when true

Returns:

true if match

matchChars
```
boolean matchChars(@NotNull
                   @NotNull CharSequence chars)
```
Test the sequence portion for a match to another CharSequence

Parameters:

chars - characters to match against

Returns:

true if characters at the start of this sequence match

matchCharsIgnoreCase

boolean matchCharsIgnoreCase(@NotNull
                             @NotNull CharSequence chars)

matchChars

boolean matchChars(@NotNull
                   @NotNull CharSequence chars,
                   boolean ignoreCase)

matchChars
```
boolean matchChars(@NotNull
                   @NotNull CharSequence chars,
                   int startIndex,
                   boolean ignoreCase)
```
Test the sequence portion for a match to another CharSequence

Parameters:

chars - characters to match against

startIndex - index from which to start the match

ignoreCase - if true match ignoring case differences

Returns:

true if characters at the start index of this sequence match

matchChars

boolean matchChars(@NotNull
                   @NotNull CharSequence chars,
                   int startIndex)

matchCharsIgnoreCase

boolean matchCharsIgnoreCase(@NotNull
                             @NotNull CharSequence chars,
                             int startIndex)

matchedCharCount
```
int matchedCharCount(@NotNull
                     @NotNull CharSequence chars,
                     int startIndex,
                     int endIndex,
                     boolean fullMatchOnly,
                     boolean ignoreCase)
```
Test the sequence portion for a match to another CharSequence

Parameters:

chars - characters to match against

startIndex - index from which to start the match

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

matchedCharCount

int matchedCharCount(@NotNull
                     @NotNull CharSequence chars,
                     int startIndex,
                     int endIndex,
                     boolean ignoreCase)

matchedCharCount

int matchedCharCount(@NotNull
                     @NotNull CharSequence chars,
                     int startIndex,
                     boolean ignoreCase)

matchedCharCount

int matchedCharCount(@NotNull
                     @NotNull CharSequence chars,
                     int startIndex,
                     int endIndex)

matchedCharCount

int matchedCharCount(@NotNull
                     @NotNull CharSequence chars,
                     int startIndex)

matchedCharCountIgnoreCase

int matchedCharCountIgnoreCase(@NotNull
                               @NotNull CharSequence chars,
                               int startIndex,
                               int endIndex)

matchedCharCountIgnoreCase

int matchedCharCountIgnoreCase(@NotNull
                               @NotNull CharSequence chars,
                               int startIndex)

matchCharsReversed
```
boolean matchCharsReversed(@NotNull
                           @NotNull CharSequence chars,
                           int endIndex,
                           boolean ignoreCase)
```
Test the sequence portion for a match to another CharSequence, reverse order

Parameters:

chars - characters to match against

endIndex - index from which to start the match and proceed to 0

ignoreCase - if true match ignoring case differences

Returns:

true if characters at the start index of this sequence match

matchCharsReversed

boolean matchCharsReversed(@NotNull
                           @NotNull CharSequence chars,
                           int endIndex)

matchCharsReversedIgnoreCase

boolean matchCharsReversedIgnoreCase(@NotNull
                                     @NotNull CharSequence chars,
                                     int endIndex)

matchedCharCountReversed
```
int matchedCharCountReversed(@NotNull
                             @NotNull 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

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

matchedCharCountReversed

int matchedCharCountReversed(@NotNull
                             @NotNull CharSequence chars,
                             int startIndex,
                             int fromIndex)

matchedCharCountReversedIgnoreCase

int matchedCharCountReversedIgnoreCase(@NotNull
                                       @NotNull CharSequence chars,
                                       int startIndex,
                                       int fromIndex)

matchedCharCountReversed

int matchedCharCountReversed(@NotNull
                             @NotNull CharSequence chars,
                             int fromIndex,
                             boolean ignoreCase)

matchedCharCountReversed

int matchedCharCountReversed(@NotNull
                             @NotNull CharSequence chars,
                             int fromIndex)

matchedCharCountReversedIgnoreCase

int matchedCharCountReversedIgnoreCase(@NotNull
                                       @NotNull CharSequence chars,
                                       int fromIndex)

endsWith
```
boolean endsWith(@NotNull
                 @NotNull CharSequence suffix)
```
test if this sequence ends with given characters

Parameters:

suffix - characters to test

Returns:

true if ends with suffix

endsWith

boolean endsWith(@NotNull
                 @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

endsWithEOL
```
boolean endsWithEOL()
```

endsWithAnyEOL
```
boolean endsWithAnyEOL()
```

endsWithSpace
```
boolean endsWithSpace()
```

endsWithSpaceTab
```
boolean endsWithSpaceTab()
```

endsWithWhitespace
```
boolean endsWithWhitespace()
```

endsWithIgnoreCase
```
boolean endsWithIgnoreCase(@NotNull
                           @NotNull CharSequence suffix)
```
test if this sequence ends with given characters, ignoring case differences

Parameters:

suffix - characters to test

Returns:

true if ends with suffix

endsWith
```
boolean endsWith(@NotNull
                 @NotNull CharSequence suffix,
                 boolean ignoreCase)
```
test if this sequence ends with given characters

Parameters:

suffix - characters to test

ignoreCase - case ignored when true

Returns:

true if ends with suffix

startsWith
```
boolean startsWith(@NotNull
                   @NotNull CharSequence prefix)
```
test if this sequence starts with given characters

Parameters:

prefix - characters to test

Returns:

true if starts with prefix

startsWith

boolean startsWith(@NotNull
                   @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

startsWithEOL
```
boolean startsWithEOL()
```

startsWithAnyEOL
```
boolean startsWithAnyEOL()
```

startsWithSpace
```
boolean startsWithSpace()
```

startsWithSpaceTab
```
boolean startsWithSpaceTab()
```

startsWithWhitespace
```
boolean startsWithWhitespace()
```

startsWithIgnoreCase
```
boolean startsWithIgnoreCase(@NotNull
                             @NotNull CharSequence prefix)
```
test if this sequence starts with given characters, ignoring case differences

Parameters:

prefix - characters to test

Returns:

true if starts with prefix

startsWith
```
boolean startsWith(@NotNull
                   @NotNull CharSequence prefix,
                   boolean ignoreCase)
```
test if this sequence starts with given characters

Parameters:

prefix - characters to test

ignoreCase - case ignored when true

Returns:

true if starts with prefix

removeSuffix
```
@NotNull
T removeSuffix(@NotNull
                        @NotNull CharSequence suffix)
```
Remove suffix if present

Parameters:

suffix - characters to remove

Returns:

sequence with suffix removed, or same sequence if no suffix was present

removeSuffixIgnoreCase
```
@NotNull
T removeSuffixIgnoreCase(@NotNull
                                  @NotNull CharSequence suffix)
```
Remove suffix if present, ignoring case differences

Parameters:

suffix - characters to remove

Returns:

sequence with suffix removed, or same sequence if no suffix was present

removeSuffix
```
@NotNull
T removeSuffix(@NotNull
                        @NotNull CharSequence suffix,
                        boolean ignoreCase)
```
Remove suffix if present

Parameters:

suffix - characters to remove

ignoreCase - case ignored when true

Returns:

sequence with suffix removed, or same sequence if no suffix was present

removePrefix
```
@NotNull
T removePrefix(@NotNull
                        @NotNull CharSequence prefix)
```
Remove prefix if present

Parameters:

prefix - characters to remove

Returns:

sequence with prefix removed, or same sequence if no prefix was present

removePrefixIgnoreCase
```
@NotNull
T removePrefixIgnoreCase(@NotNull
                                  @NotNull CharSequence prefix)
```
Remove prefix if present, ignoring case differences

Parameters:

prefix - characters to remove

Returns:

sequence with prefix removed, or same sequence if no prefix was present

removePrefix
```
@NotNull
T removePrefix(@NotNull
                        @NotNull CharSequence prefix,
                        boolean ignoreCase)
```
Remove prefix if present

Parameters:

prefix - characters to remove

ignoreCase - case ignored when true

Returns:

sequence with prefix removed, or same sequence if no prefix was present

removeProperSuffix
```
@NotNull
T removeProperSuffix(@NotNull
                              @NotNull CharSequence suffix)
```
Remove suffix if present but only if this sequence is longer than the suffix

Parameters:

suffix - characters to remove

Returns:

sequence with suffix removed, or same sequence if no suffix was present

removeProperSuffixIgnoreCase
```
@NotNull
T removeProperSuffixIgnoreCase(@NotNull
                                        @NotNull CharSequence suffix)
```
Remove suffix if present but only if this sequence is longer than the suffix, ignoring case differences

Parameters:

suffix - characters to remove

Returns:

sequence with suffix removed, or same sequence if no suffix was present

removeProperSuffix
```
@NotNull
T removeProperSuffix(@NotNull
                              @NotNull CharSequence suffix,
                              boolean ignoreCase)
```
Remove suffix if present but only if this sequence is longer than the suffix

Parameters:

suffix - characters to remove

ignoreCase - case ignored when true

Returns:

sequence with suffix removed, or same sequence if no suffix was present

removeProperPrefix
```
@NotNull
T removeProperPrefix(@NotNull
                              @NotNull CharSequence prefix)
```
Remove prefix if present but only if this sequence is longer than the suffix

Parameters:

prefix - characters to remove

Returns:

sequence with prefix removed, or same sequence if no prefix was present

removeProperPrefixIgnoreCase
```
@NotNull
T removeProperPrefixIgnoreCase(@NotNull
                                        @NotNull CharSequence prefix)
```
Remove prefix if present but only if this sequence is longer than the suffix, ignoring case differences

Parameters:

prefix - characters to remove

Returns:

sequence with prefix removed, or same sequence if no prefix was present

removeProperPrefix
```
@NotNull
T removeProperPrefix(@NotNull
                              @NotNull CharSequence prefix,
                              boolean ignoreCase)
```
Remove prefix if present but only if this sequence is longer than the suffix

Parameters:

prefix - characters to remove

ignoreCase - case ignored when true

Returns:

sequence with prefix removed, or same sequence if no prefix was present

insert
```
@NotNull
T insert(int index,
                  @NotNull
                  @NotNull CharSequence chars)
```
Insert char sequence at given index

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

insert

@NotNull
 @Deprecated
default T insert(@NotNull
                                       @NotNull CharSequence chars,
                                       int index)

Deprecated. use insert(int, CharSequence) instead

Parameters:: chars - chars; index - index of insertion
Returns:: resulting sequence

delete
```
@NotNull
T delete(int startIndex,
                  int endIndex)
```
Delete range in sequence

Parameters:

startIndex - start index of deletion

endIndex - end index, not inclusive, of insertion

Returns:

resulting sequence

replace
```
@NotNull
T replace(int startIndex,
                   int endIndex,
                   @NotNull
                   @NotNull CharSequence replacement)
```
Replace part of the sequence with a char sequence

Parameters:

startIndex - start index of replaced part

endIndex - end index of replaced part

replacement - char sequence

Returns:

resulting sequence

replace

@NotNull
T replace(@NotNull
                   @NotNull CharSequence find,
                   @NotNull
                   @NotNull CharSequence replace)

Replace all occurrences of one sequence with another

Parameters:: find - sequence to find; replace - replacement sequence
Returns:: array of indices

toLowerCase
```
@NotNull
T toLowerCase()
```
Map characters of this sequence to: Uppercase, Lowercase or use custom mapping

Returns:

lowercase version of sequence

toUpperCase
```
@NotNull
T toUpperCase()
```

toMapped

@NotNull
T toMapped(CharMapper mapper)

toNbSp
```
@NotNull
T toNbSp()
```
Map spaces to non break spaces

Returns:

mapped sequence with spc changed to NbSp

toSpc
```
@NotNull
T toSpc()
```
Map non break spaces to spaces

Returns:

mapped sequence with NbSp changed to spc

toVisibleWhitespaceString

@NotNull
@NotNull String toVisibleWhitespaceString()

splitList
```
@NotNull
@NotNull List<T> splitList(@NotNull
                                    @NotNull CharSequence delimiter,
                                    int limit,
                                    int flags,
                                    @Nullable
                                    @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)
```
Split helpers based on delimiter character sets contained in CharSequence

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

splitList

@NotNull
@NotNull List<T> splitList(@NotNull
                                    @NotNull CharSequence delimiter,
                                    int limit,
                                    int flags)

splitList

@NotNull
@NotNull List<T> splitList(@NotNull
                                    @NotNull CharSequence delimiter)

split

@NotNull
T[] split(@NotNull
                   @NotNull CharSequence delimiter,
                   int limit,
                   int flags,
                   @Nullable
                   @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)

split

@NotNull
T[] split(@NotNull
                   @NotNull CharSequence delimiter,
                   int limit,
                   int flags)

split

@NotNull
T[] split(@NotNull
                   @NotNull CharSequence delimiter)

split

@Deprecated
 @NotNull
default T[] split(char delimiter,
                                        int limit,
                                        int flags)

Deprecated.

split

@Deprecated
 @NotNull
default T[] split(char delimiter,
                                        int limit)

Deprecated.

split

@Deprecated
 @NotNull
default T[] split(char delimiter)

Deprecated.

splitList

@NotNull
@NotNull List<T> splitList(@NotNull
                                    @NotNull CharSequence delimiter,
                                    int limit,
                                    boolean includeDelims,
                                    @Nullable
                                    @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)

Split helpers based on delimiter character sets contained in CharPredicate

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
@NotNull List<T> splitList(@NotNull
                                    @NotNull CharSequence delimiter,
                                    boolean includeDelims,
                                    @Nullable
                                    @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)

split

@NotNull
T[] split(@NotNull
                   @NotNull CharSequence delimiter,
                   int limit,
                   boolean includeDelims,
                   @Nullable
                   @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)

split

@NotNull
T[] split(@NotNull
                   @NotNull CharSequence delimiter,
                   boolean includeDelims,
                   @Nullable
                   @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)

splitEOL
```
@NotNull
T[] splitEOL()
```

splitEOL

@NotNull
T[] splitEOL(boolean includeDelims)

splitListEOL

@NotNull
@NotNull List<T> splitListEOL()

splitListEOL

@NotNull
@NotNull List<T> splitListEOL(boolean includeDelims)

splitListEOL

@NotNull
@NotNull List<T> splitListEOL(boolean includeDelims,
                                       @Nullable
                                       @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)

indexOfAll
```
@NotNull
@NotNull int[] indexOfAll(@NotNull
                                   @NotNull CharSequence s)
```
Get indices of all occurrences of a sequence

Parameters:

s - sequence whose indices to find

Returns:

array of indices

prefixWith
```
@NotNull
T prefixWith(@Nullable
                      @Nullable CharSequence prefix)
```
Prefix this sequence with a char sequence

Parameters:

prefix - char sequence

Returns:

resulting sequence

suffixWith
```
@NotNull
T suffixWith(@Nullable
                      @Nullable CharSequence suffix)
```
Prefix this sequence with a char sequence

Parameters:

suffix - char sequence

Returns:

resulting sequence

prefixOnceWith
```
@NotNull
T prefixOnceWith(@Nullable
                          @Nullable CharSequence prefix)
```
Prefix this sequence with a char sequence if not already starting with prefix

Parameters:

prefix - char sequence

Returns:

resulting sequence

suffixOnceWith
```
@NotNull
T suffixOnceWith(@Nullable
                          @Nullable CharSequence suffix)
```
Suffix this sequence with a char sequence if not already ending with suffix

Parameters:

suffix - char sequence

Returns:

resulting sequence

appendEOL
```
@NotNull
T appendEOL()
```

suffixWithEOL
```
@NotNull
T suffixWithEOL()
```

prefixWithEOL
```
@NotNull
T prefixWithEOL()
```

prefixOnceWithEOL
```
@NotNull
T prefixOnceWithEOL()
```

suffixOnceWithEOL
```
@NotNull
T suffixOnceWithEOL()
```

appendSpace
```
@NotNull
T appendSpace()
```

suffixWithSpace
```
@NotNull
T suffixWithSpace()
```

prefixWithSpace
```
@NotNull
T prefixWithSpace()
```

appendSpaces
```
@NotNull
T appendSpaces(int count)
```

suffixWithSpaces

@NotNull
T suffixWithSpaces(int count)

prefixWithSpaces

@NotNull
T prefixWithSpaces(int count)

prefixOnceWithSpace
```
@NotNull
T prefixOnceWithSpace()
```

suffixOnceWithSpace
```
@NotNull
T suffixOnceWithSpace()
```

appendTo

@NotNull
T appendTo(@NotNull
                    @NotNull StringBuilder out,
                    @Nullable
                    @Nullable CharMapper charMapper,
                    int startIndex,
                    int endIndex)

Append helpers

Parameters:: out - string builder; startIndex - start index; endIndex - end index; charMapper - mapping to use for output or null if none
Returns:: this

appendTo

@NotNull
T appendTo(@NotNull
                    @NotNull StringBuilder out,
                    @Nullable
                    @Nullable CharMapper charMapper)

appendTo

@NotNull
T appendTo(@NotNull
                    @NotNull StringBuilder out,
                    @Nullable
                    @Nullable CharMapper charMapper,
                    int startIndex)

appendTo

@NotNull
T appendTo(@NotNull
                    @NotNull StringBuilder out,
                    int startIndex,
                    int endIndex)

appendTo

@NotNull
T appendTo(@NotNull
                    @NotNull StringBuilder out)

appendTo

@NotNull
T appendTo(@NotNull
                    @NotNull StringBuilder out,
                    int startIndex)

appendRangesTo
```
@NotNull
T appendRangesTo(@NotNull
                          @NotNull StringBuilder out,
                          @Nullable
                          @Nullable CharMapper charMapper,
                          Range... ranges)
```
Append given ranges of this sequence to string builder

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
T appendRangesTo(@NotNull
                          @NotNull StringBuilder out,
                          Range... ranges)

appendRangesTo

@NotNull
T appendRangesTo(@NotNull
                          @NotNull StringBuilder out,
                          @Nullable
                          @Nullable CharMapper charMapper,
                          Iterable<? extends Range> ranges)

appendRangesTo

@NotNull
T appendRangesTo(@NotNull
                          @NotNull StringBuilder out,
                          Iterable<? extends Range> ranges)

extractRanges
```
@NotNull
T extractRanges(Range... ranges)
```
Build a sequence of ranges in this sequence
NOTE: BasedSequence ranges must be non-overlapping and ordered by startOffset or IllegalArgumentException will be thrown

Parameters:

ranges - ranges to extract

Returns:

resulting sequence

extractRanges

@NotNull
T extractRanges(Iterable<Range> ranges)

append
```
@NotNull
T append(CharSequence... sequences)
```
Concatenate this sequence and list of others, returning sequence of result

Parameters:

sequences - list of char sequences to append to this sequence, null sequences are skipped

Returns:

appended sequence

append

@NotNull
T append(Iterable<? extends CharSequence> sequences)

lineColumnAtIndex
```
@NotNull
@NotNull com.vladsch.flexmark.util.misc.Pair<Integer,Integer> lineColumnAtIndex(int index)
```
Get the line and column information from index into sequence

Parameters:

index - index for which to get line information

Returns:

Pair(line, column) where line and column are 0 based, throws IllegalArgumentException if index < 0 or > length.

getLineColumnAtIndex

@Deprecated
 @NotNull
default @NotNull com.vladsch.flexmark.util.misc.Pair<Integer,Integer> getLineColumnAtIndex(int index)

Deprecated.

columnAtIndex
```
int columnAtIndex(int index)
```

getColumnAtIndex

@Deprecated
default int getColumnAtIndex(int index)

Deprecated.

isCharAt
```
boolean isCharAt(int index,
                 @NotNull
                 @NotNull com.vladsch.flexmark.util.misc.CharPredicate predicate)
```
Safe, if index out of range returns '\0'

Parameters:

index - index in string

predicate - character set predicate

Returns:

true if character at index tests true

toStringOrNull
```
@Nullable
@Nullable String toStringOrNull()
```
Return string or null if BaseSequence.NULL

Returns:

string or null if BaseSequence.NULL

isIn

boolean isIn(@NotNull
             @NotNull String[] texts)

isIn

boolean isIn(@NotNull
             @NotNull Collection<? extends CharSequence> texts)

Interface IRichSequence<T extends IRichSequence<T>>

Field Summary

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

Method Summary

Methods inherited from interface java.lang.CharSequence

Methods inherited from interface java.lang.Comparable

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

Method Detail

equals

hashCode

emptyArray

nullSequence

lastChar

firstChar

safeCharAt

subSequence

safeSubSequence

safeSubSequence

subSequence

subSequenceBefore

subSequenceAfter

subSequence

endSequence

endSequence

endCharAt

midSequence

midSequence

midCharAt

sequenceOf

sequenceOf

sequenceOf

getBuilder

indexOf

indexOf

indexOf

indexOf

indexOf

indexOf

indexOfAny

indexOfAny

indexOfAny

indexOfNot

indexOfNot

indexOfNot

indexOfAnyNot

indexOfAnyNot

indexOfAnyNot

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOfAny

lastIndexOfAny

lastIndexOfAny

lastIndexOfNot

lastIndexOfNot

lastIndexOfNot

lastIndexOfAnyNot

lastIndexOfAnyNot

lastIndexOfAnyNot

countLeading

countLeadingNot

countLeading

countLeadingNot

countLeading

countLeadingNot

countLeading

countTrailing

countTrailingNot

countTrailing

countTrailingNot

countTrailing

countTrailingNot

countLeadingSpace

countLeadingNotSpace

countLeadingSpace

countLeadingNotSpace

countLeadingSpace