java.lang.Object
- Torello.Java.StrTokCmpr

public class StrTokCmpr
extends java.lang.Object

Similar to class String-Compare, String-Token-Compare also provides an exhaustive suite of methods that extend the basic Java String methods

equals, contains,
 startsWith

and endsWith, but further allowing a user to specify the match-string boundary-characters.

This class is identical to class StrCmpr - save one primary difference. The substrings that are tested must be surrounded by white-space, or by a specified character-delimiter test, before the comparison logic considers them to have matched.

StrTokCmpr =>

StrTok: Token-Matches are substring matches which are found inside a supplied 'srcStr'. These matches must be both fully contained within 'srcStr', and have "match locations" (String-index position in 'srcStr' where the token matches) that are bounded / 'surrounded' by either white-space (space-character '#32', '\n', '\r', etc ) or by characters that pass a user supplied Character-Predicate test().
Cmpr: Each of the methods in this class shall return an boolean that indicates whether the input 'srcStr' matches the method's query-specifications. The various queries in this class are based on the presence or absence of a particular String (parameter 'token(s)') being inside another Source-String (parameter 'srcString').

Methods Available

Method-Name Key-Word	Explanation
NAND	May not find any matches between the primary `String srcStr` parameter, and the `String's` in `String... tokens` NAND-NOTE: There is one very important subtlety about the meaning of `'NAND'` here. In this case, the methods that use `'NAND'` interpret its meaning as "NOT ANY ONE OF..." - meaning all comparisons must fail.
XOR	Must find precisely one match between the primary `String srcStr` parameter, and the `String's` in `String... tokens`. There is one 'philosophical note' which is that if multiple copies of an identical-`String` are passed via the comparison-`String`array (`String... tokens`), all XOR methods shall not pay heed to the notion that they the `'srcStr'` parameter may have only started-with, ended-with or contained a single `String` (and 'philosophically passing' the XOR, one-and-only-one test). The internal-logical is 'programmatically ignorant' of this - multiple copies of an identical-`String` (or identical, ignoring-case) could theoretically be flagged via throwing an `IllegalArgumentException`. However, no such check is performed.
OR	Must find at least one match between the primary `String srcStr` parameter, and the `String's` in the `'tokens'` parameter.
AND	Must identify a containing-match between each and every `String` in `String... tokens` and the primary `'srcStr'` parameter.
Starts With	The provided `token-String` must match each character at the beginning of the `String`-parameter `'srcStr'`. Furthermore, the character immediately after the `token-String` in `'srcStr'` must be either: White-space (matching `'\s'`) `String`-terminus (matching `'$'`) In situations where an `extraDelimiterTest` has been passed to the method, characters that receive TRUE from the invokation of the `Character-Predicate's test(char)` method shall also be considered for a `'Token-Match'`.
Ends With	The provided `token-String` must match each character at the ending of the `String`-parameter `'srcStr'`. Furthermore, the character directly before the `token-String` in `'srcStr'` must be either: White-space (matching `'\s'`) `String`-start (matching `'^'`) In situations where an `extraDelimiterTest` has been passed to the method, characters that receive TRUE from the invokation of the `Character-Predicate's test(char)` method shall also be considered for a `'Token-Match'`.
Contains	The provided `token-String` must be a substring of the `String`-parameter `'srcStr'`. Furthermore, the characters directly before and immediately following the `token-String` match location in `'srcStr'` must assume one of the following values: White-space (matching `'\s'`) `String`-start (matching `'^'`) `String`-terminus (matching `'$'`) In situations where an `extraDelimiterTest` has been passed to the method, characters that receive TRUE from the invokation of the `Character-Predicate's test(char)` method shall also be considered for a `'Token-Match'`.
CI (Case Insensitive)	All equality-tests will be done on a `Case Insensitive` basis.

Method Parameters

Parameter	Explanation
`String srcStr`	This parameter is mandatory for every method here. It is the source `String` that is being searched. Every method is designed to iterate through the characters in this `String`, searching for matches of `token(s)`.
`int nth`	This represents the `'nth'` match of a comparison `for-loop`. When the method-signature used includes the parameter `'nth'` , the first `n-1` matches that are found - will be skipped, and the `'nth'` match is, instead, returned. EXCEPTIONS: An `NException` shall throw if the value of parameter `'nth'` is zero, negative, or larger than the size of the input html-`Vector`.
`int sPos, int ePos`	When these parameters are present, only `substring's` that are found between these specified `String` indices will be considered when returning results from `StrTokIndexOf`. NOTE: In every situation where the parameters `int sPos, int ePos` are used, *parameter `'ePos'` will accept a negative value, but parameter `'sPos'` will not. When `'ePos'` is passed a negative-value, the internal `LV` ('Loop Variable Counter') will have its `public final int end` field set to the length of the `'srcStr'` parameter `String`. EXCEPTIONS:* An `IndexOutOfBoundsException` will be thrown if: If `sPos` is negative, or if `sPos` is greater-than or equal-to the size of `'srcStr'` If `ePos` is zero, or greater than the size `'srcStr'`. If `sPos` is a larger integer than `ePos`
`String token`	This is the testing-substring that is this class' search goal. When this `String` is identified as a substring of the input-parameter `String 'srcStr'`, a potential match has been found. In order for potential matches to be returned as results, they are subsequently tested for `surrounding white-space` (or the additional `'extraDelimiterTest'`). The requirements for a potential match to be returned as a `Token Match` are as follows: The location of `'token'` in `'srcStr'` must be bounded by white-space, or be located at the very beginning or ending of the `'srcStr'`. If an `extraDelimiterTest` has been provided, the location of `'token'` in `'srcStr'` may also be bounded by characters that are a match with the `Character-Predicate` `'test(char)'` method. And, of course, the `'token'` must be a substring of `'srcStr'`
`String... tokens`	Each of the `'token' String's` passed using `Varargs array` parameter `'tokens'` must follow the exact same rules explained in the previous parameter entry (directly above) in order to be considered `token`-matches with/for input parameter `'srcStr'`. All the `Varargs String-Array` adds is that it facilitates testing multiple `tokens` all at the same time so that their comparison-results can be `AND'ed`, `OR'ed`, `NAND'ed`, etc...
`Predicate<Character> extraDelimiterTest`	When this parameter is present in the method-signature parameter-list, the decision of whether a `Token-Match` is to be included in the search result-set can be made less restrictive. Usually, a match must be delimited by white-space; meaning that the characters directly before and after the match location in `'srcStr'` must be white-space, or the `String terminus` (Regex: `'^'` and `'$'`). However, when this parameter is part of a method signature, the method body in this class that implements this search will also permit a `token-match` location to be bounded by characters that pass this `Character-Predicate's Predicate.test(char)` method. For instance, if `(Character c) -> ",.!?()".contains("" + c)` were passed to this parameter, then: `commas, periods, exclamation-points, question-marks,` and `parenthesis` would all be allowed directly before or immediately after the `token-match` location of the `'token'` parameter inside `String 'srcStr'`.

Hi-Lited Source-Code:

View Here: Torello/Java/StrTokCmpr.java
Open New Browser-Tab: Torello/Java/StrTokCmpr.java

File Size: 97,400 Bytes Line Count: 2,027 '\n' Characters Found

Stateless Class:

This class neither contains any program-state, nor can it be instantiated. The @StaticFunctional Annotation may also be called 'The Spaghetti Report'. Static-Functional classes are, essentially, C-Styled Files, without any constructors or non-static member fields. It is a concept very similar to the Java-Bean's @Stateless Annotation.

1 Constructor(s), 1 declared private, zero-argument constructor
93 Method(s), 93 declared static
6 Field(s), 6 declared static, 4 declared final
Fields excused from final modifier (with explanation):

Field 'DEBUG' is not final. Reason: DEBUGGING

Field 'DEBUG_LOG' is not final. Reason: DEBUGGING

Field Summary

Simple Debug Printing Fields

Modifier and Type	Field
`static boolean`	`DEBUG`
`static Consumer<String>`	`DEBUG_LOG`

Internal, Protected Helper Fields
Modifier and Type	Field
`protected static byte`	`AND`
`protected static byte`	`NAND`
`protected static byte`	`OR`
`protected static byte`	`XOR`

Method Summary

Contains

Modifier and Type	Method
`static boolean`	`contains(String srcStr, String token)`
`static boolean`	`containsAND(String srcStr, String... tokens)`
`static boolean`	`containsNAND(String srcStr, String... tokens)`
`static boolean`	`containsOR(String srcStr, String... tokens)`
`static boolean`	`containsXOR(String srcStr, String... tokens)`

Contains: Ⅰ Range-Limited
Modifier and Type	Method
`static boolean`	`contains(String srcStr, int sPos, int ePos, String token)`
`static boolean`	`containsAND(String srcStr, int sPos, int ePos, String... tokens)`
`static boolean`	`containsNAND(String srcStr, int sPos, int ePos, String... tokens)`
`static boolean`	`containsOR(String srcStr, int sPos, int ePos, String... tokens)`
`static boolean`	`containsXOR(String srcStr, int sPos, int ePos, String... tokens)`

Contains: Ⅱ Extra-Delimiter Test
Modifier and Type	Method
`static boolean`	`contains(String srcStr, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`containsAND(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsNAND(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsOR(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsXOR(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`

Contains: Ⅰ Range-Limited Ⅱ Extra-Delimiter Test
Modifier and Type	Method
`static boolean`	`contains(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`containsAND(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsNAND(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsOR(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsXOR(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`

Contains: Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`containsAND_CI(String srcStr, String... tokens)`
`static boolean`	`containsIgnoreCase(String srcStr, String token)`
`static boolean`	`containsNAND_CI(String srcStr, String... tokens)`
`static boolean`	`containsOR_CI(String srcStr, String... tokens)`
`static boolean`	`containsXOR_CI(String srcStr, String... tokens)`

Contains: Ⅰ Range-Limited Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`containsAND_CI(String srcStr, int sPos, int ePos, String... tokens)`
`static boolean`	`containsIgnoreCase(String srcStr, int sPos, int ePos, String token)`
`static boolean`	`containsNAND_CI(String srcStr, int sPos, int ePos, String... tokens)`
`static boolean`	`containsOR_CI(String srcStr, int sPos, int ePos, String... tokens)`
`static boolean`	`containsXOR_CI(String srcStr, int sPos, int ePos, String... tokens)`

Contains: Ⅱ Extra-Delimiter Test Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`containsAND_CI(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsIgnoreCase(String srcStr, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`containsNAND_CI(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsOR_CI(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsXOR_CI(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`

Contains: Ⅰ Range-Limited Ⅱ Extra-Delimiter Test Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`containsAND_CI(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsIgnoreCase(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`containsNAND_CI(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsOR_CI(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`containsXOR_CI(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`

Starts-With
Modifier and Type	Method
`static boolean`	`startsWith(String srcStr, String token)`
`static boolean`	`startsWithNAND(String srcStr, String... tokens)`
`static boolean`	`startsWithXOR(String srcStr, String... tokens)`

Starts-With: Ⅰ Range-Limited
Modifier and Type	Method
`static boolean`	`startsWith(String srcStr, int sPos, int ePos, String token)`
`static boolean`	`startsWithNAND(String srcStr, int sPos, int ePos, String... tokens)`
`static boolean`	`startsWithXOR(String srcStr, int sPos, int ePos, String... tokens)`

Starts-With: Ⅱ Extra-Delimiter Test
Modifier and Type	Method
`static boolean`	`startsWith(String srcStr, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`startsWithNAND(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`startsWithXOR(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`

Starts-With: Ⅰ Range-Limited Ⅱ Extra-Delimiter Test
Modifier and Type	Method
`static boolean`	`startsWith(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`startsWithNAND(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`startsWithXOR(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`

Starts-With: Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`startsWithIgnoreCase(String srcStr, String token)`
`static boolean`	`startsWithNAND_CI(String srcStr, String... tokens)`
`static boolean`	`startsWithXOR_CI(String srcStr, String... tokens)`

Starts-With: Ⅰ Range-Limited Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`startsWithIgnoreCase(String srcStr, int sPos, int ePos, String token)`
`static boolean`	`startsWithNAND_CI(String srcStr, int sPos, int ePos, String... tokens)`
`static boolean`	`startsWithXOR_CI(String srcStr, int sPos, int ePos, String... tokens)`

Starts-With: Ⅱ Extra-Delimiter Test Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`startsWithIgnoreCase(String srcStr, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`startsWithNAND_CI(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`startsWithXOR_CI(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`

Starts-With: Ⅰ Range-Limited Ⅱ Extra-Delimiter Test Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`startsWithIgnoreCase(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`startsWithNAND_CI(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`startsWithXOR_CI(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`

Ends-With
Modifier and Type	Method
`static boolean`	`endsWith(String srcStr, String token)`
`static boolean`	`endsWithNAND(String srcStr, String... tokens)`
`static boolean`	`endsWithXOR(String srcStr, String... tokens)`

Ends-With: Ⅰ Range-Limited
Modifier and Type	Method
`static boolean`	`endsWith(String srcStr, int sPos, int ePos, String token)`
`static boolean`	`endsWithNAND(String srcStr, int sPos, int ePos, String... tokens)`
`static boolean`	`endsWithXOR(String srcStr, int sPos, int ePos, String... tokens)`

Ends-With: Ⅱ Extra-Delimiter Test
Modifier and Type	Method
`static boolean`	`endsWith(String srcStr, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`endsWithNAND(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`endsWithXOR(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`

Ends-With: Ⅰ Range-Limited Ⅱ Extra-Delimiter Test
Modifier and Type	Method
`static boolean`	`endsWith(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`endsWithNAND(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`endsWithXOR(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`

Ends-With: Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`endsWithIgnoreCase(String srcStr, String token)`
`static boolean`	`endsWithNAND_CI(String srcStr, String... tokens)`
`static boolean`	`endsWithXOR_CI(String srcStr, String... tokens)`

Ends-With: Ⅰ Range-Limited Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`endsWithIgnoreCase(String srcStr, int sPos, int ePos, String token)`
`static boolean`	`endsWithNAND_CI(String srcStr, int sPos, int ePos, String... tokens)`
`static boolean`	`endsWithXOR_CI(String srcStr, int sPos, int ePos, String... tokens)`

Ends-With: Ⅱ Extra-Delimiter Test Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`endsWithIgnoreCase(String srcStr, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`endsWithNAND_CI(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`endsWithXOR_CI(String srcStr, Predicate<Character> extraDelimiterTest, String... tokens)`

Ends-With: Ⅰ Range-Limited Ⅱ Extra-Delimiter Test Ⅲ Case-Insensitive
Modifier and Type	Method
`static boolean`	`endsWithIgnoreCase(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String token)`
`static boolean`	`endsWithNAND_CI(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`
`static boolean`	`endsWithXOR_CI(String srcStr, int sPos, int ePos, Predicate<Character> extraDelimiterTest, String... tokens)`

Internal, Protected Methds. Provided for Reference, Only.
Modifier and Type	Method
`protected static boolean`	`AND(String methodName, String srcStr, String[] tokens, Predicate<String> pred)`
`protected static boolean`	`NAND(String methodName, String srcStr, String[] tokens, Predicate<String> pred)`
`protected static boolean`	`OR(String methodName, String srcStr, String[] tokens, Predicate<String> pred)`
`protected static boolean`	`XOR(String methodName, String srcStr, String[] tokens, Predicate<String> pred)`

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

- Field Detail
  - DEBUG
    
    🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean DEBUG
    
    Utility field. You may choose to set this variable to true, and the following String commands will print to an internally stored Consumer<String> DEBUG_LOG class that may be set. This is generally a very minor drain on code-efficiency. When this flag is set to FALSE, a short if-statement evaluation still occurs even when the flag is false on each occasion that the string-comparison loops identify and return a match. This is very minor performance loss, and does provide quite a lot of help to those trying to identify difficult to notice problems with partial-String comparisons.
    
    Required Setting:
    In order to use this minor Debugging Feature, it is necessary to provide a Consumer<String> to public field DEBUG_LOG! This field is a public and static field, which will be used by any invocation of the methods in this class. This String-consumer may do anything you would like it to do with the provided Debug-String data.
    
    String-Format:
    The String that is ultimately sent to the Consumer<String> you provide will be formatted, as below, in the following Code-Snippet:
    
    private static void PRNT(String methodName, String srcStr, String compareStr) { DEBUG_LOG.accept(methodName + "-MATCH[" + srcStr + ", " + compareStr + "] "); }
    
    Generally, you would assign a writer that looks like something the Lambda-Target / Function-Pointer assignment in the snippet below:
    
    StrTokCmpr.DEBUG_LOG = (String logInfoStr) -> System.out.println(logInfoStr);
    
    Finally, if you are using this field, please note that any of the methods whose name ends with the phrase "IgnoreCase" will not print to the DEBUG_LOG. This is primarily because these are all single-argument comparisons, and logging would be of only minor benefit.
    
    The primary value of a debug-log is the ability to identify whether / when a particular substring from a list of substrings actually matched.
    
    Code:
    
    Exact Field Declaration Expression:
    
    public static boolean DEBUG = false;
  - DEBUG_LOG
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static java.util.function.Consumer<java.lang.String> DEBUG_LOG
    
    This object reference cannot be null when DEBUG is TRUE. This StorageWriter will receive text-notifications every time the string-comparing loops identify a match.
    
    DEBUG_LOG is not Thread-Safe:
    No attempt has been made to ensure that this debugging feature will operate perfectly in a multi-threaded environment. The two reasons for this are:
    
    The primary purpose of this LOG is for debugging code, not putting details about string-match information into an 'on-line' or production environment.
    
    This is a best-efforts string-comparison package that would sacrifice quite a bit of its utility if it were expected to maintain multiple instances of this class just to have StrCmpr debug operations work in multiple-threads. Code readability necessitates keeping this a class with only static methods.
    
    Two threads making calls to this class StrCmpr might see log-writes that, sadly, look like they 'interlaced' (crashed), but even when this occasions, reading the log wouldn't be that difficult anyway.
    
    Code:
    
    Exact Field Declaration Expression:
    
    public static Consumer<String> DEBUG_LOG = null;
  - AND
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    protected static final byte AND
    
    Signifies that an 'AND' operation is required, but only for methods that implement one of the 'contains' variants.
    
    See Also:
    
    Constant Field Values
    
    Code:
    
    Exact Field Declaration Expression:
    
    protected static final byte AND = 0;
  - OR
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    protected static final byte OR
    
    Signifies that an 'AND' operation is required, but only for methods that implement one of the 'contains' variants.
    
    See Also:
    
    Constant Field Values
    
    Code:
    
    Exact Field Declaration Expression:
    
    protected static final byte OR = 1;
  - NAND
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    protected static final byte NAND
    
    Signifies that an 'AND' operation is required, but only for methods that implement one of the 'contains' variants.
    
    See Also:
    
    Constant Field Values
    
    Code:
    
    Exact Field Declaration Expression:
    
    protected static final byte NAND = 2;
  - XOR
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    protected static final byte XOR
    
    Signifies that an 'AND' operation is required, but only for methods that implement one of the 'contains' variants.
    
    See Also:
    
    Constant Field Values
    
    Code:
    
    Exact Field Declaration Expression:
    
    protected static final byte XOR = 3;
- Method Detail
  - AND
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    protected static boolean AND (java.lang.String methodName, java.lang.String srcStr, java.lang.String[] tokens, java.util.function.Predicate<java.lang.String> pred)
    
    This performs the internal AND. It expects a comparison Predicate in order for the comparison to work.
    
    Parameters:
    
    methodName - If printing-debug information is expected, by the DEBUG global-variable, this String is used.
    
    srcStr - This is the same source-string parameter from all the methods in this class.
    
    tokens - This is the same var-args string array from all the methods in this class.
    
    pred - This is the comparison Predicate provided by the methods in this class that call this method.
    
    Returns:
    
    The AND of these String's, using the provided Predicate.
    
    Throws:
    
    StrCmprException - This exception shall throw if there are any invalid String's in the compare-string parameter array.
    
    Note: The conditions that would cause this exception to throw should remind the reader that each and every method here will throw exception 'StrCmprException' if invalid input has been passed to the "Compare String" Variable-Arguments String... Parameter.
    
    Code:
    
    Exact Method Body:
    
    StrCmprException.check(tokens); for (String cmp: tokens) if (! pred.test(cmp)) { if (DEBUG) PRNT(methodName + "-MATCHFAIL", srcStr, cmp); return false; } return true;
  - NAND
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    protected static boolean NAND (java.lang.String methodName, java.lang.String srcStr, java.lang.String[] tokens, java.util.function.Predicate<java.lang.String> pred)
    
    This performs the internal NAND. It expects a comparison Predicate in order for the comparison to work.
    
    Parameters:
    
    methodName - If printing-debug information is expected, by the DEBUG global-variable, this String is used.
    
    srcStr - This is the same source-string parameter from all the methods in this class.
    
    tokens - This is the same var-args string array from all the methods in this class.
    
    pred - This is the comparison Predicate provided by the methods in this class that call this method.
    
    Returns:
    
    The NAND of these String's, using the provided Predicate.
    
    Throws:
    
    StrCmprException - This exception shall throw if there are any invalid String's in the compare-string parameter array.
    
    Note: The conditions that would cause this exception to throw should remind the reader that each and every method here will throw exception 'StrCmprException' if invalid input has been passed to the "Compare String" Variable-Arguments String... Parameter.
    
    Code:
    
    Exact Method Body:
    
    StrCmprException.check(tokens); for (String cmp: tokens) if (pred.test(cmp)) { if (DEBUG) PRNT(methodName + "-MATCH", srcStr, cmp); return false; } return true;
  - OR
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    protected static boolean OR (java.lang.String methodName, java.lang.String srcStr, java.lang.String[] tokens, java.util.function.Predicate<java.lang.String> pred)
    
    This performs the internal OR. It expects a comparison Predicate in order for the comparison to work.
    
    Parameters:
    
    methodName - If printing-debug information is expected, by the DEBUG global-variable, this String is used.
    
    srcStr - This is the same source-string parameter from all the methods in this class.
    
    tokens - This is the same var-args string array from all the methods in this class.
    
    pred - This is the comparison Predicate provided by the methods in this class that call this method.
    
    Returns:
    
    The OR of these String's, using the provided Predicate.
    
    Throws:
    
    StrCmprException - This exception shall throw if there are any invalid String's in the compare-string parameter array.
    
    Note: The conditions that would cause this exception to throw should remind the reader that each and every method here will throw exception 'StrCmprException' if invalid input has been passed to the "Compare String" Variable-Arguments String... Parameter.
    
    Code:
    
    Exact Method Body:
    
    StrCmprException.check(tokens); for (String cmp: tokens) if (pred.test(cmp)) { if (DEBUG) PRNT(methodName + "-MATCH", srcStr, cmp); return true; } return false;
  - XOR
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    protected static boolean XOR (java.lang.String methodName, java.lang.String srcStr, java.lang.String[] tokens, java.util.function.Predicate<java.lang.String> pred)
    
    This performs the internal XOR. It expects a comparison Predicate in order for the comparison to work.
    
    Parameters:
    
    methodName - If printing-debug information is expected, by the DEBUG global-variable, this String is used.
    
    srcStr - This is the same source-string parameter from all the methods in this class.
    
    tokens - This is the same var-args string array from all the methods in this class.
    
    pred - This is the comparison Predicate provided by the methods in this class that call this method.
    
    Returns:
    
    The XOR of these String's, using the provided Predicate.
    
    Throws:
    
    StrCmprException - This exception shall throw if there are any invalid String's in the compare-string parameter array.
    
    Note: The conditions that would cause this exception to throw should remind the reader that each and every method here will throw exception 'StrCmprException' if invalid input has been passed to the "Compare String" Variable-Arguments String... Parameter.
    
    Code:
    
    Exact Method Body:
    
    StrCmprException.check(tokens); int count=0; for (String cmp: tokens) if (pred.test(cmp)) if (++count > 1) { if (DEBUG) PRNT(methodName + "-MATCH", srcStr, cmp); return false; } return count == 1;
  - containsOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsOR(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains at least one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' contains at least one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(false, OR, srcStr, tokens);
  - containsAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsAND(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains every one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' contains every one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(false, AND, srcStr, tokens);
  - containsXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsXOR(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' contains exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(false, XOR, srcStr, tokens);
  - containsNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsNAND(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not contain any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' does not contain any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(false, NAND, srcStr, tokens);
  - containsOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsOR_CI(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains at least one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' contains at least one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(true, OR, srcStr, tokens);
  - containsAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsAND_CI(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains every one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' contains every one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(true, AND, srcStr, tokens);
  - containsXOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsXOR_CI(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' contains exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(true, XOR, srcStr, tokens);
  - containsNAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsNAND_CI(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not contain any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' does not contain any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(true, NAND, srcStr, tokens);
  - endsWithXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithXOR(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' ends with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if 'srcStr' ends with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return XOR( "endsWithXOR", srcStr, tokens, cmp -> TokCmprEW.ew(srcStr, new LV(srcStr, 0, -1), cmp) );
  - endsWithNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithNAND(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not end with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if 'srcStr' does not end with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return NAND( "endsWithNAND", srcStr, tokens, cmp -> TokCmprEW.ew(srcStr, new LV(srcStr, 0, -1), cmp) );
  - startsWithXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithXOR(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' starts with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' starts with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return XOR( "startsWithXOR", srcStr, tokens, cmp -> TokCmprSW.sw(srcStr, new LV(srcStr, 0, -1), cmp) );
  - startsWithNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithNAND(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not start with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' does not start with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return NAND( "startsWithNAND", srcStr, tokens, cmp -> TokCmprSW.sw(srcStr, new LV(srcStr, 0, -1), cmp) );
  - endsWithXOR_CI
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean endsWithXOR_CI(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' ends with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if 'srcStr' ends with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    endsWithIgnoreCase(String, String), XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return XOR("endsWithXOR_CI", srcStr, tokens, cmp -> endsWithIgnoreCase(srcStr, cmp));
  - endsWithNAND_CI
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean endsWithNAND_CI(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not end with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if 'srcStr' does not end with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    endsWithIgnoreCase(String, String), NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return NAND("endsWithNAND_CI", srcStr, tokens, cmp -> endsWithIgnoreCase(srcStr, cmp));
  - startsWithXOR_CI
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean startsWithXOR_CI(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' starts with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' starts with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    startsWithIgnoreCase(String, String), XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return XOR("startsWithXOR_CI", srcStr, tokens, cmp -> startsWithIgnoreCase(srcStr, cmp));
  - startsWithNAND_CI
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean startsWithNAND_CI(java.lang.String srcStr, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not start with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' does not start with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    startsWithIgnoreCase(String, String), NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return NAND("startsWithNAND_CI", srcStr, tokens, cmp -> startsWithIgnoreCase(srcStr, cmp));
  - startsWith
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean startsWith(java.lang.String srcStr, java.lang.String token)
    
    Checks to ensure that 'srcStr' starts with the 'compareStr' token.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' starts with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return srcStr.startsWith(token) && ( (token.length() == srcStr.length()) || Character.isWhitespace(srcStr.charAt(token.length())));
  - endsWith
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean endsWith(java.lang.String srcStr, java.lang.String token)
    
    Checks to ensure that 'srcStr' ends with the 'compareStr' token.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if 'srcStr' ends with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return srcStr.endsWith(token) && ( (token.length() == srcStr.length()) || (Character.isWhitespace(srcStr.charAt(srcStr.length() - token.length() - 1))));
  - contains
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean contains(java.lang.String srcStr, java.lang.String token)
    
    Checks to ensure that 'srcStr' contains the 'compareStr' token.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' contains the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    int tokenLen = token.length(); int loopLen = srcStr.length() - tokenLen; for (int i=0; i <= loopLen; i++) if ( srcStr.regionMatches(i, token, 0, tokenLen) && ( (i == 0) || Character.isWhitespace(srcStr.charAt(i-1))) && ( ((i + tokenLen) == srcStr.length()) || Character.isWhitespace(srcStr.charAt(i + tokenLen))) ) return true; return false;
  - startsWithIgnoreCase
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean startsWithIgnoreCase(java.lang.String srcStr, java.lang.String token)
    
    Checks to ensure that 'srcStr' starts with the 'compareStr' token.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' starts with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return srcStr.regionMatches(true, 0, token, 0, token.length()) && ( (token.length() == srcStr.length()) || Character.isWhitespace(srcStr.charAt(token.length())));
  - endsWithIgnoreCase
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean endsWithIgnoreCase(java.lang.String srcStr, java.lang.String token)
    
    Checks to ensure that 'srcStr' ends with the 'compareStr' token.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if 'srcStr' ends with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    int tokenLen = token.length(); int startPos = srcStr.length() - tokenLen; return srcStr.regionMatches(true, startPos, token, 0, tokenLen) && ( (tokenLen == srcStr.length()) || (Character.isWhitespace(srcStr.charAt(startPos - 1))));
  - containsIgnoreCase
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean containsIgnoreCase(java.lang.String srcStr, java.lang.String token)
    
    Checks to ensure that 'srcStr' contains the 'compareStr' token.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if 'srcStr' contains the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.containsIgnoreCase(srcStr, new LV(srcStr, 0, srcStr.length()), token);
  - containsOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsOR(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains at least one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains at least one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS_LV(false, OR, l, srcStr, tokens);
  - containsAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsAND(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains every one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains every one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS_LV(false, AND, l, srcStr, tokens);
  - containsXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsXOR(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS_LV(false, XOR, l, srcStr, tokens);
  - containsNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsNAND(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not contain any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not contain any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS_LV(false, NAND, l, srcStr, tokens);
  - containsOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsOR_CI(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains at least one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains at least one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS_LV(true, OR, l, srcStr, tokens);
  - containsAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsAND_CI(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains every one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains every one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS_LV(true, AND, l, srcStr, tokens);
  - containsXOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsXOR_CI(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS_LV(true, XOR, l, srcStr, tokens);
  - containsNAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsNAND_CI(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not contain any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not contain any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS_LV(true, NAND, l, srcStr, tokens);
  - endsWithXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithXOR(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), ends with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos ends with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return XOR("endsWithXOR", srcStr, tokens, cmp -> TokCmprEW.ew(srcStr, l, cmp));
  - endsWithNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithNAND(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not end with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not end with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return NAND("endsWithNAND", srcStr, tokens, cmp -> TokCmprEW.ew(srcStr, l, cmp));
  - startsWithXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithXOR(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), starts with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos starts with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return XOR("startsWithXOR", srcStr, tokens, cmp -> TokCmprSW.sw(srcStr, l, cmp));
  - startsWithNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithNAND(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not start with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not start with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return NAND("startsWithNAND", srcStr, tokens, cmp -> TokCmprSW.sw(srcStr, l, cmp));
  - endsWithXOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithXOR_CI(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), ends with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos ends with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return XOR("endsWithXOR_CI", srcStr, tokens, cmp -> TokCmprEW.ew_CI(srcStr, l, cmp));
  - endsWithNAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithNAND_CI(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not end with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not end with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return NAND("endsWithNAND_CI", srcStr, tokens, cmp -> TokCmprEW.ew_CI(srcStr, l, cmp));
  - startsWithXOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithXOR_CI(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), starts with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos starts with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return XOR("startsWithXOR_CI", srcStr, tokens, cmp -> TokCmprSW.sw_CI(srcStr, l, cmp));
  - startsWithNAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithNAND_CI(java.lang.String srcStr, int sPos, int ePos, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not start with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not start with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return NAND("startsWithNAND_CI", srcStr, tokens, cmp -> TokCmprSW.sw_CI(srcStr, l, cmp));
  - startsWith
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWith(java.lang.String srcStr, int sPos, int ePos, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' starts with the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos starts with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprSW.sw(srcStr, new LV(srcStr, sPos, ePos), token);
  - startsWithIgnoreCase
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithIgnoreCase(java.lang.String srcStr, int sPos, int ePos, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' starts with the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos starts with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprSW.sw_CI(srcStr, new LV(srcStr, sPos, ePos), token);
  - endsWith
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWith(java.lang.String srcStr, int sPos, int ePos, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' ends with the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos ends with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprEW.ew(srcStr, new LV(srcStr, sPos, ePos), token);
  - endsWithIgnoreCase
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithIgnoreCase(java.lang.String srcStr, int sPos, int ePos, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' ends with the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these two values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos ends with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprEW.ew_CI(srcStr, new LV(srcStr, sPos, ePos), token);
  - contains
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean contains(java.lang.String srcStr, int sPos, int ePos, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' contains the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.contains(srcStr, new LV(srcStr, sPos, ePos), token);
  - containsIgnoreCase
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean containsIgnoreCase(java.lang.String srcStr, int sPos, int ePos, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' contains the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.containsIgnoreCase(srcStr, new LV(srcStr, sPos, ePos), token);
  - containsOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsOR (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains at least one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' contains at least one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(false, OR, srcStr, extraDelimiterTest, tokens);
  - containsAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsAND (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains every one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' contains every one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(false, AND, srcStr, extraDelimiterTest, tokens);
  - containsXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsXOR (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' contains exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(false, XOR, srcStr, extraDelimiterTest, tokens);
  - containsNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsNAND (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not contain any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' does not contain any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(false, NAND, srcStr, extraDelimiterTest, tokens);
  - containsOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsOR_CI (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains at least one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' contains at least one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(true, OR, srcStr, extraDelimiterTest, tokens);
  - containsAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsAND_CI (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains every one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' contains every one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(true, AND, srcStr, extraDelimiterTest, tokens);
  - containsXOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsXOR_CI (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' contains exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' contains exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(true, XOR, srcStr, extraDelimiterTest, tokens);
  - containsNAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsNAND_CI (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not contain any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' does not contain any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.CONTAINS(true, NAND, srcStr, extraDelimiterTest, tokens);
  - endsWithXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithXOR (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' ends with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' ends with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return XOR( "endsWithXOR", srcStr, tokens, cmp -> TokCmprEW.ew(srcStr, new LV(srcStr, 0, -1), extraDelimiterTest, cmp) );
  - endsWithNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithNAND (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not end with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' does not end with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return NAND( "endsWithNAND", srcStr, tokens, cmp -> TokCmprEW.ew(srcStr, new LV(srcStr, 0, -1), extraDelimiterTest, cmp) );
  - startsWithXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithXOR (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' starts with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' starts with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return XOR( "startsWithXOR", srcStr, tokens, cmp -> TokCmprSW.sw(srcStr, new LV(srcStr, 0, -1), extraDelimiterTest, cmp) );
  - startsWithNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithNAND (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not start with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' does not start with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return NAND( "startsWithNAND", srcStr, tokens, cmp -> TokCmprSW.sw(srcStr, new LV(srcStr, 0, -1), extraDelimiterTest, cmp) );
  - endsWithXOR_CI
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean endsWithXOR_CI (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' ends with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' ends with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    endsWithIgnoreCase(String, String), XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return XOR( "endsWithXOR_CI", srcStr, tokens, cmp -> endsWithIgnoreCase(srcStr, extraDelimiterTest, cmp) );
  - endsWithNAND_CI
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean endsWithNAND_CI (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not end with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' does not end with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    endsWithIgnoreCase(String, String), NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return NAND( "endsWithNAND_CI", srcStr, tokens, cmp -> endsWithIgnoreCase(srcStr, extraDelimiterTest, cmp) );
  - startsWithXOR_CI
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean startsWithXOR_CI (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' starts with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' starts with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    startsWithIgnoreCase(String, Predicate, String), XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return XOR( "startsWithXOR_CI", srcStr, tokens, cmp -> startsWithIgnoreCase(srcStr, extraDelimiterTest, cmp) );
  - startsWithNAND_CI
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean startsWithNAND_CI (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that parameter 'srcStr' does not start with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' does not start with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    startsWithIgnoreCase(String, Predicate, String), NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    return NAND( "startsWithNAND_CI", srcStr, tokens, cmp -> startsWithIgnoreCase(srcStr, extraDelimiterTest, cmp) );
  - startsWith
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean startsWith (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks to ensure that 'srcStr' starts with the 'compareStr' token.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' starts with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return srcStr.startsWith(token) && ( (token.length() == srcStr.length()) || Character.isWhitespace(srcStr.charAt(token.length())) || extraDelimiterTest.test(srcStr.charAt(token.length())));
  - endsWith
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean endsWith (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks to ensure that 'srcStr' ends with the 'compareStr' token.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' ends with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    int tokenLen = token.length(); return srcStr.endsWith(token) && ( ((srcStr.length() - tokenLen) == 0) || Character.isWhitespace(srcStr.charAt(srcStr.length() - tokenLen - 1)) || extraDelimiterTest.test(srcStr.charAt(srcStr.length() - tokenLen - 1)));
  - contains
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean contains (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks to ensure that 'srcStr' contains the 'compareStr' token.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' contains the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    int tokenLen = token.length(); int loopLen = srcStr.length() - tokenLen; for (int i=0; i <= loopLen; i++) if ( srcStr.regionMatches(i, token, 0, tokenLen) && ( (i == 0) || Character.isWhitespace(srcStr.charAt(i - 1)) || extraDelimiterTest.test(srcStr.charAt(i - 1))) && ( ((i + tokenLen) == srcStr.length()) || Character.isWhitespace(srcStr.charAt(i + tokenLen)) || extraDelimiterTest.test(srcStr.charAt(i + tokenLen))) ) return true; return false;
  - startsWithIgnoreCase
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean startsWithIgnoreCase (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks to ensure that 'srcStr' starts with the 'compareStr' token.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' starts with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return srcStr.regionMatches(true, 0, token, 0, token.length()) && ( (token.length() == srcStr.length()) || Character.isWhitespace(srcStr.charAt(token.length())) || extraDelimiterTest.test(srcStr.charAt(token.length())));
  - endsWithIgnoreCase
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean endsWithIgnoreCase (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks to ensure that 'srcStr' ends with the 'compareStr' token.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' ends with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    int tokenLen = token.length(); return srcStr.regionMatches(true, srcStr.length() - tokenLen, token, 0, tokenLen) && ( ((srcStr.length() - tokenLen) == 0) || Character.isWhitespace(srcStr.charAt(srcStr.length() - tokenLen - 1)) || extraDelimiterTest.test(srcStr.charAt(srcStr.length() - tokenLen - 1)));
  - containsIgnoreCase
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean containsIgnoreCase (java.lang.String srcStr, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks to ensure that 'srcStr' contains the 'compareStr' token.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if 'srcStr' contains the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.containsIgnoreCase (srcStr, new LV(srcStr, 0, srcStr.length()), extraDelimiterTest, token);
  - containsOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsOR (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains at least one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains at least one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS(false, OR, l, srcStr, extraDelimiterTest, tokens);
  - containsAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsAND (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains every one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains every one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS(false, AND, l, srcStr, extraDelimiterTest, tokens);
  - containsXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsXOR (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS(false, XOR, l, srcStr, extraDelimiterTest, tokens);
  - containsNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsNAND (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not contain any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not contain any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS(false, NAND, l, srcStr, extraDelimiterTest, tokens);
  - containsOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsOR_CI (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains at least one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains at least one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS(true, OR, l, srcStr, extraDelimiterTest, tokens);
  - containsAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsAND_CI (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains every one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains every one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS(true, AND, l, srcStr, extraDelimiterTest, tokens);
  - containsXOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsXOR_CI (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), contains exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS(true, XOR, l, srcStr, extraDelimiterTest, tokens);
  - containsNAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean containsNAND_CI (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not contain any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not contain any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return TokCmprCN.CONTAINS(true, NAND, l, srcStr, extraDelimiterTest, tokens);
  - endsWithXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithXOR (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), ends with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos ends with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return XOR( "endsWithXOR", srcStr, tokens, cmp -> TokCmprEW.ew(srcStr, l, extraDelimiterTest, cmp) );
  - endsWithNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithNAND (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not end with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not end with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return NAND( "endsWithNAND", srcStr, tokens, cmp -> TokCmprEW.ew(srcStr, l, extraDelimiterTest, cmp) );
  - startsWithXOR
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithXOR (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), starts with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos starts with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return XOR( "startsWithXOR", srcStr, tokens, cmp -> TokCmprSW.sw(srcStr, l, extraDelimiterTest, cmp) );
  - startsWithNAND
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithNAND (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not start with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not start with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return NAND( "startsWithNAND", srcStr, tokens, cmp -> TokCmprSW.sw(srcStr, l, extraDelimiterTest, cmp) );
  - endsWithXOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithXOR_CI (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), ends with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos ends with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return XOR( "endsWithXOR_CI", srcStr, tokens, cmp -> TokCmprEW.ew_CI(srcStr, l, extraDelimiterTest, cmp) );
  - endsWithNAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithNAND_CI (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not ends with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not ends with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return NAND( "endsWithNAND_CI", srcStr, tokens, cmp -> TokCmprEW.ew_CI(srcStr, l, extraDelimiterTest, cmp) );
  - startsWithXOR_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithXOR_CI (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), starts with exactly one of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos starts with exactly one of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    XOR(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return XOR( "startsWithXOR_CI", srcStr, tokens, cmp -> TokCmprSW.sw_CI(srcStr, l, extraDelimiterTest, cmp) );
  - startsWithNAND_CI
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithNAND_CI (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String... tokens)
    
    Checks to ensure that the 'srcStr' substring, which is demarcated by 'sPos' (inclusive) and 'ePos' (exclusive), does not start with any of the tokens supplied by the 'tokens' array.
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    tokens - The String's used in the comparison against 'srcStr'
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos does not start with any of the user-provided tokens. Matches are only taken into consideration if they are delimited appropriately. Token-Matches are sufficient, while Sub-String-Matches are not.
    
    See Also:
    
    NAND(String, String, String[], Predicate)
    
    Code:
    
    Exact Method Body:
    
    final LV l = new LV(srcStr, sPos, ePos); return NAND( "startsWithNAND_CI", srcStr, tokens, cmp -> TokCmprSW.sw_CI(srcStr, l, extraDelimiterTest, cmp) );
  - startsWith
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWith (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' starts with the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos starts with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprSW.sw(srcStr, new LV(srcStr, sPos, ePos), extraDelimiterTest, token);
  - startsWithIgnoreCase
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean startsWithIgnoreCase (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' starts with the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that begins at srcStr.charAt(0), it will check the character directly after that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-terminus (matching '$')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos starts with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprSW.sw_CI(srcStr, new LV(srcStr, sPos, ePos), extraDelimiterTest, token);
  - endsWith
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWith (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' ends with the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos ends with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprEW.ew(srcStr, new LV(srcStr, sPos, ePos), extraDelimiterTest, token);
  - endsWithIgnoreCase
    
    🡅 🡇 ⇈ ⮫ External-Java: ⮫ 🗕 🗗 🗖
    public static boolean endsWithIgnoreCase (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' ends with the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match within String parameter 'srcStr' that ends at srcStr.charAt(srcStr.length() - 1), it will check the character immediately preceding that match in order to ensure that it assumes only one of these three values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos ends with the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprEW.ew_CI(srcStr, new LV(srcStr, sPos, ePos), extraDelimiterTest, token);
  - contains
    
    🡅 🡇 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean contains (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' contains the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.contains(srcStr, new LV(srcStr, sPos, ePos), extraDelimiterTest, token);
  - containsIgnoreCase
    
    🡅 ⇈ ⮫ 🗕 🗗 🗖
    public static boolean containsIgnoreCase (java.lang.String srcStr, int sPos, int ePos, java.util.function.Predicate<java.lang.Character> extraDelimiterTest, java.lang.String token)
    
    Checks whether or not a substring of 'srcStr' contains the 'compareStr' token. The substring that is checked is demarcated by 'sPos' (inclusive), and 'ePos' (exclusive).
    
    The test performed here ** is not ** case-sensitive.
    
    Parameters:
    
    srcStr - Any non-null instance of java.lang.String
    
    extraDelimiterTest - Can be used if characters other than white-space should be considered as token-delimiters. Useful CharPredicate's to this parameter are, for example, tests to further allow punctuation - commas, periods, parenthesis, etc... as match boundaries.
    
    Useful Predicate's to provide might include (but are not limited to) the following:
    
    ① Character::isSpaceChar (includes UNICODE White-Space)
    ② Character::isDigit
    ③ c -> ".,:;!?()".contains(c) (Miscellaneous Punctuation)
    ④ Any character test of your choosing
    
    token - The String used in the comparison against srcStr
    
    When this method makes token comparisons using the input String-token parameter(s), if the logic finds a match anywhere within String parameter 'srcStr', it will check both the character immediately preceding and the character directly after that match in order to ensure that they assume only one of these four values:
    
    ① white-space (matching '\s')
    ② String-start (matching '^')
    ③ String-terminus (matching '$')
    ④ any character which passes the parameter-provided Predicate<Character> delimiter test
    
    Returns:
    
    TRUE if the Sub-String consisting of the characters inside 'srcStr', between sPos and ePos contains the specified token. A match is only taken into consideration if it is delimited appropriately. A Token-Match is sufficient, while a Sub-String-Match is not.
    
    Code:
    
    Exact Method Body:
    
    return TokCmprCN.containsIgnoreCase (srcStr, new LV(srcStr, sPos, ePos), extraDelimiterTest, token);

Field 'DEBUG' is not final.	Reason: DEBUGGING
Field 'DEBUG_LOG' is not final.	Reason: DEBUGGING

Class StrTokCmpr

StrTokCmpr =>

Methods Available

Method Parameters

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DEBUG

DEBUG_LOG

AND

OR

NAND

XOR

Method Detail

AND

NAND

OR

XOR

containsOR

containsAND

containsXOR

containsNAND

containsOR_CI

containsAND_CI

containsXOR_CI

containsNAND_CI

endsWithXOR

endsWithNAND

startsWithXOR

startsWithNAND

endsWithXOR_CI

endsWithNAND_CI

startsWithXOR_CI

startsWithNAND_CI

startsWith

endsWith

contains

startsWithIgnoreCase

endsWithIgnoreCase

containsIgnoreCase

containsOR

containsAND

containsXOR

containsNAND

containsOR_CI

containsAND_CI

containsXOR_CI

containsNAND_CI

endsWithXOR

endsWithNAND

startsWithXOR

startsWithNAND

endsWithXOR_CI

endsWithNAND_CI

startsWithXOR_CI

startsWithNAND_CI

startsWith

startsWithIgnoreCase

endsWith

endsWithIgnoreCase

contains

containsIgnoreCase

containsOR

containsAND

containsXOR

containsNAND

containsOR_CI

containsAND_CI

containsXOR_CI

containsNAND_CI

endsWithXOR

endsWithNAND

startsWithXOR

startsWithNAND

endsWithXOR_CI

endsWithNAND_CI

startsWithXOR_CI

startsWithNAND_CI

startsWith