feat(string): Merge startWith/endsWith implementations

Author: slurmlord

Core/GameEngine/Include/Common/UnicodeString.h

@@ -306,6 +306,30 @@ class UnicodeString
 	*/
 	int compareNoCase(const WideChar* s) const;
 
+	/**
+		return true iff self starts with the given string.
+	*/
+	Bool startsWith(const WideChar* p) const;
+	inline Bool startsWith(const UnicodeString& stringSrc) const { return startsWith(stringSrc.str()); }
+
+	/**
+		return true iff self starts with the given string. (case insensitive)
+	*/
+	Bool startsWithNoCase(const WideChar* p) const;
+	inline Bool startsWithNoCase(const UnicodeString& stringSrc) const { return startsWithNoCase(stringSrc.str()); }
+
+	/**
+		return true iff self ends with the given string.
+	*/
+	Bool endsWith(const WideChar* p) const;
+	Bool endsWith(const UnicodeString& stringSrc) const { return endsWith(stringSrc.str()); }
+
+	/**
+		return true iff self ends with the given string. (case insensitive)
+	*/
+	Bool endsWithNoCase(const WideChar* p) const;
+	Bool endsWithNoCase(const UnicodeString& stringSrc) const { return endsWithNoCase(stringSrc.str()); }
+
 	/**
 		conceptually similar to strtok():
 

Core/GameEngine/Source/Common/System/AsciiString.cpp

@@ -477,57 +477,25 @@ void AsciiString::format_va(const char* format, va_list args)
 // -----------------------------------------------------
 Bool AsciiString::startsWith(const char* p) const
 {
-	if (*p == 0)
-		return true;	// everything starts with the empty string
-
-	int lenThis = getLength();
-	int lenThat = strlen(p);
-	if (lenThis < lenThat)
-		return false;	// that must be smaller than this
-
-	return strncmp(peek(), p, lenThat) == 0;
+	return ::startsWith(peek(), p);
 }
 
 // -----------------------------------------------------
 Bool AsciiString::startsWithNoCase(const char* p) const
 {
-	if (*p == 0)
-		return true;	// everything starts with the empty string
-
-	int lenThis = getLength();
-	int lenThat = strlen(p);
-	if (lenThis < lenThat)
-		return false;	// that must be smaller than this
-
-	return strnicmp(peek(), p, lenThat) == 0;
+	return ::startsWithNoCase(peek(), p);
 }
 
 // -----------------------------------------------------
 Bool AsciiString::endsWith(const char* p) const
 {
-	if (*p == 0)
-		return true;	// everything ends with the empty string
-
-	int lenThis = getLength();
-	int lenThat = strlen(p);
-	if (lenThis < lenThat)
-		return false;	// that must be smaller than this
-
-	return strncmp(peek() + lenThis - lenThat, p, lenThat) == 0;
+	return ::endsWith(peek(), p);
 }
 
 // -----------------------------------------------------
 Bool AsciiString::endsWithNoCase(const char* p) const
 {
-	if (*p == 0)
-		return true;	// everything ends with the empty string
-
-	int lenThis = getLength();
-	int lenThat = strlen(p);
-	if (lenThis < lenThat)
-		return false;	// that must be smaller than this
-
-	return strnicmp(peek() + lenThis - lenThat, p, lenThat) == 0;
+	return ::endsWithNoCase(peek(), p);
 }
 
 //-----------------------------------------------------------------------------

Core/GameEngine/Source/Common/System/UnicodeString.cpp

@@ -406,6 +406,30 @@ void UnicodeString::format_va(const WideChar* format, va_list args)
 	}
 }
 
+// -----------------------------------------------------
+Bool UnicodeString::startsWith(const WideChar* p) const
+{
+	return ::startsWith(peek(), p);
+}
+
+// -----------------------------------------------------
+Bool UnicodeString::startsWithNoCase(const WideChar* p) const
+{
+	return ::startsWithNoCase(peek(), p);
+}
+
+// -----------------------------------------------------
+Bool UnicodeString::endsWith(const WideChar* p) const
+{
+	return ::endsWith(peek(), p);
+}
+
+// -----------------------------------------------------
+Bool UnicodeString::endsWithNoCase(const WideChar* p) const
+{
+	return ::endsWithNoCase(peek(), p);
+}
+
 //-----------------------------------------------------------------------------
 Bool UnicodeString::nextToken(UnicodeString* tok, UnicodeString delimiters)
 {

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

@@ -55,6 +55,11 @@ 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);
+
 
 // Implementation
 
@@ -182,3 +187,47 @@ template<size_t Size> size_t strlcat_t(char (&dst)[Size], const char *src) { ret
 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)
+{
+	return caseSensitive ? strncmp(a, b, maxCount) : _strnicmp(a, b, maxCount);
+}
+
+inline int compare_string(const wchar_t *a, const wchar_t *b, const size_t maxCount, const bool caseSensitive = true)
+{
+	return caseSensitive ? wcsncmp(a, b, maxCount) : _wcsnicmp(a, b, maxCount);
+}
+
+template<typename T> bool string_edge_equals(const T *str, const T *smaller, const bool endEdge, const bool case_sensitive = true)
+{
+	if (*smaller == T(0))
+		return true;	// everything starts or ends 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 T* strStart = endEdge ? str + strlen - smallen : str;
+
+	return compare_string(strStart, smaller, smallen, case_sensitive) == 0;
+}
+
+template<typename T> bool startsWith(const T *str, const T *prefix)
+{
+	return string_edge_equals(str, prefix, false);
+};
+template<typename T> bool startsWithNoCase(const T *str, const T *prefix)
+{
+	return string_edge_equals(str, prefix, false, false);
+};
+
+template<typename T> bool endsWith(const T *str, const T *suffix)
+{
+	return string_edge_equals(str, suffix, true);
+};
+
+template<typename T> bool endsWithNoCase(const T *str, const T *suffix)
+{
+	return string_edge_equals(str, suffix, true, false);
+};