[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,
@@ skipping 21 matching lines @@
 namespace addressinput {
 
 namespace {
 
 typedef std::map<std::string, int> NameMessageIdMap;
 
 const char kAdminAreaNameTypeKey[] = "state_name_type";
 const char kFormatKey[] = "fmt";
 const char kLanguageKey[] = "lang";
 const char kLanguagesKey[] = "languages";
+const char kPostalCodeExamplesKey[] = "zipex";
+const char kPostalCodeFormatKey[] = "zip";
 const char kPostalCodeNameTypeKey[] = "zip_name_type";
+const char kPostalCodesUrlKey[] = "posturl";
+const char kRequiredKey[] = "require";
 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));
@@ skipping 52 matching lines @@
 const Rule& InitDefaultRule() {
   static Rule rule;
   rule.ParseSerializedRule(RegionDataConstants::GetDefaultRegionData());
   return rule;
 }
 
 }  // namespace
 
 Rule::Rule()
     : format_(),
+      required_(),
       sub_keys_(),
       languages_(),
       language_(),
+      postal_code_examples_(),
+      postal_code_format_(),
+      postal_codes_url_(),
       admin_area_name_message_id_(INVALID_MESSAGE_ID),
       postal_code_name_message_id_(INVALID_MESSAGE_ID) {}
 
 Rule::~Rule() {}
 
 // static
 const Rule& Rule::GetDefault() {
   // Returns the constant reference to the Rule object from InitDefaultRule().
   // The static object is in InitDefaultRule(), but this function maintains a
   // constant static reference to it. The constant static reference avoids
   // re-parsing the default region data.
   static const Rule& kDefaultRule(InitDefaultRule());
   return kDefaultRule;
 }
 
 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_examples_ = rule.postal_code_examples_;
+  postal_code_format_ = rule.postal_code_format_;
+  postal_codes_url_ = rule.postal_codes_url_;
   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;
   }
 
   if (json->HasStringValueForKey(kFormatKey)) {
     ParseAddressFieldsFormat(json->GetStringValueForKey(kFormatKey), &format_);
   }
 
+  if (json->HasStringValueForKey(kRequiredKey)) {
+    ParseAddressFieldsRequired(
+        json->GetStringValueForKey(kRequiredKey), &required_);
+  }
+
   if (json->HasStringValueForKey(kSubKeysKey)) {
     SplitString(
         json->GetStringValueForKey(kSubKeysKey), kSeparator, &sub_keys_);
   }
 
   if (json->HasStringValueForKey(kLanguagesKey)) {
     SplitString(
         json->GetStringValueForKey(kLanguagesKey), kSeparator, &languages_);
   }
 
   if (json->HasStringValueForKey(kLanguageKey)) {
     language_ = json->GetStringValueForKey(kLanguageKey);
   }
 
+  if (json->HasStringValueForKey(kPostalCodeExamplesKey)) {
+    postal_code_examples_ = json->GetStringValueForKey(kPostalCodeExamplesKey);
+  }
+
+  if (json->HasStringValueForKey(kPostalCodeFormatKey)) {
+    postal_code_format_ = json->GetStringValueForKey(kPostalCodeFormatKey);
+  }
+
+  if (json->HasStringValueForKey(kPostalCodesUrlKey)) {
+    postal_codes_url_ = json->GetStringValueForKey(kPostalCodesUrlKey);
+  }
+
   if (json->HasStringValueForKey(kAdminAreaNameTypeKey)) {
     admin_area_name_message_id_ =
         GetMessageIdFromName(json->GetStringValueForKey(kAdminAreaNameTypeKey),
                              GetAdminAreaMessageIds());
   }
 
   if (json->HasStringValueForKey(kPostalCodeNameTypeKey)) {
     postal_code_name_message_id_ =
         GetMessageIdFromName(json->GetStringValueForKey(kPostalCodeNameTypeKey),
                              GetPostalCodeMessageIds());
   }
 
   return true;
 }
 
 }  // namespace addressinput
 }  // namespace i18n