AAPT2: Rename to match new style
Use Google3 naming style to match new
projects' and open source google projects' style.
Preferred to do this in a massive CL so as to avoid
style inconsistencies that plague legacy code bases.
This is a relatively NEW code base, may as well keep
it up to date.
Test: name/style refactor - existing tests pass
Change-Id: Ie80ecb78d46ec53efdfca2336bb57d96cbb7fb87
diff --git a/tools/aapt2/Locale.cpp b/tools/aapt2/Locale.cpp
index a0f7641..78f56c7a 100644
--- a/tools/aapt2/Locale.cpp
+++ b/tools/aapt2/Locale.cpp
@@ -15,174 +15,176 @@
*/
#include "Locale.h"
-#include "util/Util.h"
#include <ctype.h>
+
#include <algorithm>
#include <string>
#include <vector>
+#include "util/Util.h"
+
namespace aapt {
using android::ResTable_config;
-void LocaleValue::setLanguage(const char* languageChars) {
+void LocaleValue::set_language(const char* language_chars) {
size_t i = 0;
- while ((*languageChars) != '\0') {
- language[i++] = ::tolower(*languageChars);
- languageChars++;
+ while ((*language_chars) != '\0') {
+ language[i++] = ::tolower(*language_chars);
+ language_chars++;
}
}
-void LocaleValue::setRegion(const char* regionChars) {
+void LocaleValue::set_region(const char* region_chars) {
size_t i = 0;
- while ((*regionChars) != '\0') {
- region[i++] = ::toupper(*regionChars);
- regionChars++;
+ while ((*region_chars) != '\0') {
+ region[i++] = ::toupper(*region_chars);
+ region_chars++;
}
}
-void LocaleValue::setScript(const char* scriptChars) {
+void LocaleValue::set_script(const char* script_chars) {
size_t i = 0;
- while ((*scriptChars) != '\0') {
+ while ((*script_chars) != '\0') {
if (i == 0) {
- script[i++] = ::toupper(*scriptChars);
+ script[i++] = ::toupper(*script_chars);
} else {
- script[i++] = ::tolower(*scriptChars);
+ script[i++] = ::tolower(*script_chars);
}
- scriptChars++;
+ script_chars++;
}
}
-void LocaleValue::setVariant(const char* variantChars) {
+void LocaleValue::set_variant(const char* variant_chars) {
size_t i = 0;
- while ((*variantChars) != '\0') {
- variant[i++] = *variantChars;
- variantChars++;
+ while ((*variant_chars) != '\0') {
+ variant[i++] = *variant_chars;
+ variant_chars++;
}
}
-static inline bool isAlpha(const std::string& str) {
+static inline bool is_alpha(const std::string& str) {
return std::all_of(std::begin(str), std::end(str), ::isalpha);
}
-static inline bool isNumber(const std::string& str) {
+static inline bool is_number(const std::string& str) {
return std::all_of(std::begin(str), std::end(str), ::isdigit);
}
-bool LocaleValue::initFromFilterString(const StringPiece& str) {
+bool LocaleValue::InitFromFilterString(const StringPiece& str) {
// A locale (as specified in the filter) is an underscore separated name such
// as "en_US", "en_Latn_US", or "en_US_POSIX".
- std::vector<std::string> parts = util::splitAndLowercase(str, '_');
+ std::vector<std::string> parts = util::SplitAndLowercase(str, '_');
- const int numTags = parts.size();
+ const int num_tags = parts.size();
bool valid = false;
- if (numTags >= 1) {
+ if (num_tags >= 1) {
const std::string& lang = parts[0];
- if (isAlpha(lang) && (lang.length() == 2 || lang.length() == 3)) {
- setLanguage(lang.c_str());
+ if (is_alpha(lang) && (lang.length() == 2 || lang.length() == 3)) {
+ set_language(lang.c_str());
valid = true;
}
}
- if (!valid || numTags == 1) {
+ if (!valid || num_tags == 1) {
return valid;
}
// At this point, valid == true && numTags > 1.
const std::string& part2 = parts[1];
- if ((part2.length() == 2 && isAlpha(part2)) ||
- (part2.length() == 3 && isNumber(part2))) {
- setRegion(part2.c_str());
- } else if (part2.length() == 4 && isAlpha(part2)) {
- setScript(part2.c_str());
+ if ((part2.length() == 2 && is_alpha(part2)) ||
+ (part2.length() == 3 && is_number(part2))) {
+ set_region(part2.c_str());
+ } else if (part2.length() == 4 && is_alpha(part2)) {
+ set_script(part2.c_str());
} else if (part2.length() >= 4 && part2.length() <= 8) {
- setVariant(part2.c_str());
+ set_variant(part2.c_str());
} else {
valid = false;
}
- if (!valid || numTags == 2) {
+ if (!valid || num_tags == 2) {
return valid;
}
// At this point, valid == true && numTags > 1.
const std::string& part3 = parts[2];
- if (((part3.length() == 2 && isAlpha(part3)) ||
- (part3.length() == 3 && isNumber(part3))) &&
+ if (((part3.length() == 2 && is_alpha(part3)) ||
+ (part3.length() == 3 && is_number(part3))) &&
script[0]) {
- setRegion(part3.c_str());
+ set_region(part3.c_str());
} else if (part3.length() >= 4 && part3.length() <= 8) {
- setVariant(part3.c_str());
+ set_variant(part3.c_str());
} else {
valid = false;
}
- if (!valid || numTags == 3) {
+ if (!valid || num_tags == 3) {
return valid;
}
const std::string& part4 = parts[3];
if (part4.length() >= 4 && part4.length() <= 8) {
- setVariant(part4.c_str());
+ set_variant(part4.c_str());
} else {
valid = false;
}
- if (!valid || numTags > 4) {
+ if (!valid || num_tags > 4) {
return false;
}
return true;
}
-ssize_t LocaleValue::initFromParts(std::vector<std::string>::iterator iter,
+ssize_t LocaleValue::InitFromParts(std::vector<std::string>::iterator iter,
std::vector<std::string>::iterator end) {
- const std::vector<std::string>::iterator startIter = iter;
+ const std::vector<std::string>::iterator start_iter = iter;
std::string& part = *iter;
if (part[0] == 'b' && part[1] == '+') {
// This is a "modified" BCP 47 language tag. Same semantics as BCP 47 tags,
// except that the separator is "+" and not "-".
- std::vector<std::string> subtags = util::splitAndLowercase(part, '+');
+ std::vector<std::string> subtags = util::SplitAndLowercase(part, '+');
subtags.erase(subtags.begin());
if (subtags.size() == 1) {
- setLanguage(subtags[0].c_str());
+ set_language(subtags[0].c_str());
} else if (subtags.size() == 2) {
- setLanguage(subtags[0].c_str());
+ set_language(subtags[0].c_str());
// The second tag can either be a region, a variant or a script.
switch (subtags[1].size()) {
case 2:
case 3:
- setRegion(subtags[1].c_str());
+ set_region(subtags[1].c_str());
break;
case 4:
if ('0' <= subtags[1][0] && subtags[1][0] <= '9') {
// This is a variant: fall through
} else {
- setScript(subtags[1].c_str());
+ set_script(subtags[1].c_str());
break;
}
case 5:
case 6:
case 7:
case 8:
- setVariant(subtags[1].c_str());
+ set_variant(subtags[1].c_str());
break;
default:
return -1;
}
} else if (subtags.size() == 3) {
// The language is always the first subtag.
- setLanguage(subtags[0].c_str());
+ set_language(subtags[0].c_str());
// The second subtag can either be a script or a region code.
// If its size is 4, it's a script code, else it's a region code.
if (subtags[1].size() == 4) {
- setScript(subtags[1].c_str());
+ set_script(subtags[1].c_str());
} else if (subtags[1].size() == 2 || subtags[1].size() == 3) {
- setRegion(subtags[1].c_str());
+ set_region(subtags[1].c_str());
} else {
return -1;
}
@@ -190,15 +192,15 @@
// The third tag can either be a region code (if the second tag was
// a script), else a variant code.
if (subtags[2].size() >= 4) {
- setVariant(subtags[2].c_str());
+ set_variant(subtags[2].c_str());
} else {
- setRegion(subtags[2].c_str());
+ set_region(subtags[2].c_str());
}
} else if (subtags.size() == 4) {
- setLanguage(subtags[0].c_str());
- setScript(subtags[1].c_str());
- setRegion(subtags[2].c_str());
- setVariant(subtags[3].c_str());
+ set_language(subtags[0].c_str());
+ set_script(subtags[1].c_str());
+ set_region(subtags[2].c_str());
+ set_variant(subtags[3].c_str());
} else {
return -1;
}
@@ -206,25 +208,25 @@
++iter;
} else {
- if ((part.length() == 2 || part.length() == 3) && isAlpha(part) &&
+ if ((part.length() == 2 || part.length() == 3) && is_alpha(part) &&
part != "car") {
- setLanguage(part.c_str());
+ set_language(part.c_str());
++iter;
if (iter != end) {
- const std::string& regionPart = *iter;
- if (regionPart.c_str()[0] == 'r' && regionPart.length() == 3) {
- setRegion(regionPart.c_str() + 1);
+ const std::string& region_part = *iter;
+ if (region_part.c_str()[0] == 'r' && region_part.length() == 3) {
+ set_region(region_part.c_str() + 1);
++iter;
}
}
}
}
- return static_cast<ssize_t>(iter - startIter);
+ return static_cast<ssize_t>(iter - start_iter);
}
-void LocaleValue::initFromResTable(const ResTable_config& config) {
+void LocaleValue::InitFromResTable(const ResTable_config& config) {
config.unpackLanguage(language);
config.unpackRegion(region);
if (config.localeScript[0] && !config.localeScriptWasComputed) {
@@ -236,7 +238,7 @@
}
}
-void LocaleValue::writeTo(ResTable_config* out) const {
+void LocaleValue::WriteTo(ResTable_config* out) const {
out->packLanguage(language);
out->packRegion(region);