TextHelper ( Frame4J -- the Java framework de.frame4j... )

java.lang.Object
- de.frame4j.text.TextHelper

```
@MinDoc(copyright="Copyright 2000 - 2013, 2021  A. Weinert",
        author="Albrecht Weinert",
        version="V.65",
        lastModified="3.06.2024",
        usage="import",
        purpose="common text utilities: check, parse and formating of texts")
public abstract class TextHelper
extends Object
```
Text handling — support for Java applications.

This class has static methods, and (internal) interfaces and classes for formatting, parsing and modifying texts, which include
- straight implementation of frequently needed formats,
- parsers accepting a wider range of (human used) input formats,
- processing of parameter arrays,
- decomposing of strings into parameters (token),
- some methods to compare and search extending those featured by String, as among others
  - the comparison of a file name with a wildcard pattern,
  - some search and compare methods optionally ignoring case and / or white space,
- powerful search and replace,
- partly using Rabin Karp algorithms, implemented by RK,
- find and replace by visitors (visitor pattern).
The mentioned white-space ignoring comparisons analyse both sequences as if all white space had been moved out. They often are a more simple (and faster) substitute for things like regular expressions (that, clearly, may be more adequate in certain circumstances). They have been heavily used over decades in Frame4J (respectively predecessor) based tools to recognise pattern in white space ignoring languages (HTML, XML, Java). Here it was adequate in all our and partners use cases:
<table cols="3" summary="Lit"> and
<table cols= "3" summary = "Lit" >
were (correctly) considered as equivalent, but (falsely) also
<ta b lecols="3"su mmary="L it"> .
The white-space ignoring methods can — as this example shows — safely be used. If one can assume some minimal correctness of the text under work the quite significant performance gain is worth the sacrifice of regular expressions' checking power.

© Copyright 2000 - 2009, 2021 Albrecht Weinert
See Also:

PropMap

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static interface`	`TextHelper.MessageComponents` Deliverer of messageFormat components.
`static interface`	`TextHelper.ReplaceVisitor` Visitor for text replacements.

Field Summary

Fields
Modifier and Type Field and Description

static Exception lastFormatingExc
The last exception when formatting.

Fields
Modifier and Type	Field and Description
`static Exception`	`lastFormatingExc` The last exception when formatting.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static Appendable`	`append(Appendable dest, byte[] bA)` Byte array as separated sequence of two digit hex numbers.
`static Appendable`	`append(Appendable dest, byte[] bA, int off, int len)` Part of byte array as separated sequence of two digit hex numbers.
`static boolean`	`areEqual(CharSequence s1, CharSequence s2, boolean ignCase)` Compare two character sequences, optionally ignoring case.
`static boolean`	`asBoolean(CharSequence value)` Interpret a character sequence as boolean.
`static boolean`	`asBoolean(CharSequence value, boolean def)` Interpret a character sequence as Boolean.
`static Boolean`	`asBoolObj(CharSequence value)` Interpret a character sequence as Boolean.
`static Boolean`	`asBoolObj(Object value)` Interpret an Object as Boolean.
`static int`	`asInt(CharSequence value, int def)` Interpret a character sequence as int with default value.
`static Integer`	`asIntObj(CharSequence value)` Interpret a character sequence as Integer.
`static String`	`checkLanguage(CharSequence language, CharSequence defValue)` Check and correct language code.
`static boolean`	`checkMac(StringBuilder leMac)` Check (quite rawly) the syntax and uniform a MAC address.
`static String`	`checkMail(CharSequence adr, CharSequence defaultServer, boolean forceServer)` Check / complete an e-Mail address.
`static String`	`checkRegion(CharSequence region, CharSequence defValue)` Check and correct region code.
`static int`	`compare(CharSequence s1, CharSequence s2, boolean ignCase)` A String compare optionally (optimised) ignoring case.
`static String`	`con3cat(CharSequence s1, CharSequence s2, CharSequence s3)` Concatenate three Strings.
`static int`	`countParams(String[] args)` Count of non empty Strings or arguments in a (parameter) array.
`static char`	`dig(int value)` A decimal digit as char.
`static Appendable`	`eightDigitHex(Appendable dest, int value)` Format as eight digit hexadecimal number.
`static boolean`	`endsWith(CharSequence st1, CharSequence st2, boolean ignoreCase)` Determine if a character sequence ends with another one.
`static int`	`equalsTil(CharSequence[] sequences, boolean ignoreCase)` Index of first mismatch optionally ignoring case.
`static int`	`equalsTil(CharSequence sequ, int sI, CharSequence seq2, boolean ignoreCase)` Index of first mismatch optionally ignoring case.
`static Appendable`	`format(Appendable dest, CharSequence name, CharSequence[] sA, int sLen)` Format a String array.
`static StringBuilder`	`formatDuration(StringBuilder dest, long dur)` Formatting a runtime or period (long ms) as text.
`static Appendable`	`formDec(Appendable dest, int value, int width)` Format decimal number right justified .
`static Appendable`	`fourDigitHex(Appendable dest, int value)` Format as four digit hexadecimal number.
`static int`	`fUr(CharSequence source, StringBuilder dest, CharSequence oldText, CharSequence newText, boolean ignoreCase)` Find and Replace a character sequence's parts (multiply).
`static int`	`fUr(CharSequence source, StringBuilder dest, CharSequence oldStart, CharSequence oldEnd, CharSequence newText, boolean ignoreCase)` Find and Replace character sequence's parts (multiply).
`static int`	`fUr(CharSequence source, StringBuilder dest, CleverSSS oldStart, CleverSSS oldEnd, String newText, boolean ckWd)` Find and Replace character sequence's parts (multiple, String).
`static int`	`fUr(CharSequence quell, StringBuilder dest, CleverSSS oldStart, CleverSSS oldEnd, TextHelper.ReplaceVisitor repl)` Find and Replace character sequence's parts (multiple as visitor).
`static int`	`fUr(CharSequence quell, StringBuilder ziel, String oldStart, String oldEnd, boolean ignoreCase, TextHelper.ReplaceVisitor repl)` Find and Replace character sequence's parts (multiple as visitor).
`static Pattern`	`getCommaSemicolonWSpattern()` Pattern for separation at comma, semicolon or white space.
`static String`	`getPropertyText(CharSequence text, CharSequence default1, String default2)` Select (property-) text from different choices.
`static String`	`getPropertyText(CharSequence text, String def)` Select (property-) text from different choices — simple trim.
`static int`	`indexOf(CharSequence sequ, CharSequence sub, int sI, boolean ignoreCase)` An "indexOf" ignoring case.
`static int`	`indexOf(String text, String[] list)` Search a character sequence in a list / array.
`static int`	`indexOfOpt(CharSequence sequ, CharSequence sub, int sI, boolean ignoreCase)` An optimistic "indexOf" optionally ignoring case.
`static int`	`isFrntMttr(CharSequence txt)` Check if a text starts with a Jekyll front matter.
`static int`	`lastIndexOf(CharSequence sequ, CharSequence sub)` A lastIndexOf ignoring case.
`static int`	`lastIndexOf(CharSequence sequ, CharSequence sub, int sI)` A lastIndexOf ignoring case.
`static int`	`lastIndexOf(CharSequence sequ, CharSequence sub, int sI, boolean ignoreCase)` A lastIndexOf optionally ignoring case.
`static int`	`lastIndexOfWS(CharSequence sequ, int sI)` A white space searching lastIndexOf.
`static String`	`makeFName(CharSequence name, String ext)` Construct a file name.
`static String`	`makeFNameUJ(CharSequence name)` Construct a file name for URLs or .jar entries.
`static String`	`makeFNL(String path)` Working up names of files or of file name lists.
`static TextHelper.MessageComponents`	`makeMessageComponents(Object[] oa)` Make MessageComponents from an array.
`static StringBuilder`	`messageFormat(StringBuilder dest, CharSequence pattern, Object args)` A simple message formatter.
`static String[]`	`prepParams(CharSequence argLine, int endArg)` Make a parameter array from a character sequence (command line).
`static String[]`	`prepParams(CharSequence argLine, String commSt, boolean unQuote)` Make a parameter array from a character sequence (command line).
`static String`	`prepParams(String[] args)` Make an argument line from a parameter array.
`static String[]`	`prepParams(String[] args, String commSt, boolean unQuote)` Working up of parameter arrays.
`static boolean`	`shouldQuote(CharSequence akt)` Make a recommendation about quoting argument.
`static boolean`	`simpCharEqu(char c1, char c2, boolean ignCase)` Character equals optionally ignoring case.
`static Appendable`	`sixDigitHex(Appendable dest, int value)` Format as six digit hexadecimal number.
`static String[]`	`splitCsWS(CharSequence input)` Separating at comma, semicolon or white space.
`static String[]`	`splitWords(String origContent)` Split a String to single words.
`static boolean`	`startsWith(CharSequence st1, CharSequence st2, boolean ignoreCase)` Determine if a character sequence begins with another one.
`static String`	`threeDigit(int value)` Format as three digit number with leading zeros.
`static String`	`trimUq(CharSequence val, String def)` Trim and "un-quote" a character sequence.
`static String`	`twoDigit(int value)` Format as two digit number with leading zero.
`static Appendable`	`twoDigitDec(Appendable dest, int value)` Format as two digit decimal number with leading zero.
`static Appendable`	`twoDigitHex(Appendable dest, int value)` Format as two digit hexadecimal number.
`static String`	`twoDigitHex(int value)` Format as two digit hexadecimal number.
`static String`	`unComment(String s, char stC, char endC, boolean nested, CharSequence repl)` Remove bracketed comments, optionally nested.
`static boolean`	`wildEqual(CharSequence wildName, CharSequence name, boolean ignoreCase)` Compare a name and a pattern with wildcards.
`static void`	`write(PrintWriter out, CharSequence name, CharSequence[] sA)` Output a String array.
`static char`	`zif(int value)` A hexadecimal digit as char.

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

- Field Detail
  - lastFormatingExc
```
public static Exception lastFormatingExc
```
    The last exception when formatting.
    
    If the destination Appendable object is not a supplied or generated StringBuilder but e.g. a PrintWriter IOExceptions may occur. They are caught silently in the formatting method but recorded here.
    Applications formatting to stream or writers might rest this value to null and check it afterwards.
- Method Detail
  - con3cat
```
public static String con3cat(CharSequence s1,
                             CharSequence s2,
                             CharSequence s3)
```
    Concatenate three Strings.
    
    The three String parameters will be concatenated and returned s1 + s2 + s3 as far as not null or empty in each case.
    
    If all three are empty an empty String (ComVar.EMPTY_STRING) is returned.
    
    Hint: The effect (and internal work) of this is method is not the same as just doing (s1 + s2 +..).
    
    Returns:
    
    the concatenated content of the parameters; may be empty but never null
  - getPropertyText
```
public static String getPropertyText(CharSequence text,
                                     CharSequence default1,
                                     String default2)
```
    Select (property-) text from different choices.
    
    text is freed / stripped of all surrounding white spaces. If (then) not empty, it is returned.
    
    Otherwise the same proceeding is done with default1. Does that also give no non empty value, default2 is returned as is.
  - getPropertyText
```
public static String getPropertyText(CharSequence text,
                                     String def)
```
    Select (property-) text from different choices — simple trim.
    
    text is freed / stripped of all surrounding white spaces. If (then) not empty, it is returned. Otherwise default2 is returned as is.
    
    The difference to trimUq(text, default2) is this method having no "un-quote"; see there. The differences to String.trim() are the acceptance of any CharSequence and the default value. String.trim() behaviour is got by supplying ComVar.EMPTY_STRING as def.
    
    See Also:
    
    getPropertyText(CharSequence, CharSequence, String), trimUq(CharSequence, String)
  - makeFName
```
public static String makeFName(CharSequence name,
                               String ext)
```
    Construct a file name.
    
    This method returns a non empty filename according to the parameters name and ext or it returns null.
    
    name will be stripped from surrounding white space. If then empty null will be returned.
    
    Forward / respectively back \ slashes will be replaced by the underlying system's file separator (ComVar.FS). If ext is not null or empty (after stripping white spaces) it will be prefixed by a dot (.) if does not yet start so.
    The (dot prefixed) ext will be appended to the name if that is not yet ending so (disregarding case).
    
    Parameters:
    
    name - file name demanded
    
    ext - default extension (appended if not yet name's end)
    
    Returns:
    
    the worked up file name
  - makeFNameUJ
```
public static String makeFNameUJ(CharSequence name)
```
    Construct a file name for URLs or .jar entries.
    
    This method returns a non empty filename according to the parameter name or null.
    
    name will be stripped from surrounding white space. If then empty null will be returned.
    
    Backslashes \ will be replaced by forward slashes /. This changes a Windows file name to one suitable for URLs or for within .jar files respectively to the JAR-entry syntax.
    
    Parameters:
    
    name - file or entry name
  - makeFNL
```
public static String makeFNL(String path)
```
    Working up names of files or of file name lists.
    
    This method returns a non empty file denotation according to the parameter path or null. path will be stripped from surrounding white space. If then empty null will be returned.
    
    forward / respectively back \ slashes will be replaced by the underlying system's file separator (ComVar.FS).
    
    To uniquely handle lists a semicolon will be used as list separator. Under Windows it is expected to be so. If the path separator is a colon (: meaning Linux or Unix) it will be replaced by semicolon (;).
  - isFrntMttr
```
public static int isFrntMttr(CharSequence txt)
```
    Check if a text starts with a Jekyll front matter.
    
    A jekyll page (markdown, .md) or layout file may start with a front matter enclosed in two lines of just three minuses, i.e. "---".
    Find the syntax here and:
    Note a: The first --- line is the very beginning of the file / txt.
    Note b: Both enclosing --- lines must not contain anything else.
    
    If the text txt starts with such front matter this function returns the index of the first character after the terminating second line "---\r\n" or "---\n".
    If the no starting and ending lines were found -1 is returned.
    
    Parameters:
    
    txt - the text to be checked
    
    Returns:
    
    the index of the first character after the second line '---' or -1 if
  - simpCharEqu
```
public static boolean simpCharEqu(char c1,
                                  char c2,
                                  boolean ignCase)
```
    Character equals optionally ignoring case.
    
    This method returns true
    - if the characters c1 and c2 supplied are equal or
    - if they are equal when both converted to lower case.
    Otherwise false is returned.
    Returns:
    
    true if c1 and c2 are really equal or equal ignoring case if ignCase is true
  - endsWith
```
public static boolean endsWith(CharSequence st1,
                               CharSequence st2,
                               boolean ignoreCase)
```
    Determine if a character sequence ends with another one.
    
    This method returns true if the character sequence st1 ends with the sequence st2, disregarding case if ignoreCase is true.
    This method returns false, if st1 is null or empty.
    It returns true, if st2 is null or empty.
    
    Parameters:
    
    st1 - the sequence which's end is tested to be st2
    
    st2 - the sequence to be matched to the end of st1
    
    ignoreCase - if true the comparison is not case sensitive
    
    Returns:
    
    true if st1 ends with st2 (optionally disregarding case)
    
    See Also:
    
    simpCharEqu(char, char, boolean)
  - startsWith
```
public static boolean startsWith(CharSequence st1,
                                 CharSequence st2,
                                 boolean ignoreCase)
```
    Determine if a character sequence begins with another one.
    
    This method returns true if the character sequence st1 begins with the sequence st2, disregarding case if ignoreCase is true.
    This method returns false, if st1 is null or empty.
    It returns true, if st2 is null or empty.
    
    See Also:
    
    endsWith(CharSequence, CharSequence, boolean), simpCharEqu(char, char, boolean)
  - asBoolean
```
public static boolean asBoolean(CharSequence value)
```
    Interpret a character sequence as boolean.
    
    This method returns true, if the sequence value is "true", "wahr", "ja", "yes", "an" or "on" disregarding case.
    All other cases including null and empty return false.
  - asBoolObj
```
public static Boolean asBoolObj(Object value)
```
    Interpret an Object as Boolean.
    
    This method returns a value of type Boolean as is and delegates CharSequences to the method asBoolObj(CharSequence).
    
    All other types return null.
    
    Hint: Later versions of this method may (in future) interpret the 0 as false and the value 1 as true for some numerical types.
    
    See Also:
    
    asBoolObj(CharSequence)
  - asBoolObj
```
public static Boolean asBoolObj(CharSequence value)
```
    Interpret a character sequence as Boolean.
    
    This method returns Boolean.TRUE, if the sequence value is "true", "wahr", "ja", "yes", "an" or "on" disregarding case.
    It returns Boolean.FALSE, if the sequence value is "fals?", "fals??", (including thus "false" and "falsch"), "ne??", "nein", "no", "aus" or "off" (? means any character) , also disregarding case.
    
    Otherwise null is returned.
  - asBoolean
```
public static boolean asBoolean(CharSequence value,
                                boolean def)
```
    Interpret a character sequence as Boolean.
    
    This method returns true, if the sequence value is "true", "wahr", "ja", "yes", "an" or "on" disregarding case.
    This method returns false, if the sequence value is "fals?", "fals??", "false", "falsch", "ne??", "nein", "no", "aus" or "off" (? means any character).
    
    Otherwise def is returned.
    
    Hint: Of all (three) asBoolean respectively asBoolObj methods this is the most efficient (fastest) as the parsing is steered (shortened) by the default value supplied.
  - asIntObj
```
public static Integer asIntObj(CharSequence value)
```
    Interpret a character sequence as Integer.
    
    value will be stripped from surrounding white space and perhaps enclosing quotes. If value is (then) empty (Integer)null will be returned.
    
    Otherwise it is tried to interpret the (remaining) sequence as whole number given in decimal, hexadecimal (0x) or octal (leading 0) notation. In case of success an Integer object wrapping the number is returned and null in case of the no interpretation succeeded.
    
    Hint: This method is a comfortable and " exception free wrapper" for Integer.decode(java.lang.String).
    
    Parameters:
    
    value - the sequence to be interpreted as whole number
    
    Returns:
    
    Integer object on success, null otherwise
    
    See Also:
    
    trimUq(CharSequence, String)
  - asInt
```
public static int asInt(CharSequence value,
                        int def)
```
    Interpret a character sequence as int with default value.
    
    value will be stripped from surrounding white space and perhaps enclosing quotes. If value is (then) empty def will be returned.
    
    Parameters:
    
    value - the sequence to be interpreted as whole number
    
    def - the substitute value
    
    Returns:
    
    the number fitting value or def
    
    See Also:
    
    trimUq(CharSequence, String), asIntObj(CharSequence)
  - compare
```
public static int compare(CharSequence s1,
                          CharSequence s2,
                          boolean ignCase)
```
    A String compare optionally (optimised) ignoring case. This is a lexical String compare. s1 is considered greater if the first occurrence of a unequal character is greater or if it is longer.
    
    Parameters:
    
    s1 - the first String to be compared
    
    s2 - the second String to be compared
    
    ignCase - true: compare ignore case
    
    Returns:
    
    0: s1 and s2 are equal or the same; +: s1 is greater; -: s2 is greater
    
    See Also:
    
    areEqual(CharSequence, CharSequence, boolean)
  - trimUq
```
public static String trimUq(CharSequence val,
                            String def)
```
    Trim and "un-quote" a character sequence.
    
    Is the character sequence val null or empty the substitute def is returned. Usual choices for the default value def are null or the empty String (ComVar.EMPTY_STRING).
    
    Otherwise the character sequence val will be stripped from leading and trailing white spaces (spaces, tabulators, feeds). If then empty, the substitute def is returned.
    
    Otherwise the (may be shortened) sequence val is returned as String, if it not begins and ends with double quotes (").
    
    In the latter case those surrounding quotes found are removed and the sequence is returned as it then is (meaning even if now empty or perhaps surrounded by white spaces).
    
    Parameters:
    
    val - the character sequence to consider
    
    def - substitute value for null or empty or white space only
    
    Returns:
    
    val without surrounding whitespace and quotes or def
    
    See Also:
    
    getPropertyText(CharSequence, String), getPropertyText(CharSequence, CharSequence, String)
  - areEqual
```
public static boolean areEqual(CharSequence s1,
                               CharSequence s2,
                               boolean ignCase)
```
    Compare two character sequences, optionally ignoring case.
    
    This method compares the two given character sequences.
    If both are null true is returned.
    If both are empty true is returned.
    Otherwise true is returned if and only if every character in s1 equals the corresponding character in s2, optionally ignoring case.
    
    See Also:
    
    compare(CharSequence, CharSequence, boolean)
  - wildEqual
```
public static boolean wildEqual(CharSequence wildName,
                                CharSequence name,
                                boolean ignoreCase)
```
    Compare a name and a pattern with wildcards.
    
    This method compares the (second parameter) name to a pattern wildName, that may contain the wildcard characters ? and * (question mark and asterisk / starlet).
    
    name and wildName are considered as as equal if the characters coincide, applying the extra rules for characters in wildName:
    - ? coincides with any character of name.
    - * coincides with any character sequence of name of any length including 0.
      If a * wildName is followed by another character the "sequence of any length" in name (the coincidence) ends at the first occurrence of that character. From then on the comparing goes on as described.
    This method provides among others the file name comparison according to most file / operating systems wildcard rules including DOS and Windows, but goes a bit further.
    
    Examples:
    A name 1234.567.890 would fit the pattern wildName
    1234.567.890 , 12??.567.890 , 123*.890 , 12*.*0 and 123*4.567.890
    but not the pattern
    1234.567.89 , 1234.567.890a , 12?.567.890 , 123*.567.890 and 123?*4.567.890
    
    Hints:
    Command line parameters containing wildcards will be expanded to a number of parameters fitting all existing files' names (if any) by most Unix / Linux shells. To mimic this behaviour, under all seen Windows JVMs (java.exe, javaw.exe) emulate this dangerous behaviour. To avoid this one has to put those parameters in quotes. Some of Frame4J's methods and tools consider the plus sign (+) as equivalent to the wildcard asterisk, featuring another "expansion avoidance".
    This method does not so; here the + is no *.
    Parameters:
    
    wildName - the pattern to match; included wildcards (* ?) are interpreted as described. In case of null or empty true is returned.
    
    name - the name to match / compare. If name is null or empty (and wildName not so) false is returned.
    
    ignoreCase - if true the comparison is not case sensitive
    
    Returns:
    
    true is matching according to rules described
  - fUr
```
public static int fUr(CharSequence source,
                      StringBuilder dest,
                      CharSequence oldText,
                      CharSequence newText,
                      boolean ignoreCase)
```
    Find and Replace a character sequence's parts (multiply).
    
    The character sequence source will be appended to the StringBuilder dest. Hereby any sequence oldText (out of source} will be be replaced by newText (while transferring into dest). If ignoreCase is true, the sequences oldText are searched for disregarding case.
    
    Returned is the total number of oldText by newText replacements. In case of 0 (due to no occurrence of oldText in source) the StringBuilder dest is not touched.
    
    Hint: If the last part — not touching dest if no replacements — is unwanted on has to do dest.append(source) on return of 0.
    
    The call is equivalent to:
    fUr(source, dest, oldText, null, newText, ignoreCase)
  - fUr
```
public static int fUr(CharSequence source,
                      StringBuilder dest,
                      CharSequence oldStart,
                      CharSequence oldEnd,
                      CharSequence newText,
                      boolean ignoreCase)
```
    Find and Replace character sequence's parts (multiply).
    
    This method is equivalent to the simpler fUr() except for the following extra: There is not just one pattern for the source's sequence to be replaced but a bracket of to pattern oldStart and oldEnd that might enclose arbitrary other text to be replaced by newText. ignoreCase would apply to both oldStart and oldEnd. If oldEnd is null only oldStart is searched for in source.
    
    Returns:
    
    number of replacements
    
    See Also:
    
    fUr(CharSequence, StringBuilder, CleverSSS, CleverSSS, ReplaceVisitor)
  - fUr
```
public static int fUr(CharSequence quell,
                      StringBuilder ziel,
                      String oldStart,
                      String oldEnd,
                      boolean ignoreCase,
                      TextHelper.ReplaceVisitor repl)
```
    Find and Replace character sequence's parts (multiple as visitor).
    
    The character sequence source will be appended to the StringBuilder dest. Hereby any sequence in source consisting of
    oldStart, any sequence and oldEnd
    is searched for. If ignoreCase is true the character comparison is made disregarding case.
    
    For each found block (oldStart, text, oldEnd) the method repl.visit() is called with those three sequences as parameters. In the case of ignoreCase true the found brackets are supplied and not oldStart and oldEnd which might differ in case. The value returned by the TextHelper.ReplaceVisitor's method visit() will be put to dest instead of that "block of three". If null is returned by the visitor that spot will be transfered unchanged and this will not be counted as replacement.
    
    Returned is the total number of replacements. In case of no (0) replacements the text source was transferred unmodified to the StringBuilder dest.
    
    oldEnd is null only oldStart is searched for in source and the TextHelper.ReplaceVisitor's method visit() will be called so visit(null, oldStart, null). To be exact: in the case of ignoreCase true the original text fitting oldStart is supplied as parameter.
    
    This method implements the visitor pattern for arbitrary text replacements by separating the single "calculation of the replacement text" (just a function on text for up to three) from doing all the searching, matching and the replacing.
    
    Returns:
    
    number of replacements
    
    See Also:
    
    ReplaceVisitor.visit()
  - fUr
```
public static int fUr(CharSequence quell,
                      StringBuilder dest,
                      CleverSSS oldStart,
                      CleverSSS oldEnd,
                      TextHelper.ReplaceVisitor repl)
```
    Find and Replace character sequence's parts (multiple as visitor).
    
    The character sequence source will be appended to the StringBuilder dest. Hereby any sequence in source consisting of
    oldStart, any sequence and oldEnd
    is searched (by CleverSSS.where(quell, index)).
    
    For each found block (oldStart, text, oldEnd) the method repl.visit() is called with those three sequences as parameters. As oldStart and oldEnd the brackets found in quell are supplied to the visitor. (They might differ in case and length to the CleverSSS's internal search sequence.) The value returned by the TextHelper.ReplaceVisitor's method visit() will be put to dest instead of that "block of three". If null is returned by the visitor that spot will be transfered unchanged and this will not be counted as replacement.
    
    Returned is the total number of replacements. In case of no (0) replacements the text source was transferred unmodified to the StringBuilder dest.
    
    If oldEnd is null only oldStart is searched for in source and the TextHelper.ReplaceVisitor's method visit() will be called so visit(null, oldStart, null).
    If oldEnd is not null, a (last) finding of oldStar without closing oldEnd will not be regarded add treated as hit.
    
    This method implements the visitor pattern for arbitrary text replacements by separating the single "calculation of the replacement text" (just a function on text for up to three) from doing all the searching, matching and the replacing. By using CleverSSS objects as matchers any flexibility in optionally ignoring case or white space as well as CleverSSS's inheritor's (like RK or KMP) speed is featured here.
    
    Returns:
    
    number of replacements
    
    See Also:
    
    ReplaceVisitor.visit()
  - fUr
```
public static int fUr(CharSequence source,
                      StringBuilder dest,
                      CleverSSS oldStart,
                      CleverSSS oldEnd,
                      String newText,
                      boolean ckWd)
```
    Find and Replace character sequence's parts (multiple, String).
    
    The character sequence source will be appended to the StringBuilder dest. Hereby any sequence in source consisting of
    oldStart, any sequence and oldEnd
    is searched (by CleverSSS.where(source, index)).
    
    Each found block (oldStart anyText oldEnd) will be completely replaced by the String newText. If newText is null or empty the block found is effectively removed.
    
    Returned is the total number of replacements. In case of no (0) replacements the StringBuilder dest has not been touched.
    Hint: That behaviour differs from fUr(CharSequence, StringBuilder, CleverSSS, CleverSSS, ReplaceVisitor) !
    
    If oldEnd is null or empty only oldStart is searched for in source and just the text block found by oldStart will be replaced.
    If oldEnd is not null, a (last) finding of oldStart without closing oldEnd will not be regarded and treated as hit.
    
    This method implements the visitor pattern for arbitrary text replacements by separating the single "calculation of the replacement text" from doing all the searching, matching and the replacing. By using CleverSSS objects as matchers any flexibility like optionally ignoring case or white space as well as CleverSSS' inheritor's (like RK or KMP) speed is available here.
    
    A special feature meant for hyphenation (see below) is ckWd or "check for (pure text) word". When true the surrounding characters of a text (block) to be replaced are looked at:
    1. If the character before the block is [ or * the block is accepted (as never part of a href=" or src=" or in markdown always a text) for replacement.
    2. If the character before the block is not <= 32 (poor man's isWhiteSpace) the block's replacement is rejected.
    3. If the character after the block is one of ] ! ; , ? * or (poor man's) white space the block is accepted (as no one should use those as part of a path).
    4. If the second character after the block is one of ] ! ; , ? * or (poor man's) white space the block is accepted. Otherwise it is rejected. Considering the second character, also, allows for a a dot as well as an additional character for plural (German) genitive, dative or else.
  Rationale / use case: This feature is to avoid the FuR's hyphenation of words in links. Example (German):
  "Feuerwehr. " may be hyphenated as Feuerwehr. but "./Feuerwehr.pdf" would never.
  Remark: Above simple (for speed) "grammar" to avoid spoiling links in HTML and markdown by hyphenation is not perfect in either way.
  Some surroundings or words not in links will inhibit legal hyphenation. If insisting hyphenation would have to added by hand.
  And one could construct unusually exotic links that would be spoiled by hyphenation by, e.g. having path names containing punctuation characters or brackets. No problem when not doing such abstruse things.

Parameters:: source - the text to be appended to dest with replacements; dest - where to append source (with replacements to; oldStart - text (or its start) to be replaced; oldEnd - optional (closing) end of text to be replaced; newText - the replacement text; ckWd - check if text to be replaced is (probably) a pure text word)
Returns:: number of replacements; replacements rejected will not count except for the very first one.
See Also:: FuR

indexOf
```
public static int indexOf(CharSequence sequ,
                          CharSequence sub,
                          int sI,
                          boolean ignoreCase)
```
An "indexOf" ignoring case.

This method is similar to String.indexOf(String, int) except for optionally ignoring case. Additionally by accepting any CharSequences instead of Strings only this method is more versatile.

This method never throws any exception; if parameters don't allow the search -1 (not found) is returned.

Hint: If the subsequence sub is searched for more than once using the same settings on ignoring case or white space it is better to make a CleverSSS object for it and use that's search methods.

Parameters:

sequ - the String to be searched within

sub - the Substring to be found in sequ

sI - the index in sequ to start the search for sub (<0 is regarded as 0)

ignoreCase - true means ignore case in the matching process

Returns:

find / start index (>= sI) in sequ or -1

indexOfOpt
```
public static int indexOfOpt(CharSequence sequ,
                             CharSequence sub,
                             int sI,
                             boolean ignoreCase)
```
An optimistic "indexOf" optionally ignoring case.

This method is functionally equivalent to indexOf(CharSequence, CharSequence, int, boolean).

The difference is that this method optimistically assumes that any starting pattern of sub (also ignoring case if so opted) is not repeated within sub.
This is not (!) checked by this method. If the assumption is wrong, this method may return false results.

Warning: Do not use this method if an unreliable "optimistic assumption" might lead to intolerable false results. In that cases better use indexOf() or one of CleverSSS (see hint below) inheritors instead.

The most simple case fulfilling the condition is sub's first character being unique in sub (optionally ignoring case).

Examples: As parameter sub "PD323S", "aBB" or "$Date: " are OK, but "PD3PD323S" or "aaBB" are not. The reason is that this method would not hit "...aaaBB..." by "aaBB" e.g.

The rationale behind relying on the assumption (to be made by the caller / programmer) is the guaranteed reduction from O(n*m) to O(n) for the search complexity / run time with no extra efforts.

Hint: The class CleverSSS's and its inheritors methods where(), indexOf(), lastWhere.. etc. switch to a similar optimistic search automatically.

No exceptions are thrown; non adequate parameters return -1 .

Parameters:

sequ - the String to be searched within.

sub - the Substring to be found in sequ.

sI - the index in sequ to start the search for sub (<0 is regarded as 0)

ignoreCase - true means ignore case in the matching process

Returns:

find / start index (>= sI) in sequ or -1

lastIndexOf
```
public static int lastIndexOf(CharSequence sequ,
                              CharSequence sub)
```
A lastIndexOf ignoring case.

This method is similar to String.lastIndexOf(String) but with case insensitive match and more freedom for the types CharSequence instead of String only.

The call is equivalent to lastIndexOf(sequ, sub, -1, true).

No exceptions: inadequate parameters return -1.

Parameters:

sequ - the sequence, which is searched in.

sub - the (sub) sequence searched for.

Returns:

next found (index) or -1

See Also:

indexOf()

lastIndexOf
```
public static int lastIndexOf(CharSequence sequ,
                              CharSequence sub,
                              int sI)
```
A lastIndexOf ignoring case.

This method is equivalent to String.lastIndexOf(String,int) but with case insensitive match.

No exceptions: inadequate parameters return -1.

Parameters:

sequ - the sequence, which sub is searched in.

sub - the (sub) sequence searched for.

sI - the character in sequ, the search is started (default from the end).

Returns:

next found (index) or -1

See Also:

indexOf()

lastIndexOf
```
public static int lastIndexOf(CharSequence sequ,
                              CharSequence sub,
                              int sI,
                              boolean ignoreCase)
```
A lastIndexOf optionally ignoring case.

This method is equivalent to String.lastIndexOf(String,int) with the additional ability to (optionally) ignore case.

No exceptions: inadequate parameters return -1.

Parameters:

sequ - the sequence, which white space is searched in

sub - the (sub) sequence searched for.

sI - the character in sequ, the search is started (default from the end).

ignoreCase - true: ignore case for fitting

Returns:

next found (index) or -1

See Also:

indexOf()

lastIndexOfWS
```
public static int lastIndexOfWS(CharSequence sequ,
                                int sI)
```
A white space searching lastIndexOf.

This method returns the last index <= sI of white space's occurrence in sequ.

The definition of white space here / in this class simply <= space (in accordance with String.trim() — which means breaking white space.

No exceptions: inadequate parameters return -1.

Parameters:

sequ - the sequence, which white space is searched in.

Returns:

next occurrence <= sI -1

See Also:

indexOf()

equalsTil
```
public static int equalsTil(CharSequence sequ,
                            int sI,
                            CharSequence seq2,
                            boolean ignoreCase)
```
Index of first mismatch optionally ignoring case.

This method compares (a little bit like String.equals(Object) respectively .equalsIgnoreCase(String)) two character sequences character by character.

Returned will be the index of the first non matching character. A mismatch hence will give a value in the range 0 to smaller length (or common equal length -1).
A full match will return -3.
If both (partial) sequences are empty or null -2 is returned.
One sequence empty or null returns -1.

Parameters:

sequ - The first character sequence (pattern from sI).

sI - The spot in sequ, where the matching will start (<0 is taken as 0)

seq2 - The second character sequence; matching object, starting index here is always 0.

ignoreCase - if true matching is not case sensitive

Returns:

The index (in seq2 or relative to sI) of the first mismatch; -3 : full match (including length of seq2 and length of sequ -sI); -2 : both null or empty; -1 : one null or empty.

equalsTil
```
public static int equalsTil(CharSequence[] sequences,
                            boolean ignoreCase)
```
Index of first mismatch optionally ignoring case.

This method applies the comparison of the method equalsTil(CharSequence, int, CharSequence, boolean) (with sI = 0 and ignoreCase forwarded) to any pair of sequences. The maximum of all returned values is returned.

This return value + 1 (this maximum + 1) is the minimal length of an unambiguous abbreviation for all elements in sequences. Applied to English or German days of week the return value will be 1. This means, that two characters ("Mo") will unambiguously abbreviate days of week in these languages. For Portuguese days of week 2 would be returned, as you need three letter abbreviations to distinguish Seg./Sex.

Parameters:

sequences - The sequences to be pairwise matched

ignoreCase - if true matching is not case sensitive

Returns:

the maximum Index of all mismatches; -4, if sequences itself is null or shorter than 2

zif
```
public static char zif(int value)
```
A hexadecimal digit as char.

Parameters:

value - the value for the least significant hexadecimal digit

Returns:

the hexadecimal digit 0..9A..F for value % 16 respectively value & 0x0F

dig
```
public static char dig(int value)
```
A decimal digit as char.

Parameters:

value - the value in the range 0..100 for the least significant decimal digit

Returns:

the least significant decimal digit 0..9 for value; outside the range 0..127 the result is rubbish

twoDigitHex
```
public static String twoDigitHex(int value)
```
Format as two digit hexadecimal number.

The two digit hexadecimal representation of value's lower 8 bits is returned as String.

If the target is a StringBuilder, PrintWriter etc. take twoDigitHex(Appendable, int) instead of this method.

Parameters:

value - the number

Returns:

the two digit hex of the LSB "00".."FF"

twoDigitHex
```
public static Appendable twoDigitHex(Appendable dest,
                                     int value)
```
Format as two digit hexadecimal number.

Appended to dest (generated StringBuilder if supplied as null) is the two digit hexadecimal representation of value's lower 8 bits.

Parameters:

dest - destination to append to; if null dest is made as StringBuilder with initial capacity of 10

value - the number

Returns:

dest (appended is "00".."FF")

See Also:

twoDigitDec(Appendable, int), fourDigitHex(Appendable, int), sixDigitHex(Appendable, int), eightDigitHex(Appendable, int)

fourDigitHex
```
public static Appendable fourDigitHex(Appendable dest,
                                      int value)
```
Format as four digit hexadecimal number.

Appended to dest (generated StringBuilder if supplied as null) is the four digit hexadecimal representation of value's lower 16 bits.

Parameters:

dest - destination to append to; if null dest is made as StringBuilder with initial capacity of 10

Returns:

dest (appended is "0000".."FFFF"

See Also:

twoDigitHex(Appendable, int), sixDigitHex(Appendable, int), eightDigitHex(Appendable, int)

sixDigitHex
```
public static Appendable sixDigitHex(Appendable dest,
                                     int value)
```
Format as six digit hexadecimal number.

Appended to dest (generated StringBuilder if supplied as null) is the six digit hexadecimal representation of value's lower 24 bits. This representation is quite usual for 24 bit RGB colours.

Parameters:

dest - destination to append to; if null dest is made as StringBuilder with initial capacity of 12

Returns:

dest (appended is "000000".."FFFFFF"

See Also:

Color, twoDigitDec(Appendable, int), twoDigitHex(Appendable, int), fourDigitHex(Appendable, int), eightDigitHex(Appendable, int)

eightDigitHex
```
public static Appendable eightDigitHex(Appendable dest,
                                       int value)
```
Format as eight digit hexadecimal number.

Appended to dest (generated StringBuilder if supplied as null) is the six digit hexadecimal representation of value's lower 24 bits. This representation is quite usual for 24 bit RGB colours.

Parameters:

dest - destination to append to; if null dest is made as StringBuilder with initial capacity of 14

Returns:

dest (appended is "000000".."FFFFFF"

See Also:

Color, twoDigitDec(Appendable, int), twoDigitHex(Appendable, int), fourDigitHex(Appendable, int), sixDigitHex(Appendable, int)

append
```
public static Appendable append(Appendable dest,
                                byte[] bA)
```
Byte array as separated sequence of two digit hex numbers.

Appended to dest (generated StringBuilder if supplied as null) will be the content of the array bA as a sequence of two digit hex numbers (like made by zweiStellHex()). The numbers are separated by ", " (comma blank).

Parameters:

dest - destination to append to; if null dest is made as StringBuilder with initial capacity reserve of 20

Returns:

dest

append
```
public static Appendable append(Appendable dest,
                                byte[] bA,
                                int off,
                                int len)
```
Part of byte array as separated sequence of two digit hex numbers.

Appended to the (generated if supplied as null) StringBuilder dest will be the max. len bytes of the array bA starting from index off as a sequence of two digit hex numbers (like made by zweiStellHex()). The numbers are separated by ", " (comma blank).

Parameters:

dest - destination to append to; if null dest is made as StringBuilder with initial capacity reserve of 20

len - wished number of bytes processed, will be limited if too large; < 0 means as much as possible

off - staring index in bA; < 0 is taken as 0

Returns:

dest

twoDigitDec
```
public static Appendable twoDigitDec(Appendable dest,
                                     int value)
```
Format as two digit decimal number with leading zero.

Appended to dest (generated StringBuilder if supplied as null) is the two digit decimal representation of value if in the range 0..99's. Otherwise two blanks are appended.

Parameters:

dest - destination to append to; if null dest is made as StringBuilder with initial capacity of 6

value - the number

Returns:

dest (appended is "00".."99")

formDec
```
public static Appendable formDec(Appendable dest,
                                 int value,
                                 int width)
```
Format decimal number right justified .

Appended to dest (generated StringBuilder if supplied as null) is the decimal representation of value filled from left with blanks to get at least width (1..38).

Parameters:

dest - destination to append to; if null dest is made as StringBuilder with initial capacity of width + 4

value - the number

width - the minimal field width (max. 38) filled from left with blanks if the number is shorter.

Returns:

dest (appended is "00".."99")

twoDigit
```
public static String twoDigit(int value)
```
Format as two digit number with leading zero.

A positive number will be formatted as two digit decimal number (tens and ones) with leading zero.
A negative value and 0 return "00".
For a value > 100 the modulo 100 will be taken.

Application example is time and date formatting: 16.06.09 00:02:05

Parameters:

value - the number

Returns:

something between "00" and "99"

threeDigit
```
public static String threeDigit(int value)
```
Format as three digit number with leading zeros.

A positive number will be formatted as three digit decimal number (hundreds, tens and ones) with leading zero(s).
A negative value and 0 return "000".
For a value > 1000 the modulo 1000 will be taken.

Application example is time formatting with milliseconds: 00:02:05,020

Parameters:

value - the number

Returns:

something between "000" and "999"

checkMac
```
public static boolean checkMac(StringBuilder leMac)
```
Check (quite rawly) the syntax and uniform a MAC address.

In the StringBuilder a MAC address in the forms 00:04:76:19:5C:5F or 00-04-76-19-5C-5F or 00 04 76 19 5C 5F is expected and will be transformed to the form 00:04:76:19:5C:5F

If length and allowed separators it, true is returned.

Parameters:

leMac - containing just one (correct) MAC address + nothing

checkLanguage
```
public static String checkLanguage(CharSequence language,
                                   CharSequence defValue)
```
Check and correct language code.

Syntactically correct language codes are (to this method) just two lower case ASCII (a..z) letter Strings.

The parameter language will be white space stripped. If it is two letters ASCII (a..z or A..Z) its lower case equivalent will be returned.

Otherwise the same procedure will be taken for the parameter defValue.

If both are syntactically not acceptable or correctable ComVar.UL or "en" will be returned.

Parameters:

language - the language (1st choice)

defValue - the language (default)

Returns:

a two letter (lower case) language code, never null

See Also:

checkRegion(CharSequence, CharSequence), trimUq(CharSequence, String)

checkRegion
```
public static String checkRegion(CharSequence region,
                                 CharSequence defValue)
```
Check and correct region code.

Syntactically correct region codes are (to this method) just two upper case ASCII (A..Z) letter Strings.

The parameter region will be white space stripped. If it is two letters ASCII (a..z or A..Z) its upper case equivalent will be returned.

Otherwise the same procedure will be taken for the parameter defValue.

If both are syntactically unacceptable or uncorrectable ComVar.UR or GB will be returned.

Parameters:

region - the region (1st choice)

defValue - the region (default)

Returns:

a two letter (upper case) region code, never null

See Also:

checkLanguage(CharSequence, CharSequence), trimUq(CharSequence, String)

unComment
```
public static String unComment(String s,
                               char stC,
                               char endC,
                               boolean nested,
                               CharSequence repl)
```
Remove bracketed comments, optionally nested.

Subsequences (named comments here) beginning with the single character stC (opening brace ( e.g.) and ending with endC (closing brace ) e.g.) will be removed from the s and replaced by repl (if that is not empty).

If nested is true the parethis is nested. In that case within " with a ( com(en)t ) !" would "( com(en)t )" be recognised as comment and not "( com(en)".

An application (the use case within Frame4J) is the removing of bracketed (even nested) comments found in some time denotations got from the Internet.

s's end will be regarded as the closing of the comment even if the parethis might not have been closed. If and stC and endC are equal nested is true everything starting from the first occurrence of stC will be removed or replaced.

If no comment is found s is returned as is.

Hint: This method is not performing well for long Strings containing many comments.

Parameters:

s - the String to "uncomment"

Returns:

s freed from comments (never null, may be empty

indexOf

public static int indexOf(String text,
                          String[] list)

Search a character sequence in a list / array.

Returns:: the index of text in list or -1 if not inside

prepParams
```
public static String[] prepParams(String[] args,
                                  String commSt,
                                  boolean unQuote)
```
Working up of parameter arrays.

This method returns an array of (parameter) Strings according to the String array args supplied. The returned array is either empty or a newly created one; the latter may be a complete copy.

If args is null or empty (length 0) the empty array ComVar.NO_STRINGS will be returned.

All single Strings out of args will be put into the (new) array returned in their sequence. This copying ends where the (sub) sequence commSt (begin of comment) is detected within one such String that is not enclosed in quotes.

Strings (parameters) in args that are null will not be copied to the new array.

Due to the comment function and the masking of null parameters the returned array may be shorter than args and it's last String may also be shorter (by the comment removed) than its counterpart in the original args.

Parameters:

args - the original parameter array

commSt - the start sequence for comment (if not null or empty)

unQuote - if true parameter enclosed in quotation marks (") will get them removed

Returns:

A new parameter array may be shortened or empty, but never null

prepParams
```
public static String[] prepParams(CharSequence argLine,
                                  String commSt,
                                  boolean unQuote)
```
Make a parameter array from a character sequence (command line).

This method returns a decomposition of the sequence argLine to an array of Strings.

argLine will be cut to pieces separated by white space or enclosed in double quotes ("). These pieces will be put into a String array and returned as such.

The first subsequence commSt (comment start) in one of the pieces not in quotes will end that transfer to the target array.

Not by chance, this decomposition is the one needed for separating arguments from command lines. This type of decomposition is quite often needed, also for other use cases. This implementation does it better as it could be made by StringTokenizer or regular expressions.

Parameters:

argLine - the "e;line" with the parameters

commSt - the start sequence for comment (if not null or empty)

unQuote - if true parameter enclosed in quotation marks (") will get them removed

Returns:

A new parameter array may be shortened or empty, but never null

See Also:

splitCsWS(CharSequence)

prepParams
```
public static String[] prepParams(CharSequence argLine,
                                  int endArg)
```
Make a parameter array from a character sequence (command line).

This method returns a decomposition of the sequence argLine to an array of Strings.

argLine will be cut to pieces separated by white space or enclosed in double quotes ("). These pieces will be put into a String array and returned as such.

The decomposition will end at the piece with index endArg. If endArg is low enough return[endArg] will contain everything after the first whitespace separating the preceding element.
prepParams("a bc   u h xx   ", 2)
will return { "a", "bc", " u h xx "}

The special case of endArg == 0 will return the argLine without preceding white space in one String packed in a String arrays of length 1.

Parameters:

argLine - the "e;line" with the parameters

endArg - the maximum index of the last Sting (element) returned

Returns:

A new parameter array may be shortened or empty, but never null

See Also:

splitCsWS(CharSequence), splitWords(String), prepParams(CharSequence, String, boolean)

splitWords
```
public static String[] splitWords(String origContent)
```
Split a String to single words.

This method returns a decomposition of the sequence origContent to an array of Strings.

origContent will be cut to pieces separated by white space, comma (,), semicolon (;), braces (()), quotes ("'), ETligature (&) or colon (:). Single characters so separated will be ignored. These pieces will be put into a String array and returned as such.

This decomposition is just the one needed for the use case of separating single words of word forms quite efficiently. It is done better here as it could be made by StringTokenizer or regular expressions.

Parameters:

origContent - the "e;line" with the parameters

Returns:

A new String array containing the single words; may be empty but never null

See Also:

prepParams(CharSequence, String, boolean)

splitCsWS
```
public static String[] splitCsWS(CharSequence input)
```
Separating at comma, semicolon or white space.

This method separates a character sequence (input) at comma, semicolon or white space, mostly like described for getCommaSemicolonWSpattern(). Additionally this method regards subsequences enclosed in quotes as one piece or token.

An empty input sequence returns the empty String array.
An input sequence without occurrence of one of the separating characters named (outside quotes) will be returned as String inside a String array of length one.

Example: ", a ,, b \",,,a,,,\",, c;" returns
{ "", "a", "", "", "b", ",,,a,,,", "", "c" }.

Example 2: "Z:;X:" returns
{ "Z:", "X:" }.

Hint: Instead of this method one may be tempted to use StringTokenizer or a regular expression like getCommaSemicolonWSpattern() with getCommaSemicolonWSpattern().split(input, -1). Regular expressions are even more costly than the StringTokenizer, but would avoid the following mistake:
A StringTokenizer (using " ,;\t\n\r" as pattern) would see for "a ; ; , , b" only one instead of four separations giving only two instead of five token returned by a suitable regular expression and by this method.

Parameters:

input - the character sequence to tokenise

Returns:

result array (all token)
the length may be maximal input.length() (if input is all comma e.g).
never null bat may be empty as ComVar.NO_STRINGS

See Also:

getCommaSemicolonWSpattern(), ComVar.NO_STRINGS, splitWords(String)

countParams
```
public static int countParams(String[] args)
```
Count of non empty Strings or arguments in a (parameter) array.

This method return the number of non empty entries in a String array. The array is left untouched.
One application is to determine the number of start parameters not evaluated and cleared by partial parsing.

Parameters:

args - the parameter array

Returns:

the corresponding (command) line

See Also:

prepParams(String[])

prepParams
```
public static String prepParams(String[] args)
```
Make an argument line from a parameter array.

This method generates one (command) line from an array of arguments or parameters separated by one space each.

Parameter, containing space ( ), semicolon (;), comma (,), question mark (?), asterisk(*) or sharp (#), will be set in quotes (") if not yet so.

If there are no parameters the empty String is returned.

Parameters:

args - the parameters

Returns:

the corresponding (command) line

See Also:

countParams(String[])

shouldQuote
```
public static boolean shouldQuote(CharSequence akt)
```
Make a recommendation about quoting argument.

It says if a sequence should be quoted as command line argument.

Null or empty return true.
Begin and end by quote (already) returns false.
Any occurrence of ?, *, ;, ,(comma), # or space returns true.

checkMail
```
public static String checkMail(CharSequence adr,
                               CharSequence defaultServer,
                               boolean forceServer)
```
Check / complete an e-Mail address.

It will be checked if adr fulfils (at lest) the minimal / basic requirements on a robust (ASCCI) mail address. The server part, if missing, will be added by the value of defaultServer resulting in adr@defaultServer.

In the case of forceServer true a server part may already be given in the parameter adr but that must then be equal to defaultServer.

Returned is the accepted or completed address or null for all cases of rejection.

format
```
public static Appendable format(Appendable dest,
                                CharSequence name,
                                CharSequence[] sA,
                                int sLen)
```
Format a String array.

The String array sA now named name will be output to dest (made as StringBuilder if supplied as null).
The multi-line format is equivalent to the Java's initialised String[] declaration syntax.

Parameters:

dest - destination to append to; if null dest is made as StringBuilder with initial capacity of 50 + 16 * sA's length

name - the name to be given to sA; null will be taken as "..."

sA - the String[] to be formatted / listed

sLen - if >= 0 and < sA.length used to reduce the effective length of sA to format

Returns:

dest

See Also:

write(PrintWriter, CharSequence, CharSequence[])

write
```
public static void write(PrintWriter out,
                         CharSequence name,
                         CharSequence[] sA)
```
Output a String array.

The String array sA now named name will be output to out. The multi-line format is equivalent to the Java's initialised String[] declaration syntax.
This method does (almost) the same and in fact delegates to format(out, name, sA, 0, except for doing nothing when out is 0 and outputting always the whole String array

See Also:

format(Appendable, CharSequence, CharSequence[], int)

formatDuration
```
public static StringBuilder formatDuration(StringBuilder dest,
                                           long dur)
```
Formatting a runtime or period (long ms) as text.

dur is duration in ms (milliseconds). According to its magnitude it will formatted in four ways, namely like 9788ms, 3599s, 1h00min or 1d00h00min

Parameters:

dest - destination to append to; if null dest is made as StringBuilder with initial capacity of 16

dur - the duration

Returns:

dest

See Also:

App.getExecTimeMs()

getCommaSemicolonWSpattern
```
public static Pattern getCommaSemicolonWSpattern()
```
Pattern for separation at comma, semicolon or white space.

This method returns a pattern, i.e. a compiled regular expression for
(any white space) 0 or 1 times (comma or semicolon) (any white space)
in total at least one character (white space, comma or semicolon).

This pattern is able to separate character sequences at just those spots and hence tokenise the usual (parameter) lists generated by humans or by tools (CSV etc.).

A call
TextHelper.getCommaColonWSpattern().split("a,b, c , d , e ,, f g ,, ", -1)
for example would get 10 token (as String[]), among those one empty before the "f" and two empty after the "g".

Hint: A leading white space before the example's "a" would get an extra empty first token (avoided by trimming before; see trimUq(CharSequence, String)).

Hint 2: A call
TextHelper.getCommaColonWSpattern().split(string, -1)
is better (cheaper) replaced by
TextHelper.splitCcWS(string)

Hint 3: This method always returns the (singleton) object made at the very first call. Pattern objects are threadsafe as immutable (Matchers by the way are not).

Hint 4: split() is preferable over String.split().

See Also:

Pattern.split(java.lang.CharSequence, int), String.split(java.lang.String), splitCsWS(CharSequence)

messageFormat
```
public static StringBuilder messageFormat(StringBuilder dest,
                                          CharSequence pattern,
                                          Object args)
```
A simple message formatter.

This method provides a basic "message format" for the frequent cases, where the class MessageFormat is much to circumstantial or just overkill.

ChoiceFormat, Currency etc. will not be supported here, however the most flexible time / date formatting by using pattern directly given in the format strings.

For the ever recurring case of formatting just integer values an int[] instead of the costly Object[] containing Integers is accepted as well. Additionally the case of just one parameter (the frequent {0} only case) is supported by supplying just the object instead of a new Object[]{arg} with just that one element.

In pattern the simplest cases are like {0} {1} etc.; here all between the braces including them is a placeholder just replaced by the the String representation toString() of the argument indexed by the number. For theses simple cases pattern is compatible between this method and the format()-methods of MessageFormat.
For an opening { brace to be considered as a placeholder and not go through unprocessed the next character must be a digit 0..9 or a space. A double {{ goes as one { unprocessed.

Is one argument ({19} for example ) of type xxxtimexxx, everything between the last index digit and the closing } brace ({19D, M d Y, H:i:s} for example) is taken as format string to {xxx ConstTime#toString(CharSequence)}. This controlled formatting of time (in this framework) considers the user, platform or application settings for the language.

Example with two pattern:
"Die Anwendung {1} startete am{ 0 D, j. F Y, H:i:s T I}."
"Application {1} started at{0 D, Y/d/m, H:i:s (T)}."

Example of using those (as variable pat):
log.println(TextHelper.messageFormat(null, pat, uIInfo));
The uIInfo used in the example is for App inheritors the object itself by grace of the method App.getMessageComponent(int); a (inter) nationalised start message generated by this schema is returned by the method App.twoLineStartMsg().

If one argument ({21} e.g.) of type Boolean, anything between the last index digit and the closing } ({21Dateien?Datei} e.g. or {21chicken?mice}) is used as format String for the boolean value. If that contains a ? this separates two parts the first taken for true and the last for false. Without the ? the whole thing (except the index digits is taken for true and nothing for false. The same applies if the argument is a number (int or Integer), where value != 1 (= plural) is taken as boolean; examples:
"There {19are?is} {19} child{19ren}." or
"{0} file{0s} + {1} director{1ies?y} of {2} deleted"

Parameters:

dest - StringBuilder to append to; if null it is made with a starting capacity of 81

pattern - the pattern to append to

args - An array of the arguments; may be of type Object[] or int[]; null or empty means pattern being appended to dest uninterpreted.
If args is no array it is considered as just one argument of index null.
Additionally args may be an object of type TextHelper.MessageComponents whose method TextHelper.MessageComponents.getMessageComponent(int) will be called to provide (dynamically) the arguments denoted in pattern.

Returns:

dest

See Also:

AppLangMap

makeMessageComponents

public static TextHelper.MessageComponents makeMessageComponents(Object[] oa)

Make MessageComponents from an array.

Class TextHelper

Nested Class Summary

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

lastFormatingExc

Method Detail

con3cat

getPropertyText

getPropertyText

makeFName

makeFNameUJ

makeFNL

isFrntMttr

simpCharEqu

endsWith

startsWith

asBoolean

asBoolObj

asBoolObj

asBoolean

asIntObj

asInt

compare

trimUq

areEqual

wildEqual

fUr

fUr

fUr

fUr

fUr

indexOf

indexOfOpt

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOfWS

equalsTil

equalsTil

zif

dig

twoDigitHex

twoDigitHex

fourDigitHex

sixDigitHex

eightDigitHex

append

append

twoDigitDec

formDec

twoDigit

threeDigit

checkMac

checkLanguage

checkRegion

unComment

indexOf

prepParams

prepParams

prepParams

splitWords

splitCsWS

countParams

prepParams

shouldQuote

checkMail

format

write

formatDuration

getCommaSemicolonWSpattern

messageFormat

makeMessageComponents