Dropped templates and defined the functions explicitly

Author: slurmlord

Core/Libraries/Source/WWVegas/WWLib/stringex.h

@@ -24,48 +24,48 @@
 
 // Declaration
 
-template<typename T> size_t strlen_t(const T *str);
-template<typename T> size_t strnlen_t(const T *str, size_t maxlen);
+template<typename T> size_t strlen_t(const T* str);
+template<typename T> size_t strnlen_t(const T* str, size_t maxlen);
 
 #if defined(_MSC_VER) && _MSC_VER < 1300
-size_t strnlen(const char *str, size_t maxlen);
-size_t wcsnlen(const wchar_t *str, size_t maxlen);
+size_t strnlen(const char* str, size_t maxlen);
+size_t wcsnlen(const wchar_t* str, size_t maxlen);
 #endif
 
-template<typename T> size_t strlcpy_t(T *dst, const T *src, size_t dstsize);
-template<typename T> size_t strlcat_t(T *dst, const T *src, size_t dstsize);
+template<typename T> size_t strlcpy_t(T* dst, const T* src, size_t dstsize);
+template<typename T> size_t strlcat_t(T* dst, const T* src, size_t dstsize);
 
-size_t strlcpy(char *dst, const char *src, size_t dstsize);
-size_t strlcat(char *dst, const char *src, size_t dstsize);
-size_t wcslcpy(wchar_t *dst, const wchar_t *src, size_t dstsize);
-size_t wcslcat(wchar_t *dst, const wchar_t *src, size_t dstsize);
+size_t strlcpy(char* dst, const char* src, size_t dstsize);
+size_t strlcat(char* dst, const char* src, size_t dstsize);
+size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dstsize);
+size_t wcslcat(wchar_t* dst, const wchar_t* src, size_t dstsize);
 
-template<typename T> size_t strlmove_t(T *dst, const T *src, size_t dstsize);
-template<typename T> size_t strlmcat_t(T *dst, const T *src, size_t dstsize);
+template<typename T> size_t strlmove_t(T* dst, const T* src, size_t dstsize);
+template<typename T> size_t strlmcat_t(T* dst, const T* src, size_t dstsize);
 
-size_t strlmove(char *dst, const char *src, size_t dstsize);
-size_t strlmcat(char *dst, const char *src, size_t dstsize);
-size_t wcslmove(wchar_t *dst, const wchar_t *src, size_t dstsize);
-size_t wcslmcat(wchar_t *dst, const wchar_t *src, size_t dstsize);
+size_t strlmove(char* dst, const char* src, size_t dstsize);
+size_t strlmcat(char* dst, const char* src, size_t dstsize);
+size_t wcslmove(wchar_t* dst, const wchar_t* src, size_t dstsize);
+size_t wcslmcat(wchar_t* dst, const wchar_t* src, size_t dstsize);
 
 #if !(defined(_MSC_VER) && _MSC_VER < 1300)
-template<size_t Size> size_t strlcpy_t(char (&dst)[Size], const char *src);
-template<size_t Size> size_t strlcat_t(char (&dst)[Size], const char *src);
-template<size_t Size> size_t strlmove_t(char (&dst)[Size], const char *src);
-template<size_t Size> size_t strlmcat_t(char (&dst)[Size], const char *src);
+template<size_t Size> size_t strlcpy_t(char(&dst)[Size], const char* src);
+template<size_t Size> size_t strlcat_t(char(&dst)[Size], const char* src);
+template<size_t Size> size_t strlmove_t(char(&dst)[Size], const char* src);
+template<size_t Size> size_t strlmcat_t(char(&dst)[Size], const char* src);
 #endif
 
-template<typename T> bool startsWith(const T *str, const T *prefix);
-template<typename T> bool startsWithNoCase(const T *str, const T *prefix);
-template<typename T> bool endsWith(const T *str, const T *suffix);
-template<typename T> bool endsWithNoCase(const T *str, const T *suffix);
+template<typename T> bool startsWith(const T* str, const T* prefix);
+template<typename T> bool startsWithNoCase(const T* str, const T* prefix);
+template<typename T> bool endsWith(const T* str, const T* suffix);
+template<typename T> bool endsWithNoCase(const T* str, const T* suffix);
 
 
 // Implementation
 
 // Templated strlen.
 // Returns the number of characters until the first zero character.
-template<typename T> size_t strlen_t(const T *str)
+template<typename T> size_t strlen_t(const T* str)
 {
 	const T* begin = str;
 	while (*str)
@@ -75,7 +75,7 @@ template<typename T> size_t strlen_t(const T *str)
 
 // Templated strlen.
 // Returns the number of characters until the first zero character or when maxlen is reached.
-template<typename T> size_t strnlen_t(const T *str, size_t maxlen)
+template<typename T> size_t strnlen_t(const T* str, size_t maxlen)
 {
 	const T* begin = str;
 	const T* end = str + maxlen;
@@ -85,14 +85,14 @@ template<typename T> size_t strnlen_t(const T *str, size_t maxlen)
 }
 
 #if defined(_MSC_VER) && _MSC_VER < 1300
-inline size_t strnlen(const char *str, size_t maxlen) { return strnlen_t(str, maxlen); }
-inline size_t wcsnlen(const wchar_t *str, size_t maxlen) { return strnlen_t(str, maxlen); }
+inline size_t strnlen(const char* str, size_t maxlen) { return strnlen_t(str, maxlen); }
+inline size_t wcsnlen(const wchar_t* str, size_t maxlen) { return strnlen_t(str, maxlen); }
 #endif
 
 // Templated strlcpy. Prefer using this over strncpy.
 // Copies src into dst until dstsize minus one. Always null terminates.
 // Returns the length of src, excluding the null terminator.
-template<typename T> size_t strlcpy_t(T *dst, const T *src, size_t dstsize)
+template<typename T> size_t strlcpy_t(T* dst, const T* src, size_t dstsize)
 {
 	const size_t srclen = strlen_t(src);
 	if (dstsize != 0)
@@ -107,7 +107,7 @@ template<typename T> size_t strlcpy_t(T *dst, const T *src, size_t dstsize)
 // Templated strlcat. Prefer using this over strncpy.
 // Appends src into dst until dstsize minus one. Always null terminates.
 // Returns the length of dst + src, excluding the null terminator.
-template<typename T> size_t strlcat_t(T *dst, const T *src, size_t dstsize)
+template<typename T> size_t strlcat_t(T* dst, const T* src, size_t dstsize)
 {
 	const size_t dstlen = strnlen_t(dst, dstsize);
 	const size_t srclen = strlen_t(src);
@@ -129,18 +129,18 @@ template<typename T> size_t strlcat_t(T *dst, const T *src, size_t dstsize)
 }
 
 #ifndef HAVE_STRLCPY
-inline size_t strlcpy(char *dst, const char *src, size_t dstsize) { return strlcpy_t(dst, src, dstsize); }
+inline size_t strlcpy(char* dst, const char* src, size_t dstsize) { return strlcpy_t(dst, src, dstsize); }
 #endif
 #ifndef HAVE_STRLCAT
-inline size_t strlcat(char *dst, const char *src, size_t dstsize) { return strlcat_t(dst, src, dstsize); }
+inline size_t strlcat(char* dst, const char* src, size_t dstsize) { return strlcat_t(dst, src, dstsize); }
 #endif
-inline size_t wcslcpy(wchar_t *dst, const wchar_t *src, size_t dstsize) { return strlcpy_t(dst, src, dstsize); }
-inline size_t wcslcat(wchar_t *dst, const wchar_t *src, size_t dstsize) { return strlcat_t(dst, src, dstsize); }
+inline size_t wcslcpy(wchar_t* dst, const wchar_t* src, size_t dstsize) { return strlcpy_t(dst, src, dstsize); }
+inline size_t wcslcat(wchar_t* dst, const wchar_t* src, size_t dstsize) { return strlcat_t(dst, src, dstsize); }
 
 // Templated strlmove. Prefer using this over strlcpy if dst and src overlap.
 // Moves src into dst until dstsize minus one. Always null terminates.
 // Returns the length of src, excluding the null terminator.
-template<typename T> size_t strlmove_t(T *dst, const T *src, size_t dstsize)
+template<typename T> size_t strlmove_t(T* dst, const T* src, size_t dstsize)
 {
 	const size_t srclen = strlen_t(src);
 	if (dstsize > 0)
@@ -155,7 +155,7 @@ template<typename T> size_t strlmove_t(T *dst, const T *src, size_t dstsize)
 // Templated strlmcat. Prefer using this over strlcat if dst and src overlap.
 // Appends src into dst until dstsize minus one. Always null terminates.
 // Returns the length of dst + src, excluding the null terminator.
-template<typename T> size_t strlmcat_t(T *dst, const T *src, size_t dstsize)
+template<typename T> size_t strlmcat_t(T* dst, const T* src, size_t dstsize)
 {
 	const size_t dstlen = strnlen_t(dst, dstsize);
 	const size_t srclen = strlen_t(src);
@@ -176,58 +176,118 @@ template<typename T> size_t strlmcat_t(T *dst, const T *src, size_t dstsize)
 	return dstlen + srclen; // length tried to create
 }
 
-inline size_t strlmove(char *dst, const char *src, size_t dstsize) { return strlmove_t(dst, src, dstsize); }
-inline size_t strlmcat(char *dst, const char *src, size_t dstsize) { return strlmcat_t(dst, src, dstsize); }
-inline size_t wcslmove(wchar_t *dst, const wchar_t *src, size_t dstsize) { return strlmove_t(dst, src, dstsize); }
-inline size_t wcslmcat(wchar_t *dst, const wchar_t *src, size_t dstsize) { return strlmcat_t(dst, src, dstsize); }
+inline size_t strlmove(char* dst, const char* src, size_t dstsize) { return strlmove_t(dst, src, dstsize); }
+inline size_t strlmcat(char* dst, const char* src, size_t dstsize) { return strlmcat_t(dst, src, dstsize); }
+inline size_t wcslmove(wchar_t* dst, const wchar_t* src, size_t dstsize) { return strlmove_t(dst, src, dstsize); }
+inline size_t wcslmcat(wchar_t* dst, const wchar_t* src, size_t dstsize) { return strlmcat_t(dst, src, dstsize); }
 
 #if !(defined(_MSC_VER) && _MSC_VER < 1300)
-template<size_t Size> size_t strlcpy_t(char (&dst)[Size], const char *src) { return strlcpy_t(dst, src, Size); }
-template<size_t Size> size_t strlcat_t(char (&dst)[Size], const char *src) { return strlcat_t(dst, src, Size); }
-template<size_t Size> size_t strlmove_t(char (&dst)[Size], const char *src) { return strlmove_t(dst, src, Size); }
-template<size_t Size> size_t strlmcat_t(char (&dst)[Size], const char *src) { return strlmcat_t(dst, src, Size); }
+template<size_t Size> size_t strlcpy_t(char(&dst)[Size], const char* src) { return strlcpy_t(dst, src, Size); }
+template<size_t Size> size_t strlcat_t(char(&dst)[Size], const char* src) { return strlcat_t(dst, src, Size); }
+template<size_t Size> size_t strlmove_t(char(&dst)[Size], const char* src) { return strlmove_t(dst, src, Size); }
+template<size_t Size> size_t strlmcat_t(char(&dst)[Size], const char* src) { return strlmcat_t(dst, src, Size); }
 #endif
 
-inline int compare_string(const char *a, const char *b, const size_t maxCount, const bool caseSensitive = true)
+inline bool startsWith(const char* str, const char* prefix)
 {
-	return caseSensitive ? strncmp(a, b, maxCount) : _strnicmp(a, b, maxCount);
+	if (*prefix == char(0))
+		return true;	// everything starts with the empty string
+
+	const size_t strlen = ::strlen(str);
+	const size_t prefixlen = ::strlen(prefix);
+	if (strlen < prefixlen)
+		return false;	// prefix must be as long or shorter than str
+
+	return ::strncmp(str, prefix, prefixlen) == 0;
 }
 
-inline int compare_string(const wchar_t *a, const wchar_t *b, const size_t maxCount, const bool caseSensitive = true)
+inline bool startsWith(const wchar_t* str, const wchar_t* prefix)
 {
-	return caseSensitive ? wcsncmp(a, b, maxCount) : _wcsnicmp(a, b, maxCount);
+	if (*prefix == wchar_t(0))
+		return true;	// everything starts with the empty string
+
+	const size_t strlen = ::wcslen(str);
+	const size_t prefixlen = ::wcslen(prefix);
+	if (strlen < prefixlen)
+		return false;	// prefix must be as long or shorter than str
+
+	return ::wcsncmp(str, prefix, prefixlen) == 0;
 }
 
-template<typename T> bool string_edge_equals(const T *str, const T *smaller, const bool endEdge, const bool case_sensitive = true)
+inline bool startsWithNoCase(const char* str, const char* prefix)
 {
-	if (*smaller == T(0))
-		return true;	// everything starts or ends with the empty string
+	if (*prefix == char(0))
+		return true;	// everything starts with the empty string
 
-	const size_t strlen = strlen_t(str);
-	const size_t smallen = strlen_t(smaller);
-	if (strlen < smallen)
-		return false;	// smaller must be smaller than str
+	const size_t strlen = ::strlen(str);
+	const size_t prefixlen = ::strlen(prefix);
+	if (strlen < prefixlen)
+		return false;	// prefix must be as long or shorter than str
 
-	const T* strStart = endEdge ? str + strlen - smallen : str;
+	return ::strnicmp(str, prefix, prefixlen) == 0;
+}
 
-	return compare_string(strStart, smaller, smallen, case_sensitive) == 0;
+inline bool startsWithNoCase(const wchar_t* str, const wchar_t* prefix)
+{
+	if (*prefix == wchar_t(0))
+		return true;	// everything starts with the empty string
+
+	const size_t strlen = ::wcslen(str);
+	const size_t prefixlen = ::wcslen(prefix);
+	if (strlen < prefixlen)
+		return false;	// prefix must be as long or shorter than str
+
+	return ::wcsnicmp(str, prefix, prefixlen) == 0;
 }
 
-template<typename T> bool startsWith(const T *str, const T *prefix)
+inline bool endsWith(const char* str, const char* suffix)
 {
-	return string_edge_equals(str, prefix, false);
-};
-template<typename T> bool startsWithNoCase(const T *str, const T *prefix)
+	if (*suffix == char(0))
+		return true;	// everything ends with the empty string
+
+	const size_t strlen = ::strlen(str);
+	const size_t suffixlen = ::strlen(suffix);
+	if (strlen < suffixlen)
+		return false;	// suffix must be as long or shorter than str
+
+	return ::strncmp(str + strlen - suffixlen, suffix, suffixlen) == 0;
+}
+
+inline bool endsWith(const wchar_t* str, const wchar_t* suffix)
 {
-	return string_edge_equals(str, prefix, false, false);
-};
+	if (*suffix == wchar_t(0))
+		return true;	// everything ends with the empty string
+
+	const size_t strlen = ::wcslen(str);
+	const size_t suffixlen = ::wcslen(suffix);
+	if (strlen < suffixlen)
+		return false;	// suffix must be as long or shorter than str
 
-template<typename T> bool endsWith(const T *str, const T *suffix)
+	return ::wcsncmp(str + strlen - suffixlen, suffix, suffixlen) == 0;
+}
+
+inline bool endsWithNoCase(const char* str, const char* suffix)
 {
-	return string_edge_equals(str, suffix, true);
-};
+	if (*suffix == char(0))
+		return true;	// everything ends with the empty string
+
+	const size_t strlen = ::strlen(str);
+	const size_t suffixlen = ::strlen(suffix);
+	if (strlen < suffixlen)
+		return false;	// suffix must be as long or shorter than str
 
-template<typename T> bool endsWithNoCase(const T *str, const T *suffix)
+	return ::strnicmp(str + strlen - suffixlen, suffix, suffixlen) == 0;
+}
+
+inline bool endsWithNoCase(const wchar_t* str, const wchar_t* suffix)
 {
-	return string_edge_equals(str, suffix, true, false);
-};
+	if (*suffix == wchar_t(0))
+		return true;	// everything ends with the empty string
+
+	const size_t strlen = ::wcslen(str);
+	const size_t suffixlen = ::wcslen(suffix);
+	if (strlen < suffixlen)
+		return false;	// suffix must be as long or shorter than str
+
+	return ::wcsnicmp(str + strlen - suffixlen, suffix, suffixlen) == 0;
+}