1 files changed, 68 insertions, 66 deletions

diff --git a/tools/aapt2/Locale.cpp b/tools/aapt2/Locale.cpp
index a0f764175e24..78f56c7a5b93 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 @@ ssize_t LocaleValue::initFromParts(std::vector<std::string>::iterator iter,
       // 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 @@ ssize_t LocaleValue::initFromParts(std::vector<std::string>::iterator iter,
     ++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::initFromResTable(const ResTable_config& config) {
   }
 }
 
-void LocaleValue::writeTo(ResTable_config* out) const {
+void LocaleValue::WriteTo(ResTable_config* out) const {
   out->packLanguage(language);
   out->packRegion(region);