AAPT2: Remove usage of u16string
For legacy reasons, we kept around the use of UTF-16 internally
in AAPT2. We don't need this and this CL removes all instances of
std::u16string and StringPiece16. The only places still needed
are when interacting with the ResTable APIs that only operate in
UTF16.
Change-Id: I492475b84bb9014fa13bf992cff447ee7a5fe588
diff --git a/tools/aapt2/compile/Compile.cpp b/tools/aapt2/compile/Compile.cpp
index 5d11c40..39e4489 100644
--- a/tools/aapt2/compile/Compile.cpp
+++ b/tools/aapt2/compile/Compile.cpp
@@ -43,8 +43,8 @@
struct ResourcePathData {
Source source;
- std::u16string resourceDir;
- std::u16string name;
+ std::string resourceDir;
+ std::string name;
std::string extension;
// Original config str. We keep this because when we parse the config, we may add on
@@ -96,8 +96,8 @@
return ResourcePathData{
Source(path),
- util::utf8ToUtf16(dirStr),
- util::utf8ToUtf16(name),
+ dirStr.toString(),
+ name.toString(),
extension.toString(),
configStr.toString(),
config
@@ -127,7 +127,7 @@
}
static bool isHidden(const StringPiece& filename) {
- return util::stringStartsWith<char>(filename, ".");
+ return util::stringStartsWith(filename, ".");
}
/**
@@ -200,7 +200,7 @@
parserOptions.errorOnPositionalArguments = !options.legacyMode;
// If the filename includes donottranslate, then the default translatable is false.
- parserOptions.translatable = pathData.name.find(u"donottranslate") == std::string::npos;
+ parserOptions.translatable = pathData.name.find("donottranslate") == std::string::npos;
ResourceParser resParser(context->getDiagnostics(), &table, pathData.source,
pathData.config, parserOptions);
@@ -440,8 +440,8 @@
return nullptr;
}
- const std::u16string& getCompilationPackage() override {
- static std::u16string empty;
+ const std::string& getCompilationPackage() override {
+ static std::string empty;
return empty;
}
@@ -530,7 +530,7 @@
context.getDiagnostics()->note(DiagMessage(pathData.source) << "processing");
}
- if (pathData.resourceDir == u"values") {
+ if (pathData.resourceDir == "values") {
// Overwrite the extension.
pathData.extension = "arsc";
diff --git a/tools/aapt2/compile/IdAssigner.cpp b/tools/aapt2/compile/IdAssigner.cpp
index aa4a580..341c9b3 100644
--- a/tools/aapt2/compile/IdAssigner.cpp
+++ b/tools/aapt2/compile/IdAssigner.cpp
@@ -15,7 +15,6 @@
*/
#include "ResourceTable.h"
-
#include "compile/IdAssigner.h"
#include "process/IResourceTableConsumer.h"
#include "util/Util.h"
diff --git a/tools/aapt2/compile/IdAssigner_test.cpp b/tools/aapt2/compile/IdAssigner_test.cpp
index e25a17a..802e99a 100644
--- a/tools/aapt2/compile/IdAssigner_test.cpp
+++ b/tools/aapt2/compile/IdAssigner_test.cpp
@@ -27,10 +27,10 @@
TEST(IdAssignerTest, AssignIds) {
std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .addSimple(u"@android:attr/foo")
- .addSimple(u"@android:attr/bar")
- .addSimple(u"@android:id/foo")
- .setPackageId(u"android", 0x01)
+ .addSimple("@android:attr/foo")
+ .addSimple("@android:attr/bar")
+ .addSimple("@android:id/foo")
+ .setPackageId("android", 0x01)
.build();
std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
@@ -42,12 +42,12 @@
TEST(IdAssignerTest, AssignIdsWithReservedIds) {
std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .addSimple(u"@android:attr/foo", ResourceId(0x01040006))
- .addSimple(u"@android:attr/bar")
- .addSimple(u"@android:id/foo")
- .addSimple(u"@app:id/biz")
- .setPackageId(u"android", 0x01)
- .setPackageId(u"app", 0x7f)
+ .addSimple("@android:attr/foo", ResourceId(0x01040006))
+ .addSimple("@android:attr/bar")
+ .addSimple("@android:id/foo")
+ .addSimple("@app:id/biz")
+ .setPackageId("android", 0x01)
+ .setPackageId("app", 0x7f)
.build();
std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
@@ -59,10 +59,10 @@
TEST(IdAssignerTest, FailWhenNonUniqueIdsAssigned) {
std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .addSimple(u"@android:attr/foo", ResourceId(0x01040006))
- .addSimple(u"@android:attr/bar", ResourceId(0x01040006))
- .setPackageId(u"android", 0x01)
- .setPackageId(u"app", 0x7f)
+ .addSimple("@android:attr/foo", ResourceId(0x01040006))
+ .addSimple("@android:attr/bar", ResourceId(0x01040006))
+ .setPackageId("android", 0x01)
+ .setPackageId("app", 0x7f)
.build();
std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
diff --git a/tools/aapt2/compile/Png.cpp b/tools/aapt2/compile/Png.cpp
index bbf7f41..055d8b5 100644
--- a/tools/aapt2/compile/Png.cpp
+++ b/tools/aapt2/compile/Png.cpp
@@ -1234,7 +1234,7 @@
goto bail;
}
- if (util::stringEndsWith<char>(source.path, ".9.png")) {
+ if (util::stringEndsWith(source.path, ".9.png")) {
std::string errorMsg;
if (!do9Patch(&pngInfo, &errorMsg)) {
mDiag->error(DiagMessage() << errorMsg);
diff --git a/tools/aapt2/compile/PseudolocaleGenerator.cpp b/tools/aapt2/compile/PseudolocaleGenerator.cpp
index d080e16..732101f 100644
--- a/tools/aapt2/compile/PseudolocaleGenerator.cpp
+++ b/tools/aapt2/compile/PseudolocaleGenerator.cpp
@@ -29,7 +29,7 @@
StringPool* pool) {
Pseudolocalizer localizer(method);
- const StringPiece16 originalText = *string->value->str;
+ const StringPiece originalText = *string->value->str;
StyleString localized;
@@ -147,7 +147,7 @@
}
void visit(String* string) override {
- std::u16string result = mLocalizer.start() + mLocalizer.text(*string->value) +
+ std::string result = mLocalizer.start() + mLocalizer.text(*string->value) +
mLocalizer.end();
std::unique_ptr<String> localized = util::make_unique<String>(mPool->makeRef(result));
localized->setSource(string->getSource());
diff --git a/tools/aapt2/compile/PseudolocaleGenerator_test.cpp b/tools/aapt2/compile/PseudolocaleGenerator_test.cpp
index 4cb6ea2..1816abc 100644
--- a/tools/aapt2/compile/PseudolocaleGenerator_test.cpp
+++ b/tools/aapt2/compile/PseudolocaleGenerator_test.cpp
@@ -15,21 +15,18 @@
*/
#include "compile/PseudolocaleGenerator.h"
-#include "test/Builders.h"
-#include "test/Common.h"
-#include "test/Context.h"
+#include "test/Test.h"
#include "util/Util.h"
#include <androidfw/ResourceTypes.h>
-#include <gtest/gtest.h>
namespace aapt {
TEST(PseudolocaleGeneratorTest, PseudolocalizeStyledString) {
StringPool pool;
StyleString originalStyle;
- originalStyle.str = u"Hello world!";
- originalStyle.spans = { Span{ u"b", 2, 3 }, Span{ u"b", 6, 7 }, Span{ u"i", 1, 10 } };
+ originalStyle.str = "Hello world!";
+ originalStyle.spans = { Span{ "b", 2, 3 }, Span{ "b", 6, 7 }, Span{ "i", 1, 10 } };
std::unique_ptr<StyledString> newString = pseudolocalizeStyledString(
util::make_unique<StyledString>(pool.makeRef(originalStyle)).get(),
@@ -38,51 +35,51 @@
EXPECT_EQ(originalStyle.str, *newString->value->str);
ASSERT_EQ(originalStyle.spans.size(), newString->value->spans.size());
- EXPECT_EQ(2u, newString->value->spans[0].firstChar);
- EXPECT_EQ(3u, newString->value->spans[0].lastChar);
- EXPECT_EQ(std::u16string(u"b"), *newString->value->spans[0].name);
+ EXPECT_EQ(std::string("He").size(), newString->value->spans[0].firstChar);
+ EXPECT_EQ(std::string("Hel").size(), newString->value->spans[0].lastChar);
+ EXPECT_EQ(std::string("b"), *newString->value->spans[0].name);
- EXPECT_EQ(6u, newString->value->spans[1].firstChar);
- EXPECT_EQ(7u, newString->value->spans[1].lastChar);
- EXPECT_EQ(std::u16string(u"b"), *newString->value->spans[1].name);
+ EXPECT_EQ(std::string("Hello ").size(), newString->value->spans[1].firstChar);
+ EXPECT_EQ(std::string("Hello w").size(), newString->value->spans[1].lastChar);
+ EXPECT_EQ(std::string("b"), *newString->value->spans[1].name);
- EXPECT_EQ(1u, newString->value->spans[2].firstChar);
- EXPECT_EQ(10u, newString->value->spans[2].lastChar);
- EXPECT_EQ(std::u16string(u"i"), *newString->value->spans[2].name);
+ EXPECT_EQ(std::string("H").size(), newString->value->spans[2].firstChar);
+ EXPECT_EQ(std::string("Hello worl").size(), newString->value->spans[2].lastChar);
+ EXPECT_EQ(std::string("i"), *newString->value->spans[2].name);
- originalStyle.spans.push_back(Span{ u"em", 0, 11u });
+ originalStyle.spans.push_back(Span{ "em", 0, 11u });
newString = pseudolocalizeStyledString(
util::make_unique<StyledString>(pool.makeRef(originalStyle)).get(),
Pseudolocalizer::Method::kAccent, &pool);
- EXPECT_EQ(std::u16string(u"[Ĥéļļö ŵöŕļð¡ one two]"), *newString->value->str);
+ EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļð¡ one two]"), *newString->value->str);
ASSERT_EQ(originalStyle.spans.size(), newString->value->spans.size());
- EXPECT_EQ(3u, newString->value->spans[0].firstChar);
- EXPECT_EQ(4u, newString->value->spans[0].lastChar);
+ EXPECT_EQ(std::string("[Ĥé").size(), newString->value->spans[0].firstChar);
+ EXPECT_EQ(std::string("[Ĥéļ").size(), newString->value->spans[0].lastChar);
- EXPECT_EQ(7u, newString->value->spans[1].firstChar);
- EXPECT_EQ(8u, newString->value->spans[1].lastChar);
+ EXPECT_EQ(std::string("[Ĥéļļö ").size(), newString->value->spans[1].firstChar);
+ EXPECT_EQ(std::string("[Ĥéļļö ŵ").size(), newString->value->spans[1].lastChar);
- EXPECT_EQ(2u, newString->value->spans[2].firstChar);
- EXPECT_EQ(11u, newString->value->spans[2].lastChar);
+ EXPECT_EQ(std::string("[Ĥ").size(), newString->value->spans[2].firstChar);
+ EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļ").size(), newString->value->spans[2].lastChar);
- EXPECT_EQ(1u, newString->value->spans[3].firstChar);
- EXPECT_EQ(12u, newString->value->spans[3].lastChar);
+ EXPECT_EQ(std::string("[").size(), newString->value->spans[3].firstChar);
+ EXPECT_EQ(std::string("[Ĥéļļö ŵöŕļð").size(), newString->value->spans[3].lastChar);
}
TEST(PseudolocaleGeneratorTest, PseudolocalizeOnlyDefaultConfigs) {
std::unique_ptr<ResourceTable> table = test::ResourceTableBuilder()
- .addString(u"@android:string/one", u"one")
- .addString(u"@android:string/two", ResourceId{}, test::parseConfigOrDie("en"), u"two")
- .addString(u"@android:string/three", u"three")
- .addString(u"@android:string/three", ResourceId{}, test::parseConfigOrDie("en-rXA"),
- u"three")
- .addString(u"@android:string/four", u"four")
+ .addString("@android:string/one", "one")
+ .addString("@android:string/two", ResourceId{}, test::parseConfigOrDie("en"), "two")
+ .addString("@android:string/three", "three")
+ .addString("@android:string/three", ResourceId{}, test::parseConfigOrDie("en-rXA"),
+ "three")
+ .addString("@android:string/four", "four")
.build();
- String* val = test::getValue<String>(table.get(), u"@android:string/four");
+ String* val = test::getValue<String>(table.get(), "@android:string/four");
val->setTranslateable(false);
std::unique_ptr<IAaptContext> context = test::ContextBuilder().build();
@@ -90,31 +87,31 @@
ASSERT_TRUE(generator.consume(context.get(), table.get()));
// Normal pseudolocalization should take place.
- ASSERT_NE(nullptr, test::getValueForConfig<String>(table.get(), u"@android:string/one",
+ ASSERT_NE(nullptr, test::getValueForConfig<String>(table.get(), "@android:string/one",
test::parseConfigOrDie("en-rXA")));
- ASSERT_NE(nullptr, test::getValueForConfig<String>(table.get(), u"@android:string/one",
+ ASSERT_NE(nullptr, test::getValueForConfig<String>(table.get(), "@android:string/one",
test::parseConfigOrDie("ar-rXB")));
// No default config for android:string/two, so no pseudlocales should exist.
- ASSERT_EQ(nullptr, test::getValueForConfig<String>(table.get(), u"@android:string/two",
+ ASSERT_EQ(nullptr, test::getValueForConfig<String>(table.get(), "@android:string/two",
test::parseConfigOrDie("en-rXA")));
- ASSERT_EQ(nullptr, test::getValueForConfig<String>(table.get(), u"@android:string/two",
+ ASSERT_EQ(nullptr, test::getValueForConfig<String>(table.get(), "@android:string/two",
test::parseConfigOrDie("ar-rXB")));
// Check that we didn't override manual pseudolocalization.
- val = test::getValueForConfig<String>(table.get(), u"@android:string/three",
+ val = test::getValueForConfig<String>(table.get(), "@android:string/three",
test::parseConfigOrDie("en-rXA"));
ASSERT_NE(nullptr, val);
- EXPECT_EQ(std::u16string(u"three"), *val->value);
+ EXPECT_EQ(std::string("three"), *val->value);
- ASSERT_NE(nullptr, test::getValueForConfig<String>(table.get(), u"@android:string/three",
+ ASSERT_NE(nullptr, test::getValueForConfig<String>(table.get(), "@android:string/three",
test::parseConfigOrDie("ar-rXB")));
// Check that four's translateable marker was honored.
- ASSERT_EQ(nullptr, test::getValueForConfig<String>(table.get(), u"@android:string/four",
+ ASSERT_EQ(nullptr, test::getValueForConfig<String>(table.get(), "@android:string/four",
test::parseConfigOrDie("en-rXA")));
- ASSERT_EQ(nullptr, test::getValueForConfig<String>(table.get(), u"@android:string/four",
+ ASSERT_EQ(nullptr, test::getValueForConfig<String>(table.get(), "@android:string/four",
test::parseConfigOrDie("ar-rXB")));
}
diff --git a/tools/aapt2/compile/Pseudolocalizer.cpp b/tools/aapt2/compile/Pseudolocalizer.cpp
index 767d746..90d0d85 100644
--- a/tools/aapt2/compile/Pseudolocalizer.cpp
+++ b/tools/aapt2/compile/Pseudolocalizer.cpp
@@ -20,41 +20,41 @@
namespace aapt {
// String basis to generate expansion
-static const std::u16string k_expansion_string = u"one two three "
+static const std::string k_expansion_string = "one two three "
"four five six seven eight nine ten eleven twelve thirteen "
"fourteen fiveteen sixteen seventeen nineteen twenty";
// Special unicode characters to override directionality of the words
-static const std::u16string k_rlm = u"\u200f";
-static const std::u16string k_rlo = u"\u202e";
-static const std::u16string k_pdf = u"\u202c";
+static const std::string k_rlm = "\u200f";
+static const std::string k_rlo = "\u202e";
+static const std::string k_pdf = "\u202c";
// Placeholder marks
-static const std::u16string k_placeholder_open = u"\u00bb";
-static const std::u16string k_placeholder_close = u"\u00ab";
+static const std::string k_placeholder_open = "\u00bb";
+static const std::string k_placeholder_close = "\u00ab";
-static const char16_t k_arg_start = u'{';
-static const char16_t k_arg_end = u'}';
+static const char k_arg_start = '{';
+static const char k_arg_end = '}';
class PseudoMethodNone : public PseudoMethodImpl {
public:
- std::u16string text(const StringPiece16& text) override { return text.toString(); }
- std::u16string placeholder(const StringPiece16& text) override { return text.toString(); }
+ std::string text(const StringPiece& text) override { return text.toString(); }
+ std::string placeholder(const StringPiece& text) override { return text.toString(); }
};
class PseudoMethodBidi : public PseudoMethodImpl {
public:
- std::u16string text(const StringPiece16& text) override;
- std::u16string placeholder(const StringPiece16& text) override;
+ std::string text(const StringPiece& text) override;
+ std::string placeholder(const StringPiece& text) override;
};
class PseudoMethodAccent : public PseudoMethodImpl {
public:
PseudoMethodAccent() : mDepth(0), mWordCount(0), mLength(0) {}
- std::u16string start() override;
- std::u16string end() override;
- std::u16string text(const StringPiece16& text) override;
- std::u16string placeholder(const StringPiece16& text) override;
+ std::string start() override;
+ std::string end() override;
+ std::string text(const StringPiece& text) override;
+ std::string placeholder(const StringPiece& text) override;
private:
size_t mDepth;
size_t mWordCount;
@@ -79,12 +79,12 @@
}
}
-std::u16string Pseudolocalizer::text(const StringPiece16& text) {
- std::u16string out;
+std::string Pseudolocalizer::text(const StringPiece& text) {
+ std::string out;
size_t depth = mLastDepth;
size_t lastpos, pos;
const size_t length = text.size();
- const char16_t* str = text.data();
+ const char* str = text.data();
bool escaped = false;
for (lastpos = pos = 0; pos < length; pos++) {
char16_t c = str[pos];
@@ -111,7 +111,7 @@
}
size_t size = nextpos - lastpos;
if (size) {
- std::u16string chunk = text.substr(lastpos, size).toString();
+ std::string chunk = text.substr(lastpos, size).toString();
if (pseudo) {
chunk = mImpl->text(chunk);
} else if (str[lastpos] == k_arg_start && str[nextpos - 1] == k_arg_end) {
@@ -131,67 +131,67 @@
return out;
}
-static const char16_t* pseudolocalizeChar(const char16_t c) {
+static const char* pseudolocalizeChar(const char c) {
switch (c) {
- case 'a': return u"\u00e5";
- case 'b': return u"\u0253";
- case 'c': return u"\u00e7";
- case 'd': return u"\u00f0";
- case 'e': return u"\u00e9";
- case 'f': return u"\u0192";
- case 'g': return u"\u011d";
- case 'h': return u"\u0125";
- case 'i': return u"\u00ee";
- case 'j': return u"\u0135";
- case 'k': return u"\u0137";
- case 'l': return u"\u013c";
- case 'm': return u"\u1e3f";
- case 'n': return u"\u00f1";
- case 'o': return u"\u00f6";
- case 'p': return u"\u00fe";
- case 'q': return u"\u0051";
- case 'r': return u"\u0155";
- case 's': return u"\u0161";
- case 't': return u"\u0163";
- case 'u': return u"\u00fb";
- case 'v': return u"\u0056";
- case 'w': return u"\u0175";
- case 'x': return u"\u0445";
- case 'y': return u"\u00fd";
- case 'z': return u"\u017e";
- case 'A': return u"\u00c5";
- case 'B': return u"\u03b2";
- case 'C': return u"\u00c7";
- case 'D': return u"\u00d0";
- case 'E': return u"\u00c9";
- case 'G': return u"\u011c";
- case 'H': return u"\u0124";
- case 'I': return u"\u00ce";
- case 'J': return u"\u0134";
- case 'K': return u"\u0136";
- case 'L': return u"\u013b";
- case 'M': return u"\u1e3e";
- case 'N': return u"\u00d1";
- case 'O': return u"\u00d6";
- case 'P': return u"\u00de";
- case 'Q': return u"\u0071";
- case 'R': return u"\u0154";
- case 'S': return u"\u0160";
- case 'T': return u"\u0162";
- case 'U': return u"\u00db";
- case 'V': return u"\u03bd";
- case 'W': return u"\u0174";
- case 'X': return u"\u00d7";
- case 'Y': return u"\u00dd";
- case 'Z': return u"\u017d";
- case '!': return u"\u00a1";
- case '?': return u"\u00bf";
- case '$': return u"\u20ac";
- default: return NULL;
+ case 'a': return "\u00e5";
+ case 'b': return "\u0253";
+ case 'c': return "\u00e7";
+ case 'd': return "\u00f0";
+ case 'e': return "\u00e9";
+ case 'f': return "\u0192";
+ case 'g': return "\u011d";
+ case 'h': return "\u0125";
+ case 'i': return "\u00ee";
+ case 'j': return "\u0135";
+ case 'k': return "\u0137";
+ case 'l': return "\u013c";
+ case 'm': return "\u1e3f";
+ case 'n': return "\u00f1";
+ case 'o': return "\u00f6";
+ case 'p': return "\u00fe";
+ case 'q': return "\u0051";
+ case 'r': return "\u0155";
+ case 's': return "\u0161";
+ case 't': return "\u0163";
+ case 'u': return "\u00fb";
+ case 'v': return "\u0056";
+ case 'w': return "\u0175";
+ case 'x': return "\u0445";
+ case 'y': return "\u00fd";
+ case 'z': return "\u017e";
+ case 'A': return "\u00c5";
+ case 'B': return "\u03b2";
+ case 'C': return "\u00c7";
+ case 'D': return "\u00d0";
+ case 'E': return "\u00c9";
+ case 'G': return "\u011c";
+ case 'H': return "\u0124";
+ case 'I': return "\u00ce";
+ case 'J': return "\u0134";
+ case 'K': return "\u0136";
+ case 'L': return "\u013b";
+ case 'M': return "\u1e3e";
+ case 'N': return "\u00d1";
+ case 'O': return "\u00d6";
+ case 'P': return "\u00de";
+ case 'Q': return "\u0071";
+ case 'R': return "\u0154";
+ case 'S': return "\u0160";
+ case 'T': return "\u0162";
+ case 'U': return "\u00db";
+ case 'V': return "\u03bd";
+ case 'W': return "\u0174";
+ case 'X': return "\u00d7";
+ case 'Y': return "\u00dd";
+ case 'Z': return "\u017d";
+ case '!': return "\u00a1";
+ case '?': return "\u00bf";
+ case '$': return "\u20ac";
+ default: return nullptr;
}
}
-static bool isPossibleNormalPlaceholderEnd(const char16_t c) {
+static bool isPossibleNormalPlaceholderEnd(const char c) {
switch (c) {
case 's': return true;
case 'S': return true;
@@ -218,11 +218,11 @@
}
}
-static std::u16string pseudoGenerateExpansion(const unsigned int length) {
- std::u16string result = k_expansion_string;
- const char16_t* s = result.data();
+static std::string pseudoGenerateExpansion(const unsigned int length) {
+ std::string result = k_expansion_string;
+ const char* s = result.data();
if (result.size() < length) {
- result += u" ";
+ result += " ";
result += pseudoGenerateExpansion(length - result.size());
} else {
int ext = 0;
@@ -238,26 +238,26 @@
return result;
}
-std::u16string PseudoMethodAccent::start() {
- std::u16string result;
+std::string PseudoMethodAccent::start() {
+ std::string result;
if (mDepth == 0) {
- result = u"[";
+ result = "[";
}
mWordCount = mLength = 0;
mDepth++;
return result;
}
-std::u16string PseudoMethodAccent::end() {
- std::u16string result;
+std::string PseudoMethodAccent::end() {
+ std::string result;
if (mLength) {
- result += u" ";
+ result += " ";
result += pseudoGenerateExpansion(mWordCount > 3 ? mLength : mLength / 2);
}
mWordCount = mLength = 0;
mDepth--;
if (mDepth == 0) {
- result += u"]";
+ result += "]";
}
return result;
}
@@ -267,17 +267,17 @@
*
* Note: This leaves placeholder syntax untouched.
*/
-std::u16string PseudoMethodAccent::text(const StringPiece16& source)
+std::string PseudoMethodAccent::text(const StringPiece& source)
{
- const char16_t* s = source.data();
- std::u16string result;
+ const char* s = source.data();
+ std::string result;
const size_t I = source.size();
bool lastspace = true;
for (size_t i = 0; i < I; i++) {
- char16_t c = s[i];
+ char c = s[i];
if (c == '%') {
// Placeholder syntax, no need to pseudolocalize
- std::u16string chunk;
+ std::string chunk;
bool end = false;
chunk.append(&c, 1);
while (!end && i + 1 < I) {
@@ -300,7 +300,7 @@
bool tag_closed = false;
while (!tag_closed && i < I) {
if (c == '&') {
- std::u16string escapeText;
+ std::string escapeText;
escapeText.append(&c, 1);
bool end = false;
size_t htmlCodePos = i;
@@ -322,7 +322,7 @@
}
}
result += escapeText;
- if (escapeText != u"<") {
+ if (escapeText != "<") {
tag_closed = true;
}
continue;
@@ -338,11 +338,11 @@
}
} else {
// This is a pure text that should be pseudolocalized
- const char16_t* p = pseudolocalizeChar(c);
+ const char* p = pseudolocalizeChar(c);
if (p != nullptr) {
result += p;
} else {
- bool space = util::isspace16(c);
+ bool space = isspace(c);
if (lastspace && !space) {
mWordCount++;
}
@@ -356,19 +356,19 @@
return result;
}
-std::u16string PseudoMethodAccent::placeholder(const StringPiece16& source) {
+std::string PseudoMethodAccent::placeholder(const StringPiece& source) {
// Surround a placeholder with brackets
return k_placeholder_open + source.toString() + k_placeholder_close;
}
-std::u16string PseudoMethodBidi::text(const StringPiece16& source) {
- const char16_t* s = source.data();
- std::u16string result;
+std::string PseudoMethodBidi::text(const StringPiece& source) {
+ const char* s = source.data();
+ std::string result;
bool lastspace = true;
bool space = true;
for (size_t i = 0; i < source.size(); i++) {
- char16_t c = s[i];
- space = util::isspace16(c);
+ char c = s[i];
+ space = isspace(c);
if (lastspace && !space) {
// Word start
result += k_rlm + k_rlo;
@@ -386,7 +386,7 @@
return result;
}
-std::u16string PseudoMethodBidi::placeholder(const StringPiece16& source) {
+std::string PseudoMethodBidi::placeholder(const StringPiece& source) {
// Surround a placeholder with directionality change sequence
return k_rlm + k_rlo + source.toString() + k_pdf + k_rlm;
}
diff --git a/tools/aapt2/compile/Pseudolocalizer.h b/tools/aapt2/compile/Pseudolocalizer.h
index 8818c17..7db88de 100644
--- a/tools/aapt2/compile/Pseudolocalizer.h
+++ b/tools/aapt2/compile/Pseudolocalizer.h
@@ -29,10 +29,10 @@
class PseudoMethodImpl {
public:
virtual ~PseudoMethodImpl() {}
- virtual std::u16string start() { return {}; }
- virtual std::u16string end() { return {}; }
- virtual std::u16string text(const StringPiece16& text) = 0;
- virtual std::u16string placeholder(const StringPiece16& text) = 0;
+ virtual std::string start() { return {}; }
+ virtual std::string end() { return {}; }
+ virtual std::string text(const StringPiece& text) = 0;
+ virtual std::string placeholder(const StringPiece& text) = 0;
};
class Pseudolocalizer {
@@ -45,9 +45,9 @@
Pseudolocalizer(Method method);
void setMethod(Method method);
- std::u16string start() { return mImpl->start(); }
- std::u16string end() { return mImpl->end(); }
- std::u16string text(const StringPiece16& text);
+ std::string start() { return mImpl->start(); }
+ std::string end() { return mImpl->end(); }
+ std::string text(const StringPiece& text);
private:
std::unique_ptr<PseudoMethodImpl> mImpl;
size_t mLastDepth;
diff --git a/tools/aapt2/compile/Pseudolocalizer_test.cpp b/tools/aapt2/compile/Pseudolocalizer_test.cpp
index 36c8896..c33e152 100644
--- a/tools/aapt2/compile/Pseudolocalizer_test.cpp
+++ b/tools/aapt2/compile/Pseudolocalizer_test.cpp
@@ -28,9 +28,8 @@
static ::testing::AssertionResult simpleHelper(const char* input, const char* expected,
Pseudolocalizer::Method method) {
Pseudolocalizer pseudo(method);
- std::string result = util::utf16ToUtf8(
- pseudo.start() + pseudo.text(util::utf8ToUtf16(input)) + pseudo.end());
- if (StringPiece(expected) != result) {
+ std::string result = pseudo.start() + pseudo.text(input) + pseudo.end();
+ if (result != expected) {
return ::testing::AssertionFailure() << expected << " != " << result;
}
return ::testing::AssertionSuccess();
@@ -40,12 +39,9 @@
const char* expected,
Pseudolocalizer::Method method) {
Pseudolocalizer pseudo(method);
- std::string result = util::utf16ToUtf8(pseudo.start() +
- pseudo.text(util::utf8ToUtf16(in1)) +
- pseudo.text(util::utf8ToUtf16(in2)) +
- pseudo.text(util::utf8ToUtf16(in3)) +
- pseudo.end());
- if (StringPiece(expected) != result) {
+ std::string result = pseudo.start() + pseudo.text(in1) + pseudo.text(in2) + pseudo.text(in3) +
+ pseudo.end();
+ if (result != expected) {
return ::testing::AssertionFailure() << expected << " != " << result;
}
return ::testing::AssertionSuccess();
@@ -218,10 +214,10 @@
TEST(PseudolocalizerTest, RedefineMethod) {
Pseudolocalizer pseudo(Pseudolocalizer::Method::kAccent);
- std::u16string result = pseudo.text(u"Hello, ");
+ std::string result = pseudo.text("Hello, ");
pseudo.setMethod(Pseudolocalizer::Method::kNone);
- result += pseudo.text(u"world!");
- ASSERT_EQ(StringPiece("Ĥéļļö, world!"), util::utf16ToUtf8(result));
+ result += pseudo.text("world!");
+ ASSERT_EQ(StringPiece("Ĥéļļö, world!"), result);
}
} // namespace aapt
diff --git a/tools/aapt2/compile/XmlIdCollector_test.cpp b/tools/aapt2/compile/XmlIdCollector_test.cpp
index a37ea86..ea1ced3 100644
--- a/tools/aapt2/compile/XmlIdCollector_test.cpp
+++ b/tools/aapt2/compile/XmlIdCollector_test.cpp
@@ -38,13 +38,13 @@
ASSERT_TRUE(collector.consume(context.get(), doc.get()));
EXPECT_EQ(1, std::count(doc->file.exportedSymbols.begin(), doc->file.exportedSymbols.end(),
- SourcedResourceName{ test::parseNameOrDie(u"@id/foo"), 3u }));
+ SourcedResourceName{ test::parseNameOrDie("@id/foo"), 3u }));
EXPECT_EQ(1, std::count(doc->file.exportedSymbols.begin(), doc->file.exportedSymbols.end(),
- SourcedResourceName{ test::parseNameOrDie(u"@id/bar"), 3u }));
+ SourcedResourceName{ test::parseNameOrDie("@id/bar"), 3u }));
EXPECT_EQ(1, std::count(doc->file.exportedSymbols.begin(), doc->file.exportedSymbols.end(),
- SourcedResourceName{ test::parseNameOrDie(u"@id/car"), 6u }));
+ SourcedResourceName{ test::parseNameOrDie("@id/car"), 6u }));
}
TEST(XmlIdCollectorTest, DontCollectNonIds) {