[rac] Validate an address.

third_party/libaddressinput/chromium/cpp/src/lookup_key.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 "lookup_key.h"
 
+#include <libaddressinput/address_data.h>
 #include <libaddressinput/address_field.h>
 #include <libaddressinput/util/basictypes.h>
 #include <libaddressinput/util/scoped_ptr.h>
 
 #include <cassert>
 #include <cstddef>
+#include <map>
 #include <string>
 #include <utility>
 
 #include "rule.h"
 #include "util/stl_util.h"
 
 namespace i18n {
 namespace addressinput {
 
+namespace {
+
+// Returns the value of the |field| in the |address|. The |field| can be only
+// ADMIN_AREA, LOCALITY, and DEPENDENT_LOCALITY.
+const std::string& GetAddressFieldValue(const AddressData& address,

[Evan Stade, 2013/12/19 02:12:38]

this seems like it should be an AddressData method. Also, why isn't country
supported?

[please use gerrit instead, 2014/01/08 00:55:52]

Done.

+                                        AddressField field) {
+  switch (field) {
+    case ADMIN_AREA:
+      return address.administrative_area;
+    case LOCALITY:
+      return address.locality;
+    case DEPENDENT_LOCALITY:
+      return address.dependent_locality;
+    default:
+      assert(false);
+      static const std::string kEmptyString;
+      return kEmptyString;
+  }
+}
+
+}  // namespace
+
 LookupKey::LookupKey(const std::string& country_code)
     : value_("data/" + country_code),
       level_(COUNTRY),
       rule_(),
       sub_keys_(),
       language_code_keys_() {}
 
 LookupKey::~LookupKey() {
   STLDeleteContainerPairSecondPointers(sub_keys_.begin(), sub_keys_.end());
   STLDeleteContainerPairSecondPointers(
@@ skipping 28 matching lines @@
 }
 
 LookupKey* LookupKey::AddLanguageCodeKey(const std::string& language_code) {
   assert(language_code_keys_.find(language_code) == language_code_keys_.end());
   LookupKey* language_code_key =
       new LookupKey(value_ + "--" + language_code, level_);
   language_code_keys_.insert(std::make_pair(language_code, language_code_key));
   return language_code_key;
 }
 
+const LookupKey* LookupKey::GetSubKey(const std::string& sub_region) const {
+  LookupKeys::const_iterator it = sub_keys_.find(sub_region);
+  return it == sub_keys_.end() ? NULL : it->second;
+}
+
+const LookupKey* LookupKey::GetLanguageCodeKey(
+    const std::string& language_code) const {
+  LookupKeys::const_iterator it = language_code_keys_.find(language_code);
+  return it == language_code_keys_.end() ? NULL : it->second;
+}
+
+std::map<AddressField, const Rule*> LookupKey::BuildFieldRuleMap(

[Evan Stade, 2013/12/19 02:12:38]

this actually feels like it should be a method on AddressData, mainly because
you only use |this| once, but you use |address| 5 times (if you count the refs
in GetAddressFieldValue)

[please use gerrit instead, 2014/01/08 00:55:52]

AddressData is public API, but Rule is not. Moving this method to AddressData
will require exposing Rule as part of the public API. I don't think we should do
that.

+    const AddressData& address) const {
+  static const int kNumberOfLevels  = 4;

[Evan Stade, 2013/12/19 02:12:38]

use arraysize()

[please use gerrit instead, 2014/01/08 00:55:52]

No longer applicable.

+  static const AddressField kLevels[kNumberOfLevels] = {
+    COUNTRY,
+    ADMIN_AREA,
+    LOCALITY,
+    DEPENDENT_LOCALITY
+  };
+  std::map<AddressField, const Rule*> result;
+  const LookupKey* key = this;

[Evan Stade, 2013/12/19 02:12:38]

does this assume |this| is a country level LookupKey? could you at least add an
assert?

[please use gerrit instead, 2014/01/08 00:55:52]

No longer applicable.

+  for (int i = 0; i < kNumberOfLevels && key != NULL; ++i) {
+    const LookupKey* language_code_key =
+        key->GetLanguageCodeKey(address.language_code);
+    result.insert(std::make_pair(
+        kLevels[i],
+        language_code_key == NULL
+            ? key->GetRule()
+            : language_code_key->GetRule()));
+    key = i == kNumberOfLevels - 1
+        ? NULL
+        : key->GetSubKey(GetAddressFieldValue(address, kLevels[i + 1]));
+  }
+  return result;
+}
+
 LookupKey::LookupKey(const std::string& key_value, AddressField level)
     : value_(key_value),
       level_(level),
       rule_(),
       sub_keys_(),
       language_code_keys_() {}
 
 }  // namespace addressinput
 }  // namespace i18n