[rac] Format an address for display.

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 53 matching lines @@
       *field = RECIPIENT;
       return true;
     default:
       return false;
   }
 }
 
 // Clears |fields|, parses |format|, and adds the format address fields to
 // |fields|.
 //
-// For example, the address format in Switzerland is "%O%n%N%n%A%nAX-%Z
-// %C%nÅLAND". It includes the allowed fields prefixed with %, newlines denoted
-// %n, and the extra text that should be included on an envelope. This function
-// parses only the tokens denoted % to determine how an address input form
-// should be laid out.
-//
-// The format string "%O%n%N%n%A%nAX-%Z%C%nÅLAND" is parsed into
-// {{ORGANIZATION}, {RECIPIENT}, {STREET_ADDRESS}, {POSTAL_CODE, LOCALITY}, {}}.
-void ParseAddressFieldsFormat(const std::string& format,
-                              std::vector<std::vector<AddressField> >* fields) {
-  assert(fields != NULL);
-  fields->clear();
-  fields->resize(1);
-  std::vector<std::string> format_parts;
-  SplitString(format, '%', &format_parts);
-  for (size_t i = 1; i < format_parts.size(); ++i) {
+// For example, the address format in Finland is "%O%n%N%n%A%nAX-%Z %C%nÅLAND".
+// It includes the allowed fields prefixed with %, newlines denoted %n, and the
+// extra text that should be included on an envelope. It is parsed into:
+// {
+//     {ORGANIZATION},
+//     {RECIPIENT},
+//     {STREET_ADDRESS},
+//     {"AX-", POSTAL_CODE, " ", LOCALITY},
+//     {"ÅLAND"}
+// }
+void ParseAddressFieldsFormat(
+    const std::string& data,
+    std::vector<std::vector<FormatElement> >* elements) {

[Evan Stade, 2014/01/14 23:45:36]

nit: s/elements/lines

[please use gerrit instead, 2014/01/15 00:05:47]

Done.

+  assert(elements != NULL);
+  elements->clear();
+  elements->resize(1);
+
+  std::vector<std::string> data_parts;
+  SplitString(data, '%', &data_parts);
+
+  // If the address format starts with a literal, then it will be in the first
+  // element of |data_parts|. This literal does not begin with % and should not
+  // be parsed as a token.
+  if (!data_parts.empty() && !data_parts[0].empty()) {
+    elements->back().push_back(FormatElement(data_parts[0]));
+  }
+
+

[Evan Stade, 2014/01/14 23:45:36]

^H

[please use gerrit instead, 2014/01/15 00:05:47]

Done.

+  // The rest of the elements in |data_parts| begin with %. The first character
+  // after % denotes a field or a newline token. The rest of the string after
+  // the token is a literal.

[Evan Stade, 2014/01/14 23:45:36]

thanks for the explanation. To make the code more self-documenting, you could
use some local variables:

const char control_character = data_parts[i][0];
std::string literal = data_parts[i].substr(1);

[please use gerrit instead, 2014/01/15 00:05:47]

Done.

+  for (size_t i = 1; i < data_parts.size(); ++i) {
     AddressField field = COUNTRY;
-    if (ParseToken(format_parts[i][0], &field)) {
-      fields->back().push_back(field);
-    } else if (format_parts[i][0] == 'n') {
-      fields->push_back(std::vector<AddressField>());
+    if (ParseToken(data_parts[i][0], &field)) {
+      elements->back().push_back(FormatElement(field));
+    } else if (data_parts[i][0] == 'n') {
+      elements->push_back(std::vector<FormatElement>());
+    }
+    if (data_parts[i].length() > 1) {
+      elements->back().push_back(FormatElement(data_parts[i].substr(1)));
     }
   }
 }
 
 // Clears |fields|, parses |required|, and adds the required fields to |fields|.
 // For example, parses "SCDX" into {ADMIN_AREA, LOCALITY, DEPENDENT_LOCALITY,
 // SORTING_CODE}.
 void ParseAddressFieldsRequired(const std::string& required,
                                 std::vector<AddressField>* fields) {
   assert(fields != NULL);
@@ skipping 61 matching lines @@
   }
   if (postal_code_type == "zip") {
     return error ? IDS_LIBADDRESSINPUT_I18N_INVALID_ZIP_CODE_LABEL
                  : IDS_LIBADDRESSINPUT_I18N_ZIP_CODE_LABEL;
   }
   return INVALID_MESSAGE_ID;
 }
 
 }  // namespace
 
+FormatElement::FormatElement(AddressField field)
+    : field(field), literal() {}
+
+FormatElement::FormatElement(const std::string& literal)
+    : field(COUNTRY), literal(literal) {
+  assert(!literal.empty());
+}
+
+FormatElement::~FormatElement() {}
+
+bool FormatElement::operator==(const FormatElement& other) const {
+  return field == other.field && literal == other.literal;
+}
+
 Rule::Rule()
     : format_(),
       required_(),
       sub_keys_(),
       languages_(),
       language_(),
       postal_code_format_(),
       admin_area_name_message_id_(INVALID_MESSAGE_ID),
       postal_code_name_message_id_(INVALID_MESSAGE_ID) {}
 
@@ skipping 81 matching lines @@
       return IDS_LIBADDRESSINPUT_I18N_INVALID_DEPENDENT_LOCALITY_LABEL;
     case POSTAL_CODE:
       return invalid_postal_code_message_id_;
     default:
       return IDS_LIBADDRESSINPUT_I18N_INVALID_ENTRY;
   }
 }
 
 }  // namespace addressinput
 }  // namespace i18n