| OLD | NEW |
|---|
| (Empty) |
| 1 // Copyright (C) 2013 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 "rule.h" | |
| 16 | |
| 17 #include <libaddressinput/address_field.h> | |
| 18 #include <libaddressinput/util/scoped_ptr.h> | |
| 19 | |
| 20 #include <cassert> | |
| 21 #include <cstddef> | |
| 22 #include <string> | |
| 23 #include <vector> | |
| 24 | |
| 25 #include "region_data_constants.h" | |
| 26 #include "util/json.h" | |
| 27 #include "util/string_util.h" | |
| 28 | |
| 29 namespace i18n { | |
| 30 namespace addressinput { | |
| 31 | |
| 32 namespace { | |
| 33 | |
| 34 bool ParseToken(char c, AddressField* field) { | |
| 35 assert(field != NULL); | |
| 36 switch (c) { | |
| 37 case 'R': | |
| 38 *field = COUNTRY; | |
| 39 return true; | |
| 40 case 'S': | |
| 41 *field = ADMIN_AREA; | |
| 42 return true; | |
| 43 case 'C': | |
| 44 *field = LOCALITY; | |
| 45 return true; | |
| 46 case 'D': | |
| 47 *field = DEPENDENT_LOCALITY; | |
| 48 return true; | |
| 49 case 'X': | |
| 50 *field = SORTING_CODE; | |
| 51 return true; | |
| 52 case 'Z': | |
| 53 *field = POSTAL_CODE; | |
| 54 return true; | |
| 55 case 'A': | |
| 56 *field = STREET_ADDRESS; | |
| 57 return true; | |
| 58 case 'O': | |
| 59 *field = ORGANIZATION; | |
| 60 return true; | |
| 61 case 'N': | |
| 62 *field = RECIPIENT; | |
| 63 return true; | |
| 64 default: | |
| 65 return false; | |
| 66 } | |
| 67 } | |
| 68 | |
| 69 // Clears |lines|, parses |format|, and adds the address fields and literals to | |
| 70 // |lines|. | |
| 71 // | |
| 72 // For example, the address format in Finland is "%O%n%N%n%A%nAX-%Z %C%nÅLAND". | |
| 73 // It includes the allowed fields prefixed with %, newlines denoted %n, and the | |
| 74 // extra text that should be included on an envelope. It is parsed into: | |
| 75 // { | |
| 76 // {ORGANIZATION}, | |
| 77 // {RECIPIENT}, | |
| 78 // {STREET_ADDRESS}, | |
| 79 // {"AX-", POSTAL_CODE, " ", LOCALITY}, | |
| 80 // {"ÅLAND"} | |
| 81 // } | |
| 82 void ParseAddressFieldsFormat(const std::string& format, | |
| 83 std::vector<std::vector<FormatElement> >* lines) { | |
| 84 assert(lines != NULL); | |
| 85 lines->clear(); | |
| 86 lines->resize(1); | |
| 87 | |
| 88 std::vector<std::string> format_parts; | |
| 89 SplitString(format, '%', &format_parts); | |
| 90 | |
| 91 // If the address format starts with a literal, then it will be in the first | |
| 92 // element of |format_parts|. This literal does not begin with % and should | |
| 93 // not be parsed as a token. | |
| 94 if (!format_parts.empty() && !format_parts[0].empty()) { | |
| 95 lines->back().push_back(FormatElement(format_parts[0])); | |
| 96 } | |
| 97 | |
| 98 // The rest of the elements in |format_parts| begin with %. | |
| 99 for (size_t i = 1; i < format_parts.size(); ++i) { | |
| 100 if (format_parts[i].empty()) { | |
| 101 continue; | |
| 102 } | |
| 103 | |
| 104 // The first character after % denotes a field or a newline token. | |
| 105 const char control_character = format_parts[i][0]; | |
| 106 | |
| 107 // The rest of the string after the token is a literal. | |
| 108 const std::string literal = format_parts[i].substr(1); | |
| 109 | |
| 110 AddressField field = COUNTRY; | |
| 111 if (ParseToken(control_character, &field)) { | |
| 112 lines->back().push_back(FormatElement(field)); | |
| 113 } else if (control_character == 'n') { | |
| 114 lines->push_back(std::vector<FormatElement>()); | |
| 115 } | |
| 116 | |
| 117 if (!literal.empty()) { | |
| 118 lines->back().push_back(FormatElement(literal)); | |
| 119 } | |
| 120 } | |
| 121 } | |
| 122 | |
| 123 // Clears |fields|, parses |required|, and adds the required fields to |fields|. | |
| 124 // For example, parses "SCDX" into {ADMIN_AREA, LOCALITY, DEPENDENT_LOCALITY, | |
| 125 // SORTING_CODE}. | |
| 126 void ParseAddressFieldsRequired(const std::string& required, | |
| 127 std::vector<AddressField>* fields) { | |
| 128 assert(fields != NULL); | |
| 129 fields->clear(); | |
| 130 for (size_t i = 0; i < required.length(); ++i) { | |
| 131 AddressField field = COUNTRY; | |
| 132 if (ParseToken(required[i], &field)) { | |
| 133 fields->push_back(field); | |
| 134 } | |
| 135 } | |
| 136 } | |
| 137 | |
| 138 // Finds |target| in |values_to_compare| and sets |selected_value| to the | |
| 139 // associated value from |values_to_select|. Returns true if |target| is in | |
| 140 // |values_to_compare|. |selected_value| should not be NULL. |values_to_compare| | |
| 141 // should not be larger than |values_to_select|. | |
| 142 bool GetMatchingValue(const std::string& target, | |
| 143 const std::vector<std::string>& values_to_compare, | |
| 144 const std::vector<std::string>& values_to_select, | |
| 145 std::string* selected_value) { | |
| 146 assert(selected_value != NULL); | |
| 147 assert(values_to_select.size() >= values_to_compare.size()); | |
| 148 for (size_t i = 0; i < values_to_compare.size(); ++i) { | |
| 149 if (LooseStringCompare(values_to_compare[i], target)) { | |
| 150 *selected_value = values_to_select[i]; | |
| 151 return true; | |
| 152 } | |
| 153 } | |
| 154 return false; | |
| 155 } | |
| 156 | |
| 157 } // namespace | |
| 158 | |
| 159 FormatElement::FormatElement(AddressField field) | |
| 160 : field(field), literal() {} | |
| 161 | |
| 162 FormatElement::FormatElement(const std::string& literal) | |
| 163 : field(COUNTRY), literal(literal) { | |
| 164 assert(!literal.empty()); | |
| 165 } | |
| 166 | |
| 167 FormatElement::~FormatElement() {} | |
| 168 | |
| 169 bool FormatElement::operator==(const FormatElement& other) const { | |
| 170 return field == other.field && literal == other.literal; | |
| 171 } | |
| 172 | |
| 173 Rule::Rule() {} | |
| 174 | |
| 175 Rule::~Rule() {} | |
| 176 | |
| 177 // static | |
| 178 const Rule& Rule::GetDefault() { | |
| 179 // Allocated once and leaked on shutdown. | |
| 180 static Rule* default_rule = NULL; | |
| 181 if (default_rule == NULL) { | |
| 182 default_rule = new Rule; | |
| 183 default_rule->ParseSerializedRule( | |
| 184 RegionDataConstants::GetDefaultRegionData()); | |
| 185 } | |
| 186 return *default_rule; | |
| 187 } | |
| 188 | |
| 189 void Rule::CopyFrom(const Rule& rule) { | |
| 190 key_ = rule.key_; | |
| 191 name_ = rule.name_; | |
| 192 latin_name_ = rule.latin_name_; | |
| 193 format_ = rule.format_; | |
| 194 latin_format_ = rule.latin_format_; | |
| 195 required_ = rule.required_; | |
| 196 sub_keys_ = rule.sub_keys_; | |
| 197 languages_ = rule.languages_; | |
| 198 input_languages_ = rule.input_languages_; | |
| 199 language_ = rule.language_; | |
| 200 sub_keys_ = rule.sub_keys_; | |
| 201 sub_names_ = rule.sub_names_; | |
| 202 sub_lnames_ = rule.sub_lnames_; | |
| 203 postal_code_format_ = rule.postal_code_format_; | |
| 204 admin_area_name_type_ = rule.admin_area_name_type_; | |
| 205 postal_code_name_type_ = rule.postal_code_name_type_; | |
| 206 } | |
| 207 | |
| 208 bool Rule::ParseSerializedRule(const std::string& serialized_rule) { | |
| 209 scoped_ptr<Json> json(Json::Build()); | |
| 210 if (!json->ParseObject(serialized_rule)) { | |
| 211 return false; | |
| 212 } | |
| 213 ParseJsonRule(*json); | |
| 214 return true; | |
| 215 } | |
| 216 | |
| 217 void Rule::ParseJsonRule(const Json& json_rule) { | |
| 218 std::string value; | |
| 219 if (json_rule.GetStringValueForKey("key", &value)) { | |
| 220 key_.swap(value); | |
| 221 } | |
| 222 | |
| 223 if (json_rule.GetStringValueForKey("name", &value)) { | |
| 224 name_.swap(value); | |
| 225 } | |
| 226 | |
| 227 if (json_rule.GetStringValueForKey("lname", &value)) { | |
| 228 latin_name_.swap(value); | |
| 229 } | |
| 230 | |
| 231 if (json_rule.GetStringValueForKey("fmt", &value)) { | |
| 232 ParseAddressFieldsFormat(value, &format_); | |
| 233 } | |
| 234 | |
| 235 if (json_rule.GetStringValueForKey("lfmt", &value)) { | |
| 236 ParseAddressFieldsFormat(value, &latin_format_); | |
| 237 } | |
| 238 | |
| 239 if (json_rule.GetStringValueForKey("require", &value)) { | |
| 240 ParseAddressFieldsRequired(value, &required_); | |
| 241 } | |
| 242 | |
| 243 // Used as a separator in a list of items. For example, the list of supported | |
| 244 // languages can be "de~fr~it". | |
| 245 static const char kSeparator = '~'; | |
| 246 if (json_rule.GetStringValueForKey("sub_keys", &value)) { | |
| 247 SplitString(value, kSeparator, &sub_keys_); | |
| 248 } | |
| 249 | |
| 250 if (json_rule.GetStringValueForKey("sub_names", &value)) { | |
| 251 SplitString(value, kSeparator, &sub_names_); | |
| 252 assert(sub_names_.size() == sub_keys_.size()); | |
| 253 } | |
| 254 | |
| 255 if (json_rule.GetStringValueForKey("sub_lnames", &value)) { | |
| 256 SplitString(value, kSeparator, &sub_lnames_); | |
| 257 assert(sub_lnames_.size() == sub_keys_.size()); | |
| 258 } | |
| 259 | |
| 260 if (json_rule.GetStringValueForKey("languages", &value)) { | |
| 261 SplitString(value, kSeparator, &languages_); | |
| 262 } | |
| 263 | |
| 264 if (json_rule.GetStringValueForKey("input_languages", &value)) { | |
| 265 SplitString(value, kSeparator, &input_languages_); | |
| 266 } | |
| 267 | |
| 268 if (json_rule.GetStringValueForKey("lang", &value)) { | |
| 269 language_.swap(value); | |
| 270 } | |
| 271 | |
| 272 if (json_rule.GetStringValueForKey("zip", &value)) { | |
| 273 postal_code_format_.swap(value); | |
| 274 } | |
| 275 | |
| 276 if (json_rule.GetStringValueForKey("state_name_type", &value)) { | |
| 277 admin_area_name_type_.swap(value); | |
| 278 } | |
| 279 | |
| 280 if (json_rule.GetStringValueForKey("zip_name_type", &value)) { | |
| 281 postal_code_name_type_.swap(value); | |
| 282 } | |
| 283 } | |
| 284 | |
| 285 const std::string& Rule::GetIdentityField(IdentityField identity_field) const { | |
| 286 switch (identity_field) { | |
| 287 case KEY: | |
| 288 return key_; | |
| 289 case NAME: | |
| 290 return name_; | |
| 291 case LATIN_NAME: | |
| 292 return latin_name_; | |
| 293 case IDENTITY_FIELDS_SIZE: | |
| 294 assert(false); | |
| 295 } | |
| 296 return key_; | |
| 297 } | |
| 298 | |
| 299 bool Rule::CanonicalizeSubKey(const std::string& user_input, | |
| 300 bool keep_input_latin, | |
| 301 std::string* sub_key) const { | |
| 302 assert(sub_key != NULL); | |
| 303 | |
| 304 if (sub_keys_.empty()) { | |
| 305 *sub_key = user_input; | |
| 306 return true; | |
| 307 } | |
| 308 | |
| 309 return GetMatchingValue(user_input, sub_keys_, sub_keys_, sub_key) || | |
| 310 GetMatchingValue(user_input, sub_names_, sub_keys_, sub_key) || | |
| 311 (keep_input_latin && | |
| 312 GetMatchingValue(user_input, sub_lnames_, sub_lnames_, sub_key)) || | |
| 313 GetMatchingValue(user_input, sub_lnames_, sub_keys_, sub_key); | |
| 314 } | |
| 315 | |
| 316 } // namespace addressinput | |
| 317 } // namespace i18n | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 298863012:
Use upstream libaddressinput in Chrome. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src