replace Phonemetadata API for repeated fields, in preparation for switch to nanoproto

java/libphonenumber/src/com/google/i18n/phonenumbers/AsYouTypeFormatter.java

@@ -176,12 +176,12 @@ public class AsYouTypeFormatter {
   }
 
   private void getAvailableFormats(String leadingDigits) {
-    List<NumberFormat> formatList =
-        (isCompleteNumber && currentMetadata.intlNumberFormatSize() > 0)
-        ? currentMetadata.intlNumberFormats()
-        : currentMetadata.numberFormats();
-    boolean nationalPrefixIsUsedByCountry = !currentMetadata.nationalPrefix.isEmpty();
-    for (NumberFormat format : formatList) {
+    NumberFormat[] numberFormats =
+        (isCompleteNumber && currentMetadata.intlNumberFormat.length > 0)
+        ? currentMetadata.intlNumberFormat
+        : currentMetadata.numberFormat;
+    boolean nationalPrefixIsUsedByCountry = (currentMetadata.nationalPrefix.length() != 0);
+    for (NumberFormat format : numberFormats) {
       if (!nationalPrefixIsUsedByCountry || isCompleteNumber ||
           format.nationalPrefixOptionalWhenFormatting ||
           PhoneNumberUtil.formattingRuleHasFirstGroupOnly(
@@ -203,14 +203,14 @@ public class AsYouTypeFormatter {
     Iterator<NumberFormat> it = possibleFormats.iterator();
     while (it.hasNext()) {
       NumberFormat format = it.next();
-      if (format.leadingDigitsPatternSize() == 0) {
+      if (format.leadingDigitsPattern.length == 0) {
         // Keep everything that isn't restricted by leading digits.
         continue;
       }
       int lastLeadingDigitsPattern =
-          Math.min(indexOfLeadingDigitsPattern, format.leadingDigitsPatternSize() - 1);
+          Math.min(indexOfLeadingDigitsPattern, format.leadingDigitsPattern.length - 1);
       Pattern leadingDigitsPattern = regexCache.getPatternForRegex(
-          format.getLeadingDigitsPattern(lastLeadingDigitsPattern));
+          format.leadingDigitsPattern[lastLeadingDigitsPattern]);
       Matcher m = leadingDigitsPattern.matcher(leadingDigits);
       if (!m.lookingAt()) {
         it.remove();

java/libphonenumber/src/com/google/i18n/phonenumbers/MetadataManager.java

@@ -79,7 +79,7 @@ class MetadataManager {
       in = new ObjectInputStream(source);
       PhoneMetadataCollection alternateFormats = new PhoneMetadataCollection();
       alternateFormats.readExternal(in);
-      for (PhoneMetadata metadata : alternateFormats.getMetadataList()) {
+      for (PhoneMetadata metadata : alternateFormats.metadata) {
         callingCodeToAlternateFormatsMap.put(metadata.countryCode, metadata);
       }
     } catch (IOException e) {
@@ -109,7 +109,7 @@ class MetadataManager {
       in = new ObjectInputStream(source);
       PhoneMetadataCollection shortNumberMetadata = new PhoneMetadataCollection();
       shortNumberMetadata.readExternal(in);
-      for (PhoneMetadata metadata : shortNumberMetadata.getMetadataList()) {
+      for (PhoneMetadata metadata : shortNumberMetadata.metadata) {
         regionCodeToShortNumberMetadataMap.put(regionCode, metadata);
       }
     } catch (IOException e) {

java/libphonenumber/src/com/google/i18n/phonenumbers/MultiFileMetadataSourceImpl.java

@@ -107,15 +107,15 @@ final class MultiFileMetadataSourceImpl implements MetadataSource {
     try {
       in = new ObjectInputStream(source);
       PhoneMetadataCollection metadataCollection = loadMetadataAndCloseInput(in);
-      List<PhoneMetadata> metadataList = metadataCollection.getMetadataList();
-      if (metadataList.isEmpty()) {
+      PhoneMetadata[] metadataList = metadataCollection.metadata;
+      if (metadataList.length == 0) {
         logger.log(Level.SEVERE, "empty metadata: " + fileName);
         throw new IllegalStateException("empty metadata: " + fileName);
       }
-      if (metadataList.size() > 1) {
+      if (metadataList.length > 1) {
         logger.log(Level.WARNING, "invalid metadata (too many entries): " + fileName);
       }
-      PhoneMetadata metadata = metadataList.get(0);
+      PhoneMetadata metadata = metadataList[0];
       if (isNonGeoRegion) {
         countryCodeToNonGeographicalMetadataMap.put(countryCallingCode, metadata);
       } else {

java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberMatcher.java

@@ -585,7 +585,7 @@ final class PhoneNumberMatcher implements Iterator<PhoneNumberMatch> {
     PhoneMetadata alternateFormats =
         MetadataManager.getAlternateFormatsForCountry(number.getCountryCode());
     if (alternateFormats != null) {
-      for (NumberFormat alternateFormat : alternateFormats.numberFormats()) {
+      for (NumberFormat alternateFormat : alternateFormats.numberFormat) {
         formattedNumberGroups = getNationalNumberGroups(util, number, alternateFormat);
         if (checker.checkGroups(util, number, normalizedCandidate, formattedNumberGroups)) {
           return true;
@@ -665,7 +665,7 @@ final class PhoneNumberMatcher implements Iterator<PhoneNumberMatch> {
     // Check if a national prefix should be present when formatting this number.
     String nationalNumber = util.getNationalSignificantNumber(number);
     NumberFormat formatRule =
-        util.chooseFormattingPatternForNumber(metadata.numberFormats(), nationalNumber);
+        util.chooseFormattingPatternForNumber(metadata.numberFormat, nationalNumber);
     // To do this, we check that a national prefix formatting rule was present and that it wasn't
     // just the first-group symbol ($1) with punctuation.
     if ((formatRule != null) && formatRule.nationalPrefixFormattingRule.length() > 0) {

java/libphonenumber/src/com/google/i18n/phonenumbers/PhoneNumberUtil.java

@@ -1113,7 +1113,8 @@ public class PhoneNumberUtil {
     StringBuilder formattedNumber = new StringBuilder(20);
 
     NumberFormat formattingPattern =
-        chooseFormattingPatternForNumber(userDefinedFormats, nationalSignificantNumber);
+        chooseFormattingPatternForNumber(userDefinedFormats.toArray(
+            new NumberFormat[userDefinedFormats.size()]), nationalSignificantNumber);
     if (formattingPattern == null) {
       // If no pattern above is matched, we format the number as a whole.
       formattedNumber.append(nationalSignificantNumber);
@@ -1446,7 +1447,7 @@ public class PhoneNumberUtil {
         PhoneMetadata metadata = getMetadataForRegion(regionCode);
         String nationalNumber = getNationalSignificantNumber(number);
         NumberFormat formatRule =
-            chooseFormattingPatternForNumber(metadata.numberFormats(), nationalNumber);
+            chooseFormattingPatternForNumber(metadata.numberFormat, nationalNumber);
         // The format rule could still be null here if the national number was 0 and there was no
         // raw input (this should not be possible for numbers generated by the phonenumber library
         // as they would also not have a country calling code and we would have exited earlier).
@@ -1533,7 +1534,7 @@ public class PhoneNumberUtil {
     }
     String nationalNumber = getNationalSignificantNumber(number);
     NumberFormat formatRule =
-        chooseFormattingPatternForNumber(metadata.numberFormats(), nationalNumber);
+        chooseFormattingPatternForNumber(metadata.numberFormat, nationalNumber);
     return formatRule != null;
   }
 
@@ -1597,7 +1598,7 @@ public class PhoneNumberUtil {
     } else if (metadataForRegionCallingFrom != null &&
                countryCode == getCountryCodeForValidRegion(regionCallingFrom)) {
       NumberFormat formattingPattern =
-          chooseFormattingPatternForNumber(metadataForRegionCallingFrom.numberFormats(),
+          chooseFormattingPatternForNumber(metadataForRegionCallingFrom.numberFormat,
                                            nationalNumber);
       if (formattingPattern == null) {
         // If no pattern above is matched, we format the original input.
@@ -1707,26 +1708,26 @@ public class PhoneNumberUtil {
                            PhoneMetadata metadata,
                            PhoneNumberFormat numberFormat,
                            String carrierCode) {
-    List<NumberFormat> intlNumberFormats = metadata.intlNumberFormats();
+    NumberFormat[] intlNumberFormats = metadata.intlNumberFormat;
     // When the intlNumberFormats exists, we use that to format national number for the
     // INTERNATIONAL format instead of using the numberDesc.numberFormats.
-    List<NumberFormat> availableFormats =
-        (intlNumberFormats.size() == 0 || numberFormat == PhoneNumberFormat.NATIONAL)
-        ? metadata.numberFormats()
-        : metadata.intlNumberFormats();
+    NumberFormat[] availableFormats =
+        (intlNumberFormats.length == 0 || numberFormat == PhoneNumberFormat.NATIONAL)
+        ? metadata.numberFormat
+        : metadata.intlNumberFormat;
     NumberFormat formattingPattern = chooseFormattingPatternForNumber(availableFormats, number);
     return (formattingPattern == null)
         ? number
         : formatNsnUsingPattern(number, formattingPattern, numberFormat, carrierCode);
   }
 
-  NumberFormat chooseFormattingPatternForNumber(List<NumberFormat> availableFormats,
+  NumberFormat chooseFormattingPatternForNumber(NumberFormat[] availableFormats,
                                                 String nationalNumber) {
     for (NumberFormat numFormat : availableFormats) {
-      int size = numFormat.leadingDigitsPatternSize();
+      int size = numFormat.leadingDigitsPattern.length;
       if (size == 0 || regexCache.getPatternForRegex(
               // We always use the last leading_digits_pattern, as it is the most detailed.
-              numFormat.getLeadingDigitsPattern(size - 1)).matcher(nationalNumber).lookingAt()) {
+              numFormat.leadingDigitsPattern[size - 1]).matcher(nationalNumber).lookingAt()) {
         Matcher m = regexCache.getPatternForRegex(numFormat.pattern).matcher(nationalNumber);
         if (m.matches()) {
           return numFormat;

java/libphonenumber/src/com/google/i18n/phonenumbers/Phonemetadata.java

@@ -22,6 +22,9 @@
 
 package com.google.i18n.phonenumbers;
 
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
 import java.io.Externalizable;
 import java.io.IOException;
 import java.io.ObjectInput;
@@ -41,21 +44,7 @@ public final class Phonemetadata {
     public String format = "";
 
     // repeated string leading_digits_pattern = 3;
-    private java.util.List<String> leadingDigitsPattern_ = new java.util.ArrayList<String>();
-    public java.util.List<String> leadingDigitPatterns() {
-      return leadingDigitsPattern_;
-    }
-    public int leadingDigitsPatternSize() { return leadingDigitsPattern_.size(); }
-    public String getLeadingDigitsPattern(int index) {
-      return leadingDigitsPattern_.get(index);
-    }
-    public NumberFormat addLeadingDigitsPattern(String value) {
-      if (value == null) {
-        throw new NullPointerException();
-      }
-      leadingDigitsPattern_.add(value);
-      return this;
-    }
+    public String[] leadingDigitsPattern = new String[0];
 
     // optional string national_prefix_formatting_rule = 4;
     public String nationalPrefixFormattingRule = "";
@@ -73,9 +62,10 @@ public final class Phonemetadata {
       if (other.format.length() != 0) {
         format = other.format;
       }
-      int leadingDigitsPatternSize = other.leadingDigitsPatternSize();
+      int leadingDigitsPatternSize = other.leadingDigitsPattern.length;
+      leadingDigitsPattern = new String[leadingDigitsPatternSize];
       for (int i = 0; i < leadingDigitsPatternSize; i++) {
-        addLeadingDigitsPattern(other.getLeadingDigitsPattern(i));
+        leadingDigitsPattern[i] = other.leadingDigitsPattern[i];
       }
       if (other.nationalPrefixFormattingRule.length() != 0) {
         nationalPrefixFormattingRule = other.nationalPrefixFormattingRule;
@@ -90,10 +80,10 @@ public final class Phonemetadata {
     public void writeExternal(ObjectOutput objectOutput) throws IOException {
       objectOutput.writeUTF(pattern);
       objectOutput.writeUTF(format);
-      int leadingDigitsPatternSize = leadingDigitsPatternSize();
+      int leadingDigitsPatternSize = leadingDigitsPattern.length;
       objectOutput.writeInt(leadingDigitsPatternSize);
       for (int i = 0; i < leadingDigitsPatternSize; i++) {
-        objectOutput.writeUTF(leadingDigitsPattern_.get(i));
+        objectOutput.writeUTF(leadingDigitsPattern[i]);
       }
 
       objectOutput.writeBoolean(nationalPrefixFormattingRule.length() != 0);
@@ -111,8 +101,9 @@ public final class Phonemetadata {
       pattern = objectInput.readUTF();
       format = objectInput.readUTF();
       int leadingDigitsPatternSize = objectInput.readInt();
+      leadingDigitsPattern = new String[leadingDigitsPatternSize];
       for (int i = 0; i < leadingDigitsPatternSize; i++) {
-        leadingDigitsPattern_.add(objectInput.readUTF());
+        leadingDigitsPattern[i] = objectInput.readUTF();
       }
       if (objectInput.readBoolean()) {
         nationalPrefixFormattingRule = objectInput.readUTF();
@@ -268,44 +259,10 @@ public final class Phonemetadata {
     public boolean sameMobileAndFixedLinePattern = false;
 
     // repeated NumberFormat number_format = 19;
-    private java.util.List<NumberFormat> numberFormat_ = new java.util.ArrayList<NumberFormat>();
-    public java.util.List<NumberFormat> numberFormats() {
-      return numberFormat_;
-    }
-    public int numberFormatSize() { return numberFormat_.size(); }
-    public NumberFormat getNumberFormat(int index) {
-      return numberFormat_.get(index);
-    }
-    public PhoneMetadata addNumberFormat(NumberFormat value) {
-      if (value == null) {
-        throw new NullPointerException();
-      }
-      numberFormat_.add(value);
-      return this;
-    }
+    public NumberFormat[] numberFormat = new NumberFormat[0];
 
     // repeated NumberFormat intl_number_format = 20;
-    private java.util.List<NumberFormat> intlNumberFormat_ =
-        new java.util.ArrayList<NumberFormat>();
-    public java.util.List<NumberFormat> intlNumberFormats() {
-      return intlNumberFormat_;
-    }
-    public int intlNumberFormatSize() { return intlNumberFormat_.size(); }
-    public NumberFormat getIntlNumberFormat(int index) {
-      return intlNumberFormat_.get(index);
-    }
-
-    public PhoneMetadata addIntlNumberFormat(NumberFormat value) {
-      if (value == null) {
-        throw new NullPointerException();
-      }
-      intlNumberFormat_.add(value);
-      return this;
-    }
-    public PhoneMetadata clearIntlNumberFormat() {
-      intlNumberFormat_.clear();
-      return this;
-    }
+    public NumberFormat[] intlNumberFormat = new NumberFormat[0];
 
     // optional bool main_country_for_code = 22 [default = false];
     public boolean mainCountryForCode = false;
@@ -416,16 +373,16 @@ public final class Phonemetadata {
 
       objectOutput.writeBoolean(sameMobileAndFixedLinePattern);
 
-      int numberFormatSize = numberFormatSize();
+      int numberFormatSize = numberFormat.length;
       objectOutput.writeInt(numberFormatSize);
       for (int i = 0; i < numberFormatSize; i++) {
-        numberFormat_.get(i).writeExternal(objectOutput);
+        numberFormat[i].writeExternal(objectOutput);
       }
 
-      int intlNumberFormatSize = intlNumberFormatSize();
+      int intlNumberFormatSize = intlNumberFormat.length;
       objectOutput.writeInt(intlNumberFormatSize);
       for (int i = 0; i < intlNumberFormatSize; i++) {
-        intlNumberFormat_.get(i).writeExternal(objectOutput);
+        intlNumberFormat[i].writeExternal(objectOutput);
       }
 
       objectOutput.writeBoolean(mainCountryForCode);
@@ -570,17 +527,17 @@ public final class Phonemetadata {
       sameMobileAndFixedLinePattern = objectInput.readBoolean();
 
       int nationalFormatSize = objectInput.readInt();
+      numberFormat = new NumberFormat[nationalFormatSize];
       for (int i = 0; i < nationalFormatSize; i++) {
-        NumberFormat numFormat = new NumberFormat();
-        numFormat.readExternal(objectInput);
-        numberFormat_.add(numFormat);
+        numberFormat[i] = new NumberFormat();
+        numberFormat[i].readExternal(objectInput);
       }
 
       int intlNumberFormatSize = objectInput.readInt();
+      intlNumberFormat = new NumberFormat[intlNumberFormatSize];
       for (int i = 0; i < intlNumberFormatSize; i++) {
-        NumberFormat numFormat = new NumberFormat();
-        numFormat.readExternal(objectInput);
-        intlNumberFormat_.add(numFormat);
+        intlNumberFormat[i] = new NumberFormat();
+        intlNumberFormat[i].readExternal(objectInput);
       }
 
       mainCountryForCode = objectInput.readBoolean();
@@ -601,40 +558,41 @@ public final class Phonemetadata {
     public PhoneMetadataCollection() {}
 
     // repeated PhoneMetadata metadata = 1;
-    private java.util.List<PhoneMetadata> metadata_ = new java.util.ArrayList<PhoneMetadata>();
-
-    public java.util.List<PhoneMetadata> getMetadataList() {
-      return metadata_;
-    }
-    public int getMetadataCount() { return metadata_.size(); }
+    public PhoneMetadata[] metadata = new PhoneMetadata[0];
 
     public PhoneMetadataCollection addMetadata(PhoneMetadata value) {
       if (value == null) {
         throw new NullPointerException();
       }
-      metadata_.add(value);
+      List<PhoneMetadata> metadataList =
+          new ArrayList<PhoneMetadata>(Arrays.asList(metadata));
+      metadataList.add(value);
+      metadata = metadataList.toArray(new PhoneMetadata[metadataList.size()]);
       return this;
     }
 
     public void writeExternal(ObjectOutput objectOutput) throws IOException {
-      int size = getMetadataCount();
+      int size = metadata.length;
       objectOutput.writeInt(size);
       for (int i = 0; i < size; i++) {
-        metadata_.get(i).writeExternal(objectOutput);
+        metadata[i].writeExternal(objectOutput);
       }
     }
 
     public void readExternal(ObjectInput objectInput) throws IOException {
       int size = objectInput.readInt();
       for (int i = 0; i < size; i++) {
-        PhoneMetadata metadata = new PhoneMetadata();
-        metadata.readExternal(objectInput);
-        metadata_.add(metadata);
+        PhoneMetadata phoneMetadata = new PhoneMetadata();
+        phoneMetadata.readExternal(objectInput);
+        List<PhoneMetadata> metadataList =
+            new ArrayList<PhoneMetadata>(Arrays.asList(metadata));
+        metadataList.add(phoneMetadata);
+        metadata = metadataList.toArray(new PhoneMetadata[metadataList.size()]);
       }
     }
 
     public PhoneMetadataCollection clear() {
-      metadata_.clear();
+      metadata = new PhoneMetadata[0];
       return this;
     }
 

java/libphonenumber/src/com/google/i18n/phonenumbers/SingleFileMetadataSourceImpl.java

@@ -104,8 +104,8 @@ final class SingleFileMetadataSourceImpl implements MetadataSource {
     try {
       in = new ObjectInputStream(source);
       PhoneMetadataCollection metadataCollection = loadMetadataAndCloseInput(in);
-      List<PhoneMetadata> metadataList = metadataCollection.getMetadataList();
-      if (metadataList.isEmpty()) {
+      PhoneMetadata[] metadataList = metadataCollection.metadata;
+      if (metadataList.length == 0) {
         logger.log(Level.SEVERE, "empty metadata: " + fileName);
         throw new IllegalStateException("empty metadata: " + fileName);
       }

java/libphonenumber/test/com/google/i18n/phonenumbers/MetadataManagerTest.java

@@ -29,7 +29,7 @@ public class MetadataManagerTest extends TestCase {
     // We should have some data for Germany.
     PhoneMetadata germanyAlternateFormats = MetadataManager.getAlternateFormatsForCountry(49);
     assertNotNull(germanyAlternateFormats);
-    assertTrue(germanyAlternateFormats.numberFormats().size() > 0);
+    assertTrue(germanyAlternateFormats.numberFormat.length > 0);
   }
 
   public void testShortNumberMetadataContainsData() throws Exception {

java/libphonenumber/test/com/google/i18n/phonenumbers/PhoneNumberUtilTest.java

@@ -138,10 +138,10 @@ public class PhoneNumberUtilTest extends TestMetadataTestCase {
     assertEquals(1, metadata.countryCode);
     assertEquals("011", metadata.internationalPrefix);
     assertTrue(metadata.nationalPrefix.length() != 0);
-    assertEquals(2, metadata.numberFormatSize());
+    assertEquals(2, metadata.numberFormat.length);
     assertEquals("(\\d{3})(\\d{3})(\\d{4})",
-                 metadata.getNumberFormat(1).pattern);
-    assertEquals("$1 $2 $3", metadata.getNumberFormat(1).format);
+                 metadata.numberFormat[1].pattern);
+    assertEquals("$1 $2 $3", metadata.numberFormat[1].format);
     assertEquals("[13-689]\\d{9}|2[0-35-9]\\d{8}",
                  metadata.generalDesc.nationalNumberPattern);
     assertEquals("\\d{7}(?:\\d{3})?", metadata.generalDesc.possibleNumberPattern);
@@ -159,12 +159,12 @@ public class PhoneNumberUtilTest extends TestMetadataTestCase {
     assertEquals(49, metadata.countryCode);
     assertEquals("00", metadata.internationalPrefix);
     assertEquals("0", metadata.nationalPrefix);
-    assertEquals(6, metadata.numberFormatSize());
-    assertEquals(1, metadata.getNumberFormat(5).leadingDigitsPatternSize());
-    assertEquals("900", metadata.getNumberFormat(5).getLeadingDigitsPattern(0));
+    assertEquals(6, metadata.numberFormat.length);
+    assertEquals(1, metadata.numberFormat[5].leadingDigitsPattern.length);
+    assertEquals("900", metadata.numberFormat[5].leadingDigitsPattern[0]);
     assertEquals("(\\d{3})(\\d{3,4})(\\d{4})",
-                 metadata.getNumberFormat(5).pattern);
-    assertEquals("$1 $2 $3", metadata.getNumberFormat(5).format);
+                 metadata.numberFormat[5].pattern);
+    assertEquals("$1 $2 $3", metadata.numberFormat[5].format);
     assertEquals("(?:[24-6]\\d{2}|3[03-9]\\d|[789](?:[1-9]\\d|0[2-9]))\\d{1,8}",
                  metadata.fixedLine.nationalNumberPattern);
     assertEquals("\\d{2,14}", metadata.fixedLine.possibleNumberPattern);
@@ -181,20 +181,20 @@ public class PhoneNumberUtilTest extends TestMetadataTestCase {
     assertEquals("0", metadata.nationalPrefix);
     assertEquals("0(?:(11|343|3715)15)?", metadata.nationalPrefixForParsing);
     assertEquals("9$1", metadata.nationalPrefixTransformRule);
-    assertEquals("$2 15 $3-$4", metadata.getNumberFormat(2).format);
+    assertEquals("$2 15 $3-$4", metadata.numberFormat[2].format);
     assertEquals("(9)(\\d{4})(\\d{2})(\\d{4})",
-                 metadata.getNumberFormat(3).pattern);
+                 metadata.numberFormat[3].pattern);
     assertEquals("(9)(\\d{4})(\\d{2})(\\d{4})",
-                 metadata.getIntlNumberFormat(3).pattern);
-    assertEquals("$1 $2 $3 $4", metadata.getIntlNumberFormat(3).format);
+                 metadata.intlNumberFormat[3].pattern);
+    assertEquals("$1 $2 $3 $4", metadata.intlNumberFormat[3].format);
   }
 
   public void testGetInstanceLoadInternationalTollFreeMetadata() {
     PhoneMetadata metadata = phoneUtil.getMetadataForNonGeographicalRegion(800);
     assertEquals("001", metadata.id);
     assertEquals(800, metadata.countryCode);
-    assertEquals("$1 $2", metadata.getNumberFormat(0).format);
-    assertEquals("(\\d{4})(\\d{4})", metadata.getNumberFormat(0).pattern);
+    assertEquals("$1 $2", metadata.numberFormat[0].format);
+    assertEquals("(\\d{4})(\\d{4})", metadata.numberFormat[0].pattern);
     assertEquals("12345678", metadata.generalDesc.exampleNumber);
     assertEquals("12345678", metadata.tollFree.exampleNumber);
   }

tools/java/common/src/com/google/i18n/phonenumbers/BuildMetadataFromXml.java

@@ -27,6 +27,7 @@ import org.w3c.dom.NodeList;
 
 import java.io.File;
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 import java.util.Map;
 import java.util.TreeMap;
@@ -125,7 +126,7 @@ public class BuildMetadataFromXml {
       PhoneMetadataCollection metadataCollection) {
     Map<Integer, List<String>> countryCodeToRegionCodeMap =
         new TreeMap<Integer, List<String>>();
-    for (PhoneMetadata metadata : metadataCollection.getMetadataList()) {
+    for (PhoneMetadata metadata : metadataCollection.metadata) {
       String regionCode = metadata.id;
       int countryCode = metadata.countryCode;
       if (countryCodeToRegionCodeMap.containsKey(countryCode)) {
@@ -258,7 +259,10 @@ public class BuildMetadataFromXml {
     }
 
     if (!intlFormat.format.isEmpty()) {
-      metadata.addIntlNumberFormat(intlFormat);
+      List<NumberFormat> formatList =
+          new ArrayList<NumberFormat> (Arrays.asList(metadata.intlNumberFormat));
+      formatList.add(intlFormat);
+      metadata.intlNumberFormat = formatList.toArray(new NumberFormat[formatList.size()]);
     }
     return hasExplicitIntlFormatDefined;
   }
@@ -333,7 +337,10 @@ public class BuildMetadataFromXml {
           format.domesticCarrierCodeFormattingRule = carrierCodeFormattingRule;
         }
         loadNationalFormat(metadata, numberFormatElement, format);
-        metadata.addNumberFormat(format);
+        List<NumberFormat> formatList =
+            new ArrayList<NumberFormat> (Arrays.asList(metadata.numberFormat));
+        formatList.add(format);
+        metadata.numberFormat = formatList.toArray(new NumberFormat[formatList.size()]);
 
         if (loadInternationalFormat(metadata, numberFormatElement, format)) {
           hasExplicitIntlFormatDefined = true;
@@ -344,7 +351,7 @@ public class BuildMetadataFromXml {
       // metadata. To minimize the size of the metadata file, we only keep intlNumberFormats that
       // actually differ in some way to the national formats.
       if (!hasExplicitIntlFormatDefined) {
-        metadata.clearIntlNumberFormat();
+        metadata.intlNumberFormat = new NumberFormat[0];
       }
     }
   }
@@ -354,10 +361,12 @@ public class BuildMetadataFromXml {
     NodeList leadingDigitsPatternNodes = numberFormatElement.getElementsByTagName(LEADING_DIGITS);
     int numOfLeadingDigitsPatterns = leadingDigitsPatternNodes.getLength();
     if (numOfLeadingDigitsPatterns > 0) {
+      List<String> patternList = new ArrayList<String>(Arrays.asList(format.leadingDigitsPattern));
       for (int i = 0; i < numOfLeadingDigitsPatterns; i++) {
-        format.addLeadingDigitsPattern(
+        patternList.add(
             validateRE((leadingDigitsPatternNodes.item(i)).getFirstChild().getNodeValue(), true));
       }
+      format.leadingDigitsPattern = patternList.toArray(new String[patternList.size()]);
     }
   }
 

tools/java/common/test/com/google/i18n/phonenumbers/BuildMetadataFromXmlTest.java

@@ -176,7 +176,7 @@ public class BuildMetadataFromXmlTest extends TestCase {
 
     assertTrue(BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
                                                             nationalFormat));
-    assertEquals(intlFormat, metadata.getIntlNumberFormat(0).format);
+    assertEquals(intlFormat, metadata.intlNumberFormat[0].format);
   }
 
   public void testLoadInternationalFormatWithBothNationalAndIntlFormatsDefined()
@@ -190,7 +190,7 @@ public class BuildMetadataFromXmlTest extends TestCase {
 
     assertTrue(BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
                                                             nationalFormat));
-    assertEquals(intlFormat, metadata.getIntlNumberFormat(0).format);
+    assertEquals(intlFormat, metadata.intlNumberFormat[0].format);
   }
 
   public void testLoadInternationalFormatExpectsOnlyOnePattern()
@@ -220,7 +220,7 @@ public class BuildMetadataFromXmlTest extends TestCase {
 
     assertFalse(BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
                                                              nationalFormat));
-    assertEquals(nationalPattern, metadata.getIntlNumberFormat(0).format);
+    assertEquals(nationalPattern, metadata.intlNumberFormat[0].format);
   }
 
   public void testLoadInternationalFormatCopiesNationalFormatData()
@@ -234,7 +234,7 @@ public class BuildMetadataFromXmlTest extends TestCase {
 
     assertFalse(BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
                                                              nationalFormat));
-    assertTrue(metadata.getIntlNumberFormat(0).nationalPrefixOptionalWhenFormatting);
+    assertTrue(metadata.intlNumberFormat[0].nationalPrefixOptionalWhenFormatting);
   }
 
   public void testLoadNationalFormat()
@@ -295,9 +295,9 @@ public class BuildMetadataFromXmlTest extends TestCase {
     PhoneMetadata metadata = new PhoneMetadata();
     BuildMetadataFromXml.loadAvailableFormats(
         metadata, element, "0", "", false /* NP not optional */);
-    assertEquals("($1)", metadata.getNumberFormat(0).nationalPrefixFormattingRule);
-    assertEquals("0 $CC ($1)", metadata.getNumberFormat(0).domesticCarrierCodeFormattingRule);
-    assertEquals("$1 $2 $3", metadata.getNumberFormat(0).format);
+    assertEquals("($1)", metadata.numberFormat[0].nationalPrefixFormattingRule);
+    assertEquals("0 $CC ($1)", metadata.numberFormat[0].domesticCarrierCodeFormattingRule);
+    assertEquals("$1 $2 $3", metadata.numberFormat[0].format);
   }
 
   public void testLoadAvailableFormatsPropagatesCarrierCodeFormattingRule()
@@ -314,9 +314,9 @@ public class BuildMetadataFromXmlTest extends TestCase {
     PhoneMetadata metadata = new PhoneMetadata();
     BuildMetadataFromXml.loadAvailableFormats(
         metadata, element, "0", "", false /* NP not optional */);
-    assertEquals("($1)", metadata.getNumberFormat(0).nationalPrefixFormattingRule);
-    assertEquals("0 $CC ($1)", metadata.getNumberFormat(0).domesticCarrierCodeFormattingRule);
-    assertEquals("$1 $2 $3", metadata.getNumberFormat(0).format);
+    assertEquals("($1)", metadata.numberFormat[0].nationalPrefixFormattingRule);
+    assertEquals("0 $CC ($1)", metadata.numberFormat[0].domesticCarrierCodeFormattingRule);
+    assertEquals("$1 $2 $3", metadata.numberFormat[0].format);
   }
 
   public void testLoadAvailableFormatsSetsProvidedNationalPrefixFormattingRule()
@@ -331,7 +331,7 @@ public class BuildMetadataFromXmlTest extends TestCase {
     PhoneMetadata metadata = new PhoneMetadata();
     BuildMetadataFromXml.loadAvailableFormats(
         metadata, element, "", "($1)", false /* NP not optional */);
-    assertEquals("($1)", metadata.getNumberFormat(0).nationalPrefixFormattingRule);
+    assertEquals("($1)", metadata.numberFormat[0].nationalPrefixFormattingRule);
   }
 
   public void testLoadAvailableFormatsClearsIntlFormat()
@@ -346,7 +346,7 @@ public class BuildMetadataFromXmlTest extends TestCase {
     PhoneMetadata metadata = new PhoneMetadata();
     BuildMetadataFromXml.loadAvailableFormats(
         metadata, element, "0", "($1)", false /* NP not optional */);
-    assertEquals(0, metadata.intlNumberFormatSize());
+    assertEquals(0, metadata.intlNumberFormat.length);
   }
 
   public void testLoadAvailableFormatsHandlesMultipleNumberFormats()
@@ -362,8 +362,8 @@ public class BuildMetadataFromXmlTest extends TestCase {
     PhoneMetadata metadata = new PhoneMetadata();
     BuildMetadataFromXml.loadAvailableFormats(
         metadata, element, "0", "($1)", false /* NP not optional */);
-    assertEquals("$1 $2 $3", metadata.getNumberFormat(0).format);
-    assertEquals("$1-$2", metadata.getNumberFormat(1).format);
+    assertEquals("$1 $2 $3", metadata.numberFormat[0].format);
+    assertEquals("$1-$2", metadata.numberFormat[1].format);
   }
 
   public void testLoadInternationalFormatDoesNotSetIntlFormatWhenNA()
@@ -374,9 +374,8 @@ public class BuildMetadataFromXmlTest extends TestCase {
     NumberFormat nationalFormat = new NumberFormat();
     nationalFormat.format = "$1 $2";
 
-    BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
-                                                 nationalFormat);
-    assertEquals(0, metadata.intlNumberFormatSize());
+    BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement, nationalFormat);
+    assertEquals(0, metadata.intlNumberFormat.length);
   }
 
   // Tests setLeadingDigitsPatterns() in the case of international and national formatting rules
@@ -399,12 +398,12 @@ public class BuildMetadataFromXmlTest extends TestCase {
     PhoneMetadata metadata = new PhoneMetadata();
     BuildMetadataFromXml.loadAvailableFormats(
         metadata, element, "0", "", false /* NP not optional */);
-    assertEquals(1, metadata.getNumberFormat(0).leadingDigitsPatternSize());
-    assertEquals(1, metadata.getNumberFormat(1).leadingDigitsPatternSize());
+    assertEquals(1, metadata.numberFormat[0].leadingDigitsPattern.length);
+    assertEquals(1, metadata.numberFormat[1].leadingDigitsPattern.length);
     // When we merge the national format rules into the international format rules, we shouldn't add
     // the leading digit patterns multiple times.
-    assertEquals(1, metadata.getIntlNumberFormat(0).leadingDigitsPatternSize());
-    assertEquals(1, metadata.getIntlNumberFormat(1).leadingDigitsPatternSize());
+    assertEquals(1, metadata.intlNumberFormat[0].leadingDigitsPattern.length);
+    assertEquals(1, metadata.intlNumberFormat[1].leadingDigitsPattern.length);
   }
 
   // Tests setLeadingDigitsPatterns().
@@ -418,8 +417,8 @@ public class BuildMetadataFromXmlTest extends TestCase {
     NumberFormat numberFormat = new NumberFormat();
     BuildMetadataFromXml.setLeadingDigitsPatterns(numberFormatElement, numberFormat);
 
-    assertEquals("1", numberFormat.getLeadingDigitsPattern(0));
-    assertEquals("2", numberFormat.getLeadingDigitsPattern(1));
+    assertEquals("1", numberFormat.leadingDigitsPattern[0]);
+    assertEquals("2", numberFormat.leadingDigitsPattern[1]);
   }
 
   // Tests getNationalPrefixFormattingRuleFromElement().
@@ -617,9 +616,9 @@ public class BuildMetadataFromXmlTest extends TestCase {
     PhoneMetadata metadata = BuildMetadataFromXml.loadCountryMetadata("FR", territoryElement,
         false /* liteBuild */, false /* isShortNumberMetadata */,
         true /* isAlternateFormatsMetadata */);
-    assertEquals("(1)(\\d{3})", metadata.getNumberFormat(0).pattern);
-    assertEquals("1", metadata.getNumberFormat(0).getLeadingDigitsPattern(0));
-    assertEquals("$1", metadata.getNumberFormat(0).format);
+    assertEquals("(1)(\\d{3})", metadata.numberFormat[0].pattern);
+    assertEquals("1", metadata.numberFormat[0].leadingDigitsPattern[0]);
+    assertEquals("$1", metadata.numberFormat[0].format);
     assertNull(metadata.fixedLine);
     assertNull(metadata.shortCode);
   }
@@ -645,11 +644,11 @@ public class BuildMetadataFromXmlTest extends TestCase {
     PhoneMetadata metadata = BuildMetadataFromXml.loadCountryMetadata("FR", territoryElement,
         false /* liteBuild */, false /* isShortNumberMetadata */,
         true /* isAlternateFormatsMetadata */);
-    assertTrue(metadata.getNumberFormat(0).nationalPrefixOptionalWhenFormatting);
+    assertTrue(metadata.numberFormat[0].nationalPrefixOptionalWhenFormatting);
     // This is inherited from the territory, with $NP replaced by the actual national prefix, and
     // $FG replaced with $1.
-    assertEquals("0$1", metadata.getNumberFormat(0).nationalPrefixFormattingRule);
+    assertEquals("0$1", metadata.numberFormat[0].nationalPrefixFormattingRule);
     // Here it is explicitly set to false.
-    assertFalse(metadata.getNumberFormat(1).nationalPrefixOptionalWhenFormatting);
+    assertFalse(metadata.numberFormat[1].nationalPrefixOptionalWhenFormatting);
   }
 }

tools/java/java-build/src/com/google/i18n/phonenumbers/BuildMetadataJsonFromXml.java

@@ -130,7 +130,7 @@ public class BuildMetadataJsonFromXml extends Command {
                                                 BufferedWriter writer) throws IOException {
     writer.write("{\n");
     boolean isFirstTimeInLoop = true;
-    for (PhoneMetadata metadata : metadataCollection.getMetadataList()) {
+    for (PhoneMetadata metadata : metadataCollection.metadata) {
       if (isFirstTimeInLoop) {
         isFirstTimeInLoop = false;
       } else {
@@ -186,11 +186,11 @@ public class BuildMetadataJsonFromXml extends Command {
     // required string format = 2;
     jsArrayBuilder.append(format.format);
     // repeated string leading_digits_pattern = 3;
-    int leadingDigitsPatternSize = format.leadingDigitsPatternSize();
+    int leadingDigitsPatternSize = format.leadingDigitsPattern.length;
     if (leadingDigitsPatternSize > 0) {
       jsArrayBuilder.beginArray();
       for (int i = 0; i < leadingDigitsPatternSize; i++) {
-        jsArrayBuilder.append(format.getLeadingDigitsPattern(i));
+        jsArrayBuilder.append(format.leadingDigitsPattern[i]);
       }
       jsArrayBuilder.endArray();
     } else {
@@ -334,22 +334,22 @@ public class BuildMetadataJsonFromXml extends Command {
       jsArrayBuilder.append(null);
     }
     // repeated NumberFormat number_format = 19;
-    int numberFormatSize = metadata.numberFormatSize();
+    int numberFormatSize = metadata.numberFormat.length;
     if (numberFormatSize > 0) {
       jsArrayBuilder.beginArray();
       for (int i = 0; i < numberFormatSize; i++) {
-        toJsArray(metadata.getNumberFormat(i), jsArrayBuilder);
+        toJsArray(metadata.numberFormat[i], jsArrayBuilder);
       }
       jsArrayBuilder.endArray();
     } else {
       jsArrayBuilder.append(null);
     }
     // repeated NumberFormat intl_number_format = 20;
-    int intlNumberFormatSize = metadata.intlNumberFormatSize();
+    int intlNumberFormatSize = metadata.intlNumberFormat.length;
     if (intlNumberFormatSize > 0) {
       jsArrayBuilder.beginArray();
       for (int i = 0; i < intlNumberFormatSize; i++) {
-        toJsArray(metadata.getIntlNumberFormat(i), jsArrayBuilder);
+        toJsArray(metadata.intlNumberFormat[i], jsArrayBuilder);
       }
       jsArrayBuilder.endArray();
     } else {

tools/java/java-build/src/com/google/i18n/phonenumbers/BuildMetadataProtoFromXml.java

@@ -164,7 +164,7 @@ public class BuildMetadataProtoFromXml extends Command {
         metadataCollection.writeExternal(out);
         out.close();
       } else {
-        for (PhoneMetadata metadata : metadataCollection.getMetadataList()) {
+        for (PhoneMetadata metadata : metadataCollection.metadata) {
           String regionCode = metadata.id;
           // For non-geographical country calling codes (e.g. +800), or for alternate formats, use the
           // country calling codes instead of the region code to form the file name.