[rac] Validate an address.

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,
@@ 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) {
+int GetAdminAreaMessageId(const std::string& admin_area_type, bool error) {
   if (admin_area_type == "area") {
-    return IDS_LIBADDRESSINPUT_I18N_AREA;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_AREA
+                 : IDS_LIBADDRESSINPUT_I18N_AREA;
   }
   if (admin_area_type == "county") {
-    return IDS_LIBADDRESSINPUT_I18N_COUNTY_LABEL;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_COUNTY_LABEL
+                 : IDS_LIBADDRESSINPUT_I18N_COUNTY_LABEL;
   }
   if (admin_area_type == "department") {
-    return IDS_LIBADDRESSINPUT_I18N_DEPARTMENT;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_DEPARTMENT
+                 : IDS_LIBADDRESSINPUT_I18N_DEPARTMENT;
   }
   if (admin_area_type == "district") {
-    return IDS_LIBADDRESSINPUT_I18N_DEPENDENT_LOCALITY_LABEL;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_DEPENDENT_LOCALITY_LABEL
+                 : IDS_LIBADDRESSINPUT_I18N_DEPENDENT_LOCALITY_LABEL;
   }
   if (admin_area_type == "do_si") {
-    return IDS_LIBADDRESSINPUT_I18N_DO_SI;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_DO_SI
+                 : IDS_LIBADDRESSINPUT_I18N_DO_SI;
   }
   if (admin_area_type == "emirate") {
-    return IDS_LIBADDRESSINPUT_I18N_EMIRATE;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_EMIRATE
+                 : IDS_LIBADDRESSINPUT_I18N_EMIRATE;
   }
   if (admin_area_type == "island") {
-    return IDS_LIBADDRESSINPUT_I18N_ISLAND;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_ISLAND
+                 : IDS_LIBADDRESSINPUT_I18N_ISLAND;
   }
   if (admin_area_type == "parish") {
-    return IDS_LIBADDRESSINPUT_I18N_PARISH;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_PARISH
+                 : IDS_LIBADDRESSINPUT_I18N_PARISH;
   }
   if (admin_area_type == "prefecture") {
-    return IDS_LIBADDRESSINPUT_I18N_PREFECTURE;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_PREFECTURE
+                 : IDS_LIBADDRESSINPUT_I18N_PREFECTURE;
   }
   if (admin_area_type == "province") {
-    return IDS_LIBADDRESSINPUT_I18N_PROVINCE;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_PROVINCE
+                 : IDS_LIBADDRESSINPUT_I18N_PROVINCE;
   }
   if (admin_area_type == "state") {
-    return IDS_LIBADDRESSINPUT_I18N_STATE_LABEL;
+    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) {
+int GetPostalCodeMessageId(const std::string& postal_code_type, bool error) {
   if (postal_code_type == "postal") {
-    return IDS_LIBADDRESSINPUT_I18N_POSTAL_CODE_LABEL;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_POSTAL_CODE_LABEL
+                 : IDS_LIBADDRESSINPUT_I18N_POSTAL_CODE_LABEL;
   }
   if (postal_code_type == "zip") {
-    return IDS_LIBADDRESSINPUT_I18N_ZIP_CODE_LABEL;
+    return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_ZIP_CODE_LABEL
+                 : IDS_LIBADDRESSINPUT_I18N_ZIP_CODE_LABEL;
   }
   return INVALID_MESSAGE_ID;
 }
 
 }  // namespace
 
 Rule::Rule()
     : format_(),
       required_(),
       sub_keys_(),
@@ skipping 18 matching lines @@
 }
 
 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_;
+  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_;
 }
 
 bool Rule::ParseSerializedRule(const std::string& serialized_rule) {
   scoped_ptr<Json> json(Json::Build());
   if (!json->ParseObject(serialized_rule)) {
     return false;
   }
 
   std::string value;
   if (json->GetStringValueForKey("fmt", &value)) {
@@ skipping 17 matching lines @@
 
   if (json->GetStringValueForKey("lang", &value)) {
     language_ = value;
   }
 
   if (json->GetStringValueForKey("zip", &value)) {
     postal_code_format_ = value;
   }
 
   if (json->GetStringValueForKey("state_name_type", &value)) {
-    admin_area_name_message_id_ = GetAdminAreaMessageId(value);
+    admin_area_name_message_id_ = GetAdminAreaMessageId(value, false);
+    invalid_admin_area_message_id_ = GetAdminAreaMessageId(value, true);
   }
 
   if (json->GetStringValueForKey("zip_name_type", &value)) {
-    postal_code_name_message_id_ = GetPostalCodeMessageId(value);
+    postal_code_name_message_id_ = GetPostalCodeMessageId(value, false);
+    invalid_postal_code_message_id_ = GetPostalCodeMessageId(value, true);
   }
 
   return true;
 }
 
+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;
+  }
+}
+
 }  // namespace addressinput
 }  // namespace i18n