/** ****************************************************************************************
* Interprets given \p src as a verbosity.
* A case insensitive comparison of only the first (!) character of the start of the string
* is performed (against 'v', 'i', 'w' and 'e').
* If no match is found, \e %Verbosity::Off is returned.
* @param src The string to 'parse'.
* @returns The verbosity read.
******************************************************************************************/
public static Verbosity ReadVerbosity(Substring src)
{
int idx = src.IndexOfAny(CString.DefaultWhitespaces, Inclusion.Exclude);
if (idx >= 0)
{
char c = Char.ToLower(src.CharAt(idx));
if (c == 'v')
{
return(Verbosity.Verbose);
}
if (c == 'i')
{
return(Verbosity.Info);
}
if (c == 'w')
{
return(Verbosity.Warning);
}
if (c == 'e')
{
return(Verbosity.Error);
}
}
return(Verbosity.Off);
}
void tIndexOfAny(bool forward, String haystack, String needles, int startPos, Inclusion inclusion, int expectedResult)
{
char[] needlesArr = needles.ToCharArray();
haystackAString._()._(haystack);
haystackSubsPlain.Set(haystack);
haystackSubstring.Set("01" + haystack + haystack + "234", 2 + haystack.Length, haystack.Length);
if (startPos == DEF)
{
if (forward)
{
UT_EQ(expectedResult, haystackAString.IndexOfAny(needlesArr, inclusion));
UT_EQ(expectedResult, haystackSubsPlain.IndexOfAny(needlesArr, inclusion));
UT_EQ(expectedResult, haystackSubstring.IndexOfAny(needlesArr, inclusion));
}
else
{
UT_EQ(expectedResult, haystackAString.LastIndexOfAny(needlesArr, inclusion));
UT_EQ(expectedResult, haystackSubsPlain.LastIndexOfAny(needlesArr, inclusion));
UT_EQ(expectedResult, haystackSubstring.LastIndexOfAny(needlesArr, inclusion));
}
}
else
{
if (forward)
{
UT_EQ(expectedResult, haystackAString.IndexOfAny(needlesArr, inclusion, startPos));
UT_EQ(expectedResult, haystackSubsPlain.IndexOfAny(needlesArr, inclusion, startPos));
UT_EQ(expectedResult, haystackSubstring.IndexOfAny(needlesArr, inclusion, startPos));
}
else
{
UT_EQ(expectedResult, haystackAString.LastIndexOfAny(needlesArr, inclusion, startPos));
UT_EQ(expectedResult, haystackSubsPlain.LastIndexOfAny(needlesArr, inclusion, startPos));
UT_EQ(expectedResult, haystackSubstring.LastIndexOfAny(needlesArr, inclusion, startPos));
}
}
}
/** ****************************************************************************************
* Interprets given \p src as a value of enum type
* \ref cs::aworx::lib::enums::Inclusion "enums.Inclusion".
* If the case insensitive comparison of the first non-whitespace characters of the string
* with values "i", "y", "t", "1"
* matches, \b %Inclusion.Include is returned.
* Otherwise, including the case that \p src is 'nulled', \b %Inclusion.Exclude is returned.
*
* @param src The string to 'parse'.
*
* @returns The \b %Inclusion value read.
******************************************************************************************/
public static Inclusion ReadInclusion(Substring src)
{
int idx = src.IndexOfAny(CString.DefaultWhitespaces, Inclusion.Exclude);
if (idx >= 0)
{
int c = Char.ToLower(src.CharAt(idx));
foreach (char v in trueValuesInclusion)
{
if (c == v)
{
return(Inclusion.Include);
}
}
}
return(Inclusion.Exclude);
}
/** ****************************************************************************************
* Interprets given \p src as a value of enum type
* \ref aworx.lib::enums::Case "enums.Case".
* If the case insensitive comparison of the first non-whitespace characters of the string
* with values "s", "y", "t", "1"
* matches, \b %Case.Sensitive is returned.
* Otherwise, including the case that \p src is 'nulled', \b %Case.Ignore is returned.
*
* @param src The string to 'parse'.
*
* @returns The \b %Case value read.
******************************************************************************************/
public static Case ReadCase(Substring src)
{
int idx = src.IndexOfAny(CString.DefaultWhitespaces, Inclusion.Exclude);
if (idx >= 0)
{
int c = Char.ToLower(src.CharAt(idx));
foreach (char v in trueValuesCase)
{
if (c == v)
{
return(Case.Sensitive);
}
}
}
return(Case.Ignore);
}
/** ****************************************************************************************
* Interprets given \p src as a boolean value.
* \ref cs::aworx::lib::enums::Inclusion "enums.Inclusion".
* If the case insensitive comparison of the first non-whitespace characters of the string with
* with values "t", "1", "y", "on", "ok"
* matches, \c true is returned.
* Otherwise, including the case that \p src is 'nulled', \c false is returned.
*
* @param src The string to 'parse'.
*
* @returns The \b %Case value read.
******************************************************************************************/
public static bool ReadBoolean(Substring src)
{
int idx = src.IndexOfAny(CString.DefaultWhitespaces, Inclusion.Exclude);
if (idx >= 0)
{
char c = Char.ToLower(src.CharAt(idx));
foreach (char v in trueValuesBoolean)
{
if (c == v)
{
return(true);
}
}
char c2 = Char.ToLower(src.CharAt(idx + 1));
if (c == 'o' && (c2 == 'n' || c2 == 'k'))
{
return(true);
}
}
return(false);
}
public void IndexOf()
{
Substring subs;
// indexOf()
{
subs = new Substring("ABCD");
UT_EQ(-1, subs.IndexOf('X'));
UT_EQ(0, subs.IndexOf('A'));
UT_EQ(1, subs.IndexOf('B'));
UT_EQ(2, subs.IndexOf('C'));
UT_EQ(3, subs.IndexOf('D'));
}
// search characters
subs.Set("abc@" + "abcd abcd" + "abc@de", 4, 9);
{
UT_EQ(-1, subs.IndexOf('@', -5));
UT_EQ(-1, subs.IndexOf('@'));
UT_EQ(-1, subs.IndexOf('@', 5));
UT_EQ(-1, subs.IndexOf('@', 150));
UT_EQ(0, subs.IndexOf('a'));
UT_EQ(1, subs.IndexOf('b'));
UT_EQ(2, subs.IndexOf('c'));
UT_EQ(0, subs.IndexOf('a', 0));
UT_EQ(1, subs.IndexOf('b', 0));
UT_EQ(2, subs.IndexOf('c', 0));
UT_EQ(5, subs.IndexOf('a', 1));
UT_EQ(1, subs.IndexOf('b', 1));
UT_EQ(2, subs.IndexOf('c', 1));
UT_EQ(5, subs.IndexOf('a', 2));
UT_EQ(6, subs.IndexOf('b', 2));
UT_EQ(2, subs.IndexOf('c', 2));
UT_EQ(5, subs.IndexOf('a', 3));
UT_EQ(6, subs.IndexOf('b', 3));
UT_EQ(7, subs.IndexOf('c', 3));
UT_EQ(8, subs.IndexOf('d', 7));
UT_EQ(8, subs.IndexOf('d', 8));
UT_EQ(-1, subs.IndexOf('d', 9));
}
// search null, empty string
subs.Set("abc@" + "abcd abcd" + "abc@de", 4, 9);
{
UT_EQ(0, subs.IndexOf((AString)null));
UT_EQ(5, subs.IndexOf((AString)null, 5));
UT_EQ(-1, subs.IndexOf((AString)null, 50));
UT_EQ(0, subs.IndexOf((AString)null, -5));
UT_EQ(0, subs.IndexOf((String)null));
UT_EQ(5, subs.IndexOf((String)null, 5));
UT_EQ(-1, subs.IndexOf((String)null, 50));
UT_EQ(0, subs.IndexOf((String)null, -5));
UT_EQ(0, subs.IndexOf("", -5));
UT_EQ(0, subs.IndexOf("", 0));
UT_EQ(4, subs.IndexOf("", 4));
UT_EQ(-1, subs.IndexOf("", 100));
}
// search
subs.Set("abc@" + "abcd abcd" + "abc@de", 4, 9);
{
UT_EQ(0, subs.IndexOf("abcd"));
UT_EQ(1, subs.IndexOf("b"));
UT_EQ(4, subs.IndexOf(" abcd"));
UT_EQ(5, subs.IndexOf("abcd", 1));
UT_EQ(0, subs.IndexOf("abcd", -1));
UT_EQ(-1, subs.IndexOf("xyz", -10));
}
// ignore case
String t = "Hallo A-Worx util";
subs.Set("abc@" + t + "abc@de", 4, t.Length);
{
UT_EQ(6, subs.IndexOf("a-worx", 0, Case.Ignore));
UT_EQ(6, subs.IndexOf("a-worx", 1, Case.Ignore));
UT_EQ(6, subs.IndexOf("a-worx", -10, Case.Ignore));
UT_EQ(6, subs.IndexOf("a-worx", 6, Case.Ignore));
UT_EQ(-1, subs.IndexOf("a-worx", 7, Case.Ignore));
UT_EQ(-1, subs.IndexOf("a-worx", 100, Case.Ignore));
UT_EQ(0, subs.IndexOf("hal", 0, Case.Ignore));
UT_EQ(-1, subs.IndexOf("hal", 1, Case.Ignore));
UT_EQ(13, subs.IndexOf("util", 1, Case.Ignore));
UT_EQ(13, subs.IndexOf("UTIL", 5, Case.Ignore));
UT_EQ(13, subs.IndexOf("UTIL", 13, Case.Ignore));
UT_EQ(-1, subs.IndexOf("UTIL", 14, Case.Ignore));
}
// ------------------ search one of several characters ------------------
subs.Set("abc@" + "abcd abcde" + "abc@de", 4, 10);
{
// search one of
int l = subs.Length();
UT_EQ(4, subs.IndexOfAny(CString.DefaultWhitespaces, Inclusion.Include));
UT_EQ(-1, subs.IndexOfAny("x".ToCharArray(), Inclusion.Include));
UT_EQ(-1, subs.IndexOfAny("xy".ToCharArray(), Inclusion.Include));
UT_EQ(-1, subs.IndexOfAny("xyz".ToCharArray(), Inclusion.Include));
UT_EQ(3, subs.IndexOfAny("xyd".ToCharArray(), Inclusion.Include));
UT_EQ(3, subs.IndexOfAny("d".ToCharArray(), Inclusion.Include));
UT_EQ(3, subs.IndexOfAny("xyd".ToCharArray(), Inclusion.Include, -2));
UT_EQ(8, subs.IndexOfAny("xyd".ToCharArray(), Inclusion.Include, 4));
UT_EQ(-1, subs.IndexOfAny("xyd".ToCharArray(), Inclusion.Include, 20));
UT_EQ(-1, subs.LastIndexOfAny("".ToCharArray(), Inclusion.Include));
UT_EQ(-1, subs.LastIndexOfAny("x".ToCharArray(), Inclusion.Include));
UT_EQ(-1, subs.LastIndexOfAny("xy".ToCharArray(), Inclusion.Include));
UT_EQ(-1, subs.LastIndexOfAny("xyz".ToCharArray(), Inclusion.Include));
UT_EQ(8, subs.LastIndexOfAny("xyd".ToCharArray(), Inclusion.Include));
UT_EQ(-1, subs.LastIndexOfAny("xyd".ToCharArray(), Inclusion.Include, -2));
UT_EQ(-1, subs.LastIndexOfAny("xyd".ToCharArray(), Inclusion.Include, 2));
UT_EQ(3, subs.LastIndexOfAny("xyd".ToCharArray(), Inclusion.Include, 4));
UT_EQ(0, subs.LastIndexOfAny("a".ToCharArray(), Inclusion.Include, 4));
UT_EQ(1, subs.LastIndexOfAny("b".ToCharArray(), Inclusion.Include, 4));
UT_EQ(1, subs.LastIndexOfAny("ba".ToCharArray(), Inclusion.Include, 4));
UT_EQ(0, subs.LastIndexOfAny("xa".ToCharArray(), Inclusion.Include, 4));
UT_EQ(8, subs.LastIndexOfAny("xyd".ToCharArray(), Inclusion.Include, 20));
UT_EQ(8, subs.LastIndexOfAny("d".ToCharArray(), Inclusion.Include, 20));
UT_EQ(9, subs.LastIndexOfAny("e".ToCharArray(), Inclusion.Include, 20));
// search NOT one of
UT_EQ(0, subs.IndexOfAny("".ToCharArray(), Inclusion.Exclude));
UT_EQ(0, subs.IndexOfAny("x".ToCharArray(), Inclusion.Exclude));
UT_EQ(0, subs.IndexOfAny("xy".ToCharArray(), Inclusion.Exclude));
UT_EQ(0, subs.IndexOfAny("xyz".ToCharArray(), Inclusion.Exclude));
UT_EQ(1, subs.IndexOfAny("a".ToCharArray(), Inclusion.Exclude));
UT_EQ(2, subs.IndexOfAny("ba".ToCharArray(), Inclusion.Exclude));
UT_EQ(3, subs.IndexOfAny("abc".ToCharArray(), Inclusion.Exclude));
UT_EQ(3, subs.IndexOfAny("acb".ToCharArray(), Inclusion.Exclude));
UT_EQ(3, subs.IndexOfAny("cba".ToCharArray(), Inclusion.Exclude));
UT_EQ(3, subs.IndexOfAny("xcba".ToCharArray(), Inclusion.Exclude));
UT_EQ(l - 1, subs.LastIndexOfAny("".ToCharArray(), Inclusion.Exclude));
UT_EQ(l - 1, subs.LastIndexOfAny("x".ToCharArray(), Inclusion.Exclude));
UT_EQ(l - 1, subs.LastIndexOfAny("xy".ToCharArray(), Inclusion.Exclude));
UT_EQ(l - 2, subs.LastIndexOfAny("e".ToCharArray(), Inclusion.Exclude));
UT_EQ(l - 3, subs.LastIndexOfAny("de".ToCharArray(), Inclusion.Exclude));
UT_EQ(l - 4, subs.LastIndexOfAny("cde".ToCharArray(), Inclusion.Exclude));
UT_EQ(l - 4, subs.LastIndexOfAny("ced".ToCharArray(), Inclusion.Exclude));
UT_EQ(l - 4, subs.LastIndexOfAny("ecd".ToCharArray(), Inclusion.Exclude));
UT_EQ(5, subs.LastIndexOfAny("ecd".ToCharArray(), Inclusion.Exclude, 5));
UT_EQ(4, subs.LastIndexOfAny("ecd".ToCharArray(), Inclusion.Exclude, 4));
UT_EQ(1, subs.LastIndexOfAny("acd".ToCharArray(), Inclusion.Exclude, 3));
UT_EQ(-1, subs.LastIndexOfAny("abc".ToCharArray(), Inclusion.Exclude, 2));
UT_EQ(3, subs.LastIndexOfAny("xay".ToCharArray(), Inclusion.Exclude, 3));
UT_EQ(2, subs.LastIndexOfAny("d".ToCharArray(), Inclusion.Exclude, 3));
UT_EQ(-1, subs.LastIndexOfAny("a".ToCharArray(), Inclusion.Exclude, 0));
}
}
