SequenceUtils (flexmark-java sequence utilities 0.62.2 API)

All Known Subinterfaces:

BasedSequence, IRichSequence<T>, ReplacedBasedSequence, RichSequence

All Known Implementing Classes:

BasedSequence.EmptyBasedSequence, BasedSequenceImpl, CharSubSequence, IRichSequenceBase, MappedBasedSequence, MappedRichSequence, PrefixedSubSequence, RichSequenceImpl, SegmentedSequence, SegmentedSequenceFull, SegmentedSequenceTree, SubSequence
```
public interface SequenceUtils
```

Field Summary

Fields
Modifier and Type	Field and Description
`static String`	`ANY_EOL`
`static com.vladsch.flexmark.util.misc.CharPredicate`	`ANY_EOL_SET` Deprecated.
`static com.vladsch.flexmark.util.misc.CharPredicate`	`BACKSLASH_SET` Deprecated.
`static com.vladsch.flexmark.util.misc.CharPredicate`	`DECIMAL_DIGITS` Deprecated.
`static int[]`	`EMPTY_INDICES`
`static char`	`ENC_NUL`
`static String`	`EOL`
`static char`	`EOL_CHAR`
`static char`	`EOL_CHAR1`
`static char`	`EOL_CHAR2`
`static String`	`EOL_CHARS` Deprecated.
`static com.vladsch.flexmark.util.misc.CharPredicate`	`EOL_SET` Deprecated.
`static com.vladsch.flexmark.util.misc.CharPredicate`	`HASH_SET` Deprecated.
`static com.vladsch.flexmark.util.misc.CharPredicate`	`HEXADECIMAL_DIGITS` Deprecated.
`static String`	`LINE_SEP`
`static char`	`LS`
`static char`	`LSEP` Deprecated. use new names instead
`static char`	`NBSP`
`static String`	`NBSP_CHARS`
`static char`	`NUL`
`static com.vladsch.flexmark.util.misc.CharPredicate`	`OCTAL_DIGITS` Deprecated.
`static String`	`SPACE`
`static String`	`SPACE_EOL`
`static com.vladsch.flexmark.util.misc.CharPredicate`	`SPACE_EOL_SET` Deprecated.
`static com.vladsch.flexmark.util.misc.CharPredicate`	`SPACE_SET` Deprecated. use CharPredicate fields directly
`static String`	`SPACE_TAB`
`static com.vladsch.flexmark.util.misc.CharPredicate`	`SPACE_TAB_EOL_SET` Deprecated.
`static com.vladsch.flexmark.util.misc.CharPredicate`	`SPACE_TAB_NBSP_SET` Deprecated.
`static com.vladsch.flexmark.util.misc.CharPredicate`	`SPACE_TAB_SET` Deprecated.
`static char`	`SPC`
`static int`	`SPLIT_INCLUDE_DELIM_PARTS`
`static int`	`SPLIT_INCLUDE_DELIMS`
`static int`	`SPLIT_SKIP_EMPTY`
`static int`	`SPLIT_TRIM_PARTS`
`static int`	`SPLIT_TRIM_SKIP_EMPTY`
`static com.vladsch.flexmark.util.misc.CharPredicate`	`TAB_SET` Deprecated.
`static char`	`US`
`static String`	`US_CHARS`
`static com.vladsch.flexmark.util.misc.CharPredicate`	`US_SET` Deprecated.
`static Map<Character,String>`	`visibleSpacesMap`
`static String`	`WHITESPACE`
`static String`	`WHITESPACE_CHARS` Deprecated.
`static String`	`WHITESPACE_NBSP`
`static String`	`WHITESPACE_NBSP_CHARS` Deprecated.
`static com.vladsch.flexmark.util.misc.CharPredicate`	`WHITESPACE_NBSP_SET` Deprecated.
`static String`	`WHITESPACE_NO_EOL_CHARS` Deprecated.
`static com.vladsch.flexmark.util.misc.CharPredicate`	`WHITESPACE_SET` Deprecated.

Method Summary

All Methods Static Methods Default Methods
Modifier and Type	Method and Description
`static @NotNull List<Range>`	`blankLinesRemovedRanges(@NotNull CharSequence thizz)`
`static @NotNull List<Range>`	`blankLinesRemovedRanges(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars, int fromIndex, int endIndex)`
`static @NotNull List<Range>`	`blankLinesRemovedRanges(@NotNull CharSequence thizz, int fromIndex)`
`static @NotNull List<Range>`	`blankLinesRemovedRanges(@NotNull CharSequence thizz, int fromIndex, int endIndex)`
`static int`	`columnAtIndex(@NotNull CharSequence thizz, int index)`
`static int`	`columnsToNextTabStop(int column)`
`static int`	`compare(@Nullable CharSequence o1, @Nullable CharSequence o2)`
`static int`	`compare(@Nullable CharSequence o1, @Nullable CharSequence o2, boolean ignoreCase)`
`static int`	`compare(@Nullable CharSequence o1, @Nullable CharSequence o2, boolean ignoreCase, @Nullable com.vladsch.flexmark.util.misc.CharPredicate ignoreChars)`
`static int`	`compareReversed(@Nullable CharSequence o1, @Nullable CharSequence o2)`
`static boolean`	`containedBy(@NotNull Collection<? extends CharSequence> items, @NotNull CharSequence element)`
`static <T extends CharSequence> boolean`	`containedBy(T[] items, @NotNull CharSequence element)`
`static boolean`	`containsAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)`
`static boolean`	`containsAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int index)`
`static boolean`	`containsAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)`
`static boolean`	`containsAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex)`
`static boolean`	`containsAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex, int endIndex)`
`static int`	`countLeading(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static int`	`countLeading(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int fromIndex)`
`static int`	`countLeading(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int fromIndex, int endIndex)`
`static int`	`countLeadingColumns(@NotNull CharSequence thizz, int startColumn, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static int`	`countLeadingNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static int`	`countLeadingNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int fromIndex)`
`static int`	`countLeadingNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex, int endIndex)`
`static int`	`countLeadingNotSpace(@NotNull CharSequence thizz)`
`static int`	`countLeadingNotSpace(@NotNull CharSequence thizz, int startIndex)`
`static int`	`countLeadingNotSpace(@NotNull CharSequence thizz, int startIndex, int endIndex)`
`static int`	`countLeadingNotSpaceTab(@NotNull CharSequence thizz)`
`static int`	`countLeadingNotSpaceTab(@NotNull CharSequence thizz, int startIndex)`
`static int`	`countLeadingNotSpaceTab(@NotNull CharSequence thizz, int startIndex, int endIndex)`
`static int`	`countLeadingNotWhitespace(@NotNull CharSequence thizz)`
`static int`	`countLeadingNotWhitespace(@NotNull CharSequence thizz, int startIndex)`
`static int`	`countLeadingNotWhitespace(@NotNull CharSequence thizz, int startIndex, int endIndex)`
`static int`	`countLeadingSpace(@NotNull CharSequence thizz)`
`static int`	`countLeadingSpace(@NotNull CharSequence thizz, int startIndex)`
`static int`	`countLeadingSpace(@NotNull CharSequence thizz, int startIndex, int endIndex)`
`static int`	`countLeadingSpaceTab(@NotNull CharSequence thizz)`
`static int`	`countLeadingSpaceTab(@NotNull CharSequence thizz, int startIndex)`
`static int`	`countLeadingSpaceTab(@NotNull CharSequence thizz, int startIndex, int endIndex)`
`static int`	`countLeadingWhitespace(@NotNull CharSequence thizz)`
`static int`	`countLeadingWhitespace(@NotNull CharSequence thizz, int startIndex)`
`static int`	`countLeadingWhitespace(@NotNull CharSequence thizz, int startIndex, int endIndex)`
`static int`	`countOfAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static int`	`countOfAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int fromIndex)`
`static int`	`countOfAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex, int endIndex)`
`static int`	`countOfAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static int`	`countOfAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int fromIndex)`
`static int`	`countOfAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int fromIndex, int endIndex)`
`static int`	`countOfNotSpaceTab(@NotNull CharSequence thizz)`
`static int`	`countOfNotWhitespace(@NotNull CharSequence thizz)`
`static int`	`countOfSpaceTab(@NotNull CharSequence thizz)`
`static int`	`countOfWhitespace(@NotNull CharSequence thizz)`
`static int`	`countTrailing(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static int`	`countTrailing(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int fromIndex)`
`static int`	`countTrailing(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex, int fromIndex)`
`static int`	`countTrailingNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static int`	`countTrailingNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int fromIndex)`
`static int`	`countTrailingNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars, int startIndex, int endIndex)`
`static int`	`countTrailingNotSpace(@NotNull CharSequence thizz)`
`static int`	`countTrailingNotSpace(@NotNull CharSequence thizz, int fromIndex)`
`static int`	`countTrailingNotSpace(@NotNull CharSequence thizz, int startIndex, int fromIndex)`
`static int`	`countTrailingNotSpaceTab(@NotNull CharSequence thizz)`
`static int`	`countTrailingNotSpaceTab(@NotNull CharSequence thizz, int fromIndex)`
`static int`	`countTrailingNotSpaceTab(@NotNull CharSequence thizz, int startIndex, int fromIndex)`
`static int`	`countTrailingNotWhitespace(@NotNull CharSequence thizz)`
`static int`	`countTrailingNotWhitespace(@NotNull CharSequence thizz, int fromIndex)`
`static int`	`countTrailingNotWhitespace(@NotNull CharSequence thizz, int startIndex, int fromIndex)`
`static int`	`countTrailingSpace(@NotNull CharSequence thizz)`
`static int`	`countTrailingSpace(@NotNull CharSequence thizz, int fromIndex)`
`static int`	`countTrailingSpace(@NotNull CharSequence thizz, int startIndex, int fromIndex)`
`static int`	`countTrailingSpaceTab(@NotNull CharSequence thizz)`
`static int`	`countTrailingSpaceTab(@NotNull CharSequence thizz, int fromIndex)`
`static int`	`countTrailingSpaceTab(@NotNull CharSequence thizz, int startIndex, int fromIndex)`
`static int`	`countTrailingWhitespace(@NotNull CharSequence thizz)`
`static int`	`countTrailingWhitespace(@NotNull CharSequence thizz, int fromIndex)`
`static int`	`countTrailingWhitespace(@NotNull CharSequence thizz, int startIndex, int fromIndex)`
`static int`	`endOfDelimitedBy(@NotNull CharSequence thizz, @NotNull CharSequence s, int index)`
`static int`	`endOfDelimitedByAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int index)`
`static int`	`endOfDelimitedByAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int index)`
`static int`	`endOfLine(@NotNull CharSequence thizz, int index)`
`static int`	`endOfLineAnyEOL(@NotNull CharSequence thizz, int index)`
`static boolean`	`endsWith(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static boolean`	`endsWith(@NotNull CharSequence thizz, @NotNull CharSequence suffix)`
`static boolean`	`endsWith(@NotNull CharSequence thizz, @NotNull CharSequence suffix, boolean ignoreCase)`
`static boolean`	`endsWithAnyEOL(@NotNull CharSequence thizz)`
`static boolean`	`endsWithEOL(@NotNull CharSequence thizz)`
`static boolean`	`endsWithSpace(@NotNull CharSequence thizz)`
`static boolean`	`endsWithSpaceTab(@NotNull CharSequence thizz)`
`static boolean`	`endsWithWhitespace(@NotNull CharSequence thizz)`
`static int`	`eolEndLength(@NotNull CharSequence thizz)`
`static int`	`eolEndLength(@NotNull CharSequence thizz, int eolEnd)`
`static @NotNull Range`	`eolEndRange(@NotNull CharSequence thizz, int eolEnd)`
`static int`	`eolStartLength(@NotNull CharSequence thizz, int eolStart)`
`static @NotNull Range`	`eolStartRange(@NotNull CharSequence thizz, int eolStart)`
`static boolean`	`equals(@NotNull CharSequence thizz, Object o)` Equality comparison based on character content of this sequence, with quick fail resorting to content comparison only if length and hashCodes are equal
`static @NotNull int[]`	`expandTo(@NotNull int[] indices, int length, int step)`
`static char`	`firstChar(@NotNull CharSequence thizz)`
`static Map<Character,String>`	`getVisibleSpacesMap()`
`static int`	`hashCode(@NotNull CharSequence thizz)`
`static int`	`indexOf(@NotNull CharSequence thizz, char c)`
`static int`	`indexOf(@NotNull CharSequence thizz, char c, int fromIndex)`
`static int`	`indexOf(@NotNull CharSequence thizz, char c, int fromIndex, int endIndex)`
`static int`	`indexOf(@NotNull CharSequence thizz, @NotNull CharSequence s)`
`static int`	`indexOf(@NotNull CharSequence thizz, @NotNull CharSequence s, int fromIndex)`
`static int`	`indexOf(@NotNull CharSequence thizz, @NotNull CharSequence s, int fromIndex, int endIndex)`
`static @NotNull int[]`	`indexOfAll(@NotNull CharSequence thizz, @NotNull CharSequence s)`
`static int`	`indexOfAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)`
`static int`	`indexOfAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int index)`
`static int`	`indexOfAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex, int endIndex)`
`static int`	`indexOfAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)`
`static int`	`indexOfAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex)`
`static int`	`indexOfAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex, int endIndex)`
`static int`	`indexOfNot(@NotNull CharSequence thizz, char c)`
`static int`	`indexOfNot(@NotNull CharSequence thizz, char c, int fromIndex)`
`static int`	`indexOfNot(@NotNull CharSequence thizz, char c, int fromIndex, int endIndex)`
`static boolean`	`isBlank(@NotNull CharSequence thizz)`
`static boolean`	`isEmpty(@NotNull CharSequence thizz)`
`static boolean`	`isNotBlank(@NotNull CharSequence thizz)`
`static boolean`	`isNotEmpty(@NotNull CharSequence thizz)`
`static boolean`	`isVisibleWhitespace(char c)`
`static char`	`lastChar(@NotNull CharSequence thizz)`
`static int`	`lastIndexOf(@NotNull CharSequence thizz, char c)`
`static int`	`lastIndexOf(@NotNull CharSequence thizz, char c, int fromIndex)`
`static int`	`lastIndexOf(@NotNull CharSequence thizz, char c, int startIndex, int fromIndex)`
`static int`	`lastIndexOf(@NotNull CharSequence thizz, @NotNull CharSequence s)`
`static int`	`lastIndexOf(@NotNull CharSequence thizz, @NotNull CharSequence s, int fromIndex)`
`static int`	`lastIndexOf(@NotNull CharSequence thizz, @NotNull CharSequence s, int startIndex, int fromIndex)`
`static int`	`lastIndexOfAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)`
`static int`	`lastIndexOfAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex)`
`static int`	`lastIndexOfAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int startIndex, int fromIndex)`
`static int`	`lastIndexOfAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)`
`static int`	`lastIndexOfAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int fromIndex)`
`static int`	`lastIndexOfAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int startIndex, int fromIndex)`
`static int`	`lastIndexOfNot(@NotNull CharSequence thizz, char c)`
`static int`	`lastIndexOfNot(@NotNull CharSequence thizz, char c, int fromIndex)`
`static int`	`lastIndexOfNot(@NotNull CharSequence thizz, char c, int startIndex, int fromIndex)`
`static @NotNull Range`	`leadingBlankLinesRange(@NotNull CharSequence thizz)`
`static @NotNull Range`	`leadingBlankLinesRange(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars, int fromIndex, int endIndex)`
`static @NotNull Range`	`leadingBlankLinesRange(@NotNull CharSequence thizz, int startIndex)`
`static @NotNull Range`	`leadingBlankLinesRange(@NotNull CharSequence thizz, int fromIndex, int endIndex)`
`static @NotNull com.vladsch.flexmark.util.misc.Pair<Integer,Integer>`	`lineColumnAtIndex(@NotNull CharSequence thizz, int index)`
`static @NotNull Range`	`lineRangeAt(@NotNull CharSequence thizz, int index)`
`static @NotNull Range`	`lineRangeAtAnyEOL(@NotNull CharSequence thizz, int index)`
`static boolean`	`matchChars(@NotNull CharSequence thizz, @NotNull CharSequence chars)`
`static boolean`	`matchChars(@NotNull CharSequence thizz, @NotNull CharSequence chars, boolean ignoreCase)`
`static boolean`	`matchChars(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex)`
`static boolean`	`matchChars(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex, boolean ignoreCase)`
`static boolean`	`matchCharsIgnoreCase(@NotNull CharSequence thizz, @NotNull CharSequence chars)`
`static boolean`	`matchCharsIgnoreCase(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex)`
`static boolean`	`matchCharsReversed(@NotNull CharSequence thizz, @NotNull CharSequence chars, int endIndex)`
`static boolean`	`matchCharsReversed(@NotNull CharSequence thizz, @NotNull CharSequence chars, int endIndex, boolean ignoreCase)`
`static boolean`	`matchCharsReversedIgnoreCase(@NotNull CharSequence thizz, @NotNull CharSequence chars, int endIndex)`
`static int`	`matchedCharCount(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex)`
`static int`	`matchedCharCount(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex, boolean ignoreCase)`
`static int`	`matchedCharCount(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex, int endIndex)`
`static int`	`matchedCharCount(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex, int endIndex, boolean ignoreCase)`
`static int`	`matchedCharCount(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex, int endIndex, boolean fullMatchOnly, boolean ignoreCase)`
`static int`	`matchedCharCountIgnoreCase(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex)`
`static int`	`matchedCharCountIgnoreCase(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex, int endIndex)`
`static int`	`matchedCharCountReversed(@NotNull CharSequence thizz, @NotNull CharSequence chars, int fromIndex)`
`static int`	`matchedCharCountReversed(@NotNull CharSequence thizz, @NotNull CharSequence chars, int fromIndex, boolean ignoreCase)`
`static int`	`matchedCharCountReversed(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex, int fromIndex)`
`static int`	`matchedCharCountReversed(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex, int fromIndex, boolean ignoreCase)`
`static int`	`matchedCharCountReversedIgnoreCase(@NotNull CharSequence thizz, @NotNull CharSequence chars, int fromIndex)`
`static int`	`matchedCharCountReversedIgnoreCase(@NotNull CharSequence thizz, @NotNull CharSequence chars, int startIndex, int fromIndex)`
`static boolean`	`matches(@NotNull CharSequence thizz, @NotNull CharSequence chars)`
`static boolean`	`matches(@NotNull CharSequence thizz, @NotNull CharSequence chars, boolean ignoreCase)`
`static boolean`	`matchesIgnoreCase(@NotNull CharSequence thizz, @NotNull CharSequence chars)`
`static @NotNull String`	`padEnd(@NotNull CharSequence thizz, int length)`
`static @NotNull String`	`padEnd(@NotNull CharSequence thizz, int length, char pad)`
`static @NotNull String`	`padStart(@NotNull CharSequence thizz, int length)`
`static @NotNull String`	`padStart(@NotNull CharSequence thizz, int length, char pad)`
`static int`	`parseIntOrDefault(String text, int defaultValue)`
`static int`	`parseIntOrDefault(String text, int defaultValue, int radix)`
`static Integer`	`parseIntOrNull(String text)`
`static Integer`	`parseIntOrNull(String text, int radix)`
`static Long`	`parseLongOrNull(String text)`
`static Long`	`parseLongOrNull(String text, int radix)`
`static @Nullable Number`	`parseNumberOrNull(@Nullable String text)` Parse number from text
`static @Nullable com.vladsch.flexmark.util.misc.Pair<Number,String>`	`parseNumberPrefixOrNull(@Nullable String text, @Nullable Predicate<String> suffixTester)` Parse number from text
`static int`	`parseUnsignedIntOrDefault(String text, int defaultValue)`
`static int`	`parseUnsignedIntOrDefault(String text, int defaultValue, int radix)`
`static Integer`	`parseUnsignedIntOrNull(String text)`
`static Integer`	`parseUnsignedIntOrNull(String text, int radix)`
`static char`	`safeCharAt(@NotNull CharSequence thizz, int index)`
`static <T extends CharSequence> T[]`	`split(T thizz, T[] emptyArray, @NotNull CharSequence delimiter)`
`static <T extends CharSequence> T[]`	`split(T thizz, T[] emptyArray, @NotNull CharSequence delimiter, boolean includeDelims, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`static <T extends CharSequence> T[]`	`split(T thizz, T[] emptyArray, @NotNull CharSequence delimiter, int limit, boolean includeDelims, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`static <T extends CharSequence> T[]`	`split(T thizz, T[] emptyArray, @NotNull CharSequence delimiter, int limit, int flags)`
`static <T extends CharSequence> T[]`	`split(T thizz, T[] emptyArray, @NotNull CharSequence delimiter, int limit, int flags, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`static <T extends CharSequence> T[]`	`splitEOL(T thizz, T[] emptyArray)`
`static <T extends CharSequence> T[]`	`splitEOL(T thizz, T[] emptyArray, boolean includeDelims)`
`static <T extends CharSequence> @NotNull List<T>`	`splitList(T thizz, @NotNull CharSequence delimiter)`
`static <T extends CharSequence> @NotNull List<T>`	`splitList(T thizz, @NotNull CharSequence delimiter, boolean includeDelims, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`static <T extends CharSequence> @NotNull List<T>`	`splitList(T thizz, @NotNull CharSequence delimiter, int limit, boolean includeDelims, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`static <T extends CharSequence> @NotNull List<T>`	`splitList(T thizz, @NotNull CharSequence delimiter, int limit, int flags)`
`static <T extends CharSequence> @NotNull List<T>`	`splitList(T thizz, @NotNull CharSequence delimiter, int limit, int flags, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`static <T extends CharSequence> @NotNull List<T>`	`splitListEOL(T thizz)`
`static <T extends CharSequence> @NotNull List<T>`	`splitListEOL(T thizz, boolean includeDelims)`
`static <T extends CharSequence> @NotNull List<T>`	`splitListEOL(T thizz, boolean includeDelims, @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)`
`static int`	`startOfDelimitedBy(@NotNull CharSequence thizz, @NotNull CharSequence s, int index)`
`static int`	`startOfDelimitedByAny(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int index)`
`static int`	`startOfDelimitedByAnyNot(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate s, int index)`
`static int`	`startOfLine(@NotNull CharSequence thizz, int index)`
`static int`	`startOfLineAnyEOL(@NotNull CharSequence thizz, int index)`
`static boolean`	`startsWith(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static boolean`	`startsWith(@NotNull CharSequence thizz, @NotNull CharSequence prefix)`
`static boolean`	`startsWith(@NotNull CharSequence thizz, @NotNull CharSequence prefix, boolean ignoreCase)`
`static boolean`	`startsWithAnyEOL(@NotNull CharSequence thizz)`
`static boolean`	`startsWithEOL(@NotNull CharSequence thizz)`
`static boolean`	`startsWithSpace(@NotNull CharSequence thizz)`
`static boolean`	`startsWithSpaceTab(@NotNull CharSequence thizz)`
`static boolean`	`startsWithWhitespace(@NotNull CharSequence thizz)`
`static <T extends CharSequence> T`	`subSequence(T thizz, int startIndex)`
`static <T extends CharSequence> T`	`subSequence(T thizz, @NotNull Range range)` Get a portion of this sequence selected by range
`static <T extends CharSequence> T`	`subSequenceAfter(T thizz, @NotNull Range range)` Get a portion of this sequence after one selected by range
`static <T extends CharSequence> T`	`subSequenceBefore(T thizz, @NotNull Range range)` Get a portion of this sequence before one selected by range
`static <T extends CharSequence> @NotNull com.vladsch.flexmark.util.misc.Pair<T,T>`	`subSequenceBeforeAfter(T thizz, Range range)` Get a portions of this sequence before and after one selected by range
`static @NotNull String[]`	`toStringArray(CharSequence... sequences)`
`static @NotNull String`	`toVisibleWhitespaceString(@NotNull CharSequence thizz)`
`static @NotNull Range`	`trailingBlankLinesRange(@NotNull CharSequence thizz)`
`static @NotNull Range`	`trailingBlankLinesRange(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars, int startIndex, int fromIndex)`
`static @NotNull Range`	`trailingBlankLinesRange(@NotNull CharSequence thizz, int fromIndex)`
`static @NotNull Range`	`trailingBlankLinesRange(@NotNull CharSequence thizz, int startIndex, int fromIndex)`
`static <T extends CharSequence> T`	`trim(T thizz)`
`static <T extends CharSequence> T`	`trim(T thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trim(T thizz, int keep)`
`static <T extends CharSequence> T`	`trim(T thizz, int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trimEnd(T thizz)`
`static <T extends CharSequence> T`	`trimEnd(T thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trimEnd(T thizz, int keep)`
`static <T extends CharSequence> T`	`trimEnd(T thizz, int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static Range`	`trimEndRange(@NotNull CharSequence thizz)`
`static Range`	`trimEndRange(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static Range`	`trimEndRange(@NotNull CharSequence thizz, int keep)`
`static @NotNull Range`	`trimEndRange(@NotNull CharSequence thizz, int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trimEOL(T thizz)`
`static <T extends CharSequence> T`	`trimLeadBlankLines(T thizz)`
`static <T extends CharSequence> @NotNull com.vladsch.flexmark.util.misc.Pair<T,T>`	`trimmed(T thizz)`
`static <T extends CharSequence> @NotNull com.vladsch.flexmark.util.misc.Pair<T,T>`	`trimmed(T thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> @NotNull com.vladsch.flexmark.util.misc.Pair<T,T>`	`trimmed(T thizz, int keep)`
`static <T extends CharSequence> @NotNull com.vladsch.flexmark.util.misc.Pair<T,T>`	`trimmed(T thizz, int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trimmedEnd(T thizz)`
`static <T extends CharSequence> T`	`trimmedEnd(T thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trimmedEnd(T thizz, int keep)`
`static <T extends CharSequence> T`	`trimmedEnd(T thizz, int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trimmedEOL(T thizz)`
`static <T extends CharSequence> T`	`trimmedStart(T thizz)`
`static <T extends CharSequence> T`	`trimmedStart(T thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trimmedStart(T thizz, int keep)`
`static <T extends CharSequence> T`	`trimmedStart(T thizz, int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static Range`	`trimRange(@NotNull CharSequence thizz)`
`static Range`	`trimRange(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static Range`	`trimRange(@NotNull CharSequence thizz, int keep)`
`static @NotNull Range`	`trimRange(@NotNull CharSequence thizz, int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trimStart(T thizz)`
`static <T extends CharSequence> T`	`trimStart(T thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trimStart(T thizz, int keep)`
`static <T extends CharSequence> T`	`trimStart(T thizz, int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static Range`	`trimStartRange(@NotNull CharSequence thizz)`
`static Range`	`trimStartRange(@NotNull CharSequence thizz, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static Range`	`trimStartRange(@NotNull CharSequence thizz, int keep)`
`static @NotNull Range`	`trimStartRange(@NotNull CharSequence thizz, int keep, @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)`
`static <T extends CharSequence> T`	`trimTailBlankLines(T thizz)`
`static @NotNull int[]`	`truncateTo(@NotNull int[] indices, int length)`
`static void`	`validateIndex(int index, int length)`
`static void`	`validateIndexInclusiveEnd(int index, int length)`
`static void`	`validateStartEnd(int startIndex, int endIndex, int length)`

Field Detail

EOL
```
static final String EOL
```
See Also:

Constant Field Values

SPACE
```
static final String SPACE
```
See Also:

Constant Field Values

ANY_EOL
```
static final String ANY_EOL
```
See Also:

Constant Field Values

EOL_CHAR
```
static final char EOL_CHAR
```

EOL_CHAR1
```
static final char EOL_CHAR1
```

EOL_CHAR2
```
static final char EOL_CHAR2
```

SPC
```
static final char SPC
```
See Also:

Constant Field Values

NUL
```
static final char NUL
```
See Also:

Constant Field Values

ENC_NUL
```
static final char ENC_NUL
```
See Also:

Constant Field Values

NBSP
```
static final char NBSP
```
See Also:

Constant Field Values

LS
```
static final char LS
```
See Also:

Constant Field Values

US
```
static final char US
```
See Also:

Constant Field Values

LINE_SEP
```
static final String LINE_SEP
```

SPACE_TAB
```
static final String SPACE_TAB
```
See Also:

Constant Field Values

SPACE_EOL
```
static final String SPACE_EOL
```
See Also:

Constant Field Values

US_CHARS
```
static final String US_CHARS
```

WHITESPACE
```
static final String WHITESPACE
```
See Also:

Constant Field Values

NBSP_CHARS
```
static final String NBSP_CHARS
```

WHITESPACE_NBSP
```
static final String WHITESPACE_NBSP
```
See Also:

Constant Field Values

SPACE_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate SPACE_SET

Deprecated. use CharPredicate fields directly

TAB_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate TAB_SET

Deprecated.

EOL_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate EOL_SET

Deprecated.

SPACE_TAB_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate SPACE_TAB_SET

Deprecated.

SPACE_TAB_NBSP_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate SPACE_TAB_NBSP_SET

Deprecated.

SPACE_TAB_EOL_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate SPACE_TAB_EOL_SET

Deprecated.

SPACE_EOL_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate SPACE_EOL_SET

Deprecated.

ANY_EOL_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate ANY_EOL_SET

Deprecated.

WHITESPACE_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate WHITESPACE_SET

Deprecated.

WHITESPACE_NBSP_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate WHITESPACE_NBSP_SET

Deprecated.

BACKSLASH_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate BACKSLASH_SET

Deprecated.

US_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate US_SET

Deprecated.

HASH_SET

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate HASH_SET

Deprecated.

DECIMAL_DIGITS

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate DECIMAL_DIGITS

Deprecated.

HEXADECIMAL_DIGITS

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate HEXADECIMAL_DIGITS

Deprecated.

OCTAL_DIGITS

@Deprecated
static final com.vladsch.flexmark.util.misc.CharPredicate OCTAL_DIGITS

Deprecated.

LSEP
```
@Deprecated
static final char LSEP
```
Deprecated. use new names instead

See Also:

Constant Field Values

EOL_CHARS
```
@Deprecated
static final String EOL_CHARS
```
Deprecated.

See Also:

Constant Field Values

WHITESPACE_NO_EOL_CHARS
```
@Deprecated
static final String WHITESPACE_NO_EOL_CHARS
```
Deprecated.

See Also:

Constant Field Values

WHITESPACE_CHARS
```
@Deprecated
static final String WHITESPACE_CHARS
```
Deprecated.

See Also:

Constant Field Values

WHITESPACE_NBSP_CHARS
```
@Deprecated
static final String WHITESPACE_NBSP_CHARS
```
Deprecated.

See Also:

Constant Field Values

SPLIT_INCLUDE_DELIMS
```
static final int SPLIT_INCLUDE_DELIMS
```
See Also:

Constant Field Values

SPLIT_TRIM_PARTS
```
static final int SPLIT_TRIM_PARTS
```
See Also:

Constant Field Values

SPLIT_SKIP_EMPTY
```
static final int SPLIT_SKIP_EMPTY
```
See Also:

Constant Field Values

SPLIT_INCLUDE_DELIM_PARTS
```
static final int SPLIT_INCLUDE_DELIM_PARTS
```
See Also:

Constant Field Values

SPLIT_TRIM_SKIP_EMPTY
```
static final int SPLIT_TRIM_SKIP_EMPTY
```
See Also:

Constant Field Values

visibleSpacesMap

static final Map<Character,String> visibleSpacesMap

EMPTY_INDICES
```
static final int[] EMPTY_INDICES
```

Method Detail

getVisibleSpacesMap

static Map<Character,String> getVisibleSpacesMap()

subSequence

@NotNull
static <T extends CharSequence> T subSequence(@NotNull
                                                       T thizz,
                                                       int startIndex)

subSequence
```
@NotNull
static <T extends CharSequence> T subSequence(@NotNull
                                                       T thizz,
                                                       @NotNull
                                                       @NotNull Range range)
```
Get a portion of this sequence selected by range

Type Parameters:

T - type of character sequence

Parameters:

thizz - char sequence

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

Returns:

sequence whose contents reflect the selected portion, if range.isNull() then this is returned

subSequenceBefore
```
@Nullable
static <T extends CharSequence> T subSequenceBefore(@NotNull
                                                              T thizz,
                                                              @NotNull
                                                              @NotNull Range range)
```
Get a portion of this sequence before one selected by range

Type Parameters:

T - type of character sequence

Parameters:

thizz - char sequence

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

Returns:

sequence whose contents come before the selected range, if range.isNull() then null

subSequenceAfter
```
@Nullable
static <T extends CharSequence> T subSequenceAfter(@NotNull
                                                             T thizz,
                                                             @NotNull
                                                             @NotNull Range range)
```
Get a portion of this sequence after one selected by range

Type Parameters:

T - type of character sequence

Parameters:

thizz - char sequence

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

Returns:

sequence whose contents come after the selected range, if range.isNull() then null

subSequenceBeforeAfter

@NotNull
static <T extends CharSequence> @NotNull com.vladsch.flexmark.util.misc.Pair<T,T> subSequenceBeforeAfter(@NotNull
                                                                                                                  T thizz,
                                                                                                                  Range range)

Get a portions of this sequence before and after one selected by range

Type Parameters:: T - type of character sequence
Parameters:: thizz - char sequence; range - range to get, coordinates offset form start of this sequence
Returns:: sequence whose contents come before and after the selected range, if range.isNull() then pair of nulls

containsAny

static boolean containsAny(@NotNull
                           @NotNull CharSequence thizz,
                           @NotNull
                           @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)

containsAny

static boolean containsAny(@NotNull
                           @NotNull CharSequence thizz,
                           @NotNull
                           @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                           int index)

containsAnyNot

static boolean containsAnyNot(@NotNull
                              @NotNull CharSequence thizz,
                              @NotNull
                              @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)

containsAnyNot

static boolean containsAnyNot(@NotNull
                              @NotNull CharSequence thizz,
                              @NotNull
                              @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                              int fromIndex)

containsAnyNot

static boolean containsAnyNot(@NotNull
                              @NotNull CharSequence thizz,
                              @NotNull
                              @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                              int fromIndex,
                              int endIndex)

indexOf

static int indexOf(@NotNull
                   @NotNull CharSequence thizz,
                   @NotNull
                   @NotNull CharSequence s)

indexOf

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

indexOf

static int indexOf(@NotNull
                   @NotNull CharSequence thizz,
                   char c)

indexOf

static int indexOf(@NotNull
                   @NotNull CharSequence thizz,
                   char c,
                   int fromIndex)

indexOfAny

static int indexOfAny(@NotNull
                      @NotNull CharSequence thizz,
                      @NotNull
                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)

indexOfAny

static int indexOfAny(@NotNull
                      @NotNull CharSequence thizz,
                      @NotNull
                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                      int index)

indexOfAnyNot

static int indexOfAnyNot(@NotNull
                         @NotNull CharSequence thizz,
                         @NotNull
                         @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)

indexOfAnyNot

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

indexOfAnyNot

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

indexOfNot

static int indexOfNot(@NotNull
                      @NotNull CharSequence thizz,
                      char c)

indexOfNot

static int indexOfNot(@NotNull
                      @NotNull CharSequence thizz,
                      char c,
                      int fromIndex)

lastIndexOf

static int lastIndexOf(@NotNull
                       @NotNull CharSequence thizz,
                       @NotNull
                       @NotNull CharSequence s)

lastIndexOf

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

lastIndexOf

static int lastIndexOf(@NotNull
                       @NotNull CharSequence thizz,
                       char c)

lastIndexOf

static int lastIndexOf(@NotNull
                       @NotNull CharSequence thizz,
                       char c,
                       int fromIndex)

lastIndexOfAny

static int lastIndexOfAny(@NotNull
                          @NotNull CharSequence thizz,
                          @NotNull
                          @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)

lastIndexOfAny

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

lastIndexOfAnyNot

static int lastIndexOfAnyNot(@NotNull
                             @NotNull CharSequence thizz,
                             @NotNull
                             @NotNull com.vladsch.flexmark.util.misc.CharPredicate s)

lastIndexOfAnyNot

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

lastIndexOfAnyNot

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

lastIndexOfNot

static int lastIndexOfNot(@NotNull
                          @NotNull CharSequence thizz,
                          char c)

lastIndexOfNot

static int lastIndexOfNot(@NotNull
                          @NotNull CharSequence thizz,
                          char c,
                          int fromIndex)

indexOf

static int indexOf(@NotNull
                   @NotNull CharSequence thizz,
                   char c,
                   int fromIndex,
                   int endIndex)

indexOf

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

lastIndexOf

static int lastIndexOf(@NotNull
                       @NotNull CharSequence thizz,
                       char c,
                       int startIndex,
                       int fromIndex)

indexOfNot

static int indexOfNot(@NotNull
                      @NotNull CharSequence thizz,
                      char c,
                      int fromIndex,
                      int endIndex)

indexOfAny

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

lastIndexOf

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

lastIndexOfNot

static int lastIndexOfNot(@NotNull
                          @NotNull CharSequence thizz,
                          char c,
                          int startIndex,
                          int fromIndex)

lastIndexOfAny

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

equals

@Contract(pure=true,
          value="_, null -> false")
static boolean equals(@NotNull
                                                                               @NotNull CharSequence thizz,
                                                                               Object o)

Equality comparison based on character content of this sequence, with quick fail resorting to content comparison only if length and hashCodes are equal

Parameters:: thizz - char sequence to test for equality; o - any character sequence
Returns:: true if character contents are equal

hashCode

@Contract(pure=true)
static int hashCode(@NotNull
                                         @NotNull CharSequence thizz)

compareReversed

static int compareReversed(@Nullable
                           @Nullable CharSequence o1,
                           @Nullable
                           @Nullable CharSequence o2)

compare

static int compare(@Nullable
                   @Nullable CharSequence o1,
                   @Nullable
                   @Nullable CharSequence o2)

compare

static int compare(@Nullable
                   @Nullable CharSequence o1,
                   @Nullable
                   @Nullable CharSequence o2,
                   boolean ignoreCase)

compare

static int compare(@Nullable
                   @Nullable CharSequence o1,
                   @Nullable
                   @Nullable CharSequence o2,
                   boolean ignoreCase,
                   @Nullable
                   @Nullable com.vladsch.flexmark.util.misc.CharPredicate ignoreChars)

toStringArray

@NotNull
static @NotNull String[] toStringArray(CharSequence... sequences)

isVisibleWhitespace

static boolean isVisibleWhitespace(char c)

columnsToNextTabStop

static int columnsToNextTabStop(int column)

expandTo

@NotNull
static @NotNull int[] expandTo(@NotNull
                                        @NotNull int[] indices,
                                        int length,
                                        int step)

truncateTo

@NotNull
static @NotNull int[] truncateTo(@NotNull
                                          @NotNull int[] indices,
                                          int length)

indexOfAll

@NotNull
static @NotNull int[] indexOfAll(@NotNull
                                          @NotNull CharSequence thizz,
                                          @NotNull
                                          @NotNull CharSequence s)

matches

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

matches

static boolean matches(@NotNull
                       @NotNull CharSequence thizz,
                       @NotNull
                       @NotNull CharSequence chars)

matchesIgnoreCase

static boolean matchesIgnoreCase(@NotNull
                                 @NotNull CharSequence thizz,
                                 @NotNull
                                 @NotNull CharSequence chars)

matchChars

static boolean matchChars(@NotNull
                          @NotNull CharSequence thizz,
                          @NotNull
                          @NotNull CharSequence chars,
                          int startIndex,
                          boolean ignoreCase)

matchChars

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

matchCharsIgnoreCase

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

matchChars

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

matchChars

static boolean matchChars(@NotNull
                          @NotNull CharSequence thizz,
                          @NotNull
                          @NotNull CharSequence chars)

matchCharsIgnoreCase

static boolean matchCharsIgnoreCase(@NotNull
                                    @NotNull CharSequence thizz,
                                    @NotNull
                                    @NotNull CharSequence chars)

matchCharsReversed

static boolean matchCharsReversed(@NotNull
                                  @NotNull CharSequence thizz,
                                  @NotNull
                                  @NotNull CharSequence chars,
                                  int endIndex,
                                  boolean ignoreCase)

matchCharsReversed

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

matchCharsReversedIgnoreCase

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

matchedCharCount

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

matchedCharCount

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

matchedCharCount

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

matchedCharCount

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

matchedCharCountIgnoreCase

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

matchedCharCountIgnoreCase

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

matchedCharCountReversed

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

matchedCharCountReversedIgnoreCase

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

matchedCharCountReversed

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

matchedCharCountReversed

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

matchedCharCountReversedIgnoreCase

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

matchedCharCount

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

matchedCharCountReversed

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

countOfSpaceTab

static int countOfSpaceTab(@NotNull
                           @NotNull CharSequence thizz)

countOfNotSpaceTab

static int countOfNotSpaceTab(@NotNull
                              @NotNull CharSequence thizz)

countOfWhitespace

static int countOfWhitespace(@NotNull
                             @NotNull CharSequence thizz)

countOfNotWhitespace

static int countOfNotWhitespace(@NotNull
                                @NotNull CharSequence thizz)

countOfAny

static int countOfAny(@NotNull
                      @NotNull CharSequence thizz,
                      @NotNull
                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                      int fromIndex)

countOfAny

static int countOfAny(@NotNull
                      @NotNull CharSequence thizz,
                      @NotNull
                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countOfAnyNot

static int countOfAnyNot(@NotNull
                         @NotNull CharSequence thizz,
                         @NotNull
                         @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                         int fromIndex,
                         int endIndex)

countOfAnyNot

static int countOfAnyNot(@NotNull
                         @NotNull CharSequence thizz,
                         @NotNull
                         @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                         int fromIndex)

countOfAnyNot

static int countOfAnyNot(@NotNull
                         @NotNull CharSequence thizz,
                         @NotNull
                         @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countOfAny

static int countOfAny(@NotNull
                      @NotNull CharSequence thizz,
                      @NotNull
                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate s,
                      int fromIndex,
                      int endIndex)

countLeadingSpace

static int countLeadingSpace(@NotNull
                             @NotNull CharSequence thizz)

countLeadingSpace

static int countLeadingSpace(@NotNull
                             @NotNull CharSequence thizz,
                             int startIndex)

countLeadingSpace

static int countLeadingSpace(@NotNull
                             @NotNull CharSequence thizz,
                             int startIndex,
                             int endIndex)

countLeadingNotSpace

static int countLeadingNotSpace(@NotNull
                                @NotNull CharSequence thizz)

countLeadingNotSpace

static int countLeadingNotSpace(@NotNull
                                @NotNull CharSequence thizz,
                                int startIndex)

countLeadingNotSpace

static int countLeadingNotSpace(@NotNull
                                @NotNull CharSequence thizz,
                                int startIndex,
                                int endIndex)

countTrailingSpace

static int countTrailingSpace(@NotNull
                              @NotNull CharSequence thizz)

countTrailingSpace

static int countTrailingSpace(@NotNull
                              @NotNull CharSequence thizz,
                              int fromIndex)

countTrailingSpace

static int countTrailingSpace(@NotNull
                              @NotNull CharSequence thizz,
                              int startIndex,
                              int fromIndex)

countTrailingNotSpace

static int countTrailingNotSpace(@NotNull
                                 @NotNull CharSequence thizz)

countTrailingNotSpace

static int countTrailingNotSpace(@NotNull
                                 @NotNull CharSequence thizz,
                                 int fromIndex)

countTrailingNotSpace

static int countTrailingNotSpace(@NotNull
                                 @NotNull CharSequence thizz,
                                 int startIndex,
                                 int fromIndex)

countLeadingSpaceTab

static int countLeadingSpaceTab(@NotNull
                                @NotNull CharSequence thizz)

countLeadingSpaceTab

static int countLeadingSpaceTab(@NotNull
                                @NotNull CharSequence thizz,
                                int startIndex)

countLeadingSpaceTab

static int countLeadingSpaceTab(@NotNull
                                @NotNull CharSequence thizz,
                                int startIndex,
                                int endIndex)

countLeadingNotSpaceTab

static int countLeadingNotSpaceTab(@NotNull
                                   @NotNull CharSequence thizz)

countLeadingNotSpaceTab

static int countLeadingNotSpaceTab(@NotNull
                                   @NotNull CharSequence thizz,
                                   int startIndex)

countLeadingNotSpaceTab

static int countLeadingNotSpaceTab(@NotNull
                                   @NotNull CharSequence thizz,
                                   int startIndex,
                                   int endIndex)

countTrailingSpaceTab

static int countTrailingSpaceTab(@NotNull
                                 @NotNull CharSequence thizz)

countTrailingSpaceTab

static int countTrailingSpaceTab(@NotNull
                                 @NotNull CharSequence thizz,
                                 int fromIndex)

countTrailingSpaceTab

static int countTrailingSpaceTab(@NotNull
                                 @NotNull CharSequence thizz,
                                 int startIndex,
                                 int fromIndex)

countTrailingNotSpaceTab

static int countTrailingNotSpaceTab(@NotNull
                                    @NotNull CharSequence thizz)

countTrailingNotSpaceTab

static int countTrailingNotSpaceTab(@NotNull
                                    @NotNull CharSequence thizz,
                                    int fromIndex)

countTrailingNotSpaceTab

static int countTrailingNotSpaceTab(@NotNull
                                    @NotNull CharSequence thizz,
                                    int startIndex,
                                    int fromIndex)

countLeadingWhitespace

static int countLeadingWhitespace(@NotNull
                                  @NotNull CharSequence thizz)

countLeadingWhitespace

static int countLeadingWhitespace(@NotNull
                                  @NotNull CharSequence thizz,
                                  int startIndex)

countLeadingWhitespace

static int countLeadingWhitespace(@NotNull
                                  @NotNull CharSequence thizz,
                                  int startIndex,
                                  int endIndex)

countLeadingNotWhitespace

static int countLeadingNotWhitespace(@NotNull
                                     @NotNull CharSequence thizz)

countLeadingNotWhitespace

static int countLeadingNotWhitespace(@NotNull
                                     @NotNull CharSequence thizz,
                                     int startIndex)

countLeadingNotWhitespace

static int countLeadingNotWhitespace(@NotNull
                                     @NotNull CharSequence thizz,
                                     int startIndex,
                                     int endIndex)

countTrailingWhitespace

static int countTrailingWhitespace(@NotNull
                                   @NotNull CharSequence thizz)

countTrailingWhitespace

static int countTrailingWhitespace(@NotNull
                                   @NotNull CharSequence thizz,
                                   int fromIndex)

countTrailingWhitespace

static int countTrailingWhitespace(@NotNull
                                   @NotNull CharSequence thizz,
                                   int startIndex,
                                   int fromIndex)

countTrailingNotWhitespace

static int countTrailingNotWhitespace(@NotNull
                                      @NotNull CharSequence thizz)

countTrailingNotWhitespace

static int countTrailingNotWhitespace(@NotNull
                                      @NotNull CharSequence thizz,
                                      int fromIndex)

countTrailingNotWhitespace

static int countTrailingNotWhitespace(@NotNull
                                      @NotNull CharSequence thizz,
                                      int startIndex,
                                      int fromIndex)

countLeading

static int countLeading(@NotNull
                        @NotNull CharSequence thizz,
                        @NotNull
                        @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countLeading

static int countLeading(@NotNull
                        @NotNull CharSequence thizz,
                        @NotNull
                        @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                        int fromIndex)

countLeadingNot

static int countLeadingNot(@NotNull
                           @NotNull CharSequence thizz,
                           @NotNull
                           @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countLeadingNot

static int countLeadingNot(@NotNull
                           @NotNull CharSequence thizz,
                           @NotNull
                           @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                           int fromIndex)

countTrailing

static int countTrailing(@NotNull
                         @NotNull CharSequence thizz,
                         @NotNull
                         @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countTrailing

static int countTrailing(@NotNull
                         @NotNull CharSequence thizz,
                         @NotNull
                         @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                         int fromIndex)

countTrailingNot

static int countTrailingNot(@NotNull
                            @NotNull CharSequence thizz,
                            @NotNull
                            @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countTrailingNot

static int countTrailingNot(@NotNull
                            @NotNull CharSequence thizz,
                            @NotNull
                            @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                            int fromIndex)

countLeadingNot

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

countTrailingNot

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

countLeading

static int countLeading(@NotNull
                        @NotNull CharSequence thizz,
                        @NotNull
                        @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars,
                        int fromIndex,
                        int endIndex)

countLeadingColumns

static int countLeadingColumns(@NotNull
                               @NotNull CharSequence thizz,
                               int startColumn,
                               @NotNull
                               @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

countTrailing

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

trimStart

@NotNull
static <T extends CharSequence> T trimStart(@NotNull
                                                     T thizz,
                                                     @NotNull
                                                     @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmedStart

@Nullable
static <T extends CharSequence> T trimmedStart(@NotNull
                                                         T thizz,
                                                         @NotNull
                                                         @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimEnd

@NotNull
static <T extends CharSequence> T trimEnd(@NotNull
                                                   T thizz,
                                                   @NotNull
                                                   @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmedEnd

@Nullable
static <T extends CharSequence> T trimmedEnd(@NotNull
                                                       T thizz,
                                                       @NotNull
                                                       @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trim

@NotNull
static <T extends CharSequence> T trim(@NotNull
                                                T thizz,
                                                @NotNull
                                                @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmed

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

trimStart

@NotNull
static <T extends CharSequence> T trimStart(@NotNull
                                                     T thizz,
                                                     int keep)

trimmedStart

@Nullable
static <T extends CharSequence> T trimmedStart(@NotNull
                                                         T thizz,
                                                         int keep)

trimEnd

@NotNull
static <T extends CharSequence> T trimEnd(@NotNull
                                                   T thizz,
                                                   int keep)

trimmedEnd

@Nullable
static <T extends CharSequence> T trimmedEnd(@NotNull
                                                       T thizz,
                                                       int keep)

trim

@NotNull
static <T extends CharSequence> T trim(@NotNull
                                                T thizz,
                                                int keep)

trimmed

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

trimStart

@NotNull
static <T extends CharSequence> T trimStart(@NotNull
                                                     T thizz)

trimmedStart

@Nullable
static <T extends CharSequence> T trimmedStart(@NotNull
                                                         T thizz)

trimEnd

@NotNull
static <T extends CharSequence> T trimEnd(@NotNull
                                                   T thizz)

trimmedEnd

@Nullable
static <T extends CharSequence> T trimmedEnd(@NotNull
                                                       T thizz)

trim

@NotNull
static <T extends CharSequence> T trim(@NotNull
                                                T thizz)

trimmed

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

trimStart

@NotNull
static <T extends CharSequence> T trimStart(@NotNull
                                                     T thizz,
                                                     int keep,
                                                     @NotNull
                                                     @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmedStart

@Nullable
static <T extends CharSequence> T trimmedStart(@NotNull
                                                         T thizz,
                                                         int keep,
                                                         @NotNull
                                                         @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimEnd

@NotNull
static <T extends CharSequence> T trimEnd(@NotNull
                                                   T thizz,
                                                   int keep,
                                                   @NotNull
                                                   @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmedEnd

@Nullable
static <T extends CharSequence> T trimmedEnd(@NotNull
                                                       T thizz,
                                                       int keep,
                                                       @NotNull
                                                       @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trim

@NotNull
static <T extends CharSequence> T trim(@NotNull
                                                T thizz,
                                                int keep,
                                                @NotNull
                                                @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimmed

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

trimStartRange

static Range trimStartRange(@NotNull
                            @NotNull CharSequence thizz,
                            @NotNull
                            @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimEndRange

static Range trimEndRange(@NotNull
                          @NotNull CharSequence thizz,
                          @NotNull
                          @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimRange

static Range trimRange(@NotNull
                       @NotNull CharSequence thizz,
                       @NotNull
                       @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimStartRange

static Range trimStartRange(@NotNull
                            @NotNull CharSequence thizz,
                            int keep)

trimEndRange

static Range trimEndRange(@NotNull
                          @NotNull CharSequence thizz,
                          int keep)

trimRange

static Range trimRange(@NotNull
                       @NotNull CharSequence thizz,
                       int keep)

trimStartRange

static Range trimStartRange(@NotNull
                            @NotNull CharSequence thizz)

trimEndRange

static Range trimEndRange(@NotNull
                          @NotNull CharSequence thizz)

trimRange

static Range trimRange(@NotNull
                       @NotNull CharSequence thizz)

trimStartRange

@NotNull
static @NotNull Range trimStartRange(@NotNull
                                              @NotNull CharSequence thizz,
                                              int keep,
                                              @NotNull
                                              @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimEndRange

@NotNull
static @NotNull Range trimEndRange(@NotNull
                                            @NotNull CharSequence thizz,
                                            int keep,
                                            @NotNull
                                            @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

trimRange

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

padStart

@NotNull
static @NotNull String padStart(@NotNull
                                         @NotNull CharSequence thizz,
                                         int length,
                                         char pad)

padEnd

@NotNull
static @NotNull String padEnd(@NotNull
                                       @NotNull CharSequence thizz,
                                       int length,
                                       char pad)

padStart

@NotNull
static @NotNull String padStart(@NotNull
                                         @NotNull CharSequence thizz,
                                         int length)

padEnd

@NotNull
static @NotNull String padEnd(@NotNull
                                       @NotNull CharSequence thizz,
                                       int length)

toVisibleWhitespaceString

@NotNull
static @NotNull String toVisibleWhitespaceString(@NotNull
                                                          @NotNull CharSequence thizz)

lastChar

static char lastChar(@NotNull
                     @NotNull CharSequence thizz)

firstChar

static char firstChar(@NotNull
                      @NotNull CharSequence thizz)

safeCharAt

static char safeCharAt(@NotNull
                       @NotNull CharSequence thizz,
                       int index)

eolEndLength

static int eolEndLength(@NotNull
                        @NotNull CharSequence thizz)

eolEndLength

static int eolEndLength(@NotNull
                        @NotNull CharSequence thizz,
                        int eolEnd)

eolStartLength

static int eolStartLength(@NotNull
                          @NotNull CharSequence thizz,
                          int eolStart)

endOfLine

static int endOfLine(@NotNull
                     @NotNull CharSequence thizz,
                     int index)

endOfLineAnyEOL

static int endOfLineAnyEOL(@NotNull
                           @NotNull CharSequence thizz,
                           int index)

startOfLine

static int startOfLine(@NotNull
                       @NotNull CharSequence thizz,
                       int index)

startOfLineAnyEOL

static int startOfLineAnyEOL(@NotNull
                             @NotNull CharSequence thizz,
                             int index)

startOfDelimitedByAnyNot

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

endOfDelimitedByAnyNot

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

startOfDelimitedBy

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

startOfDelimitedByAny

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

endOfDelimitedBy

static int endOfDelimitedBy(@NotNull
                            @NotNull CharSequence thizz,
                            @NotNull
                            @NotNull CharSequence s,
                            int index)

endOfDelimitedByAny

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

lineRangeAt

@NotNull
static @NotNull Range lineRangeAt(@NotNull
                                           @NotNull CharSequence thizz,
                                           int index)

lineRangeAtAnyEOL

@NotNull
static @NotNull Range lineRangeAtAnyEOL(@NotNull
                                                 @NotNull CharSequence thizz,
                                                 int index)

eolEndRange

@NotNull
static @NotNull Range eolEndRange(@NotNull
                                           @NotNull CharSequence thizz,
                                           int eolEnd)

eolStartRange

@NotNull
static @NotNull Range eolStartRange(@NotNull
                                             @NotNull CharSequence thizz,
                                             int eolStart)

trimEOL

@NotNull
static <T extends CharSequence> T trimEOL(@NotNull
                                                   T thizz)

trimmedEOL

@Nullable
static <T extends CharSequence> T trimmedEOL(@NotNull
                                                       T thizz)

trimTailBlankLines

@Nullable
static <T extends CharSequence> T trimTailBlankLines(@NotNull
                                                               T thizz)

trimLeadBlankLines

@Nullable
static <T extends CharSequence> T trimLeadBlankLines(@NotNull
                                                               T thizz)

leadingBlankLinesRange

@NotNull
static @NotNull Range leadingBlankLinesRange(@NotNull
                                                      @NotNull CharSequence thizz)

leadingBlankLinesRange

@NotNull
static @NotNull Range leadingBlankLinesRange(@NotNull
                                                      @NotNull CharSequence thizz,
                                                      int startIndex)

leadingBlankLinesRange

@NotNull
static @NotNull Range leadingBlankLinesRange(@NotNull
                                                      @NotNull CharSequence thizz,
                                                      int fromIndex,
                                                      int endIndex)

trailingBlankLinesRange

@NotNull
static @NotNull Range trailingBlankLinesRange(@NotNull
                                                       @NotNull CharSequence thizz)

trailingBlankLinesRange

@NotNull
static @NotNull Range trailingBlankLinesRange(@NotNull
                                                       @NotNull CharSequence thizz,
                                                       int fromIndex)

trailingBlankLinesRange

@NotNull
static @NotNull Range trailingBlankLinesRange(@NotNull
                                                       @NotNull CharSequence thizz,
                                                       int startIndex,
                                                       int fromIndex)

trailingBlankLinesRange

@NotNull
static @NotNull Range trailingBlankLinesRange(@NotNull
                                                       @NotNull CharSequence thizz,
                                                       @NotNull
                                                       @NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars,
                                                       int startIndex,
                                                       int fromIndex)

leadingBlankLinesRange

@NotNull
static @NotNull Range leadingBlankLinesRange(@NotNull
                                                      @NotNull CharSequence thizz,
                                                      @NotNull
                                                      @NotNull com.vladsch.flexmark.util.misc.CharPredicate eolChars,
                                                      int fromIndex,
                                                      int endIndex)

blankLinesRemovedRanges

@NotNull
static @NotNull List<Range> blankLinesRemovedRanges(@NotNull
                                                             @NotNull CharSequence thizz)

blankLinesRemovedRanges

@NotNull
static @NotNull List<Range> blankLinesRemovedRanges(@NotNull
                                                             @NotNull CharSequence thizz,
                                                             int fromIndex)

blankLinesRemovedRanges

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

blankLinesRemovedRanges

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

isEmpty

static boolean isEmpty(@NotNull
                       @NotNull CharSequence thizz)

isBlank

static boolean isBlank(@NotNull
                       @NotNull CharSequence thizz)

isNotEmpty

static boolean isNotEmpty(@NotNull
                          @NotNull CharSequence thizz)

isNotBlank

static boolean isNotBlank(@NotNull
                          @NotNull CharSequence thizz)

endsWith

static boolean endsWith(@NotNull
                        @NotNull CharSequence thizz,
                        @NotNull
                        @NotNull CharSequence suffix)

endsWith

static boolean endsWith(@NotNull
                        @NotNull CharSequence thizz,
                        @NotNull
                        @NotNull CharSequence suffix,
                        boolean ignoreCase)

startsWith

static boolean startsWith(@NotNull
                          @NotNull CharSequence thizz,
                          @NotNull
                          @NotNull CharSequence prefix)

startsWith

static boolean startsWith(@NotNull
                          @NotNull CharSequence thizz,
                          @NotNull
                          @NotNull CharSequence prefix,
                          boolean ignoreCase)

endsWith

static boolean endsWith(@NotNull
                        @NotNull CharSequence thizz,
                        @NotNull
                        @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

startsWith

static boolean startsWith(@NotNull
                          @NotNull CharSequence thizz,
                          @NotNull
                          @NotNull com.vladsch.flexmark.util.misc.CharPredicate chars)

endsWithEOL

static boolean endsWithEOL(@NotNull
                           @NotNull CharSequence thizz)

endsWithAnyEOL

static boolean endsWithAnyEOL(@NotNull
                              @NotNull CharSequence thizz)

endsWithSpace

static boolean endsWithSpace(@NotNull
                             @NotNull CharSequence thizz)

endsWithSpaceTab

static boolean endsWithSpaceTab(@NotNull
                                @NotNull CharSequence thizz)

endsWithWhitespace

static boolean endsWithWhitespace(@NotNull
                                  @NotNull CharSequence thizz)

startsWithEOL

static boolean startsWithEOL(@NotNull
                             @NotNull CharSequence thizz)

startsWithAnyEOL

static boolean startsWithAnyEOL(@NotNull
                                @NotNull CharSequence thizz)

startsWithSpace

static boolean startsWithSpace(@NotNull
                               @NotNull CharSequence thizz)

startsWithSpaceTab

static boolean startsWithSpaceTab(@NotNull
                                  @NotNull CharSequence thizz)

startsWithWhitespace

static boolean startsWithWhitespace(@NotNull
                                    @NotNull CharSequence thizz)

splitList

@NotNull
static <T extends CharSequence> @NotNull List<T> splitList(@NotNull
                                                                    T thizz,
                                                                    @NotNull
                                                                    @NotNull CharSequence delimiter)

splitList

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

splitList

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

splitList

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

splitListEOL

@NotNull
static <T extends CharSequence> @NotNull List<T> splitListEOL(@NotNull
                                                                       T thizz)

splitListEOL

@NotNull
static <T extends CharSequence> @NotNull List<T> splitListEOL(@NotNull
                                                                       T thizz,
                                                                       boolean includeDelims)

splitListEOL

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

splitEOL

@NotNull
static <T extends CharSequence> T[] splitEOL(@NotNull
                                                      T thizz,
                                                      T[] emptyArray)

splitEOL

@NotNull
static <T extends CharSequence> T[] splitEOL(@NotNull
                                                      T thizz,
                                                      T[] emptyArray,
                                                      boolean includeDelims)

split

@NotNull
static <T extends CharSequence> T[] split(@NotNull
                                                   T thizz,
                                                   T[] emptyArray,
                                                   @NotNull
                                                   @NotNull CharSequence delimiter,
                                                   boolean includeDelims,
                                                   @Nullable
                                                   @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)

split

@NotNull
static <T extends CharSequence> T[] split(@NotNull
                                                   T thizz,
                                                   T[] emptyArray,
                                                   @NotNull
                                                   @NotNull CharSequence delimiter)

split

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

split

@NotNull
static <T extends CharSequence> T[] split(@NotNull
                                                   T thizz,
                                                   T[] emptyArray,
                                                   @NotNull
                                                   @NotNull CharSequence delimiter,
                                                   int limit,
                                                   int flags)

split

@NotNull
static <T extends CharSequence> T[] split(@NotNull
                                                   T thizz,
                                                   T[] emptyArray,
                                                   @NotNull
                                                   @NotNull CharSequence delimiter,
                                                   int limit,
                                                   int flags,
                                                   @Nullable
                                                   @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)

splitList

@NotNull
static <T extends CharSequence> @NotNull List<T> splitList(@NotNull
                                                                    T thizz,
                                                                    @NotNull
                                                                    @NotNull CharSequence delimiter,
                                                                    int limit,
                                                                    int flags,
                                                                    @Nullable
                                                                    @Nullable com.vladsch.flexmark.util.misc.CharPredicate trimChars)

columnAtIndex

static int columnAtIndex(@NotNull
                         @NotNull CharSequence thizz,
                         int index)

lineColumnAtIndex

@NotNull
static @NotNull com.vladsch.flexmark.util.misc.Pair<Integer,Integer> lineColumnAtIndex(@NotNull
                                                                                                @NotNull CharSequence thizz,
                                                                                                int index)

validateIndex

static void validateIndex(int index,
                          int length)

validateIndexInclusiveEnd

static void validateIndexInclusiveEnd(int index,
                                      int length)

validateStartEnd

static void validateStartEnd(int startIndex,
                             int endIndex,
                             int length)

parseUnsignedIntOrNull

static Integer parseUnsignedIntOrNull(String text)

parseUnsignedIntOrNull

static Integer parseUnsignedIntOrNull(String text,
                                      int radix)

parseIntOrNull

static Integer parseIntOrNull(String text)

parseIntOrNull

static Integer parseIntOrNull(String text,
                              int radix)

parseLongOrNull

static Long parseLongOrNull(String text)

parseLongOrNull

static Long parseLongOrNull(String text,
                            int radix)

parseUnsignedIntOrDefault

static int parseUnsignedIntOrDefault(String text,
                                     int defaultValue)

parseUnsignedIntOrDefault

static int parseUnsignedIntOrDefault(String text,
                                     int defaultValue,
                                     int radix)

parseIntOrDefault

static int parseIntOrDefault(String text,
                             int defaultValue)

parseIntOrDefault

static int parseIntOrDefault(String text,
                             int defaultValue,
                             int radix)

parseNumberOrNull
```
@Nullable
static @Nullable Number parseNumberOrNull(@Nullable
                                                    @Nullable String text)
```
Parse number from text
Will parse 0x, 0b, octal if starts with 0, decimal

Parameters:

text - text containing the number to parse

Returns:

null or parsed number

parseNumberPrefixOrNull

@Nullable
static @Nullable com.vladsch.flexmark.util.misc.Pair<Number,String> parseNumberPrefixOrNull(@Nullable
                                                                                                      @Nullable String text,
                                                                                                      @Nullable
                                                                                                      @Nullable Predicate<String> suffixTester)

Parse number from text

Will parse 0x, 0b, octal if starts with 0, decimal

Parameters:: text - text containing the number to parse; suffixTester - predicate to test number suffix, if null or predicate returns true then sequence will be accepted as valid
Returns:: null or parsed number with unparsed suffix

containedBy

static <T extends CharSequence> boolean containedBy(@NotNull
                                                    T[] items,
                                                    @NotNull
                                                    @NotNull CharSequence element)

containedBy

static boolean containedBy(@NotNull
                           @NotNull Collection<? extends CharSequence> items,
                           @NotNull
                           @NotNull CharSequence element)

Interface SequenceUtils

Field Summary

Method Summary

Field Detail

EOL

SPACE

ANY_EOL

EOL_CHAR

EOL_CHAR1

EOL_CHAR2

SPC

NUL

ENC_NUL

NBSP

LS

US

LINE_SEP

SPACE_TAB

SPACE_EOL

US_CHARS

WHITESPACE

NBSP_CHARS

WHITESPACE_NBSP

SPACE_SET

TAB_SET

EOL_SET

SPACE_TAB_SET

SPACE_TAB_NBSP_SET

SPACE_TAB_EOL_SET

SPACE_EOL_SET

ANY_EOL_SET

WHITESPACE_SET

WHITESPACE_NBSP_SET

BACKSLASH_SET

US_SET

HASH_SET

DECIMAL_DIGITS

HEXADECIMAL_DIGITS

OCTAL_DIGITS

LSEP

EOL_CHARS

WHITESPACE_NO_EOL_CHARS

WHITESPACE_CHARS

WHITESPACE_NBSP_CHARS

SPLIT_INCLUDE_DELIMS

SPLIT_TRIM_PARTS

SPLIT_SKIP_EMPTY

SPLIT_INCLUDE_DELIM_PARTS

SPLIT_TRIM_SKIP_EMPTY

visibleSpacesMap

EMPTY_INDICES

Method Detail

getVisibleSpacesMap

subSequence

subSequence

subSequenceBefore

subSequenceAfter

subSequenceBeforeAfter

containsAny

containsAny

containsAnyNot

containsAnyNot

containsAnyNot

indexOf

indexOf

indexOf

indexOf

indexOfAny

indexOfAny

indexOfAnyNot

indexOfAnyNot

indexOfAnyNot

indexOfNot

indexOfNot

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOfAny

lastIndexOfAny