[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 50 matching lines @@
       *field = ORGANIZATION;
       return true;
     case 'N':
       *field = RECIPIENT;
       return true;
     default:
       return false;
   }
 }
 
-// Clears |fields|, parses |format|, and adds the format address fields to
-// |fields|.
+// Clears |lines|, parses |format|, and adds the address fields and literals to
+// |lines|.
 //
-// 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}, {}}.
+// 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& format,
-                              std::vector<std::vector<AddressField> >* fields) {
-  assert(fields != NULL);
-  fields->clear();
-  fields->resize(1);
+                              std::vector<std::vector<FormatElement> >* lines) {
+  assert(lines != NULL);
+  lines->clear();
+  lines->resize(1);
+
   std::vector<std::string> format_parts;
   SplitString(format, '%', &format_parts);
+
+  // If the address format starts with a literal, then it will be in the first
+  // element of |format_parts|. This literal does not begin with % and should
+  // not be parsed as a token.
+  if (!format_parts.empty() && !format_parts[0].empty()) {
+    lines->back().push_back(FormatElement(format_parts[0]));
+  }
+
+  // The rest of the elements in |format_parts| begin with %.
   for (size_t i = 1; i < format_parts.size(); ++i) {
+    if (format_parts[i].empty()) {
+      continue;
+    }
+
+    // The first character after % denotes a field or a newline token.
+    const char control_character = format_parts[i][0];
+
+    // The rest of the string after the token is a literal.
+    const std::string literal = format_parts[i].substr(1);
+
     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(control_character, &field)) {
+      lines->back().push_back(FormatElement(field));
+    } else if (control_character == 'n') {
+      lines->push_back(std::vector<FormatElement>());
+    }
+
+    if (!literal.empty()) {
+      lines->back().push_back(FormatElement(literal));
     }
   }
 }
 
 // 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