| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (C) 2014 Google Inc. | |
| 2 // | |
| 3 // Licensed under the Apache License, Version 2.0 (the "License"); | |
| 4 // you may not use this file except in compliance with the License. | |
| 5 // You may obtain a copy of the License at | |
| 6 // | |
| 7 // http://www.apache.org/licenses/LICENSE-2.0 | |
| 8 // | |
| 9 // Unless required by applicable law or agreed to in writing, software | |
| 10 // distributed under the License is distributed on an "AS IS" BASIS, | |
| 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
| 12 // See the License for the specific language governing permissions and | |
| 13 // limitations under the License. | |
| 14 | |
| 15 #include "ruleset.h" | |
| 16 | |
| 17 #include <libaddressinput/address_field.h> | |
| 18 #include <libaddressinput/util/scoped_ptr.h> | |
| 19 | |
| 20 #include <cassert> | |
| 21 #include <cstddef> | |
| 22 #include <map> | |
| 23 #include <set> | |
| 24 #include <string> | |
| 25 #include <utility> | |
| 26 | |
| 27 #include "rule.h" | |
| 28 #include "util/canonicalize_string.h" | |
| 29 #include "util/stl_util.h" | |
| 30 | |
| 31 namespace i18n { | |
| 32 namespace addressinput { | |
| 33 | |
| 34 Ruleset::Ruleset(AddressField field, scoped_ptr<Rule> rule) | |
| 35 : tries_(), | |
| 36 canonicalizer_(), | |
| 37 parent_(NULL), | |
| 38 field_(field), | |
| 39 deepest_ruleset_level_(field), | |
| 40 rule_(rule.Pass()), | |
| 41 sub_regions_(), | |
| 42 language_codes_() { | |
| 43 assert(field_ >= COUNTRY); | |
| 44 assert(field_ <= DEPENDENT_LOCALITY); | |
| 45 assert(rule_ != NULL); | |
| 46 } | |
| 47 | |
| 48 Ruleset::~Ruleset() { | |
| 49 STLDeleteValues(&sub_regions_); | |
| 50 STLDeleteValues(&language_codes_); | |
| 51 | |
| 52 // Delete the maps and trie objects owned by |tries_| field. | |
| 53 for (LanguageCodeTries::const_iterator lang_it = tries_.begin(); | |
| 54 lang_it != tries_.end(); ++lang_it) { | |
| 55 AddressFieldTries* address_field_tries = lang_it->second; | |
| 56 assert(address_field_tries != NULL); | |
| 57 | |
| 58 for (AddressFieldTries::const_iterator address_field_it = | |
| 59 address_field_tries->begin(); | |
| 60 address_field_it != address_field_tries->end(); | |
| 61 ++address_field_it) { | |
| 62 IdentityFieldTries* identity_field_tries = address_field_it->second; | |
| 63 assert(identity_field_tries != NULL); | |
| 64 | |
| 65 for (IdentityFieldTries::const_iterator identity_field_it = | |
| 66 identity_field_tries->begin(); | |
| 67 identity_field_it != identity_field_tries->end(); | |
| 68 ++identity_field_it) { | |
| 69 // The tries do not own the ruleset objects. | |
| 70 Trie<const Ruleset*>* trie = identity_field_it->second; | |
| 71 assert(trie != NULL); | |
| 72 delete trie; | |
| 73 } | |
| 74 delete identity_field_tries; | |
| 75 } | |
| 76 delete address_field_tries; | |
| 77 } | |
| 78 } | |
| 79 | |
| 80 void Ruleset::AddSubRegionRuleset(const std::string& sub_region, | |
| 81 scoped_ptr<Ruleset> ruleset) { | |
| 82 assert(sub_regions_.find(sub_region) == sub_regions_.end()); | |
| 83 assert(ruleset != NULL); | |
| 84 assert(ruleset->field() == static_cast<AddressField>(field() + 1)); | |
| 85 | |
| 86 ruleset->parent_ = this; | |
| 87 sub_regions_[sub_region] = ruleset.release(); | |
| 88 } | |
| 89 | |
| 90 void Ruleset::AddLanguageCodeRule(const std::string& language_code, | |
| 91 scoped_ptr<Rule> rule) { | |
| 92 assert(language_codes_.find(language_code) == language_codes_.end()); | |
| 93 assert(rule != NULL); | |
| 94 language_codes_[language_code] = rule.release(); | |
| 95 } | |
| 96 | |
| 97 Ruleset* Ruleset::GetSubRegionRuleset(const std::string& sub_region) const { | |
| 98 std::map<std::string, Ruleset*>::const_iterator it = | |
| 99 sub_regions_.find(sub_region); | |
| 100 return it != sub_regions_.end() ? it->second : NULL; | |
| 101 } | |
| 102 | |
| 103 const Rule& Ruleset::GetLanguageCodeRule( | |
| 104 const std::string& language_code) const { | |
| 105 std::map<std::string, const Rule*>::const_iterator it = | |
| 106 language_codes_.find(language_code); | |
| 107 return it != language_codes_.end() ? *it->second : *rule_; | |
| 108 } | |
| 109 | |
| 110 void Ruleset::BuildPrefixSearchIndex() { | |
| 111 assert(field_ == COUNTRY); | |
| 112 assert(tries_.empty()); | |
| 113 | |
| 114 // Default language tries. | |
| 115 tries_[""] = new AddressFieldTries; | |
| 116 | |
| 117 // Non-default language tries. | |
| 118 for (std::vector<std::string>::const_iterator lang_it = | |
| 119 rule_->GetLanguages().begin(); | |
| 120 lang_it != rule_->GetLanguages().end(); | |
| 121 ++lang_it) { | |
| 122 if (*lang_it != rule_->GetLanguage() && !lang_it->empty()) { | |
| 123 tries_[*lang_it] = new AddressFieldTries; | |
| 124 } | |
| 125 } | |
| 126 | |
| 127 for (LanguageCodeTries::const_iterator lang_it = tries_.begin(); | |
| 128 lang_it != tries_.end(); ++lang_it) { | |
| 129 AddressFieldTries* address_field_tries = lang_it->second; | |
| 130 address_field_tries->insert( | |
| 131 std::make_pair(ADMIN_AREA, new IdentityFieldTries)); | |
| 132 address_field_tries->insert( | |
| 133 std::make_pair(LOCALITY, new IdentityFieldTries)); | |
| 134 address_field_tries->insert( | |
| 135 std::make_pair(DEPENDENT_LOCALITY, new IdentityFieldTries)); | |
| 136 | |
| 137 for (AddressFieldTries::const_iterator address_field_it = | |
| 138 address_field_tries->begin(); | |
| 139 address_field_it != address_field_tries->end(); | |
| 140 ++address_field_it) { | |
| 141 IdentityFieldTries* identity_field_tries = address_field_it->second; | |
| 142 identity_field_tries->insert( | |
| 143 std::make_pair(Rule::KEY, new Trie<const Ruleset*>)); | |
| 144 identity_field_tries->insert( | |
| 145 std::make_pair(Rule::NAME, new Trie<const Ruleset*>)); | |
| 146 identity_field_tries->insert( | |
| 147 std::make_pair(Rule::LATIN_NAME, new Trie<const Ruleset*>)); | |
| 148 } | |
| 149 } | |
| 150 | |
| 151 canonicalizer_ = StringCanonicalizer::Build(); | |
| 152 AddSubRegionRulesetsToTrie(*this); | |
| 153 } | |
| 154 | |
| 155 void Ruleset::FindRulesetsByPrefix(const std::string& language_code, | |
| 156 AddressField ruleset_level, | |
| 157 Rule::IdentityField identity_field, | |
| 158 const std::string& prefix, | |
| 159 std::set<const Ruleset*>* result) const { | |
| 160 assert(field_ == COUNTRY); | |
| 161 assert(ruleset_level >= ADMIN_AREA); | |
| 162 assert(ruleset_level <= DEPENDENT_LOCALITY); | |
| 163 assert(result != NULL); | |
| 164 assert(canonicalizer_ != NULL); | |
| 165 | |
| 166 LanguageCodeTries::const_iterator lang_it = tries_.find(language_code); | |
| 167 AddressFieldTries* address_field_tries = lang_it != tries_.end() | |
| 168 ? lang_it->second : tries_.find("")->second; | |
| 169 assert(address_field_tries != NULL); | |
| 170 | |
| 171 AddressFieldTries::const_iterator address_field_it = | |
| 172 address_field_tries->find(ruleset_level); | |
| 173 assert(address_field_it != address_field_tries->end()); | |
| 174 | |
| 175 IdentityFieldTries* identity_field_tries = address_field_it->second; | |
| 176 assert(identity_field_tries != NULL); | |
| 177 | |
| 178 IdentityFieldTries::const_iterator identity_field_it = | |
| 179 identity_field_tries->find(identity_field); | |
| 180 assert(identity_field_it != identity_field_tries->end()); | |
| 181 | |
| 182 Trie<const Ruleset*>* trie = identity_field_it->second; | |
| 183 assert(trie != NULL); | |
| 184 | |
| 185 trie->FindDataForKeyPrefix( | |
| 186 canonicalizer_->CanonicalizeString(prefix), result); | |
| 187 } | |
| 188 | |
| 189 void Ruleset::AddSubRegionRulesetsToTrie(const Ruleset& parent_ruleset) { | |
| 190 assert(field_ == COUNTRY); | |
| 191 assert(canonicalizer_ != NULL); | |
| 192 | |
| 193 for (std::map<std::string, Ruleset*>::const_iterator sub_region_it = | |
| 194 parent_ruleset.sub_regions_.begin(); | |
| 195 sub_region_it != parent_ruleset.sub_regions_.end(); | |
| 196 ++sub_region_it) { | |
| 197 const Ruleset* ruleset = sub_region_it->second; | |
| 198 assert(ruleset != NULL); | |
| 199 | |
| 200 if (deepest_ruleset_level_ < ruleset->field()) { | |
| 201 deepest_ruleset_level_ = ruleset->field(); | |
| 202 } | |
| 203 | |
| 204 for (LanguageCodeTries::const_iterator lang_it = tries_.begin(); | |
| 205 lang_it != tries_.end(); ++lang_it) { | |
| 206 const std::string& language_code = lang_it->first; | |
| 207 const Rule& rule = ruleset->GetLanguageCodeRule(language_code); | |
| 208 | |
| 209 AddressFieldTries* address_field_tries = lang_it->second; | |
| 210 assert(address_field_tries != NULL); | |
| 211 | |
| 212 AddressFieldTries::const_iterator address_field_it = | |
| 213 address_field_tries->find(ruleset->field()); | |
| 214 assert(address_field_it != address_field_tries->end()); | |
| 215 | |
| 216 IdentityFieldTries* identity_field_tries = address_field_it->second; | |
| 217 assert(identity_field_tries != NULL); | |
| 218 | |
| 219 IdentityFieldTries::const_iterator identity_field_it = | |
| 220 identity_field_tries->find(Rule::KEY); | |
| 221 assert(identity_field_it != identity_field_tries->end()); | |
| 222 | |
| 223 Trie<const Ruleset*>* key_trie = identity_field_it->second; | |
| 224 assert(key_trie != NULL); | |
| 225 | |
| 226 identity_field_it = identity_field_tries->find(Rule::NAME); | |
| 227 assert(identity_field_it != identity_field_tries->end()); | |
| 228 | |
| 229 Trie<const Ruleset*>* name_trie = identity_field_it->second; | |
| 230 assert(name_trie != NULL); | |
| 231 | |
| 232 identity_field_it = identity_field_tries->find(Rule::LATIN_NAME); | |
| 233 assert(identity_field_it != identity_field_tries->end()); | |
| 234 | |
| 235 Trie<const Ruleset*>* latin_name_trie = identity_field_it->second; | |
| 236 assert(latin_name_trie != NULL); | |
| 237 | |
| 238 if (!rule.GetKey().empty()) { | |
| 239 key_trie->AddDataForKey( | |
| 240 canonicalizer_->CanonicalizeString(rule.GetKey()), ruleset); | |
| 241 } | |
| 242 | |
| 243 if (!rule.GetName().empty()) { | |
| 244 name_trie->AddDataForKey( | |
| 245 canonicalizer_->CanonicalizeString(rule.GetName()), ruleset); | |
| 246 } | |
| 247 | |
| 248 if (!rule.GetLatinName().empty()) { | |
| 249 latin_name_trie->AddDataForKey( | |
| 250 canonicalizer_->CanonicalizeString(rule.GetLatinName()), ruleset); | |
| 251 } | |
| 252 } | |
| 253 | |
| 254 AddSubRegionRulesetsToTrie(*ruleset); | |
| 255 } | |
| 256 } | |
| 257 | |
| 258 } // namespace addressinput | |
| 259 } // namespace i18n | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 389863002:
Remove Chrome's own version of libaddressinput in favor of the upstream. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src