autocomplete: add ability to get full address (hidden behind a flag).

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 <cassert>
 #include <cstddef>
 #include <string>
 #include <vector>
 
-#include "grit.h"
-#include "grit/libaddressinput_strings.h"
 #include "region_data_constants.h"
 #include "util/json.h"
 #include "util/string_util.h"
 
 namespace i18n {
 namespace addressinput {
 
 namespace {
 
 bool ParseToken(char c, AddressField* field) {
@@ skipping 93 matching lines @@
   assert(fields != NULL);
   fields->clear();
   for (size_t i = 0; i < required.length(); ++i) {
     AddressField field = COUNTRY;
     if (ParseToken(required[i], &field)) {
       fields->push_back(field);
     }
   }
 }
 
-int GetAdminAreaMessageId(const std::string& admin_area_type, bool error) {
-  if (admin_area_type == "area") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_AREA
-                 : IDS_LIBADDRESSINPUT_I18N_AREA;
-  }
-  if (admin_area_type == "county") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_COUNTY_LABEL
-                 : IDS_LIBADDRESSINPUT_I18N_COUNTY_LABEL;
-  }
-  if (admin_area_type == "department") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_DEPARTMENT
-                 : IDS_LIBADDRESSINPUT_I18N_DEPARTMENT;
-  }
-  if (admin_area_type == "district") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_DEPENDENT_LOCALITY_LABEL
-                 : IDS_LIBADDRESSINPUT_I18N_DEPENDENT_LOCALITY_LABEL;
-  }
-  if (admin_area_type == "do_si") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_DO_SI
-                 : IDS_LIBADDRESSINPUT_I18N_DO_SI;
-  }
-  if (admin_area_type == "emirate") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_EMIRATE
-                 : IDS_LIBADDRESSINPUT_I18N_EMIRATE;
-  }
-  if (admin_area_type == "island") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_ISLAND
-                 : IDS_LIBADDRESSINPUT_I18N_ISLAND;
-  }
-  if (admin_area_type == "parish") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_PARISH
-                 : IDS_LIBADDRESSINPUT_I18N_PARISH;
-  }
-  if (admin_area_type == "prefecture") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_PREFECTURE
-                 : IDS_LIBADDRESSINPUT_I18N_PREFECTURE;
-  }
-  if (admin_area_type == "province") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_PROVINCE
-                 : IDS_LIBADDRESSINPUT_I18N_PROVINCE;
-  }
-  if (admin_area_type == "state") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_STATE_LABEL
-                 : IDS_LIBADDRESSINPUT_I18N_STATE_LABEL;
-  }
-  return INVALID_MESSAGE_ID;
-}
-
-int GetPostalCodeMessageId(const std::string& postal_code_type, bool error) {
-  if (postal_code_type == "postal") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_POSTAL_CODE_LABEL
-                 : IDS_LIBADDRESSINPUT_I18N_POSTAL_CODE_LABEL;
-  }
-  if (postal_code_type == "zip") {
-    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_ZIP_CODE_LABEL
-                 : IDS_LIBADDRESSINPUT_I18N_ZIP_CODE_LABEL;
-  }
-  return INVALID_MESSAGE_ID;
-}
-
 // Finds |target| in |values_to_compare| and sets |selected_value| to the
 // associated value from |values_to_select|. Returns true if |target| is in
 // |values_to_compare|. |selected_value| should not be NULL. |values_to_compare|
 // should not be larger than |values_to_select|.
 bool GetMatchingValue(const std::string& target,
                       const std::vector<std::string>& values_to_compare,
                       const std::vector<std::string>& values_to_select,
                       std::string* selected_value) {
   assert(selected_value != NULL);
   assert(values_to_select.size() >= values_to_compare.size());
@@ skipping 15 matching lines @@
     : field(COUNTRY), literal(literal) {
   assert(!literal.empty());
 }
 
 FormatElement::~FormatElement() {}
 
 bool FormatElement::operator==(const FormatElement& other) const {
   return field == other.field && literal == other.literal;
 }
 
-Rule::Rule()
-    : key_(),
-      name_(),
-      latin_name_(),
-      format_(),
-      latin_format_(),
-      required_(),
-      sub_keys_(),
-      sub_names_(),
-      sub_lnames_(),
-      languages_(),
-      input_languages_(),
-      language_(),
-      postal_code_format_(),
-      admin_area_name_message_id_(INVALID_MESSAGE_ID),
-      invalid_admin_area_message_id_(INVALID_MESSAGE_ID),
-      postal_code_name_message_id_(INVALID_MESSAGE_ID),
-      invalid_postal_code_message_id_(INVALID_MESSAGE_ID) {}
+Rule::Rule() {}
 
 Rule::~Rule() {}
 
 // static
 const Rule& Rule::GetDefault() {
   // Allocated once and leaked on shutdown.
   static Rule* default_rule = NULL;
   if (default_rule == NULL) {
     default_rule = new Rule;
     default_rule->ParseSerializedRule(
@@ skipping 10 matching lines @@
   latin_format_ = rule.latin_format_;
   required_ = rule.required_;
   sub_keys_ = rule.sub_keys_;
   languages_ = rule.languages_;
   input_languages_ = rule.input_languages_;
   language_ = rule.language_;
   sub_keys_ = rule.sub_keys_;
   sub_names_ = rule.sub_names_;
   sub_lnames_ = rule.sub_lnames_;
   postal_code_format_ = rule.postal_code_format_;
-  admin_area_name_message_id_ = rule.admin_area_name_message_id_;
-  invalid_admin_area_message_id_ = rule.invalid_admin_area_message_id_;
-  postal_code_name_message_id_ = rule.postal_code_name_message_id_;
-  invalid_postal_code_message_id_ = rule.invalid_postal_code_message_id_;
+  admin_area_name_type_ = rule.admin_area_name_type_;
+  postal_code_name_type_ = rule.postal_code_name_type_;
 }
 
 bool Rule::ParseSerializedRule(const std::string& serialized_rule) {
   scoped_ptr<Json> json(Json::Build());
   if (!json->ParseObject(serialized_rule)) {
     return false;
   }
   ParseJsonRule(*json);
   return true;
 }
@@ skipping 51 matching lines @@
 
   if (json_rule.GetStringValueForKey("lang", &value)) {
     language_.swap(value);
   }
 
   if (json_rule.GetStringValueForKey("zip", &value)) {
     postal_code_format_.swap(value);
   }
 
   if (json_rule.GetStringValueForKey("state_name_type", &value)) {
-    admin_area_name_message_id_ = GetAdminAreaMessageId(value, false);
-    invalid_admin_area_message_id_ = GetAdminAreaMessageId(value, true);
+    admin_area_name_type_.swap(value);
   }
 
   if (json_rule.GetStringValueForKey("zip_name_type", &value)) {
-    postal_code_name_message_id_ = GetPostalCodeMessageId(value, false);
-    invalid_postal_code_message_id_ = GetPostalCodeMessageId(value, true);
+    postal_code_name_type_.swap(value);
   }
 }
 
 const std::string& Rule::GetIdentityField(IdentityField identity_field) const {
   switch (identity_field) {
     case KEY:
       return key_;
     case NAME:
       return name_;
     case LATIN_NAME:
       return latin_name_;
     case IDENTITY_FIELDS_SIZE:
       assert(false);
   }
   return key_;
 }
 
-int Rule::GetInvalidFieldMessageId(AddressField field) const {
-  switch (field) {
-    case ADMIN_AREA:
-      return invalid_admin_area_message_id_;
-    case LOCALITY:
-      return IDS_LIBADDRESSINPUT_I18N_INVALID_LOCALITY_LABEL;
-    case DEPENDENT_LOCALITY:
-      return IDS_LIBADDRESSINPUT_I18N_INVALID_DEPENDENT_LOCALITY_LABEL;
-    case POSTAL_CODE:
-      return invalid_postal_code_message_id_;
-    default:
-      return IDS_LIBADDRESSINPUT_I18N_INVALID_ENTRY;
-  }
-}
-
 bool Rule::CanonicalizeSubKey(const std::string& user_input,
                               bool keep_input_latin,
                               std::string* sub_key) const {
   assert(sub_key != NULL);
 
   if (sub_keys_.empty()) {
     *sub_key = user_input;
     return true;
   }
 
   return GetMatchingValue(user_input, sub_keys_, sub_keys_, sub_key) ||
       GetMatchingValue(user_input, sub_names_, sub_keys_, sub_key) ||
       (keep_input_latin &&
        GetMatchingValue(user_input, sub_lnames_, sub_lnames_, sub_key)) ||
       GetMatchingValue(user_input, sub_lnames_, sub_keys_, sub_key);
 }
 
 }  // namespace addressinput
 }  // namespace i18n