Skip to content

Commit 52635f2

Browse files
abhina-sreeabhina-sree
committed
rename CharSetConverter to EncodingConverter
1 parent 6d40922 commit 52635f2

File tree

3 files changed

+66
-65
lines changed

3 files changed

+66
-65
lines changed

‎llvm/include/llvm/Support/CharSet.h‎

Lines changed: 18 additions & 17 deletions
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ namespace llvm {
2828
template <typename T> class SmallVectorImpl;
2929

3030
namespace details {
31-
class CharSetConverterImplBase {
31+
class EncodingConverterImplBase {
3232

3333
private:
3434
/// Converts a string.
@@ -57,7 +57,7 @@ class CharSetConverterImplBase {
5757
virtual void reset() = 0;
5858

5959
public:
60-
virtual ~CharSetConverterImplBase() = default;
60+
virtual ~EncodingConverterImplBase() = default;
6161

6262
/// Converts a string and resets the converter to the initial state.
6363
std::error_code convert(StringRef Source, SmallVectorImpl<char> &Result) {
@@ -78,43 +78,44 @@ enum class TextEncoding {
7878
};
7979

8080
/// Utility class to convert between different character set encodings.
81-
class CharSetConverter {
82-
std::unique_ptr<details::CharSetConverterImplBase> Converter;
81+
class EncodingConverter {
82+
std::unique_ptr<details::EncodingConverterImplBase> Converter;
8383

84-
CharSetConverter(std::unique_ptr<details::CharSetConverterImplBase> Converter)
84+
EncodingConverter(
85+
std::unique_ptr<details::EncodingConverterImplBase> Converter)
8586
: Converter(std::move(Converter)) {}
8687

8788
public:
88-
/// Creates a CharSetConverter instance.
89+
/// Creates a EncodingConverter instance.
8990
/// Returns std::errc::invalid_argument in case the requested conversion is
9091
/// not supported.
9192
/// \param[in] CSFrom the source character encoding
9293
/// \param[in] CSTo the target character encoding
93-
/// \return a CharSetConverter instance or an error code
94-
static ErrorOr<CharSetConverter> create(TextEncoding CSFrom,
95-
TextEncoding CSTo);
94+
/// \return a EncodingConverter instance or an error code
95+
static ErrorOr<EncodingConverter> create(TextEncoding CSFrom,
96+
TextEncoding CSTo);
9697

97-
/// Creates a CharSetConverter instance.
98+
/// Creates a EncodingConverter instance.
9899
/// Returns std::errc::invalid_argument in case the requested conversion is
99100
/// not supported.
100101
/// \param[in] CPFrom name of the source character encoding
101102
/// \param[in] CPTo name of the target character encoding
102-
/// \return a CharSetConverter instance or an error code
103-
static ErrorOr<CharSetConverter> create(StringRef CPFrom, StringRef CPTo);
103+
/// \return a EncodingConverter instance or an error code
104+
static ErrorOr<EncodingConverter> create(StringRef CPFrom, StringRef CPTo);
104105

105-
CharSetConverter(const CharSetConverter &) = delete;
106-
CharSetConverter &operator=(const CharSetConverter &) = delete;
106+
EncodingConverter(const EncodingConverter &) = delete;
107+
EncodingConverter &operator=(const EncodingConverter &) = delete;
107108

108-
CharSetConverter(CharSetConverter &&Other)
109+
EncodingConverter(EncodingConverter &&Other)
109110
: Converter(std::move(Other.Converter)) {}
110111

111-
CharSetConverter &operator=(CharSetConverter &&Other) {
112+
EncodingConverter &operator=(EncodingConverter &&Other) {
112113
if (this != &Other)
113114
Converter = std::move(Other.Converter);
114115
return *this;
115116
}
116117

117-
~CharSetConverter() = default;
118+
~EncodingConverter() = default;
118119

119120
/// Converts a string.
120121
/// \param[in] Source source string

‎llvm/lib/Support/CharSet.cpp‎

Lines changed: 32 additions & 32 deletions
Original file line numberDiff line numberDiff line change
@@ -47,7 +47,7 @@ static void normalizeCharSetName(StringRef CSName,
4747
}
4848

4949
// Maps the charset name to enum constant if possible.
50-
static std::optional<TextEncoding> getKnownCharSet(StringRef CSName) {
50+
static std::optional<TextEncoding> getKnownEncoding(StringRef CSName) {
5151
SmallString<16> Normalized;
5252
normalizeCharSetName(CSName, Normalized);
5353
if (Normalized.equals("utf8"))
@@ -83,11 +83,11 @@ enum ConversionType {
8383
// aforementioned character sets. The use of tables for conversion is only
8484
// possible because EBCDIC 1047 is a single-byte, stateless encoding; other
8585
// character sets are not supported.
86-
class CharSetConverterTable : public details::CharSetConverterImplBase {
86+
class EncodingConverterTable : public details::EncodingConverterImplBase {
8787
const ConversionType ConvType;
8888

8989
public:
90-
CharSetConverterTable(ConversionType ConvType) : ConvType(ConvType) {}
90+
EncodingConverterTable(ConversionType ConvType) : ConvType(ConvType) {}
9191

9292
std::error_code convertString(StringRef Source,
9393
SmallVectorImpl<char> &Result) override;
@@ -96,8 +96,8 @@ class CharSetConverterTable : public details::CharSetConverterImplBase {
9696
};
9797

9898
std::error_code
99-
CharSetConverterTable::convertString(StringRef Source,
100-
SmallVectorImpl<char> &Result) {
99+
EncodingConverterTable::convertString(StringRef Source,
100+
SmallVectorImpl<char> &Result) {
101101
switch (ConvType) {
102102
case IBM1047ToUTF8:
103103
ConverterEBCDIC::convertToUTF8(Source, Result);
@@ -118,13 +118,13 @@ struct UConverterDeleter {
118118
};
119119
using UConverterUniquePtr = std::unique_ptr<UConverter, UConverterDeleter>;
120120

121-
class CharSetConverterICU : public details::CharSetConverterImplBase {
121+
class EncodingConverterICU : public details::EncodingConverterImplBase {
122122
UConverterUniquePtr FromConvDesc;
123123
UConverterUniquePtr ToConvDesc;
124124

125125
public:
126-
CharSetConverterICU(UConverterUniquePtr FromConverter,
127-
UConverterUniquePtr ToConverter)
126+
EncodingConverterICU(UConverterUniquePtr FromConverter,
127+
UConverterUniquePtr ToConverter)
128128
: FromConvDesc(std::move(FromConverter)),
129129
ToConvDesc(std::move(ToConverter)) {}
130130

@@ -139,8 +139,8 @@ class CharSetConverterICU : public details::CharSetConverterImplBase {
139139
// insufficient buffer size. In the future, it would better to save the partial
140140
// result and redo the conversion for the remaining string.
141141
std::error_code
142-
CharSetConverterICU::convertString(StringRef Source,
143-
SmallVectorImpl<char> &Result) {
142+
EncodingConverterICU::convertString(StringRef Source,
143+
SmallVectorImpl<char> &Result) {
144144
// Setup the input in case it has no backing data.
145145
size_t InputLength = Source.size();
146146
const char *In = InputLength ? const_cast<char *>(Source.data()) : "";
@@ -185,13 +185,13 @@ CharSetConverterICU::convertString(StringRef Source,
185185
return std::error_code();
186186
}
187187

188-
void CharSetConverterICU::reset() {
188+
void EncodingConverterICU::reset() {
189189
ucnv_reset(&*FromConvDesc);
190190
ucnv_reset(&*ToConvDesc);
191191
}
192192

193193
#elif HAVE_ICONV
194-
class CharSetConverterIconv : public details::CharSetConverterImplBase {
194+
class EncodingConverterIconv : public details::EncodingConverterImplBase {
195195
class UniqueIconvT {
196196
iconv_t ConvDesc;
197197

@@ -218,7 +218,7 @@ class CharSetConverterIconv : public details::CharSetConverterImplBase {
218218
UniqueIconvT ConvDesc;
219219

220220
public:
221-
CharSetConverterIconv(UniqueIconvT ConvDesc)
221+
EncodingConverterIconv(UniqueIconvT ConvDesc)
222222
: ConvDesc(std::move(ConvDesc)) {}
223223

224224
std::error_code convertString(StringRef Source,
@@ -232,8 +232,8 @@ class CharSetConverterIconv : public details::CharSetConverterImplBase {
232232
// insufficient buffer size. In the future, it would better to save the partial
233233
// result and redo the conversion for the remaining string.
234234
std::error_code
235-
CharSetConverterIconv::convertString(StringRef Source,
236-
SmallVectorImpl<char> &Result) {
235+
EncodingConverterIconv::convertString(StringRef Source,
236+
SmallVectorImpl<char> &Result) {
237237
// Setup the output. We directly write into the SmallVector.
238238
size_t Capacity = Result.capacity();
239239
char *Output = static_cast<char *>(Result.data());
@@ -291,38 +291,38 @@ CharSetConverterIconv::convertString(StringRef Source,
291291
return std::error_code();
292292
}
293293

294-
void CharSetConverterIconv::reset() {
294+
void EncodingConverterIconv::reset() {
295295
iconv(ConvDesc, nullptr, nullptr, nullptr, nullptr);
296296
}
297297

298298
#endif // HAVE_ICONV
299299
} // namespace
300300

301-
ErrorOr<CharSetConverter> CharSetConverter::create(TextEncoding CPFrom,
302-
TextEncoding CPTo) {
301+
ErrorOr<EncodingConverter> EncodingConverter::create(TextEncoding CPFrom,
302+
TextEncoding CPTo) {
303303

304304
// text encodings should be distinct
305-
if(CPFrom == CPTo)
305+
if (CPFrom == CPTo)
306306
return std::make_error_code(std::errc::invalid_argument);
307307

308308
ConversionType Conversion;
309309
if (CPFrom == TextEncoding::UTF8 && CPTo == TextEncoding::IBM1047)
310310
Conversion = UTF8ToIBM1047;
311-
else if (CPFrom == TextEncoding::IBM1047 &&
312-
CPTo == TextEncoding::UTF8)
311+
else if (CPFrom == TextEncoding::IBM1047 && CPTo == TextEncoding::UTF8)
313312
Conversion = IBM1047ToUTF8;
314313
else
315314
return std::error_code(errno, std::generic_category());
316315

317-
return CharSetConverter(std::make_unique<CharSetConverterTable>(Conversion));
316+
return EncodingConverter(
317+
std::make_unique<EncodingConverterTable>(Conversion));
318318
}
319319

320-
ErrorOr<CharSetConverter> CharSetConverter::create(StringRef CSFrom,
321-
StringRef CSTo) {
322-
std::optional<TextEncoding> From = getKnownCharSet(CSFrom);
323-
std::optional<TextEncoding> To = getKnownCharSet(CSTo);
320+
ErrorOr<EncodingConverter> EncodingConverter::create(StringRef CSFrom,
321+
StringRef CSTo) {
322+
std::optional<TextEncoding> From = getKnownEncoding(CSFrom);
323+
std::optional<TextEncoding> To = getKnownEncoding(CSTo);
324324
if (From && To) {
325-
ErrorOr<CharSetConverter> Converter = create(*From, *To);
325+
ErrorOr<EncodingConverter> Converter = create(*From, *To);
326326
if (Converter)
327327
return Converter;
328328
}
@@ -336,15 +336,15 @@ ErrorOr<CharSetConverter> CharSetConverter::create(StringRef CSFrom,
336336
if (U_FAILURE(EC)) {
337337
return std::error_code(errno, std::generic_category());
338338
}
339-
std::unique_ptr<details::CharSetConverterImplBase> Converter =
340-
std::make_unique<CharSetConverterICU>(std::move(FromConvDesc),
341-
std::move(ToConvDesc));
342-
return CharSetConverter(std::move(Converter));
339+
std::unique_ptr<details::EncodingConverterImplBase> Converter =
340+
std::make_unique<EncodingConverterICU>(std::move(FromConvDesc),
341+
std::move(ToConvDesc));
342+
return EncodingConverter(std::move(Converter));
343343
#elif HAVE_ICONV
344344
iconv_t ConvDesc = iconv_open(CSTo.str().c_str(), CSFrom.str().c_str());
345345
if (ConvDesc == (iconv_t)-1)
346346
return std::error_code(errno, std::generic_category());
347-
return CharSetConverter(std::make_unique<CharSetConverterIconv>(ConvDesc));
347+
return EncodingConverter(std::make_unique<EncodingConverterIconv>(ConvDesc));
348348
#else
349349
return std::make_error_code(std::errc::invalid_argument);
350350
#endif

‎llvm/unittests/Support/CharSetTest.cpp‎

Lines changed: 16 additions & 16 deletions
Original file line numberDiff line numberDiff line change
@@ -58,8 +58,8 @@ TEST(CharSet, FromUTF8) {
5858
StringRef Src(HelloA);
5959
SmallString<64> Dst;
6060

61-
ErrorOr<CharSetConverter> Conv = CharSetConverter::create(
62-
TextEncoding::UTF8, TextEncoding::IBM1047);
61+
ErrorOr<EncodingConverter> Conv =
62+
EncodingConverter::create(TextEncoding::UTF8, TextEncoding::IBM1047);
6363

6464
// Stop test if conversion is not supported.
6565
if (!Conv) {
@@ -98,8 +98,8 @@ TEST(CharSet, ToUTF8) {
9898
StringRef Src(HelloE);
9999
SmallString<64> Dst;
100100

101-
ErrorOr<CharSetConverter> Conv = CharSetConverter::create(
102-
TextEncoding::IBM1047, TextEncoding::UTF8);
101+
ErrorOr<EncodingConverter> Conv =
102+
EncodingConverter::create(TextEncoding::IBM1047, TextEncoding::UTF8);
103103

104104
// Stop test if conversion is not supported.
105105
if (!Conv) {
@@ -129,24 +129,24 @@ TEST(CharSet, ToUTF8) {
129129
}
130130

131131
TEST(CharSet, RoundTrip) {
132-
ErrorOr<CharSetConverter> ConvToUTF16 =
133-
CharSetConverter::create("IBM-1047", "UTF-16");
132+
ErrorOr<EncodingConverter> ConvToUTF16 =
133+
EncodingConverter::create("IBM-1047", "UTF-16");
134134
// Stop test if conversion is not supported (no underlying iconv support).
135135
if (!ConvToUTF16) {
136136
ASSERT_EQ(ConvToUTF16.getError(),
137137
std::make_error_code(std::errc::invalid_argument));
138138
return;
139139
}
140-
ErrorOr<CharSetConverter> ConvToUTF32 =
141-
CharSetConverter::create("UTF-16", "UTF-32");
140+
ErrorOr<EncodingConverter> ConvToUTF32 =
141+
EncodingConverter::create("UTF-16", "UTF-32");
142142
// Stop test if conversion is not supported (no underlying iconv support).
143143
if (!ConvToUTF32) {
144144
ASSERT_EQ(ConvToUTF32.getError(),
145145
std::make_error_code(std::errc::invalid_argument));
146146
return;
147147
}
148-
ErrorOr<CharSetConverter> ConvToEBCDIC =
149-
CharSetConverter::create("UTF-32", "IBM-1047");
148+
ErrorOr<EncodingConverter> ConvToEBCDIC =
149+
EncodingConverter::create("UTF-32", "IBM-1047");
150150
// Stop test if conversion is not supported (no underlying iconv support).
151151
if (!ConvToEBCDIC) {
152152
ASSERT_EQ(ConvToEBCDIC.getError(),
@@ -175,8 +175,8 @@ TEST(CharSet, ShiftState2022) {
175175
StringRef Src(EarthUTF);
176176
SmallString<8> Dst;
177177

178-
ErrorOr<CharSetConverter> ConvTo2022 =
179-
CharSetConverter::create("UTF-8", "ISO-2022-JP");
178+
ErrorOr<EncodingConverter> ConvTo2022 =
179+
EncodingConverter::create("UTF-8", "ISO-2022-JP");
180180
// Stop test if conversion is not supported (no underlying iconv support).
181181
if (!ConvTo2022) {
182182
ASSERT_EQ(ConvTo2022.getError(),
@@ -195,8 +195,8 @@ TEST(CharSet, ShiftState2022Partial) {
195195
StringRef Src(EarthUTFExtraPartial);
196196
SmallString<8> Dst;
197197

198-
ErrorOr<CharSetConverter> ConvTo2022 =
199-
CharSetConverter::create("UTF-8", "ISO-2022-JP");
198+
ErrorOr<EncodingConverter> ConvTo2022 =
199+
EncodingConverter::create("UTF-8", "ISO-2022-JP");
200200
// Stop test if conversion is not supported (no underlying iconv support).
201201
if (!ConvTo2022) {
202202
ASSERT_EQ(ConvTo2022.getError(),
@@ -214,8 +214,8 @@ TEST(CharSet, ShiftStateIBM939) {
214214
StringRef Src(EarthUTF);
215215
SmallString<64> Dst;
216216

217-
ErrorOr<CharSetConverter> ConvToIBM939 =
218-
CharSetConverter::create("UTF-8", "IBM-939");
217+
ErrorOr<EncodingConverter> ConvToIBM939 =
218+
EncodingConverter::create("UTF-8", "IBM-939");
219219
// Stop test if conversion is not supported (no underlying iconv support).
220220
if (!ConvToIBM939) {
221221
ASSERT_EQ(ConvToIBM939.getError(),

0 commit comments

Comments
 (0)