From 9f9b24ae9bc0ae771454732868cdb136fe995e42 Mon Sep 17 00:00:00 2001
From: Neil <nyamatongwe@gmail.com>
Date: Mon, 5 Apr 2021 15:48:13 +1000
Subject: Change CaseConversion to an enum class.

---
 src/CaseConvert.cxx | 38 +++++++++++++++++++-------------------
 src/CaseConvert.h   | 16 ++++++++--------
 src/CaseFolder.cxx  |  2 +-
 3 files changed, 28 insertions(+), 28 deletions(-)

(limited to 'src')

diff --git a/src/CaseConvert.cxx b/src/CaseConvert.cxx
index 9d8c9c9f3..7be4e52ef 100644
--- a/src/CaseConvert.cxx
+++ b/src/CaseConvert.cxx
@@ -676,26 +676,26 @@ CaseConverter caseConvFold;
 CaseConverter caseConvUp;
 CaseConverter caseConvLow;
 
-void AddSymmetric(enum CaseConversion conversion, int lower,int upper) {
+void AddSymmetric(CaseConversion conversion, int lower,int upper) {
 	char lowerUTF8[UTF8MaxBytes+1];
 	UTF8FromUTF32Character(lower, lowerUTF8);
 	char upperUTF8[UTF8MaxBytes+1];
 	UTF8FromUTF32Character(upper, upperUTF8);
 
 	switch (conversion) {
-	case CaseConversionFold:
+	case CaseConversion::fold:
 		caseConvFold.Add(upper, lowerUTF8);
 		break;
-	case CaseConversionUpper:
+	case CaseConversion::upper:
 		caseConvUp.Add(lower, upperUTF8);
 		break;
-	case CaseConversionLower:
+	case CaseConversion::lower:
 		caseConvLow.Add(upper, lowerUTF8);
 		break;
 	}
 }
 
-void SetupConversions(enum CaseConversion conversion) {
+void SetupConversions(CaseConversion conversion) {
 	// First initialize for the symmetric ranges
 	for (size_t i=0; i<std::size(symmetricCaseConversionRanges);) {
 		const int lower = symmetricCaseConversionRanges[i++];
@@ -752,39 +752,39 @@ void SetupConversions(enum CaseConversion conversion) {
 
 		const int character = UnicodeFromUTF8(originUTF8);
 
-		if (conversion == CaseConversionFold && foldedUTF8[0]) {
+		if (conversion == CaseConversion::fold && foldedUTF8[0]) {
 			caseConvFold.Add(character, foldedUTF8);
 		}
 
-		if (conversion == CaseConversionUpper && upperUTF8[0]) {
+		if (conversion == CaseConversion::upper && upperUTF8[0]) {
 			caseConvUp.Add(character, upperUTF8);
 		}
 
-		if (conversion == CaseConversionLower && lowerUTF8[0]) {
+		if (conversion == CaseConversion::lower && lowerUTF8[0]) {
 			caseConvLow.Add(character, lowerUTF8);
 		}
 	}
 
 	switch (conversion) {
-	case CaseConversionFold:
+	case CaseConversion::fold:
 		caseConvFold.FinishedAdding();
 		break;
-	case CaseConversionUpper:
+	case CaseConversion::upper:
 		caseConvUp.FinishedAdding();
 		break;
-	case CaseConversionLower:
+	case CaseConversion::lower:
 		caseConvLow.FinishedAdding();
 		break;
 	}
 }
 
-CaseConverter *ConverterForConversion(enum CaseConversion conversion) noexcept {
+CaseConverter *ConverterForConversion(CaseConversion conversion) noexcept {
 	switch (conversion) {
-	case CaseConversionFold:
+	case CaseConversion::fold:
 		return &caseConvFold;
-	case CaseConversionUpper:
+	case CaseConversion::upper:
 		return &caseConvUp;
-	case CaseConversionLower:
+	case CaseConversion::lower:
 		return &caseConvLow;
 	}
 	return nullptr;
@@ -794,28 +794,28 @@ CaseConverter *ConverterForConversion(enum CaseConversion conversion) noexcept {
 
 namespace Scintilla {
 
-ICaseConverter *ConverterFor(enum CaseConversion conversion) {
+ICaseConverter *ConverterFor(CaseConversion conversion) {
 	CaseConverter *pCaseConv = ConverterForConversion(conversion);
 	if (!pCaseConv->Initialised())
 		SetupConversions(conversion);
 	return pCaseConv;
 }
 
-const char *CaseConvert(int character, enum CaseConversion conversion) {
+const char *CaseConvert(int character, CaseConversion conversion) {
 	CaseConverter *pCaseConv = ConverterForConversion(conversion);
 	if (!pCaseConv->Initialised())
 		SetupConversions(conversion);
 	return pCaseConv->Find(character);
 }
 
-size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed, enum CaseConversion conversion) {
+size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed, CaseConversion conversion) {
 	CaseConverter *pCaseConv = ConverterForConversion(conversion);
 	if (!pCaseConv->Initialised())
 		SetupConversions(conversion);
 	return pCaseConv->CaseConvertString(converted, sizeConverted, mixed, lenMixed);
 }
 
-std::string CaseConvertString(const std::string &s, enum CaseConversion conversion) {
+std::string CaseConvertString(const std::string &s, CaseConversion conversion) {
 	std::string retMapped(s.length() * maxExpansionCaseConversion, 0);
 	const size_t lenMapped = CaseConvertString(&retMapped[0], retMapped.length(), s.c_str(), s.length(),
 		conversion);
diff --git a/src/CaseConvert.h b/src/CaseConvert.h
index e3057c841..c5f217d09 100644
--- a/src/CaseConvert.h
+++ b/src/CaseConvert.h
@@ -12,10 +12,10 @@
 
 namespace Scintilla {
 
-enum CaseConversion {
-	CaseConversionFold,
-	CaseConversionUpper,
-	CaseConversionLower
+enum class CaseConversion {
+	fold,
+	upper,
+	lower
 };
 
 class ICaseConverter {
@@ -23,10 +23,10 @@ public:
 	virtual size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed) = 0;
 };
 
-ICaseConverter *ConverterFor(enum CaseConversion conversion);
+ICaseConverter *ConverterFor(CaseConversion conversion);
 
 // Returns a UTF-8 string. Empty when no conversion
-const char *CaseConvert(int character, enum CaseConversion conversion);
+const char *CaseConvert(int character, CaseConversion conversion);
 
 // When performing CaseConvertString, the converted value may be up to 3 times longer than the input.
 // Ligatures are often decomposed into multiple characters and long cases include:
@@ -36,10 +36,10 @@ constexpr size_t maxExpansionCaseConversion = 3;
 // Converts a mixed case string using a particular conversion.
 // Result may be a different length to input and the length is the return value.
 // If there is not enough space then 0 is returned.
-size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed, enum CaseConversion conversion);
+size_t CaseConvertString(char *converted, size_t sizeConverted, const char *mixed, size_t lenMixed, CaseConversion conversion);
 
 // Converts a mixed case string using a particular conversion.
-std::string CaseConvertString(const std::string &s, enum CaseConversion conversion);
+std::string CaseConvertString(const std::string &s, CaseConversion conversion);
 
 }
 
diff --git a/src/CaseFolder.cxx b/src/CaseFolder.cxx
index bce593a98..d093829ba 100644
--- a/src/CaseFolder.cxx
+++ b/src/CaseFolder.cxx
@@ -53,7 +53,7 @@ void CaseFolderTable::StandardASCII() noexcept {
 
 CaseFolderUnicode::CaseFolderUnicode() {
 	StandardASCII();
-	converter = ConverterFor(CaseConversionFold);
+	converter = ConverterFor(CaseConversion::fold);
 }
 
 size_t CaseFolderUnicode::Fold(char *folded, size_t sizeFolded, const char *mixed, size_t lenMixed) {
-- 
cgit v1.2.3