changes in convert/text functions

- changed function names: PascalCase to snake_case
- templates functions moved to a seperate file (text_private.h)
- as a public api only available functions with char/wchar_t/std::string/std::wstring
- ToLower(...) changed to to_lower_emplace(...), similar ToUpper(...) to to_upper_emplace(...)
- added functions:
  std::string to_lower(const std::string & str);
  std::string to_upper(const std::string & str);
  and with std::wstring too
- functions with postfix 'NoCase' changed to 'nc'

src/convert/text_private.h

@@ -39,6 +39,7 @@
 #define headerfile_picotools_convert_text_private
 
 #include <string>
+#include "text.h"
 
 
 namespace PT
@@ -48,7 +49,7 @@ namespace pt_private
 {
 
 template<class CharType>
-CharType ToLowerGeneric(CharType c)
+CharType to_lower_generic(CharType c)
 {
 	if( c >= 'A' && c <= 'Z' )
 		return c - 'A' + 'a';
@@ -58,7 +59,7 @@ CharType ToLowerGeneric(CharType c)
 
 
 template<class CharType>
-CharType ToUpperGeneric(CharType c)
+CharType to_upper_generic(CharType c)
 {
 	if( c >= 'a' && c <= 'z' )
 		return c - 'a' + 'A';
@@ -68,25 +69,237 @@ CharType ToUpperGeneric(CharType c)
 
 
 template<class StringType>
-void ToLowerStrGeneric(StringType & s)
+void to_lower_str_generic(StringType & s)
 {
 	typename StringType::size_type i;
 
 	for(i=0 ; i<s.size() ; ++i)
-		s[i] = ToLowerGeneric(s[i]);
+		s[i] = to_lower(s[i]);
 }
 
 
 template<class StringType>
-void ToUpperStrGeneric(StringType & s)
+void to_upper_str_generic(StringType & s)
 {
 	typename StringType::size_type i;
 
 	for(i=0 ; i<s.size() ; ++i)
-		s[i] = ToUpperGeneric(s[i]);
+		s[i] = to_upper(s[i]);
 }
 
 
+template<class CharType>
+CharType * skip_white_generic(CharType * str, bool check_additional_chars, bool treat_new_line_as_white)
+{
+	while( is_white(static_cast<wchar_t>(*str), check_additional_chars, treat_new_line_as_white) )
+	{
+		str += 1;
+	}
+
+	return str;
+}
+
+
+template<class CharType>
+CharType * skip_white_from_back_generic(CharType * str_begin, CharType * str_end, bool check_additional_chars, bool treat_new_line_as_white)
+{
+	while( str_end > str_begin && is_white(static_cast<wchar_t>(*(str_end-1)), check_additional_chars, treat_new_line_as_white) )
+	{
+		str_end -= 1;
+	}
+
+	return str_end;
+}
+
+
+template<class CharType>
+CharType * skip_white_from_back_generic(CharType * str, bool check_additional_chars, bool treat_new_line_as_white)
+{
+	CharType * str_begin = str;
+
+	while( *str != 0 )
+	{
+		str += 1;
+	}
+
+	return skip_white_from_back_generic(str_begin, str, check_additional_chars, treat_new_line_as_white);
+}
+
+
+
+
+template<class StringType1, class StringType2>
+int compare_generic(const StringType1 * str1, const StringType2 * str2)
+{
+	while( *str1 && *str2 && *str1 == *str2 )
+	{
+		++str1;
+		++str2;
+	}
+
+	if( *str1 == 0 && *str2 == 0 )
+		return 0;
+
+	int c1;
+	int c2;
+
+	if constexpr (sizeof(StringType1) == 1 && sizeof(StringType2) == 1)
+	{
+		c1 = (wchar_t)(unsigned char)(*str1);
+		c2 = (wchar_t)(unsigned char)(*str2);
+	}
+	else
+	{
+		c1 = *str1;
+		c2 = *str2;
+	}
+
+	return c1 - c2;
+}
+
+
+template<class StringType1, class StringType2>
+int compare_str_generic(const StringType1 & str1, const StringType2 & str2)
+{
+	return compare_generic(str1.c_str(), str2.c_str());
+}
+
+
+template<class StringType1, class StringType2>
+int compare_generic(const StringType1 * str1_begin, const StringType1 * str1_end, const StringType2 * str2)
+{
+	while( str1_begin < str1_end && *str2 && *str1_begin == *str2 )
+	{
+		++str1_begin;
+		++str2;
+	}
+
+	if( str1_begin == str1_end && *str2 == 0 )
+		return 0;
+
+	int c1;
+	int c2;
+
+	if constexpr (sizeof(StringType1) == 1 && sizeof(StringType2) == 1)
+	{
+		c1 = str1_begin < str1_end ? (wchar_t)(unsigned char)(*str1_begin) : 0;
+		c2 = (wchar_t)(unsigned char)(*str2);
+	}
+	else
+	{
+		c1 = str1_begin < str1_end ? *str1_begin : 0;
+		c2 = *str2;
+	}
+
+	return c1 - c2;
+}
+
+
+
+template<class StringType1, class StringType2>
+int compare_nc_generic(const StringType1 * str1, const StringType2 * str2)
+{
+	while( *str1 && *str2 && to_lower(*str1) == to_lower(*str2) )
+	{
+		++str1;
+		++str2;
+	}
+
+	if( *str1 == 0 && *str2 == 0 )
+		return 0;
+
+	int c1;
+	int c2;
+
+	if constexpr (sizeof(StringType1) == 1 && sizeof(StringType2) == 1)
+	{
+		c1 = to_lower((wchar_t)(unsigned char)(*str1));
+		c2 = to_lower((wchar_t)(unsigned char)(*str2));
+	}
+	else
+	{
+		c1 = to_lower(*str1);
+		c2 = to_lower(*str2);
+	}
+
+	return c1 - c2;
+}
+
+
+template<class StringType1, class StringType2>
+int compare_nc_str_generic(const StringType1 & str1, const StringType2 & str2)
+{
+	return compare_nc(str1.c_str(), str2.c_str());
+}
+
+
+template<class StringType1, class StringType2>
+int compare_nc_generic(const StringType1 * str1_begin, const StringType1 * str1_end, const StringType2 * str2)
+{
+	while( str1_begin < str1_end && *str2 && to_lower(*str1_begin) == to_lower(*str2) )
+	{
+		++str1_begin;
+		++str2;
+	}
+
+	if( str1_begin == str1_end && *str2 == 0 )
+		return 0;
+
+	int c1;
+	int c2;
+
+	if constexpr (sizeof(StringType1) == 1 && sizeof(StringType2) == 1)
+	{
+		c1 = str1_begin < str1_end ? to_lower((wchar_t)(unsigned char)(*str1_begin)) : 0;
+		c2 = to_lower((wchar_t)(unsigned char)(*str2));
+	}
+	else
+	{
+		c1 = str1_begin < str1_end ? to_lower(*str1_begin) : 0;
+		c2 = to_lower(*str2);
+	}
+
+	return c1 - c2;
+}
+
+
+
+
+template<class StringType1, class StringType2>
+bool is_substr_generic(const StringType1 * short_str, const StringType2 * long_str)
+{
+	while( *short_str && *long_str && *short_str == *long_str )
+	{
+		++short_str;
+		++long_str;
+	}
+
+	if( *short_str == 0 )
+		return true;
+
+	return false;
+}
+
+
+
+template<class StringType1, class StringType2>
+bool is_substr_nc_generic(const StringType1 * short_str, const StringType2 * long_str)
+{
+	while( *short_str && *long_str && to_lower(*short_str) == to_lower(*long_str) )
+	{
+		++short_str;
+		++long_str;
+	}
+
+	if( *short_str == 0 )
+		return true;
+
+	return false;
+}
+
+
+
+
 } // namespace pt_private
 
 } // namespace PT