Use upstream libaddressinput in Chrome.

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

Index: third_party/libaddressinput/chromium/cpp/src/ruleset.cc
diff --git a/third_party/libaddressinput/chromium/cpp/src/ruleset.cc b/third_party/libaddressinput/chromium/cpp/src/ruleset.cc
deleted file mode 100644
index 201e407cd9ab0fb3faf66c93ac3304821eb735ee..0000000000000000000000000000000000000000
--- a/third_party/libaddressinput/chromium/cpp/src/ruleset.cc
+++ /dev/null
@@ -1,259 +0,0 @@
-// Copyright (C) 2014 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 "ruleset.h"
-
-#include <libaddressinput/address_field.h>
-#include <libaddressinput/util/scoped_ptr.h>
-
-#include <cassert>
-#include <cstddef>
-#include <map>
-#include <set>
-#include <string>
-#include <utility>
-
-#include "rule.h"
-#include "util/canonicalize_string.h"
-#include "util/stl_util.h"
-
-namespace i18n {
-namespace addressinput {
-
-Ruleset::Ruleset(AddressField field, scoped_ptr<Rule> rule)
-    : tries_(),
-      canonicalizer_(),
-      parent_(NULL),
-      field_(field),
-      deepest_ruleset_level_(field),
-      rule_(rule.Pass()),
-      sub_regions_(),
-      language_codes_() {
-  assert(field_ >= COUNTRY);
-  assert(field_ <= DEPENDENT_LOCALITY);
-  assert(rule_ != NULL);
-}
-
-Ruleset::~Ruleset() {
-  STLDeleteValues(&sub_regions_);
-  STLDeleteValues(&language_codes_);
-
-  // Delete the maps and trie objects owned by |tries_| field.
-  for (LanguageCodeTries::const_iterator lang_it = tries_.begin();
-       lang_it != tries_.end(); ++lang_it) {
-    AddressFieldTries* address_field_tries = lang_it->second;
-    assert(address_field_tries != NULL);
-
-    for (AddressFieldTries::const_iterator address_field_it =
-             address_field_tries->begin();
-         address_field_it != address_field_tries->end();
-         ++address_field_it) {
-      IdentityFieldTries* identity_field_tries = address_field_it->second;
-      assert(identity_field_tries != NULL);
-
-      for (IdentityFieldTries::const_iterator identity_field_it =
-               identity_field_tries->begin();
-           identity_field_it != identity_field_tries->end();
-           ++identity_field_it) {
-        // The tries do not own the ruleset objects.
-        Trie<const Ruleset*>* trie = identity_field_it->second;
-        assert(trie != NULL);
-        delete trie;
-      }
-      delete identity_field_tries;
-    }
-    delete address_field_tries;
-  }
-}
-
-void Ruleset::AddSubRegionRuleset(const std::string& sub_region,
-                                  scoped_ptr<Ruleset> ruleset) {
-  assert(sub_regions_.find(sub_region) == sub_regions_.end());
-  assert(ruleset != NULL);
-  assert(ruleset->field() == static_cast<AddressField>(field() + 1));
-
-  ruleset->parent_ = this;
-  sub_regions_[sub_region] = ruleset.release();
-}
-
-void Ruleset::AddLanguageCodeRule(const std::string& language_code,
-                                  scoped_ptr<Rule> rule) {
-  assert(language_codes_.find(language_code) == language_codes_.end());
-  assert(rule != NULL);
-  language_codes_[language_code] = rule.release();
-}
-
-Ruleset* Ruleset::GetSubRegionRuleset(const std::string& sub_region) const {
-  std::map<std::string, Ruleset*>::const_iterator it =
-      sub_regions_.find(sub_region);
-  return it != sub_regions_.end() ? it->second : NULL;
-}
-
-const Rule& Ruleset::GetLanguageCodeRule(
-    const std::string& language_code) const {
-  std::map<std::string, const Rule*>::const_iterator it =
-      language_codes_.find(language_code);
-  return it != language_codes_.end() ? *it->second : *rule_;
-}
-
-void Ruleset::BuildPrefixSearchIndex() {
-  assert(field_ == COUNTRY);
-  assert(tries_.empty());
-
-  // Default language tries.
-  tries_[""] = new AddressFieldTries;
-
-  // Non-default language tries.
-  for (std::vector<std::string>::const_iterator lang_it =
-           rule_->GetLanguages().begin();
-       lang_it != rule_->GetLanguages().end();
-       ++lang_it) {
-    if (*lang_it != rule_->GetLanguage() && !lang_it->empty()) {
-      tries_[*lang_it] = new AddressFieldTries;
-    }
-  }
-
-  for (LanguageCodeTries::const_iterator lang_it = tries_.begin();
-       lang_it != tries_.end(); ++lang_it) {
-    AddressFieldTries* address_field_tries = lang_it->second;
-    address_field_tries->insert(
-        std::make_pair(ADMIN_AREA, new IdentityFieldTries));
-    address_field_tries->insert(
-        std::make_pair(LOCALITY, new IdentityFieldTries));
-    address_field_tries->insert(
-        std::make_pair(DEPENDENT_LOCALITY, new IdentityFieldTries));
-
-    for (AddressFieldTries::const_iterator address_field_it =
-             address_field_tries->begin();
-         address_field_it != address_field_tries->end();
-         ++address_field_it) {
-      IdentityFieldTries* identity_field_tries = address_field_it->second;
-      identity_field_tries->insert(
-          std::make_pair(Rule::KEY, new Trie<const Ruleset*>));
-      identity_field_tries->insert(
-          std::make_pair(Rule::NAME, new Trie<const Ruleset*>));
-      identity_field_tries->insert(
-          std::make_pair(Rule::LATIN_NAME, new Trie<const Ruleset*>));
-    }
-  }
-
-  canonicalizer_ = StringCanonicalizer::Build();
-  AddSubRegionRulesetsToTrie(*this);
-}
-
-void Ruleset::FindRulesetsByPrefix(const std::string& language_code,
-                                   AddressField ruleset_level,
-                                   Rule::IdentityField identity_field,
-                                   const std::string& prefix,
-                                   std::set<const Ruleset*>* result) const {
-  assert(field_ == COUNTRY);
-  assert(ruleset_level >= ADMIN_AREA);
-  assert(ruleset_level <= DEPENDENT_LOCALITY);
-  assert(result != NULL);
-  assert(canonicalizer_ != NULL);
-
-  LanguageCodeTries::const_iterator lang_it = tries_.find(language_code);
-  AddressFieldTries* address_field_tries = lang_it != tries_.end()
-      ? lang_it->second : tries_.find("")->second;
-  assert(address_field_tries != NULL);
-
-  AddressFieldTries::const_iterator address_field_it =
-      address_field_tries->find(ruleset_level);
-  assert(address_field_it != address_field_tries->end());
-
-  IdentityFieldTries* identity_field_tries = address_field_it->second;
-  assert(identity_field_tries != NULL);
-
-  IdentityFieldTries::const_iterator identity_field_it =
-      identity_field_tries->find(identity_field);
-  assert(identity_field_it != identity_field_tries->end());
-
-  Trie<const Ruleset*>* trie = identity_field_it->second;
-  assert(trie != NULL);
-
-  trie->FindDataForKeyPrefix(
-      canonicalizer_->CanonicalizeString(prefix), result);
-}
-
-void Ruleset::AddSubRegionRulesetsToTrie(const Ruleset& parent_ruleset) {
-  assert(field_ == COUNTRY);
-  assert(canonicalizer_ != NULL);
-
-  for (std::map<std::string, Ruleset*>::const_iterator sub_region_it =
-           parent_ruleset.sub_regions_.begin();
-       sub_region_it != parent_ruleset.sub_regions_.end();
-       ++sub_region_it) {
-    const Ruleset* ruleset = sub_region_it->second;
-    assert(ruleset != NULL);
-
-    if (deepest_ruleset_level_ < ruleset->field()) {
-      deepest_ruleset_level_ = ruleset->field();
-    }
-
-    for (LanguageCodeTries::const_iterator lang_it = tries_.begin();
-         lang_it != tries_.end(); ++lang_it) {
-      const std::string& language_code = lang_it->first;
-      const Rule& rule = ruleset->GetLanguageCodeRule(language_code);
-
-      AddressFieldTries* address_field_tries = lang_it->second;
-      assert(address_field_tries != NULL);
-
-      AddressFieldTries::const_iterator address_field_it =
-          address_field_tries->find(ruleset->field());
-      assert(address_field_it != address_field_tries->end());
-
-      IdentityFieldTries* identity_field_tries = address_field_it->second;
-      assert(identity_field_tries != NULL);
-
-      IdentityFieldTries::const_iterator identity_field_it =
-          identity_field_tries->find(Rule::KEY);
-      assert(identity_field_it != identity_field_tries->end());
-
-      Trie<const Ruleset*>* key_trie = identity_field_it->second;
-      assert(key_trie != NULL);
-
-      identity_field_it = identity_field_tries->find(Rule::NAME);
-      assert(identity_field_it != identity_field_tries->end());
-
-      Trie<const Ruleset*>* name_trie = identity_field_it->second;
-      assert(name_trie != NULL);
-
-      identity_field_it = identity_field_tries->find(Rule::LATIN_NAME);
-      assert(identity_field_it != identity_field_tries->end());
-
-      Trie<const Ruleset*>* latin_name_trie = identity_field_it->second;
-      assert(latin_name_trie != NULL);
-
-      if (!rule.GetKey().empty()) {
-        key_trie->AddDataForKey(
-            canonicalizer_->CanonicalizeString(rule.GetKey()), ruleset);
-      }
-
-      if (!rule.GetName().empty()) {
-        name_trie->AddDataForKey(
-             canonicalizer_->CanonicalizeString(rule.GetName()), ruleset);
-      }
-
-      if (!rule.GetLatinName().empty()) {
-        latin_name_trie->AddDataForKey(
-            canonicalizer_->CanonicalizeString(rule.GetLatinName()), ruleset);
-      }
-    }
-
-    AddSubRegionRulesetsToTrie(*ruleset);
-  }
-}
-
-}  // namespace addressinput
-}  // namespace i18n