package Torello.HTML.NodeSearch;

import Torello.Java.*;

import java.lang.reflect.Field;
import java.util.function.BiPredicate;

/**
 * A functional-interface / lambda-target that has many pre-instantiated instances that
 * essentially serves a simplified wrappers for the many {@code String} search and comparison
 * utilities provided in <CODE>Torello&#46;Java</CODE>.
 * 
 * <BR /><BR /><EMBED CLASS='external-html' DATA-FILE-ID=TextComparitor>
 */
@FunctionalInterface
public interface TextComparitor extends BiPredicate<String, String[]>, java.io.Serializable
{
    /** <EMBED CLASS='external-html' DATA-FILE-ID=SVUIDFI>  */
    public static final long serialVersionUID = 1;

    /**
     * <EMBED CLASS='external-html' DATA-FILE-ID=FUNC_INTER_METH>
     * 
     * @param str This is usually a line of text from the {@code public final String str} field of
     * the class {@code TextNode}, if the programmer is requesting a {@code TextNode} search.  If
     * the search being performed is on {@code TagNode} attribute values, then the value of
     * parameter {@code String htmlText} will be any {@code String}-text within an HTML Element's
     * attribute <B STYLE="color: red;">value</B>.
     * 
     * @param compareText This is a list of different text-{@code String's} to be used by the 
     * method that performs the test.  View the compare-{@code String's} in the methods of classes
     * {@link StrCmpr} or {@link StrTokCmpr} to understand this more clearly.
     * 
     * @return After performing the single-input-parameter "version of" the
     * {@code accept(htmlText, compareText)} method on as many of the elements of the
     * {@code String[] compareText} input-array, this will return {@code TRUE} or {@code FALSE}
     * dependent on the expected boolean-logic behavior of the comparison.  This is simple, as the
     * four primary {@code boolean} operations: {@code AND, OR, NAND, XOR} are provided as
     * pre-defined methods here.
     * 
     * <BR /><BR /><B>NOTE: </B>All boolean evaluations done are <I>short-circuit evaluations</I>.
     * As soon as a function result-value is known, it will be returned.
     * <BR /><B>ALSO: </B>Loops begin with the first element of the {@code String[] compareText}
     * array, and stop with the last element.      
     */
    public boolean test(String str, String[] compareText);

    // ***************************************************************************************************
    // Specialized CSS Class Testers.
    // ***************************************************************************************************

    /**
     * This will check that <I><B>at least one of</I></B> the named/provided
     * "Compare-{@code String's}" are present, as tokens not substrings, in the
     * CSS-Class-{@code String} of an HTML Element.
     * 
     * <EMBED CLASS='external-html' DATA-FILE-ID=TCCSSTOK>
     * 
     * @see StrTokCmpr#containsOR(String, String[])
     */
    public static final TextComparitor CONTAINS_CSS_CLASS_OR = StrTokCmpr::containsOR;

    /**
     * This will check that <I><B>all / every-one-of</I></B> the named/provided
     * "Compare-{@code String's}" are present, as tokens not substrings, in the
     * CSS-Class-{@code String} of an HTML Element.
     *
     * <EMBED CLASS='external-html' DATA-FILE-ID=TCCSSTOK>
     * 
     * @see StrTokCmpr#containsAND(String, String[])
     */
    public static final TextComparitor CONTAINS_CSS_CLASS_AND = StrTokCmpr::containsAND;

    /**
     * This will check that <I><B>none of</I></B> the named/provided "Compare-{@code String's}" are
     * present, as tokens not substrings, in the CSS-Class-{@code String} of an HTML Element.
     * 
     * <EMBED CLASS='external-html' DATA-FILE-ID=TCCSSTOK>
     * 
     * @see StrTokCmpr#containsNAND(String, String[])
     */
    public static final TextComparitor CONTAINS_CSS_CLASS_NAND = StrTokCmpr::containsNAND;

    /**
     * This will check that <I><B>exactly one of</I></B> the named/provided
     * "Compare-{@code String's}" are present, as tokens not substrings, in the
     * CSS-Class-{@code String} of an HTML Element.
     * 
     * <EMBED CLASS='external-html' DATA-FILE-ID=TCCSSTOK>
     * 
     * @see StrTokCmpr#containsXOR(String, String[])
     */
    public static final TextComparitor CONTAINS_CSS_CLASS_XOR = StrTokCmpr::containsXOR;

    /**
     * This is used as an "abbreviation" to save typing (for convenience).  It can reduce, however,
     * readability.
     * 
     * <BR /><BR /><B>STANDARD-CSS:</B> The standard way to look for HTML Element matches using a
     * CSS-Selector is to use a boolean {@code 'or'}, not a boolean {@code 'and.'}
     * 
     * <EMBED CLASS='external-html' DATA-FILE-ID=TCCSSTOK>
     * 
     * @see #CONTAINS_CSS_CLASS_OR
     */
    public static final TextComparitor C_OR = CONTAINS_CSS_CLASS_OR;

    /**
     * This is used as an "abbreviation" to save typing (for convenience).  It can reduce, however,
     * readability.  Since this is Java, not a CSS-Style-Sheet, this "selector"
     * ({@code java.util.function.BiPredicate}) allows the programmer the flexibility to build an
     * "AND" CSS-Class-Selector, rather than an "OR" CSS-Class-Selector.
     *
     * <EMBED CLASS='external-html' DATA-FILE-ID=TCCSSTOK>
     * 
     * @see #CONTAINS_CSS_CLASS_AND
     */
    public static final TextComparitor C_AND = CONTAINS_CSS_CLASS_AND;

    /**
     * This is just used as an "abbreviation" to save typing (for convenience).  It can reduce,
     * however, readability.  Since this is Java, not a CSS-Style-Sheet, this "selector"
     * ({@code java.util.function.BiPredicate}) allows the programmer the flexibility to build a
     * "NAND" CSS-Class-Selector, rather than an "OR" CSS-Class-Selector.
     * 
     * <EMBED CLASS='external-html' DATA-FILE-ID=TCCSSTOK>
     * 
     * @see #CONTAINS_CSS_CLASS_NAND
     */
    public static final TextComparitor C_NAND = CONTAINS_CSS_CLASS_NAND;

    /**
     * This is just used as an "abbreviation" to save typing (for convenience).  It can reduce, 
     * however, readability.  Since this is Java, not a CSS-Style-Sheet, this "selector"
     * ({@code java.util.function.BiPredicate}) allows the programmer the flexibility to build an
     * "XOR" CSS-Class-Selector, rather than an "OR" CSS-Class-Selector.
     * 
     * <EMBED CLASS='external-html' DATA-FILE-ID=TCCSSTOK>
     * 
     * @see #CONTAINS_CSS_CLASS_XOR
     */
    public static final TextComparitor C_XOR = CONTAINS_CSS_CLASS_XOR;

    /**
     * This is used as an <B>EXTRA</B> "abbreviation" to save typing (for convenience).  It can
     * reduce, however, readability.
     * 
     * <BR /><BR /><B STYLE='color: red;'>STANDARD-CSS:</B> The standard way to look for HTML
     * Element matches using a CSS-Selector is to use a boolean {@code 'or'}, not a boolean
     * {@code 'and'}.
     * 
     * <BR /><BR /><B STYLE='color: red;'>ALSO:</B> CSS Classes are <B><I>not</I></B> case
     * insensitive.
     * 
     * <EMBED CLASS='external-html' DATA-FILE-ID=TCCSSTOK>
     * 
     * @see #C_OR
     * @see #CONTAINS_CSS_CLASS_OR
     */
    public static final TextComparitor C = C_OR;

    // ***************************************************************************************************
    // EQUALITY TESTING
    // ***************************************************************************************************

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If precisely one of the compare-{@code String's} equal the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}, then and only then will this
     * {@code BiPredicate} return {@code TRUE}.
     * 
     * @see StrCmpr#equalsXOR(String, String[])
     */
    public static final TextComparitor EQ = StrCmpr::equalsXOR;

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If and only if none of the candidates are equal, can this {@code BiPredicate} evaluate to
     * {@code TRUE}.
     * 
     * @see StrCmpr#equalsNAND(String, String[])
     */
    public static final TextComparitor NOT_EQ = StrCmpr::equalsNAND;

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If and only if none of the candidates are equal, can this {@code BiPredicate} evaluate to
     * {@code TRUE}.  This function-pointer is identical to the one named {@link #NOT_EQ}.
     * 
     * @see StrCmpr#equalsNAND(String, String[])
     */
    public static final TextComparitor EQ_NAND = StrCmpr::equalsNAND;

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If precisely one of the compare-{@code String's} equal the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}, then and only then will this
     * {@code BiPredicate} return {@code TRUE}.  In this function-pointer, the comparison performed
     * will ignore the case of the arguments.
     * 
     * @see StrCmpr#equalsXOR_CI(String, String[])
     */
    public static final TextComparitor EQ_CASE_INSENSITIVE = StrCmpr::equalsXOR_CI;

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If precisely one of the compare-{@code String's} equal the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}, then and only then will this
     * {@code BiPredicate} return {@code TRUE}.  In this function-pointer, the comparison performed
     * will ignore the case of the arguments.  This is an abbreviated version of the identical
     * {@code TextComparitor} {@link #EQ_CASE_INSENSITIVE}.
     * 
     * @see StrCmpr#equalsXOR_CI(String, String[])
     */
    public static final TextComparitor EQ_CI = StrCmpr::equalsXOR_CI;

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If and only if none of the candidates are equal, can this {@code BiPredicate} evaluate to
     * {@code TRUE}.  In this function-pointer, the comparison performed will ignore the case of the
     * arguments.
     * 
     * @see StrCmpr#equalsNAND_CI(String, String[])
     */
    public static final TextComparitor NOT_EQ_CASE_INSENSITIVE = StrCmpr::equalsNAND_CI;

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If and only if none of the candidates are equal, can this {@code BiPredicate} evaluate to
     * {@code TRUE}.  In this function-pointer, the comparison performed will ignore the case of the
     * arguments.  This is an abbreviated version of the identical {@code TextComparitor}
     * {@link #NOT_EQ_CASE_INSENSITIVE}.
     * 
     * @see StrCmpr#equalsNAND_CI(String, String[])
     */
    public static final TextComparitor NOT_EQ_CI = StrCmpr::equalsNAND_CI;

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If and only if none of the candidates are equal, can this {@code BiPredicate} evaluate to
     * {@code TRUE}.  In this function-pointer, the comparison performed will ignore the case of the
     * arguments.  This is an abbreviated version of the identical {@code TextComparitor}
     * {@link #NOT_EQ_CASE_INSENSITIVE}.
     * 
     * @see StrCmpr#equalsNAND_CI(String, String[])
     */
    public static final TextComparitor EQ_CI_NAND = StrCmpr::equalsNAND_CI;

    // ***************************************************************************************************
    // EQUALITY TESTING - WITH PRE TEXT CALL TO 'trim()'
    // ***************************************************************************************************

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If precisely one of the compare-{@code String's} equal the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}, then and only then will this
     * {@code BiPredicate} return {@code TRUE}.  Before the equality-comparison is performed, the
     * {@code java.lang.String.trim()} method will be invoked on the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}.
     * 
     * @see StrCmpr#equalsXOR(String, String[])
     */
    public static final TextComparitor EQ_TRM =
        (String s, String[] sArr) -> StrCmpr.equalsXOR(s.trim(), sArr);

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If and only if none of the candidates are equal, can this {@code BiPredicate} evaluate to
     * {@code TRUE}.  Before the equality-comparison is performed, the
     * {@code java.lang.String.trim()} method will be invoked on the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}.
     * 
     * @see StrCmpr#equalsNAND(String, String[])
     */
    public static final TextComparitor NOT_EQ_TRM = 
        (String s, String[] sArr) -> StrCmpr.equalsNAND(s.trim(), sArr);

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If and only if none of the candidates are equal, can this {@code BiPredicate} evaluate to
     * {@code TRUE}.  This function-pointer is identical to the one named {@link #NOT_EQ}.  Before
     * the equality-comparison is performed, the {@code java.lang.String.trim()} method will be
     * invoked on the attribute-<B STYLE="color: red;">value</B> or {@code TextNode}.
     * 
     * @see StrCmpr#equalsNAND(String, String[]) */
    public static final TextComparitor EQ_NAND_TRM = 
        (String s, String[] sArr) -> StrCmpr.equalsNAND(s.trim(), sArr);

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If precisely one of the compare-{@code String's} equal the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}, then and only then will this
     * {@code BiPredicate} return {@code TRUE}.  In this function-pointer, the comparison performed
     * will ignore the case of the arguments.  Before the equality-comparison is performed, the
     * {@code java.lang.String.trim()} method will be invoked on the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}.
     * 
     * @see StrCmpr#equalsXOR_CI(String, String[])
     */
    public static final TextComparitor EQ_CASE_INSENSITIVE_TRIM = 
        (String s, String[] sArr) -> StrCmpr.equalsXOR_CI(s.trim(), sArr);

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If precisely one of the compare-{@code String's} equal the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}, then and only then will this
     * {@code BiPredicate} return {@code TRUE}.  In this function-pointer, the comparison performed
     * will ignore the case of the arguments.  This is an abbreviated version of the identical
     * {@code TextComparitor} {@link #EQ_CASE_INSENSITIVE_TRIM}. Before the equality-comparison is
     * performed, the {@code java.lang.String.trim()} method will be invoked on the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}.
     * 
     * @see StrCmpr#equalsXOR_CI(String, String[])
     */
    public static final TextComparitor EQ_CI_TRM = 
        (String s, String[] sArr) -> StrCmpr.equalsXOR_CI(s.trim(), sArr);

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If and only if none of the candidates are equal, can this {@code BiPredicate} evaluate to
     * {@code TRUE}.  In this function-pointer, the comparison performed will ignore the case of the
     * arguments.  Before the equality-comparison is performed, the {@code java.lang.String.trim()}
     * method will be invoked on the attribute-<B STYLE="color: red;">value</B> or
     * {@code TextNode}.
     * 
     * @see StrCmpr#equalsNAND_CI(String, String[])
     */
    public static final TextComparitor NOT_EQ_CASE_INSENSITIVE_TRIM = 
        (String s, String[] sArr) -> StrCmpr.equalsNAND_CI(s.trim(), sArr);

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If and only if none of the candidates are equal, can this {@code BiPredicate} evaluate to
     * {@code TRUE}.  In this function-pointer, the comparison performed will ignore the case of the
     * arguments.  This is an abbreviated version of the identical {@code TextComparitor}
     * {@link #NOT_EQ_CASE_INSENSITIVE_TRIM}. Before the equality-comparison is performed, the
     * {@code java.lang.String.trim()} method will be invoked on the
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode}.
     * 
     * @see StrCmpr#equalsNAND_CI(String, String[])
     */
    public static final TextComparitor NOT_EQ_CI_TRM = 
        (String s, String[] sArr) -> StrCmpr.equalsNAND_CI(s.trim(), sArr);

    /**
     * Will compare an attribute-<B STYLE="color: red;">value</B> {@code String}, or
     * {@code TextNode} for equality against a list of possible {@code String}-match candidates.
     * If and only if none of the candidates are equal, can this {@code BiPredicate} evaluate to
     * {@code TRUE}.  In this function-pointer, the comparison performed will ignore the case of the
     * arguments.  Before the equality-comparison is performed, the {@code java.lang.String.trim()}
     * method will be invoked on the attribute-<B STYLE="color: red;">value</B> or
     * {@code TextNode}.
     * 
     * @see StrCmpr#equalsNAND_CI(String, String[])
     */
    public static final TextComparitor EQ_CI_NAND_TRM = 
        (String s, String[] sArr) -> StrCmpr.equalsNAND_CI(s.trim(), sArr);


    // ***************************************************************************************************
    // CONTAINS TESTING
    // ***************************************************************************************************

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify whether
     * it contains <I>at least one match</I> out of a list compare-{@code String's}.
     * 
     * @see StrCmpr#containsOR(String, String[])
     */
    public static final TextComparitor CONTAINS = StrCmpr::containsOR;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify whether
     * it contains <I>a match for every string</I> in the list compare-{@code String's}.
     * 
     * @see StrCmpr#containsAND(String, String[])
     */
    public static final TextComparitor CONTAINS_AND = StrCmpr::containsAND;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify if it
     * will <I>match precisely one and only one</I> {@code String} from a list of
     * compare-{@code String's}.
     * 
     * @see StrCmpr#containsXOR(String, String[])
     */
    public static final TextComparitor CONTAINS_XOR = StrCmpr::containsXOR;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to ensure that it
     * <I>does not contain any matches</I> with the list of compare-{@code String's}.
     * 
     * @see StrCmpr#containsNAND(String, String[])
     */
    public static final TextComparitor CONTAINS_NAND = StrCmpr::containsNAND;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify whether
     * it contains <I>at least one match</I> out of a list of compare-{@code String's}.
     * 
     * @see StrCmpr#containsOR(String, String[]) 
     */
    public static final TextComparitor CONTAINS_OR = StrCmpr::containsOR;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify whether
     * it contains <I>at least one match</I> out of a list compare-{@code String's}.  This field
     * instance has an abbreviated name (for convenience), but identical function-pointer to
     * {@link #CONTAINS} (and also {@link #CONTAINS_OR}).
     * 
     * @see StrCmpr#containsOR(String, String[])
     */
    public static final TextComparitor CN = StrCmpr::containsOR;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify whether
     * it contains <I>at least one match</I> out of a list compare-{@code String's}.  This field
     * instance has an abbreviated name (for convenience), but identical function-pointer to
     * {@link #CONTAINS_OR} (and also {@link #CONTAINS}).
     * 
     * @see StrCmpr#containsOR(String, String[])
     */
    public static final TextComparitor CN_OR = StrCmpr::containsOR;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to ensure that it
     * <I>does not contain any matches</I> with the list of compare-{@code String's}.  This field
     * instance has an abbreviated name (for convenience), but identical function-pointer to
     * {@link #CONTAINS_AND}.
     * 
     * @see StrCmpr#containsAND(String, String[])
     */
    public static final TextComparitor CN_AND = StrCmpr::containsAND;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify if it
     * will <I>match precisely one and only one</I> {@code String} from a list of
     * compare-{@code String's}. This field instance has an abbreviated name (for convenience), but
     * identical function-pointer to {@link #CONTAINS_XOR}.
     * 
     * @see StrCmpr#containsXOR(String, String[])
     */
    public static final TextComparitor CN_XOR = StrCmpr::containsXOR;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to ensure that it
     * <I>does not contain any matches</I> with the list of compare-{@code String's}.  This field
     * instance has an abbreviated name (for convenience), but identical function-pointer to
     * {@link #CONTAINS_NAND}.
     * 
     * @see StrCmpr#containsNAND(String, String[])
     */
    public static final TextComparitor CN_NAND = StrCmpr::containsNAND;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to ensure that it
     * <I>does not contain any matches</I> with the list of compare-{@code String's}.  This field
     * instance differs in name only with other pre-defined {@code static} fields in this class. 
     * It's function pointer is identical to: {@link #CN_NAND}, {@link #CONTAINS_NAND} and
     * {@link #DOES_NOT_CONTAIN}.
     * 
     * @see StrCmpr#containsNAND(String, String[])
     */
    public static final TextComparitor NOT_CN = StrCmpr::containsNAND;

    /**
     * Checks an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to ensure that it
     * <I>does not contain any matches</I> with the list of compare-{@code String's}.  It's
     * function pointer is identical to: {@link #CN_NAND}, {@link #CONTAINS_NAND} and
     * {@link #NOT_CN}.
     * 
     * @see StrCmpr#containsNAND(String, String[])
     */
    public static final TextComparitor DOES_NOT_CONTAIN = StrCmpr::containsNAND;


    // ***************************************************************************************************
    // CONTAINS TESTING - Case Insensitive versions
    // ***************************************************************************************************

    /**
     * Similar to {@code public static} field {@link #CONTAINS}, this function-pointer checks an 
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify whether it
     * contains <I>at least one match</I> out of a list compare-{@code String's}.  The difference
     * between this field and the aforementioned {@code public static} field is that this one
     * ({@code 'CONTAINS_CASE_INSENSITIVE'}) ignores the case of the lettering when performing the
     * {@code String} comparisons. 
     * 
     * @see StrCmpr#containsOR_CI(String, String[])
     */
    public static final TextComparitor CONTAINS_CASE_INSENSITIVE = StrCmpr::containsOR_CI;

    /**
     * Just like {@code public static} field {@link #CONTAINS_AND}, this function-pointer checks an
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify whether it
     * contains <I>a match for every string</I> in the list compare-{@code String's}.  The
     * difference between this field and the aforementioned {@code public static} field is that
     * this one ({@code 'CONTAINS_CASE_INSENSITIVE_AND'}) ignores the case of the lettering when
     * performing the {@code String} comparisons. 
     * 
     * @see StrCmpr#containsAND_CI(String, String[])
     */
    public static final TextComparitor CONTAINS_CASE_INSENSITIVE_AND = StrCmpr::containsAND_CI;

    /**
     * Similar to {@code public static} field {@link #CONTAINS_XOR}, this function-pointer checks
     * an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify if it will
     * <I>match precisely one and only one</I> {@code String} from a list of
     * compare-{@code String's}. The difference between this field and the aforementioned
     * {@code public static} field is that this one ({@code 'CONTAINS_CASE_INSENSITIVE_XOR'})
     * ignores the case of the lettering when performing the {@code String} comparisons. 
     * 
     * @see StrCmpr#containsXOR_CI(String, String[])
     */
    public static final TextComparitor CONTAINS_CASE_INSENSITIVE_XOR = StrCmpr::containsXOR_CI;

    /**
     * Just like {@code public static} field {@link #CONTAINS_NAND}, this function pointer checks
     * an attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to ensure that it <I>does
     * not contain any matches</I> with the list of compare-{@code String's}.  The difference
     * between this field and the aforementioned {@code public static} field is that this one
     * ({@code 'CONTAINS_CASE_INSENSITIVE_NAND'}) ignores the case of the lettering when performing
     * the {@code String} comparisons. 
     * 
     * @see StrCmpr#containsNAND_CI(String, String[])
     */
    public static final TextComparitor CONTAINS_CASE_INSENSITIVE_NAND = StrCmpr::containsNAND_CI;

    /**
     * Similar to {@code public static} field {@link #CONTAINS_OR}, this function-pointer checks an
     * attribute-<B STYLE="color: red;">value</B> or {@code TextNode} to identify whether it
     * contains <I>at least one match</I> out of a list of compare-{@code String's}.  The
     * difference between this field and the aforementioned {@code public static} field is that
     * this one ({@code 'CONTAINS_CASE_INSENSITIVE_OR'}) ignores the case of the lettering when
     * performing the {@code String} comparisons. 
     * 
     * @see StrCmpr#containsOR_CI(String, String[])
     */
    public static final TextComparitor CONTAINS_CASE_INSENSITIVE_OR = StrCmpr::containsOR_CI;

    /**
     * This function pointer's name is just an abbreviation for the {@code public static} field
     * named {@link #CONTAINS_CASE_INSENSITIVE}.  It points to the same method in {@code class
     * StrCmpr}.
     * 
     * @see StrCmpr#containsOR_CI(String, String[])
     */
    public static final TextComparitor CN_CI = StrCmpr::containsOR_CI;

    /**
     * This function pointer's name is just an abbreviation for the {@code public static} field
     * named {@link #CONTAINS_CASE_INSENSITIVE_OR}.  It points to the same method in {@code class
     * StrCmpr}.
     * 
     * @see StrCmpr#containsOR_CI(String, String[])
     */
    public static final TextComparitor CN_CI_OR = StrCmpr::containsOR_CI;

    /**
     * This function pointer's name is just an abbreviation for the {@code public static} field
     * named {@link #CONTAINS_CASE_INSENSITIVE_AND}.  It points to the same method in {@code class
     * StrCmpr}.
     * 
     * @see StrCmpr#containsAND_CI(String, String[])
     */
    public static final TextComparitor CN_CI_AND = StrCmpr::containsAND_CI;

    /**
     * This function pointer's name is just an abbreviation for the {@code public static} field
     * named {@link #CONTAINS_CASE_INSENSITIVE_XOR}.  It points to the same method in {@code class
     * StrCmpr}.
     * 
     * @see StrCmpr#containsXOR_CI(String, String[])
     */
    public static final TextComparitor CN_CI_XOR = StrCmpr::containsXOR_CI;

    /**
     * This function pointer's name is just an abbreviation for the {@code public static} field
     * named {@link #CONTAINS_CASE_INSENSITIVE_NAND}.  It points to the same method in {@code class
     * StrCmpr}.
     * 
     * @see StrCmpr#containsNAND_CI(String, String[])
     */
    public static final TextComparitor CN_CI_NAND = StrCmpr::containsNAND_CI;

    /**
     * This function pointer checks an attribute-<B STYLE="color: red;">value</B> or
     * {@code TextNode} to ensure that it <I>does not contain any matches</I> with the list of
     * compare-{@code String's}. The comparisons method used ignores the case of the text in the
     * string parameters.  Do note that all four of the following {@code static} fields
     * {@link #NOT_CN_CI}, {@link #DOES_NOT_CONTAIN_CASE_INSENSITIVE}, {@link #CN_CI_NAND} and
     * {@link #CONTAINS_CASE_INSENSITIVE_NAND} point to the same {@code StrCmpr} method.  Since the
     * variable names trade-off readability and brevity, this is done for convenience.
     * 
     * @see StrCmpr#containsNAND_CI(String, String[])
     */
    public static final TextComparitor NOT_CN_CI = StrCmpr::containsNAND_CI;

    /**
     * This function pointer checks an attribute-<B STYLE="color: red;">value</B> or
     * {@code TextNode} to ensure that it <I>does not contain any matches</I> with the list of
     * compare-{@code String's}. The comparisons method used ignores the case of the text in the
     * string parameters.  Do note that all four of the following {@code static} fields
     * {@link #NOT_CN_CI}, {@link #DOES_NOT_CONTAIN_CASE_INSENSITIVE}, {@link #CN_CI_NAND},
     * and {@link #CONTAINS_CASE_INSENSITIVE_NAND} point to the same {@code StrCmpr} method.
     * Since the variable names trade-off readability and brevity, this is done for convenience.
     * 
     * @see StrCmpr#containsNAND_CI(String, String[])
     */
    public static final TextComparitor DOES_NOT_CONTAIN_CASE_INSENSITIVE = 
        StrCmpr::containsNAND_CI;


    // ***************************************************************************************************
    // START-WITH
    // ***************************************************************************************************

    /**
     * Checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the initial
     * characters (the 'start' of the source-{@code String}) will <I>match with precisely one</I>
     * of the java {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#startsWithXOR(String, String[])
     */
    public static final TextComparitor STARTS_WITH = StrCmpr::startsWithXOR;

    /**
     * Checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the initial
     * characters (the 'start' of the source-{@code String}) <I>will not match with any</I> of the
     * java {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#startsWithNAND(String, String[])
     */
    public static final TextComparitor DOES_NOT_START_WITH = StrCmpr::startsWithNAND;

    /**
     * Nearly identical to {@link #STARTS_WITH}, but here the function-pointer points to a method
     * that ignores case when performing the comparisons.  This {@code public static} field checks
     * an input 'source {@code String}' (usually an inner-tag <B STYLE="color: red;">value</B> or a
     * {@code TextNode}) to verify that the initial characters (the 'start' of the
     * source-{@code String}) will <I>match with precisely one</I> of the java {@code var-args
     * String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#startsWithXOR_CI(String, String[])
     */
    public static final TextComparitor STARTS_WITH_CASE_INSENSITIVE = StrCmpr::startsWithXOR_CI;

    /**
     * Nearly identical to {@link #DOES_NOT_START_WITH}, but here the function-pointer points to a
     * method that ignores case when performing the comparisons.  This {@code public static} field
     * checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the initial
     * characters (the 'start' of the source-{@code String}) <I>will not match with any</I> of the
     * java {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#startsWithNAND_CI(String, String[])
     */
    public static final TextComparitor DOES_NOT_START_WITH_CASE_INSENSITIVE = 
        StrCmpr::startsWithNAND_CI;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field
     * {@link #STARTS_WITH}.
     * 
     * <BR /><BR />Checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;"> value</B> or a {@code TextNode}) to verify that the initial
     * characters (the 'start' of the source-{@code String}) will <I>match with precisely one</I>
     * of the java {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#startsWithXOR(String, String[])
     */
    public static final TextComparitor SW = StrCmpr::startsWithXOR;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field 
     * {@link #DOES_NOT_START_WITH}.
     * 
     * <BR /><BR />In fact, the following are all identical method references:
     * 
     * <BR /><BR /><UL CLASS=JDUL>
     *      <LI>{@link #DOES_NOT_START_WITH}</LI>
     *      <LI>{@link #NOT_SW}</LI>
     *      <LI>{@link #SW_NAND}</LI>
     *      <LI>{@link StrCmpr#startsWithNAND(String, String[])}</LI>
     * </UL>
     * 
     * <BR />They are just abbreviated names to allow for trading-off 'code readability' and
     * brevity.
     * 
     * <BR /><BR />Checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the initial
     * characters (the 'start' of the source-{@code String}) <I>will not match with any</I> of the
     * java {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#startsWithNAND(String, String[])
     */
    public static final TextComparitor NOT_SW = StrCmpr::startsWithNAND;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field 
     * {@link #DOES_NOT_START_WITH}.  
     * 
     * <BR /><BR />In fact, the following are all identical method references:
     * 
     * <BR /><BR /><UL CLASS=JDUL>
     *      <LI>{@link #DOES_NOT_START_WITH}</LI>
     *      <LI>{@link #NOT_SW}</LI>
     *      <LI>{@link #SW_NAND}</LI>
     *      <LI>{@link StrCmpr#startsWithNAND(String, String[])}</LI>
     * </UL>
     * 
     * <BR />They are just abbreviated names to allow for trading-off 'code readability' and
     * brevity.
     * 
     * <BR /><BR />Checks an input 'source {@code String}' (usually an inner-tag 
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the initial
     * characters (the 'start' of the source-{@code String}) <I>will not match with any</I> of the
     * java {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#startsWithNAND(String, String[])
     */
    public static final TextComparitor SW_NAND = StrCmpr::startsWithNAND;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field 
     * {@link #STARTS_WITH_CASE_INSENSITIVE}.
     * 
     * <BR /><BR />Nearly identical to {@link #STARTS_WITH}, but here the function-pointer points
     * to a method that ignores case when performing the comparisons.  This {@code public static}
     * field checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the initial
     * characters (the 'start' of the source-{@code String}) will <I>match with precisely one</I>
     * of the java {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#startsWithXOR_CI(String, String[])
     */
    public static final TextComparitor SW_CI = StrCmpr::startsWithXOR_CI;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field 
     * {@link #DOES_NOT_START_WITH_CASE_INSENSITIVE}.  
     * 
     * <BR /><BR />In fact, the following are all identical method references:
     * 
     * <BR /><BR /><UL CLASS=JDUL>
     *      <LI>{@link #DOES_NOT_START_WITH_CASE_INSENSITIVE}</LI>
     *      <LI>{@link #NOT_SW_CI}</LI>
     *      <LI>{@link #SW_CI_NAND}</LI>
     *      <LI>{@link StrCmpr#startsWithNAND_CI(String, String[])}</LI>
     * </UL>
     * 
     * <BR /> They are just abbreviated names to allow for trading-off 'code readability' and
     * brevity.
     * 
     * <BR /><BR />Nearly identical to {@link #DOES_NOT_START_WITH}, but here the function-pointer
     * points to a method that ignores case when performing the comparisons.  This {@code public
     * static} field checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the initial
     * characters (the 'start' of the source-{@code String}) <I>will not match with any</I> of the
     * java {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#startsWithNAND_CI(String, String[])
     */
    public static final TextComparitor NOT_SW_CI = StrCmpr::startsWithNAND_CI;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field 
     * {@link #DOES_NOT_START_WITH_CASE_INSENSITIVE}.
     * 
     * <BR /><BR />In fact, the following are all identical method references:
     * 
     * <BR /><BR /><UL CLASS=JDUL>
     *      <LI>{@link #DOES_NOT_START_WITH_CASE_INSENSITIVE}</LI>
     *      <LI>{@link #NOT_SW_CI}</LI>
     *      <LI>{@link #SW_CI_NAND}</LI>
     *      <LI>{@link StrCmpr#startsWithNAND_CI(String, String[])}</LI>
     * </UL>
     * 
     * <BR /><BR /> They are just abbreviated names to allow for trading-off 'code readability' and
     * brevity.
     * 
     * <BR /><BR />Nearly identical to {@link #DOES_NOT_START_WITH}, but here the function-pointer
     * points to a method that ignores case when performing the comparisons.  This {@code public
     * static} field checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the initial
     * characters (the 'start' of the source-{@code String}) <I>will not match with any</I> of the
     * java {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#startsWithNAND_CI(String, String[])
     */
    public static final TextComparitor SW_CI_NAND = StrCmpr::startsWithNAND_CI;


    // ***************************************************************************************************
    // START-WITH
    // ***************************************************************************************************

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #STARTS_WITH}.
     * 
     * @see StrCmpr#startsWithXOR(String, String[])
     */
    public static final TextComparitor STARTS_WITH_TRIM = 
        (String s, String[] sArr) -> StrCmpr.startsWithXOR(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #DOES_NOT_START_WITH}.
     * 
     * @see StrCmpr#startsWithNAND(String, String[])
     */
    public static final TextComparitor DOES_NOT_START_WITH_TRIM =
        (String s, String[] sArr) -> StrCmpr.startsWithNAND(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #STARTS_WITH_CASE_INSENSITIVE}.
     * 
     * @see StrCmpr#startsWithXOR_CI(String, String[])
     */
    public static final TextComparitor STARTS_WITH_CASE_INSENSITIVE_TRIM =
        (String s, String[] sArr) -> StrCmpr.startsWithXOR_CI(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #DOES_NOT_START_WITH_CASE_INSENSITIVE}.
     * 
     * @see StrCmpr#startsWithNAND_CI(String, String[])
     */
    public static final TextComparitor DOES_NOT_START_WITH_CASE_INSENSITIVE_TRIM =
        (String s, String[] sArr) -> StrCmpr.startsWithNAND_CI(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #SW}.
     * 
     * @see StrCmpr#startsWithXOR(String, String[])
     */
    public static final TextComparitor SW_TRM =
        (String s, String[] sArr) -> StrCmpr.startsWithXOR(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #NOT_SW}.
     * 
     * @see StrCmpr#startsWithNAND(String, String[])
     */
    public static final TextComparitor NOT_SW_TRM = 
        (String s, String[] sArr) -> StrCmpr.startsWithNAND(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #SW_NAND}.
     * 
     * @see StrCmpr#startsWithNAND(String, String[])
     */
    public static final TextComparitor SW_NAND_TRM = 
        (String s, String[] sArr) -> StrCmpr.startsWithNAND(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #SW_CI}.
     * 
     * @see StrCmpr#startsWithXOR_CI(String, String[])
     */
    public static final TextComparitor SW_CI_TRM = 
        (String s, String[] sArr) -> StrCmpr.startsWithXOR_CI(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #NOT_SW_CI}.
     * 
     * @see StrCmpr#startsWithNAND_CI(String, String[])
     */
    public static final TextComparitor NOT_SW_CI_TRM = 
        (String s, String[] sArr) -> StrCmpr.startsWithNAND_CI(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #SW_CI_NAND}.
     * 
     * @see #SW_CI_NAND
     * @see StrCmpr#startsWithNAND_CI(String, String[])
     */
    public static final TextComparitor SW_CI_NAND_TRM = 
        (String s, String[] sArr) -> StrCmpr.startsWithNAND_CI(s.trim(), sArr);


    // ***************************************************************************************************
    // END-WITH
    // ***************************************************************************************************

    /**
     * Checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the ending characters
     * (the 'tail' of the source-{@code String}) will <I>match with precisely one</I> of the java
     * {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#endsWithXOR(String, String[])
     */
    public static final TextComparitor ENDS_WITH = StrCmpr::endsWithXOR;

    /**
     * Checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the ending characters
     * (the 'tail' of the source-{@code String}) <I>will not match with any</I> of the java
     * {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#endsWithNAND(String, String[])
     */
    public static final TextComparitor DOES_NOT_END_WITH = StrCmpr::endsWithNAND;

    /**
     * Nearly identical to {@link #ENDS_WITH}, but here the function-pointer points to a method
     * that ignores case when performing the comparisons.  This {@code public static} field checks
     * an input 'source {@code String}' (usually an inner-tag <B STYLE="color: red;">value</B> or a
     * {@code TextNode}) to verify that the ending characters (the 'tail' of the
     * source-{@code String}) will <I>match with precisely one</I> of the java {@code var-args
     * String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#endsWithXOR_CI(String, String[])
     */
    public static final TextComparitor ENDS_WITH_CASE_INSENSITIVE = StrCmpr::endsWithXOR_CI;

    /**
     * Nearly identical to {@link #DOES_NOT_END_WITH}, but here the function-pointer points to a
     * method that ignores case when performing the comparisons.  This {@code public static} field
     * checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the ending characters
     * (the 'tail' of the source-{@code String}) <I>will not match with any</I> of the java
     * {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#endsWithNAND_CI(String, String[])
     */
    public static final TextComparitor DOES_NOT_END_WITH_CASE_INSENSITIVE = 
        StrCmpr::endsWithNAND_CI;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field
     * {@link #ENDS_WITH}.
     * 
     * <BR /><BR />Checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the ending characters
     * (the 'tail' of the source-{@code String}) will <I>match with precisely one</I> of the java
     * {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#endsWithXOR(String, String[])
     */
    public static final TextComparitor EW = StrCmpr::endsWithXOR;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field 
     * {@link #DOES_NOT_END_WITH}.  
     * 
     * <BR /><BR />In fact, the following are all identical method references:
     * 
     * <BR /><BR /><UL CLASS=JDUL>
     *      <LI>{@link #DOES_NOT_END_WITH}</LI>
     *      <LI>{@link #NOT_EW}</LI>
     *      <LI>{@link #EW_NAND}</LI>
     *      <LI>{@link StrCmpr#endsWithNAND(String, String[])}</LI>
     * </UL>
     * 
     * <BR />They are just abbreviated names to allow for trading-off 'code readability' and
     * brevity.
     * 
     * <BR /><BR />Checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the ending characters
     * (the 'tail' of the source-{@code String}) <I>will not match with any</I> of the java
     * {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#endsWithNAND(String, String[])
     */
    public static final TextComparitor NOT_EW = StrCmpr::endsWithNAND;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field 
     * {@link #DOES_NOT_END_WITH}.
     * 
     * <BR /><BR />In fact, the following are all identical method references:
     * 
     * <BR /><BR /><UL CLASS=JDUL>
     *      <LI>{@link #DOES_NOT_END_WITH}</LI>
     *      <LI>{@link #NOT_EW}</LI>
     *      <LI>{@link #EW_NAND}</LI>
     *      <LI>{@link StrCmpr#endsWithNAND(String, String[])}</LI>
     * </UL>
     * 
     * <BR />They are just abbreviated names to allow for trading-off 'code readability' and
     * brevity.
     * 
     * <BR /><BR />Checks an input 'source {@code String}' (usually an inner-tag 
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the ending characters
     * (the 'tail' of the source-{@code String}) <I>will not match with any</I> of the java
     * {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#endsWithNAND(String, String[])
     */
    public static final TextComparitor EW_NAND = StrCmpr::endsWithNAND;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field 
     * {@link #ENDS_WITH_CASE_INSENSITIVE}.
     * 
     * <BR /><BR />Nearly identical to {@link #ENDS_WITH}, but here the function-pointer points to
     * a method that ignores case when performing the comparisons.  This {@code public static}
     * field checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the ending characters
     * (the 'tail' of the source-{@code String}) will <I>match with precisely one</I> of the java
     * {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#endsWithXOR_CI(String, String[])
     */
    public static final TextComparitor EW_CI = StrCmpr::endsWithXOR_CI;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field 
     * {@link #DOES_NOT_END_WITH_CASE_INSENSITIVE}.
     * 
     * <BR /><BR />In fact, the following are all identical method references:
     * 
     * <BR /><BR /><UL CLASS=JDUL>
     *      <LI>{@link #DOES_NOT_END_WITH_CASE_INSENSITIVE}</LI>
     *      <LI>{@link #NOT_EW_CI}</LI>
     *      <LI>{@link #EW_CI_NAND}</LI>
     *      <LI>{@link StrCmpr#endsWithNAND_CI(String, String[])}</LI>
     * </UL>
     * 
     * <BR />They are just abbreviated names to allow for trading-off 'code readability' and
     * brevity.
     * 
     * <BR /><BR />Nearly identical to {@link #DOES_NOT_END_WITH}, but here the function-pointer 
     * points to a method that ignores case when performing the comparisons.  This {@code public
     * static} field checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the ending characters
     * (the 'tail' of the source-{@code String}) <I>will not match with any</I> of the java 
     * {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#endsWithNAND_CI(String, String[])
     */
    public static final TextComparitor NOT_EW_CI = StrCmpr::endsWithNAND_CI;

    /**
     * A static, function-pointer, field with an abbreviated name identical to field 
     * {@link #DOES_NOT_END_WITH_CASE_INSENSITIVE}.
     * 
     * <BR /><BR />In fact, the following are all identical method references:
     * 
     * <BR /><BR /><UL CLASS=JDUL>
     *      <LI>{@link #DOES_NOT_END_WITH_CASE_INSENSITIVE}</LI>
     *      <LI>{@link #NOT_EW_CI}</LI>
     *      <LI>{@link #EW_CI_NAND}</LI>
     *      <LI>{@link StrCmpr#endsWithNAND_CI(String, String[])}</LI>
     * </UL>
     * 
     * <BR />They are just abbreviated names to allow for trading-off 'code readability' and
     * brevity.
     * 
     * <BR /><BR />Nearly identical to {@link #DOES_NOT_END_WITH}, but here the function-pointer
     * points to a method that ignores case when performing the comparisons.  This {@code public
     * static} field checks an input 'source {@code String}' (usually an inner-tag
     * <B STYLE="color: red;">value</B> or a {@code TextNode}) to verify that the ending characters
     * (the 'tail' of the source-{@code String}) <I>will not match with any</I> of the java
     * {@code var-args String...} compare-{@code String's} list.
     * 
     * @see StrCmpr#endsWithNAND_CI(String, String[])
     */
    public static final TextComparitor EW_CI_NAND = StrCmpr::endsWithNAND_CI;


    // ***************************************************************************************************
    // END-WITH
    // ***************************************************************************************************

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #ENDS_WITH}.
     * 
     * @see #ENDS_WITH
     * @see StrCmpr#endsWithXOR(String, String[])
     */
    public static final TextComparitor ENDS_WITH_TRIM = 
        (String s, String[] sArr) -> StrCmpr.endsWithXOR(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #DOES_NOT_END_WITH}.
     * 
     * @see #DOES_NOT_END_WITH
     * @see StrCmpr#endsWithNAND(String, String[])
     */
    public static final TextComparitor DOES_NOT_END_WITH_TRIM = 
        (String s, String[] sArr) -> StrCmpr.endsWithNAND(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #ENDS_WITH_CASE_INSENSITIVE}.
     * 
     * @see #ENDS_WITH_CASE_INSENSITIVE
     * @see StrCmpr#endsWithXOR_CI(String, String[])
     */
    public static final TextComparitor ENDS_WITH_CASE_INSENSITIVE_TRIM = 
        (String s, String[] sArr) -> StrCmpr.endsWithXOR_CI(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #DOES_NOT_END_WITH_CASE_INSENSITIVE}.
     * 
     * @see #DOES_NOT_END_WITH_CASE_INSENSITIVE
     * @see StrCmpr#endsWithNAND_CI(String, String[])
     */
    public static final TextComparitor DOES_NOT_END_WITH_CASE_INSENSITIVE_TRIM = 
        (String s, String[] sArr) -> StrCmpr.endsWithNAND_CI(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #EW}.
     * 
     * @see #EW
     * @see StrCmpr#endsWithXOR(String, String[])
     */
    public static final TextComparitor EW_TRM = 
        (String s, String[] sArr) -> StrCmpr.endsWithXOR(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #NOT_EW}.
     * 
     * @see #NOT_EW
     * @see StrCmpr#endsWithNAND(String, String[])
     */
    public static final TextComparitor NOT_EW_TRM = 
        (String s, String[] sArr) -> StrCmpr.endsWithNAND(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #EW_NAND}.
     * 
     * @see #EW_NAND
     * @see StrCmpr#endsWithNAND(String, String[])
     */
    public static final TextComparitor EW_NAND_TRM = 
        (String s, String[] sArr) -> StrCmpr.endsWithNAND(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #EW_CI}.
     * 
     * @see #EW_CI
     * @see StrCmpr#endsWithXOR_CI(String, String[])
     */
    public static final TextComparitor EW_CI_TRM = 
        (String s, String[] sArr) -> StrCmpr.endsWithXOR_CI(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #NOT_EW_CI}.
     * 
     * @see #NOT_EW_CI
     * @see StrCmpr#endsWithNAND_CI(String, String[])
     */
    public static final TextComparitor NOT_EW_CI_TRM = 
        (String s, String[] sArr) -> StrCmpr.endsWithNAND_CI(s.trim(), sArr);

    /**
     * Invokes {@code java.lang.String.trim()} on the first input-parameter; although the remainder
     * of this {@code BiPredicate<String, String[]} is identical to {@code public static} field
     * {@link #EW_CI_NAND}.
     * 
     * @see #EW_CI_NAND
     * @see StrCmpr#endsWithNAND_CI(String, String[])
     */
    public static final TextComparitor EW_CI_NAND_TRM =
        (String s, String[] sArr) -> StrCmpr.endsWithNAND_CI(s.trim(), sArr);



    /**
     * Helper / Convenience Method.  In almost all cases, this will return the actual field /
     * variable name of an instance of {@code TextComparitor}.  The lookup method uses Java
     * Reflection.  Internal exception &amp; error reporting logic makes use of this
     * method (where it works properly), but if this method is invoked on a user-supplied
     * {@code TextComparitor}, ths method will not be able to 'guess' the variable or field
     * name from whence that instance was derived or created.
     *
     * <BR /><BR /><B>USE:</B> For {@link TextComparitor#EQ_CASE_INSENSITIVE}, this method
     * returns the <B>Java {@code String}</B> {@code "EQ_CASE_INSENSITIVE"}.
     * 
     * <BR /><BR /><B>AGAIN:</B>There are <I>certain cases</I> where this method will fail.  The
     * test performed here uses a reference-equality comparison.  For instance, if the user
     * requests the name of a <I>"Serialized Version"</I> of a {@code TextComparitor}, then the
     * instance-reference loaded from a Serialized Object File, and the instance-reference stored
     * inside this class would be different.  If, indeed, there were two instances of
     * {@code 'TextComparitor.STARTS_WITH'} then the serialized version of
     * {@code 'TextComparitor.STARTS_WITH'} (when invoking this method) would not properly return
     * the {@code String 'STARTS_WITH'}
     *
     * <BR /><BR /><B>PRIMARILY:</B> This method is used by one of the exception reporting
     * mechanisms, and therefore neither relies nor requires serialized, saved, or user-created
     * {@code TextComparitor's}.  For those purposes, retreiving the {@code static} field-name
     * of the {@code TextComparitor's} that are passed here will work fine.
     *
     * <BR /><BR /><B><SPAN STYLE="color: red;">AGAIN:</B></SPAN> This method is used internally
     * for error-reporting.
     *
     * @param tc An instance of this class, {@code TextComparitor}, which is a also a
     * {@code static} field member of this class.
     * 
     * @return If the reference provided is one of the {@code static} fields which are defined
     * inside {@code TextComparitor}, then the name of that field, as a {@code java.lang.String},
     * will be returned.  If this is a user-defined {@code TextComparitor}, then it's name will
     * not be found, and 'null' shall be returned instead.
     *
     * <DIV CLASS="EXAMPLE">{@code
     * System.out.println(TextComparitor.getName(TextComparitor.EQ));
     * 
     * // Prints the String: "EQ"
     * }</DIV>
     */
    public static String getName(TextComparitor tc)
    {
        Field[] fArr = TextComparitor.class.getDeclaredFields();

        try
            { for (Field f : fArr) if (f.get(null) == tc) return f.getName(); }

        catch (IllegalAccessException e)
            { return null; }

        return null;
    }
}