[rac] Parse postal code formats and required fields in libaddressinput.

third_party/libaddressinput/chromium/cpp/src/rule.cc

 // Copyright (C) 2013 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
 #include "rule.h"
 
 #include <libaddressinput/address_field.h>
 #include <libaddressinput/util/scoped_ptr.h>
 
-#include <map>
+#include <cassert>
+#include <cstddef>
 #include <string>
-#include <utility>
+#include <vector>
 
-#include "address_field_util.h"
 #include "grit.h"
 #include "messages.h"
 #include "util/json.h"
 #include "util/string_split.h"
 
 namespace i18n {
 namespace addressinput {
 
 namespace {
 
-typedef std::map<std::string, int> NameMessageIdMap;
+const char kCountryToken = 'R';
+const char kAdminAreaToken = 'S';
+const char kLocalityToken = 'C';
+const char kDependentLocalityToken = 'D';
+const char kSortingCodeToken = 'X';
+const char kPostalCodeToken = 'Z';
+const char kStreetAddressToken = 'A';
+const char kOrganizationToken = 'O';
+const char kRecipientToken = 'N';
 
-const char kAdminAreaNameTypeKey[] = "state_name_type";
-const char kFormatKey[] = "fmt";
-const char kLanguageKey[] = "lang";
-const char kLanguagesKey[] = "languages";
-const char kPostalCodeNameTypeKey[] = "zip_name_type";
-const char kSubKeysKey[] = "sub_keys";
-
-// Used as a separator in a list of items. For example, the list of supported
-// languages can be "de~fr~it".
-const char kSeparator = '~';
-
-NameMessageIdMap InitAdminAreaMessageIds() {
-  NameMessageIdMap message_ids;
-  message_ids.insert(std::make_pair(
-      "area", IDS_LIBADDRESSINPUT_I18N_AREA));
-  message_ids.insert(std::make_pair(
-      "county", IDS_LIBADDRESSINPUT_I18N_COUNTY_LABEL));
-  message_ids.insert(std::make_pair(
-      "department", IDS_LIBADDRESSINPUT_I18N_DEPARTMENT));
-  message_ids.insert(std::make_pair(
-      "district", IDS_LIBADDRESSINPUT_I18N_DEPENDENT_LOCALITY_LABEL));
-  message_ids.insert(std::make_pair(
-      "do_si", IDS_LIBADDRESSINPUT_I18N_DO_SI));
-  message_ids.insert(std::make_pair(
-      "emirate", IDS_LIBADDRESSINPUT_I18N_EMIRATE));
-  message_ids.insert(std::make_pair(
-      "island", IDS_LIBADDRESSINPUT_I18N_ISLAND));
-  message_ids.insert(std::make_pair(
-      "parish", IDS_LIBADDRESSINPUT_I18N_PARISH));
-  message_ids.insert(std::make_pair(
-      "prefecture", IDS_LIBADDRESSINPUT_I18N_PREFECTURE));
-  message_ids.insert(std::make_pair(
-      "province", IDS_LIBADDRESSINPUT_I18N_PROVINCE));
-  message_ids.insert(std::make_pair(
-      "state", IDS_LIBADDRESSINPUT_I18N_STATE_LABEL));
-  return message_ids;
+bool IsToken(char c) {
+  return c == kCountryToken ||
+      c == kAdminAreaToken ||
+      c == kLocalityToken ||
+      c == kDependentLocalityToken ||
+      c == kSortingCodeToken ||
+      c == kPostalCodeToken ||
+      c == kStreetAddressToken ||
+      c == kOrganizationToken ||
+      c == kRecipientToken;
 }
 
-const NameMessageIdMap& GetAdminAreaMessageIds() {
-  static const NameMessageIdMap kAdminAreaMessageIds(InitAdminAreaMessageIds());
-  return kAdminAreaMessageIds;
+AddressField ParseToken(char c) {

[Evan Stade, 2013/12/20 03:55:13]

bool ParseToken(char c, AddressField* field) {
...
}

[please use gerrit instead, 2013/12/20 22:03:32]

Nice! Done.

+  switch (c) {
+    case kCountryToken:
+      return COUNTRY;
+    case kAdminAreaToken:
+      return ADMIN_AREA;
+    case kLocalityToken:
+      return LOCALITY;
+    case kDependentLocalityToken:
+      return DEPENDENT_LOCALITY;
+    case kSortingCodeToken:
+      return SORTING_CODE;
+    case kPostalCodeToken:
+      return POSTAL_CODE;
+    case kStreetAddressToken:
+      return STREET_ADDRESS;
+    case kOrganizationToken:
+      return ORGANIZATION;
+    case kRecipientToken:
+      return RECIPIENT;
+    default:
+      assert(false);
+      return COUNTRY;
+  }
 }
 
-NameMessageIdMap InitPostalCodeMessageIds() {
-  NameMessageIdMap message_ids;
-  message_ids.insert(std::make_pair(
-      "postal", IDS_LIBADDRESSINPUT_I18N_POSTAL_CODE_LABEL));
-  message_ids.insert(std::make_pair(
-      "zip", IDS_LIBADDRESSINPUT_I18N_ZIP_CODE_LABEL));
-  return message_ids;
+// Clears |fields|, parses |format|, and adds the format address fields to
+// |fields|. For example, parses "%S%C%n%D%X" into {{ADMIN_AREA, LOCALITY},
+// {DEPENDENT_LOCALITY, SORTING_CODE}}.
+void ParseAddressFieldsFormat(const std::string& format,
+                              std::vector<std::vector<AddressField> >* fields) {
+  assert(fields != NULL);
+  fields->clear();
+  bool begin_newline = true;
+  for (std::string::const_iterator current = format.begin(),

[Evan Stade, 2013/12/20 03:55:13]

I dunno, this looks shorter and more idiomatic to me.

fields->clear();
fields->resize(1);
std::vector<string> exploded_string;
SplitString(string, '%', &exploded_string);
for (size_t i = 0; i < exploded_string.size(); i++) {
  AddressField field = COUNTRY;
  
  if (exploded_string[i] == "n") {
    fields->push_back(std::vector<AddressField>());
  } else if (ParseToken(exploded_string[i], &field) {
    fields->back().push_back(field);
  }
}

[please use gerrit instead, 2013/12/20 22:03:32]

I'll give you the idiomatic. Done.

This function is still not shorter if your take the corner cases into account
:-).

+                                   next = format.begin() + 1;
+       current != format.end() && next != format.end();
+       ++current, ++next) {
+    if (*current != '%') {

[please use gerrit instead, 2013/12/20 00:37:43]

Inlined IsTokenPrefix().

+      continue;
+    }
+    if (IsToken(*next)) {
+      if (begin_newline) {
+        fields->push_back(std::vector<AddressField>());
+        begin_newline = false;
+      }
+      fields->back().push_back(ParseToken(*next));
+    } else if (*next == 'n') {

[please use gerrit instead, 2013/12/20 00:37:43]

Inlined IsNewlineToken().

+      begin_newline = true;
+    }
+  }
 }
 
-const NameMessageIdMap& GetPostalCodeMessageIds() {
-  static const NameMessageIdMap kPostalCodeMessageIds(
-      InitPostalCodeMessageIds());
-  return kPostalCodeMessageIds;
+// Clears |fields|, parses |required|, and adds the required fields to |fields|.
+// For example, parses "SCDX" into {ADMIN_AREA, LOCALITY, DEPENDENT_LOCALITY,
+// SORTING_CODE}.
+void ParseAddressFieldsRequired(const std::string& required,
+                                std::vector<AddressField>* fields) {
+  assert(fields != NULL);
+  fields->clear();
+  for (std::string::const_iterator token = required.begin();
+       token != required.end(); ++token) {
+    if (IsToken(*token)) {
+      fields->push_back(ParseToken(*token));
+    }
+  }
 }
 
-int GetMessageIdFromName(const std::string& name,
-                         const NameMessageIdMap& message_ids) {
-  NameMessageIdMap::const_iterator it = message_ids.find(name);
-  return it != message_ids.end() ? it->second : INVALID_MESSAGE_ID;
+int GetAdminAreaMessageId(const std::string& admin_area_type) {
+  if (admin_area_type == "area") {
+    return IDS_LIBADDRESSINPUT_I18N_AREA;
+  }
+  if (admin_area_type == "county") {
+    return IDS_LIBADDRESSINPUT_I18N_COUNTY_LABEL;
+  }
+  if (admin_area_type == "department") {
+    return IDS_LIBADDRESSINPUT_I18N_DEPARTMENT;
+  }
+  if (admin_area_type == "district") {
+    return IDS_LIBADDRESSINPUT_I18N_DEPENDENT_LOCALITY_LABEL;
+  }
+  if (admin_area_type == "do_si") {
+    return IDS_LIBADDRESSINPUT_I18N_DO_SI;
+  }
+  if (admin_area_type == "emirate") {
+    return IDS_LIBADDRESSINPUT_I18N_EMIRATE;
+  }
+  if (admin_area_type == "island") {
+    return IDS_LIBADDRESSINPUT_I18N_ISLAND;
+  }
+  if (admin_area_type == "parish") {
+    return IDS_LIBADDRESSINPUT_I18N_PARISH;
+  }
+  if (admin_area_type == "prefecture") {
+    return IDS_LIBADDRESSINPUT_I18N_PREFECTURE;
+  }
+  if (admin_area_type == "province") {
+    return IDS_LIBADDRESSINPUT_I18N_PROVINCE;
+  }
+  if (admin_area_type == "state") {
+    return IDS_LIBADDRESSINPUT_I18N_STATE_LABEL;
+  }
+  return INVALID_MESSAGE_ID;
+}
+
+int GetPostalCodeMessageId(const std::string& postal_code_type) {
+  if (postal_code_type == "postal") {
+    return IDS_LIBADDRESSINPUT_I18N_POSTAL_CODE_LABEL;
+  }
+  if (postal_code_type == "zip") {
+    return IDS_LIBADDRESSINPUT_I18N_ZIP_CODE_LABEL;
+  }
+  return INVALID_MESSAGE_ID;
 }
 
 }  // namespace
 
 Rule::Rule()
     : format_(),
+      required_(),
       sub_keys_(),
       languages_(),
       language_(),
+      postal_code_format_(),
       admin_area_name_message_id_(INVALID_MESSAGE_ID),
       postal_code_name_message_id_(INVALID_MESSAGE_ID) {}
 
 Rule::~Rule() {}
 
 void Rule::CopyFrom(const Rule& rule) {
   format_ = rule.format_;
+  required_ = rule.required_;
   sub_keys_ = rule.sub_keys_;
   languages_ = rule.languages_;
   language_ = rule.language_;
+  postal_code_format_ = rule.postal_code_format_;
   admin_area_name_message_id_ = rule.admin_area_name_message_id_;
   postal_code_name_message_id_ = rule.postal_code_name_message_id_;
 }
 
 bool Rule::ParseSerializedRule(const std::string& serialized_rule) {
   scoped_ptr<Json> json(Json::Build());
   if (!json->ParseObject(serialized_rule)) {
     return false;
   }
 
+  static const char kFormatKey[] = "fmt";

[please use gerrit instead, 2013/12/20 00:37:43]

Moved the string constants to immediately before they're used.

[Evan Stade, 2013/12/20 03:55:13]

I think you can just inline them at this point.

[please use gerrit instead, 2013/12/20 22:03:32]

I prefer to avoid inlining constants that are used more than once. Each one of
these constants is used more than once.

   if (json->HasStringValueForKey(kFormatKey)) {
     ParseAddressFieldsFormat(json->GetStringValueForKey(kFormatKey), &format_);
   }
 
+  static const char kRequiredKey[] = "require";
+  if (json->HasStringValueForKey(kRequiredKey)) {
+    ParseAddressFieldsRequired(
+        json->GetStringValueForKey(kRequiredKey), &required_);
+  }
+
+
+  // Used as a separator in a list of items. For example, the list of supported
+  // languages can be "de~fr~it".
+  static const char kSeparator = '~';
+  static const char kSubKeysKey[] = "sub_keys";
   if (json->HasStringValueForKey(kSubKeysKey)) {
     SplitString(
         json->GetStringValueForKey(kSubKeysKey), kSeparator, &sub_keys_);
   }
 
+  static const char kLanguagesKey[] = "languages";
   if (json->HasStringValueForKey(kLanguagesKey)) {
     SplitString(
         json->GetStringValueForKey(kLanguagesKey), kSeparator, &languages_);
   }
 
+  static const char kLanguageKey[] = "lang";
   if (json->HasStringValueForKey(kLanguageKey)) {
     language_ = json->GetStringValueForKey(kLanguageKey);
   }
 
-  if (json->HasStringValueForKey(kAdminAreaNameTypeKey)) {
-    admin_area_name_message_id_ =
-        GetMessageIdFromName(json->GetStringValueForKey(kAdminAreaNameTypeKey),
-                             GetAdminAreaMessageIds());
+  static const char kPostalCodeFormatKey[] = "zip";
+  if (json->HasStringValueForKey(kPostalCodeFormatKey)) {
+    postal_code_format_ = json->GetStringValueForKey(kPostalCodeFormatKey);
   }
 
+  static const char kAdminAreaNameTypeKey[] = "state_name_type";
+  if (json->HasStringValueForKey(kAdminAreaNameTypeKey)) {
+    admin_area_name_message_id_ = GetAdminAreaMessageId(
+        json->GetStringValueForKey(kAdminAreaNameTypeKey));
+  }
+
+  static const char kPostalCodeNameTypeKey[] = "zip_name_type";
   if (json->HasStringValueForKey(kPostalCodeNameTypeKey)) {
-    postal_code_name_message_id_ =
-        GetMessageIdFromName(json->GetStringValueForKey(kPostalCodeNameTypeKey),
-                             GetPostalCodeMessageIds());
+    postal_code_name_message_id_ = GetPostalCodeMessageId(
+        json->GetStringValueForKey(kPostalCodeNameTypeKey));
   }
 
   return true;
 }
 
 }  // namespace addressinput
 }  // namespace i18n