WINTERMUTE: Rename FuncName->funcName in PathUtil and StringUtil

5 files changed, 89 insertions, 89 deletions

diff --git a/engines/wintermute/utils/PathUtil.cpp b/engines/wintermute/utils/PathUtil.cpp
index f975ea6199..cc1f2f3d44 100644
--- a/engines/wintermute/utils/PathUtil.cpp
+++ b/engines/wintermute/utils/PathUtil.cpp
@@ -34,7 +34,7 @@
 namespace WinterMute {

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::UnifySeparators(const AnsiString &path) {

+AnsiString PathUtil::unifySeparators(const AnsiString &path) {

 	AnsiString newPath = path;

 

 	AnsiString::iterator it;

@@ -45,37 +45,37 @@ AnsiString PathUtil::UnifySeparators(const AnsiString &path) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::NormalizeFileName(const AnsiString &path) {

-	AnsiString newPath = UnifySeparators(path);

-	StringUtil::ToLowerCase(newPath);

+AnsiString PathUtil::normalizeFileName(const AnsiString &path) {

+	AnsiString newPath = unifySeparators(path);

+	StringUtil::toLowerCase(newPath);

 	return newPath;

 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::Combine(const AnsiString &path1, const AnsiString &path2) {

-	AnsiString newPath1 = UnifySeparators(path1);

-	AnsiString newPath2 = UnifySeparators(path2);

+AnsiString PathUtil::combine(const AnsiString &path1, const AnsiString &path2) {

+	AnsiString newPath1 = unifySeparators(path1);

+	AnsiString newPath2 = unifySeparators(path2);

 

-	if (!StringUtil::EndsWith(newPath1, "/", true) && !StringUtil::StartsWith(newPath2, "/", true))

+	if (!StringUtil::endsWith(newPath1, "/", true) && !StringUtil::startsWith(newPath2, "/", true))

 		newPath1 += "/";

 

 	return newPath1 + newPath2;

 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::GetDirectoryName(const AnsiString &path) {

-	AnsiString newPath = UnifySeparators(path);

+AnsiString PathUtil::getDirectoryName(const AnsiString &path) {

+	AnsiString newPath = unifySeparators(path);

 

 	//size_t pos = newPath.find_last_of(L'/');

-	Common::String filename = GetFileName(path);

+	Common::String filename = getFileName(path);

 	return Common::String(path.c_str(), path.size() - filename.size());

 	//if (pos == AnsiString::npos) return "";

 	//else return newPath.substr(0, pos + 1);

 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::GetFileName(const AnsiString &path) {

-	AnsiString newPath = UnifySeparators(path);

+AnsiString PathUtil::getFileName(const AnsiString &path) {

+	AnsiString newPath = unifySeparators(path);

 

 	//size_t pos = newPath.find_last_of(L'/'); TODO REMOVE.

 	Common::String lastPart = Common::lastPathComponent(path, '/');

@@ -88,8 +88,8 @@ AnsiString PathUtil::GetFileName(const AnsiString &path) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::GetFileNameWithoutExtension(const AnsiString &path) {

-	AnsiString fileName = GetFileName(path);

+AnsiString PathUtil::getFileNameWithoutExtension(const AnsiString &path) {

+	AnsiString fileName = getFileName(path);

 

 	//size_t pos = fileName.find_last_of('.'); //TODO REMOVE!

 	// TODO: Prettify this.

@@ -101,8 +101,8 @@ AnsiString PathUtil::GetFileNameWithoutExtension(const AnsiString &path) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::GetExtension(const AnsiString &path) {

-	AnsiString fileName = GetFileName(path);

+AnsiString PathUtil::getExtension(const AnsiString &path) {

+	AnsiString fileName = getFileName(path);

 

 	//size_t pos = fileName.find_last_of('.');

 	return Common::lastPathComponent(path, '.');

@@ -112,8 +112,8 @@ AnsiString PathUtil::GetExtension(const AnsiString &path) {
 

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::GetSafeLogFileName() {

-	AnsiString logFileName = GetUserDirectory();

+AnsiString PathUtil::getSafeLogFileName() {

+	AnsiString logFileName = getUserDirectory();

 

 #ifdef __WIN32__

 	char moduleName[MAX_PATH];

@@ -125,25 +125,25 @@ AnsiString PathUtil::GetSafeLogFileName() {
 

 #else

 	// !PORTME

-	logFileName = Combine(logFileName, "/Wintermute Engine/wme.log");

+	logFileName = combine(logFileName, "/Wintermute Engine/wme.log");

 #endif

 

-	CreateDirectory(GetDirectoryName(logFileName));

+	createDirectory(getDirectoryName(logFileName));

 	return logFileName;

 }

 

 //////////////////////////////////////////////////////////////////////////

-bool PathUtil::CreateDirectory(const AnsiString &path) {

+bool PathUtil::createDirectory(const AnsiString &path) {

 	return false;

 }

 

 //////////////////////////////////////////////////////////////////////////

-bool PathUtil::MatchesMask(const AnsiString &fileName, const AnsiString &mask) {

+bool PathUtil::matchesMask(const AnsiString &fileName, const AnsiString &mask) {

 	return false;

 }

 

 //////////////////////////////////////////////////////////////////////////

-bool PathUtil::FileExists(const AnsiString &fileName) {

+bool PathUtil::fileExists(const AnsiString &fileName) {

 	warning("PathUtil::FileExists(%s)", fileName.c_str());

 

 	Common::File stream;

@@ -157,7 +157,7 @@ bool PathUtil::FileExists(const AnsiString &fileName) {
 

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString PathUtil::GetUserDirectory() {

+AnsiString PathUtil::getUserDirectory() {

 	warning("PathUtil::GetUserDirectory - stubbed");

 	AnsiString userDir = "./";

 #if 0

diff --git a/engines/wintermute/utils/PathUtil.h b/engines/wintermute/utils/PathUtil.h
index 0bc883a1fa..13e9e46652 100644
--- a/engines/wintermute/utils/PathUtil.h
+++ b/engines/wintermute/utils/PathUtil.h
@@ -35,20 +35,20 @@ namespace WinterMute {
 

 class PathUtil {

 public:

-	static AnsiString UnifySeparators(const AnsiString &path);

-	static AnsiString NormalizeFileName(const AnsiString &path);

-	static AnsiString Combine(const AnsiString &path1, const AnsiString &path2);

-	static AnsiString GetDirectoryName(const AnsiString &path);

-	static AnsiString GetFileName(const AnsiString &path);

-	static AnsiString GetFileNameWithoutExtension(const AnsiString &path);

-	static AnsiString GetExtension(const AnsiString &path);

-	static bool CreateDirectory(const AnsiString &path);

-	static bool MatchesMask(const AnsiString &fileName, const AnsiString &mask);

-

-	static bool FileExists(const AnsiString &fileName);

-

-	static AnsiString GetSafeLogFileName();

-	static AnsiString GetUserDirectory();

+	static AnsiString unifySeparators(const AnsiString &path);

+	static AnsiString normalizeFileName(const AnsiString &path);

+	static AnsiString combine(const AnsiString &path1, const AnsiString &path2);

+	static AnsiString getDirectoryName(const AnsiString &path);

+	static AnsiString getFileName(const AnsiString &path);

+	static AnsiString getFileNameWithoutExtension(const AnsiString &path);

+	static AnsiString getExtension(const AnsiString &path);

+	static bool createDirectory(const AnsiString &path);

+	static bool matchesMask(const AnsiString &fileName, const AnsiString &mask);

+

+	static bool fileExists(const AnsiString &fileName);

+

+	static AnsiString getSafeLogFileName();

+	static AnsiString getUserDirectory();

 };

 

 } // end of namespace WinterMute

diff --git a/engines/wintermute/utils/StringUtil.cpp b/engines/wintermute/utils/StringUtil.cpp
index 2ca392973b..53ad4c8add 100644
--- a/engines/wintermute/utils/StringUtil.cpp
+++ b/engines/wintermute/utils/StringUtil.cpp
@@ -34,32 +34,32 @@
 namespace WinterMute {

 

 //////////////////////////////////////////////////////////////////////////

-void StringUtil::ToLowerCase(AnsiString &str) {

+void StringUtil::toLowerCase(AnsiString &str) {

 	str.toLowercase();

 }

 

 //////////////////////////////////////////////////////////////////////////

-/*void StringUtil::ToLowerCase(WideString &str) {

+/*void StringUtil::toLowerCase(WideString &str) {

     std::transform(str.begin(), str.end(), str.begin(), ::towlower);

 }*/

 

 //////////////////////////////////////////////////////////////////////////

-void StringUtil::ToUpperCase(AnsiString &str) {

+void StringUtil::toUpperCase(AnsiString &str) {

 	str.toUppercase();

 }

 

 //////////////////////////////////////////////////////////////////////////

-/*void StringUtil::ToUpperCase(WideString &str) {

+/*void StringUtil::toUpperCase(WideString &str) {

     std::transform(str.begin(), str.end(), str.begin(), ::towupper);

 }*/

 

 //////////////////////////////////////////////////////////////////////////

-bool StringUtil::CompareNoCase(const AnsiString &str1, const AnsiString &str2) {

+bool StringUtil::compareNoCase(const AnsiString &str1, const AnsiString &str2) {

 	AnsiString str1lc = str1;

 	AnsiString str2lc = str2;

 

-	ToLowerCase(str1lc);

-	ToLowerCase(str2lc);

+	toLowerCase(str1lc);

+	toLowerCase(str2lc);

 

 	return (str1lc == str2lc);

 }

@@ -76,7 +76,7 @@ bool StringUtil::CompareNoCase(const AnsiString &str1, const AnsiString &str2) {
 }*/

 

 //////////////////////////////////////////////////////////////////////////

-WideString StringUtil::Utf8ToWide(const Utf8String &Utf8Str) {

+WideString StringUtil::utf8ToWide(const Utf8String &Utf8Str) {

 	error("StringUtil::Utf8ToWide - WideString not supported yet");

 	/*  size_t WideSize = Utf8Str.size();

 

@@ -125,8 +125,8 @@ WideString StringUtil::Utf8ToWide(const Utf8String &Utf8Str) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-Utf8String StringUtil::WideToUtf8(const WideString &WideStr) {

-	error("StringUtil::WideToUtf8 - Widestring not supported yet");

+Utf8String StringUtil::wideToUtf8(const WideString &WideStr) {

+	error("StringUtil::wideToUtf8 - Widestring not supported yet");

 	/*  size_t WideSize = WideStr.length();

 

 	    if (sizeof(wchar_t) == 2) {

@@ -187,7 +187,7 @@ char simpleAnsiToWide(const AnsiString &str, uint32 &offset) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-WideString StringUtil::AnsiToWide(const AnsiString &str) {

+WideString StringUtil::ansiToWide(const AnsiString &str) {

 	// TODO: This function gets called a lot, so warnings like these drown out the usefull information

 	static bool hasWarned = false;

 	if (!hasWarned) {

@@ -212,7 +212,7 @@ WideString StringUtil::AnsiToWide(const AnsiString &str) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString StringUtil::WideToAnsi(const WideString &wstr) {

+AnsiString StringUtil::wideToAnsi(const WideString &wstr) {

 	// using default os locale!

 	// TODO: This function gets called a lot, so warnings like these drown out the usefull information

 	static bool hasWarned = false;

@@ -231,7 +231,7 @@ AnsiString StringUtil::WideToAnsi(const WideString &wstr) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool StringUtil::StartsWith(const AnsiString &str, const AnsiString &pattern, bool ignoreCase) {

+bool StringUtil::startsWith(const AnsiString &str, const AnsiString &pattern, bool ignoreCase) {

 	/*  size_t strLength = str.size();

 	    size_t patternLength = pattern.size();

 

@@ -258,7 +258,7 @@ bool StringUtil::StartsWith(const AnsiString &str, const AnsiString &pattern, bo
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool StringUtil::EndsWith(const AnsiString &str, const AnsiString &pattern, bool ignoreCase) {

+bool StringUtil::endsWith(const AnsiString &str, const AnsiString &pattern, bool ignoreCase) {

 	/*  size_t strLength = str.size(); // TODO: Remove

 	    size_t patternLength = pattern.size();

 

@@ -285,13 +285,13 @@ bool StringUtil::EndsWith(const AnsiString &str, const AnsiString &pattern, bool
 }

 

 //////////////////////////////////////////////////////////////////////////

-bool StringUtil::IsUtf8BOM(const byte *Buffer, uint32 BufferSize) {

+bool StringUtil::isUtf8BOM(const byte *Buffer, uint32 BufferSize) {

 	if (BufferSize > 3 && Buffer[0] == 0xEF && Buffer[1] == 0xBB && Buffer[2] == 0xBF) return true;

 	else return false;

 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString StringUtil::Replace(const AnsiString &str, const AnsiString &from, const AnsiString &to) {

+AnsiString StringUtil::replace(const AnsiString &str, const AnsiString &from, const AnsiString &to) {

 	if (from.empty() || from == to) return str;

 

 	AnsiString result = str;

@@ -317,7 +317,7 @@ AnsiString StringUtil::Replace(const AnsiString &str, const AnsiString &from, co
 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString StringUtil::Trim(const AnsiString &str, bool fromLeft, bool fromRight, const AnsiString &chars) {

+AnsiString StringUtil::trim(const AnsiString &str, bool fromLeft, bool fromRight, const AnsiString &chars) {

 	AnsiString trimmedStr = str;

 

 	if (fromRight) {

@@ -325,7 +325,7 @@ AnsiString StringUtil::Trim(const AnsiString &str, bool fromLeft, bool fromRight
 		warning("fromRight-trim not implemented yet, %s", chars.c_str());

 	}

 	if (fromLeft) {

-		uint32 lastOf = LastIndexOf(str, chars, 0);

+		uint32 lastOf = lastIndexOf(str, chars, 0);

 		trimmedStr = Common::String(trimmedStr.c_str() + lastOf);

 		//trimmedStr.erase(0, trimmedStr.find_first_not_of(chars));

 	}

@@ -333,7 +333,7 @@ AnsiString StringUtil::Trim(const AnsiString &str, bool fromLeft, bool fromRight
 }

 

 //////////////////////////////////////////////////////////////////////////

-int StringUtil::IndexOf(const WideString &str, const WideString &toFind, size_t startFrom) {

+int StringUtil::indexOf(const WideString &str, const WideString &toFind, size_t startFrom) {

 	/*size_t pos = str.find(toFind, startFrom);

 	if (pos == str.npos) return -1;

 	else return pos;*/

@@ -345,7 +345,7 @@ int StringUtil::IndexOf(const WideString &str, const WideString &toFind, size_t
 }

 

 //////////////////////////////////////////////////////////////////////////

-int StringUtil::LastIndexOf(const WideString &str, const WideString &toFind, size_t startFrom) {

+int StringUtil::lastIndexOf(const WideString &str, const WideString &toFind, size_t startFrom) {

 	/*size_t pos = str.rfind(toFind, startFrom);

 	if (pos == str.npos) return -1;

 	else return pos;*/

@@ -368,7 +368,7 @@ int StringUtil::LastIndexOf(const WideString &str, const WideString &toFind, siz
 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString StringUtil::ToString(size_t val) {

+AnsiString StringUtil::toString(size_t val) {

 	/*  std::ostringstream str;

 	    str << val;

 	    return str.str();*/

@@ -376,7 +376,7 @@ AnsiString StringUtil::ToString(size_t val) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString StringUtil::ToString(int val) {

+AnsiString StringUtil::toString(int val) {

 	/*  std::ostringstream str;

 	    str << val;

 	    return str.str();*/

@@ -384,7 +384,7 @@ AnsiString StringUtil::ToString(int val) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString StringUtil::ToString(float val) {

+AnsiString StringUtil::toString(float val) {

 	/*  std::ostringstream str;

 	    str << val;

 	    return str.str();*/

@@ -392,7 +392,7 @@ AnsiString StringUtil::ToString(float val) {
 }

 

 //////////////////////////////////////////////////////////////////////////

-AnsiString StringUtil::ToString(double val) {

+AnsiString StringUtil::toString(double val) {

 	/*  std::ostringstream str;

 	    str << val;

 	    return str.str();*/

@@ -401,7 +401,7 @@ AnsiString StringUtil::ToString(double val) {
 

 

 //////////////////////////////////////////////////////////////////////////

-void StringUtil::Split(const AnsiString &list, const AnsiString &delimiters, AnsiStringArray &result, bool keepEmptyItems) {

+void StringUtil::split(const AnsiString &list, const AnsiString &delimiters, AnsiStringArray &result, bool keepEmptyItems) {

 	result.clear();

 //TODO: Verify this, wrt keepEmptyItems.

 	Common::StringTokenizer tokenizer(list.c_str(), delimiters.c_str());

diff --git a/engines/wintermute/utils/StringUtil.h b/engines/wintermute/utils/StringUtil.h
index a4727fabbe..e06551b09a 100644
--- a/engines/wintermute/utils/StringUtil.h
+++ b/engines/wintermute/utils/StringUtil.h
@@ -35,34 +35,34 @@ namespace WinterMute {
 

 class StringUtil {

 public:

-	static void ToLowerCase(AnsiString &str);

-	//static void ToLowerCase(WideString &str);

-	static void ToUpperCase(AnsiString &str);

-	//static void ToUpperCase(WideString &str);

-	static bool CompareNoCase(const AnsiString &str1, const AnsiString &str2);

-	//static bool CompareNoCase(const WideString &str1, const WideString &str2);

-	static WideString Utf8ToWide(const Utf8String &Utf8Str);

-	static Utf8String WideToUtf8(const WideString &WideStr);

-	static WideString AnsiToWide(const AnsiString &str);

-	static AnsiString WideToAnsi(const WideString &str);

+	static void toLowerCase(AnsiString &str);

+	//static void toLowerCase(WideString &str);

+	static void toUpperCase(AnsiString &str);

+	//static void toUpperCase(WideString &str);

+	static bool compareNoCase(const AnsiString &str1, const AnsiString &str2);

+	//static bool compareNoCase(const WideString &str1, const WideString &str2);

+	static WideString utf8ToWide(const Utf8String &Utf8Str);

+	static Utf8String wideToUtf8(const WideString &WideStr);

+	static WideString ansiToWide(const AnsiString &str);

+	static AnsiString wideToAnsi(const WideString &str);

 

-	static bool StartsWith(const AnsiString &str, const AnsiString &pattern, bool ignoreCase = false);

-	static bool EndsWith(const AnsiString &str, const AnsiString &pattern, bool ignoreCase = false);

+	static bool startsWith(const AnsiString &str, const AnsiString &pattern, bool ignoreCase = false);

+	static bool endsWith(const AnsiString &str, const AnsiString &pattern, bool ignoreCase = false);

 

-	static bool IsUtf8BOM(const byte *buffer, uint32 bufferSize);

+	static bool isUtf8BOM(const byte *buffer, uint32 bufferSize);

 

-	static AnsiString Replace(const AnsiString &str, const AnsiString &from, const AnsiString &to);

-	static AnsiString Trim(const AnsiString &str, bool fromLeft = true, bool fromRight = true, const AnsiString &chars = " \n\r\t");

+	static AnsiString replace(const AnsiString &str, const AnsiString &from, const AnsiString &to);

+	static AnsiString trim(const AnsiString &str, bool fromLeft = true, bool fromRight = true, const AnsiString &chars = " \n\r\t");

 

-	static int IndexOf(const WideString &str, const WideString &toFind, size_t startFrom);

-	static int LastIndexOf(const WideString &str, const WideString &toFind, size_t startFrom);

+	static int indexOf(const WideString &str, const WideString &toFind, size_t startFrom);

+	static int lastIndexOf(const WideString &str, const WideString &toFind, size_t startFrom);

 

-	static AnsiString ToString(size_t val);

-	static AnsiString ToString(int val);

-	static AnsiString ToString(float val);

-	static AnsiString ToString(double val);

+	static AnsiString toString(size_t val);

+	static AnsiString toString(int val);

+	static AnsiString toString(float val);

+	static AnsiString toString(double val);

 

-	static void Split(const AnsiString &list, const AnsiString &delimiters, AnsiStringArray &result, bool keepEmptyItems = false);

+	static void split(const AnsiString &list, const AnsiString &delimiters, AnsiStringArray &result, bool keepEmptyItems = false);

 };

 

 } // end of namespace WinterMute

diff --git a/engines/wintermute/utils/utils.cpp b/engines/wintermute/utils/utils.cpp
index 2f66313bb0..ae456b25e7 100644
--- a/engines/wintermute/utils/utils.cpp
+++ b/engines/wintermute/utils/utils.cpp
@@ -101,7 +101,7 @@ float CBUtils::NormalizeAngle(float Angle) {
 void CBUtils::CreatePath(const char *Path, bool PathOnly) {

 	AnsiString path;

 

-	if (!PathOnly) path = PathUtil::GetDirectoryName(Path);

+	if (!PathOnly) path = PathUtil::getDirectoryName(Path);

 	else path = Path;

 

 //	try {

@@ -237,7 +237,7 @@ bool CBUtils::MatchesPattern(const char *Pattern, const char *String) {
 

 //////////////////////////////////////////////////////////////////////////

 char *CBUtils::GetPath(const char *Filename) {

-	AnsiString path = PathUtil::GetDirectoryName(Filename);

+	AnsiString path = PathUtil::getDirectoryName(Filename);

 	//path = boost::filesystem::syste_complete(path).string();

 	warning("CBUtils::GetPath: (%s), not implemented", Filename);

 	char *ret = new char[path.size() + 1];

@@ -248,7 +248,7 @@ char *CBUtils::GetPath(const char *Filename) {
 

 //////////////////////////////////////////////////////////////////////////

 char *CBUtils::GetFilename(const char *Filename) {

-	AnsiString path = PathUtil::GetFileName(Filename);

+	AnsiString path = PathUtil::getFileName(Filename);

 	char *ret = new char[path.size() + 1];

 	strcpy(ret, path.c_str());

 	return ret;