// Build the PhoneMetadataCollection from the input XML file.
 public static PhoneMetadataCollection BuildPhoneMetadataCollection(Stream input, bool liteBuild)
 {
     using (var reader = XmlReader.Create(input, new XmlReaderSettings()
     {
         DtdProcessing = DtdProcessing.Ignore
     }))
     {
         var document = new XmlDocument();
         document.Load(reader);
         document.Normalize();
         var metadataCollection = new PhoneMetadataCollection.Builder();
         foreach (XmlElement territory in document.GetElementsByTagName("territory"))
         {
             String regionCode = "";
             // For the main metadata file this should always be set, but for other supplementary data
             // files the country calling code may be all that is needed.
             if (territory.HasAttribute("id"))
             {
                 regionCode = territory.GetAttribute("id");
             }
             PhoneMetadata metadata = LoadCountryMetadata(regionCode, territory, liteBuild);
             metadataCollection.AddMetadata(metadata);
         }
         return(metadataCollection.Build());
     }
 }
Exemplo n.º 2
0
        // Build the PhoneMetadataCollection from the input XML file.
        public static PhoneMetadataCollection buildPhoneMetadataCollection(String inputXmlFile, bool liteBuild)
        {
//    DocumentBuilderFactory builderFactory = DocumentBuilderFactory.newInstance();
//    DocumentBuilder builder = builderFactory.newDocumentBuilder();
            var document = new XmlDocument();

//    File xmlFile = new File(inputXmlFile);
//    Document document = builder.parse(xmlFile);
            document.Load(inputXmlFile);
            document.Normalize();
            var territory = document.GetElementsByTagName("territory");

            PhoneMetadataCollection.Builder metadataCollection = PhoneMetadataCollection.newBuilder();
            int numOfTerritories = territory.Count;
            // TODO: Look for other uses of these constants and possibly pull them out into
            // a separate constants file.
            bool isShortNumberMetadata      = inputXmlFile.Contains("ShortNumberMetadata");
            bool isAlternateFormatsMetadata = inputXmlFile.Contains("PhoneNumberAlternateFormats");

            for (int i = 0; i < numOfTerritories; i++)
            {
                XmlElement territoryXmlElement = (XmlElement)territory.Item(i);
                String     regionCode          = "";
                // For the main metadata file this should always be set, but for other supplementary data
                // files the country calling code may be all that is needed.
                if (territoryXmlElement.HasAttribute("id"))
                {
                    regionCode = territoryXmlElement.GetAttribute("id");
                }
                PhoneMetadata metadata = loadCountryMetadata(regionCode, territoryXmlElement, liteBuild,
                                                             isShortNumberMetadata, isAlternateFormatsMetadata);
                metadataCollection.addMetadata(metadata);
            }
            return(metadataCollection.build());
        }
        /// <summary>
        /// Extracts the country calling code from the beginning of nationalNumber to
        /// prefixBeforeNationalNumber when they are available, and places the remaining input into
        /// nationalNumber.
        /// </summary>
        /// <returns>True when a valid country calling code can be found.</returns>
        private bool AttemptToExtractCountryCallingCode()
        {
            if (nationalNumber.Length == 0)
            {
                return(false);
            }
            var numberWithoutCountryCallingCode = new StringBuilder();
            var countryCode = phoneUtil.ExtractCountryCode(nationalNumber, numberWithoutCountryCallingCode);

            if (countryCode == 0)
            {
                return(false);
            }
            nationalNumber.Length = 0;
            nationalNumber.Append(numberWithoutCountryCallingCode);
            var newRegionCode = phoneUtil.GetRegionCodeForCountryCode(countryCode);

            if (PhoneNumberUtil.REGION_CODE_FOR_NON_GEO_ENTITY.Equals(newRegionCode))
            {
                currentMetadata = phoneUtil.GetMetadataForNonGeographicalRegion(countryCode);
            }
            else if (!newRegionCode.Equals(defaultCountry))
            {
                currentMetadata = GetMetadataForRegion(newRegionCode);
            }
            var countryCodeString = countryCode.ToString();

            prefixBeforeNationalNumber.Append(countryCodeString).Append(SeparatorBeforeNationalNumber);
            // When we have successfully extracted the IDD, the previously extracted NDD should be cleared
            // because it is no longer valid.
            extractedNationalPrefix = "";
            return(true);
        }
        /**
         * Extracts the country calling code from the beginning of nationalNumber to
         * prefixBeforeNationalNumber when they are available, and places the remaining input into
         * nationalNumber.
         *
         * @return  true when a valid country calling code can be found.
         */
        private bool AttemptToExtractCountryCallingCode()
        {
            if (nationalNumber.Length == 0)
            {
                return(false);
            }
            StringBuilder numberWithoutCountryCallingCode = new StringBuilder();
            int           countryCode = phoneUtil.ExtractCountryCode(nationalNumber, numberWithoutCountryCallingCode);

            if (countryCode == 0)
            {
                return(false);
            }
            nationalNumber.Length = 0;
            nationalNumber.Append(numberWithoutCountryCallingCode);
            String newRegionCode = phoneUtil.GetRegionCodeForCountryCode(countryCode);

            if (PhoneNumberUtil.REGION_CODE_FOR_NON_GEO_ENTITY.Equals(newRegionCode))
            {
                currentMetaData = phoneUtil.GetMetadataForNonGeographicalRegion(countryCode);
            }
            else if (!newRegionCode.Equals(defaultCountry))
            {
                currentMetaData = GetMetadataForRegion(newRegionCode);
            }
            String countryCodeString = countryCode.ToString();

            prefixBeforeNationalNumber.Append(countryCodeString).Append(" ");
            return(true);
        }
Exemplo n.º 5
0
        [TestMethod] public void testNationalPrefixRulesSetCorrectly()
        {
            String xmlInput =
                "<territory countryCode=\"33\" nationalPrefix=\"0\"" +
                " nationalPrefixFormattingRule=\"$NP$FG\">" +
                "  <availableFormats>" +
                "    <numberFormat pattern=\"(1)(\\d{3})\" nationalPrefixOptionalWhenFormatting=\"true\">" +
                "      <leadingDigits>1</leadingDigits>" +
                "      <format>$1</format>" +
                "    </numberFormat>" +
                "    <numberFormat pattern=\"(\\d{3})\" nationalPrefixOptionalWhenFormatting=\"false\">" +
                "      <leadingDigits>2</leadingDigits>" +
                "      <format>$1</format>" +
                "    </numberFormat>" +
                "  </availableFormats>" +
                "  <fixedLine><nationalNumberPattern>\\d{1}</nationalNumberPattern></fixedLine>" +
                "</territory>";
            XmlElement    territoryElement = parseXmlString(xmlInput);
            PhoneMetadata metadata         = BuildMetadataFromXml.loadCountryMetadata("FR", territoryElement,
                                                                                      false /* liteBuild */, false /* isShortNumberMetadata */,
                                                                                      true /* isAlternateFormatsMetadata */);

            Assert.IsTrue(metadata.getNumberFormat(0).isNationalPrefixOptionalWhenFormatting());
            // This is inherited from the territory, with $NP replaced by the actual national prefix, and
            // $FG replaced with $1.
            Assert.AreEqual("0$1", metadata.getNumberFormat(0).getNationalPrefixFormattingRule());
            // Here it is explicitly set to false.
            Assert.IsFalse(metadata.getNumberFormat(1).isNationalPrefixOptionalWhenFormatting());
        }
 /**
  * Constructs an as-you-type formatter. Should be obtained from {@link
  * PhoneNumberUtil#getAsYouTypeFormatter}.
  *
  * @param regionCode  the country/region where the phone number is being entered
  */
 public AsYouTypeFormatter(String regionCode)
 {
     digitPattern    = new Regex(digitPlaceholder, InternalRegexOptions.Default);
     defaultCountry  = regionCode;
     currentMetaData = GetMetadataForRegion(defaultCountry);
     defaultMetaData = currentMetaData;
 }
Exemplo n.º 7
0
        [TestMethod] public void testSetRelevantDescPatternsSetsAllDescriptionsForRegularLengthNumbers()
        {
            String xmlInput =
                "<territory countryCode=\"33\">" +
                "  <fixedLine><nationalNumberPattern>\\d{1}</nationalNumberPattern></fixedLine>" +
                "  <mobile><nationalNumberPattern>\\d{2}</nationalNumberPattern></mobile>" +
                "  <pager><nationalNumberPattern>\\d{3}</nationalNumberPattern></pager>" +
                "  <tollFree><nationalNumberPattern>\\d{4}</nationalNumberPattern></tollFree>" +
                "  <premiumRate><nationalNumberPattern>\\d{5}</nationalNumberPattern></premiumRate>" +
                "  <sharedCost><nationalNumberPattern>\\d{6}</nationalNumberPattern></sharedCost>" +
                "  <personalNumber><nationalNumberPattern>\\d{7}</nationalNumberPattern></personalNumber>" +
                "  <voip><nationalNumberPattern>\\d{8}</nationalNumberPattern></voip>" +
                "  <uan><nationalNumberPattern>\\d{9}</nationalNumberPattern></uan>" +
                "</territory>";
            XmlElement territoryElement = parseXmlString(xmlInput);

            PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
            BuildMetadataFromXml.setRelevantDescPatterns(metadata, territoryElement, false /* liteBuild */,
                                                         false /* isShortNumberMetadata */);
            Assert.AreEqual("\\d{1}", metadata.getFixedLine().getNationalNumberPattern());
            Assert.AreEqual("\\d{2}", metadata.getMobile().getNationalNumberPattern());
            Assert.AreEqual("\\d{3}", metadata.getPager().getNationalNumberPattern());
            Assert.AreEqual("\\d{4}", metadata.getTollFree().getNationalNumberPattern());
            Assert.AreEqual("\\d{5}", metadata.getPremiumRate().getNationalNumberPattern());
            Assert.AreEqual("\\d{6}", metadata.getSharedCost().getNationalNumberPattern());
            Assert.AreEqual("\\d{7}", metadata.getPersonalNumber().getNationalNumberPattern());
            Assert.AreEqual("\\d{8}", metadata.getVoip().getNationalNumberPattern());
            Assert.AreEqual("\\d{9}", metadata.getUan().getNationalNumberPattern());
        }
Exemplo n.º 8
0
        [TestMethod] public void testAlternateFormatsOmitsDescPatterns()
        {
            String xmlInput =
                "<territory countryCode=\"33\">" +
                "  <availableFormats>" +
                "    <numberFormat pattern=\"(1)(\\d{3})\">" +
                "      <leadingDigits>1</leadingDigits>" +
                "      <format>$1</format>" +
                "    </numberFormat>" +
                "  </availableFormats>" +
                "  <fixedLine><nationalNumberPattern>\\d{1}</nationalNumberPattern></fixedLine>" +
                "  <shortCode><nationalNumberPattern>\\d{2}</nationalNumberPattern></shortCode>" +
                "</territory>";
            XmlElement    territoryElement = parseXmlString(xmlInput);
            PhoneMetadata metadata         = BuildMetadataFromXml.loadCountryMetadata("FR", territoryElement,
                                                                                      false /* liteBuild */, false /* isShortNumberMetadata */,
                                                                                      true /* isAlternateFormatsMetadata */);

            Assert.AreEqual("(1)(\\d{3})", metadata.getNumberFormat(0).getPattern());
            Assert.AreEqual("1", metadata.getNumberFormat(0).getLeadingDigitsPattern(0));
            Assert.AreEqual("$1", metadata.getNumberFormat(0).getFormat());
            Assert.IsFalse(metadata.HasFixedLine());
            Assert.IsNull(metadata.getFixedLine());
            Assert.IsFalse(metadata.HasShortCode());
            Assert.IsNull(metadata.getShortCode());
        }
Exemplo n.º 9
0
        // Tests setLeadingDigitsPatterns() in the case of international and national formatting rules
        // being present but not both defined for this numberFormat - we don't want to add them twice.
        [TestMethod] public void testSetLeadingDigitsPatternsNotAddedTwiceWhenInternationalFormatsPresent()
        {
            String xmlInput =
                "  <availableFormats>" +
                "    <numberFormat pattern=\"(1)(\\d{3})\">" +
                "      <leadingDigits>1</leadingDigits>" +
                "      <format>$1</format>" +
                "    </numberFormat>" +
                "    <numberFormat pattern=\"(2)(\\d{3})\">" +
                "      <leadingDigits>2</leadingDigits>" +
                "      <format>$1</format>" +
                "      <intlFormat>9-$1</intlFormat>" +
                "    </numberFormat>" +
                "  </availableFormats>";
            XmlElement element = parseXmlString(xmlInput);

            PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
            BuildMetadataFromXml.loadAvailableFormats(
                metadata, element, "0", "", false /* NP not optional */);
            Assert.AreEqual(1, metadata.getNumberFormat(0).leadingDigitsPatternSize());
            Assert.AreEqual(1, metadata.getNumberFormat(1).leadingDigitsPatternSize());
            // When we merge the national format rules into the international format rules, we shouldn't add
            // the leading digit patterns multiple times.
            Assert.AreEqual(1, metadata.getIntlNumberFormat(0).leadingDigitsPatternSize());
            Assert.AreEqual(1, metadata.getIntlNumberFormat(1).leadingDigitsPatternSize());
        }
Exemplo n.º 10
0
        private bool MatchesEmergencyNumberHelper(String number, String regionCode,
                                                  bool allowPrefixMatch)
        {
            number = PhoneNumberUtil.ExtractPossibleNumber(number);
            if (PhoneNumberUtil.PLUS_CHARS_PATTERN.MatchBeginning(number).Success)
            {
                // Returns false if the number starts with a plus sign. We don't believe dialing the country
                // code before emergency numbers (e.g. +1911) works, but later, if that proves to work, we can
                // add additional logic here to handle it.
                return(false);
            }
            PhoneMetadata metadata = phoneUtil.GetMetadataForRegion(regionCode);

            if (metadata == null || !metadata.HasEmergency)
            {
                return(false);
            }
            var emergencyNumberPattern =
                new PhoneRegex(metadata.Emergency.NationalNumberPattern);
            String normalizedNumber = PhoneNumberUtil.NormalizeDigitsOnly(number);

            // In Brazil, it is impossible to append additional digits to an emergency number to dial the
            // number.
            return((!allowPrefixMatch || regionCode.Equals("BR"))
                ? emergencyNumberPattern.MatchAll(normalizedNumber).Success
                : emergencyNumberPattern.MatchBeginning(normalizedNumber).Success);
        }
Exemplo n.º 11
0
 /**
  * Constructs an as-you-type formatter. Should be obtained from {@link
  * PhoneNumberUtil#getAsYouTypeFormatter}.
  *
  * @param regionCode  the country/region where the phone number is being entered
  */
 public AsYouTypeFormatter(String regionCode)
 {
     digitPattern    = new Regex(digitPlaceholder, Redirections.Compiled);
     defaultCountry  = regionCode;
     currentMetaData = GetMetadataForRegion(defaultCountry);
     defaultMetaData = currentMetaData;
 }
Exemplo n.º 12
0
        // Helper method to get the region code for a given phone number, from a list of possible region
        // codes. If the list contains more than one region, the first region for which the number is
        // valid is returned.
        private string GetRegionCodeForShortNumberFromRegionList(PhoneNumber number,
                                                                 List <string> regionCodes)
        {
            if (regionCodes.Count == 0)
            {
                return(null);
            }

            if (regionCodes.Count == 1)
            {
                return(regionCodes.First());
            }
            string nationalNumber = GetNationalSignificantNumber(number);

            foreach (string regionCode in regionCodes)
            {
                PhoneMetadata phoneMetadata = MetadataManager.GetShortNumberMetadataForRegion(regionCode);
                if (phoneMetadata != null &&
                    MatchesPossibleNumberAndNationalNumber(nationalNumber, phoneMetadata.ShortCode))
                {
                    // The number is valid for this region.
                    return(regionCode);
                }
            }
            return(null);
        }
 /// <summary>
 /// Constructs an as-you-type formatter. Should be obtained from
 /// <see cref="PhoneNumberUtil.GetAsYouTypeFormatter(string)"/>.
 /// </summary>
 /// <param name="regionCode">The country/region where the phone number is being entered.</param>
 /// <param name="phoneUtil"></param>
 public AsYouTypeFormatter(string regionCode, PhoneNumberUtil phoneUtil)
 {
     this.phoneUtil  = phoneUtil;
     defaultCountry  = regionCode;
     currentMetadata = GetMetadataForRegion(defaultCountry);
     defaultMetaData = currentMetadata;
 }
Exemplo n.º 14
0
        public void testAlternateFormatsContainsData()
        {
            // We should have some data for Germany.
            PhoneMetadata germanyAlternateFormats = MetadataManager.getAlternateFormatsForCountry(49);

            Assert.IsNotNull(germanyAlternateFormats);
            Assert.IsTrue(germanyAlternateFormats.numberFormats().Count > 0);
        }
Exemplo n.º 15
0
        public void testShortNumberMetadataContainsData()
        {
            // We should have some data for France.
            PhoneMetadata franceShortNumberMetadata = MetadataManager.getShortNumberMetadataForRegion("FR");

            Assert.IsNotNull(franceShortNumberMetadata);
            Assert.IsTrue(franceShortNumberMetadata.HasShortCode());
        }
Exemplo n.º 16
0
 public Builder SetMetadata(int index, PhoneMetadata value)
 {
     if (value == null)
     {
         throw new ArgumentNullException(nameof(value));
     }
     MessageBeingBuilt.metadata[index] = value;
     return(this);
 }
Exemplo n.º 17
0
 public Builder AddMetadata(PhoneMetadata value)
 {
     if (value == null)
     {
         throw new ArgumentNullException(nameof(value));
     }
     MessageBeingBuilt.metadata.Add(value);
     return(this);
 }
Exemplo n.º 18
0
 public PhoneMetadataCollection addMetadata(PhoneMetadata value)
 {
     if (value == null)
     {
         throw new NullPointerException();
     }
     metadata_.add(value);
     return(this);
 }
Exemplo n.º 19
0
 // @VisibleForTesting
 internal static PhoneMetadata.Builder loadTerritoryTagMetadata(String regionCode, XmlElement element,
                                                                String nationalPrefix)
 {
     PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
     metadata.setId(regionCode);
     if (element.HasAttribute(COUNTRY_CODE))
     {
         metadata.setCountryCode(int.Parse(element.GetAttribute(COUNTRY_CODE)));
     }
     if (element.HasAttribute(LEADING_DIGITS))
     {
         metadata.setLeadingDigits(validateRE(element.GetAttribute(LEADING_DIGITS)));
     }
     metadata.setInternationalPrefix(validateRE(element.GetAttribute(INTERNATIONAL_PREFIX)));
     if (element.HasAttribute(PREFERRED_INTERNATIONAL_PREFIX))
     {
         String preferredInternationalPrefix = element.GetAttribute(PREFERRED_INTERNATIONAL_PREFIX);
         metadata.setPreferredInternationalPrefix(preferredInternationalPrefix);
     }
     if (element.HasAttribute(NATIONAL_PREFIX_FOR_PARSING))
     {
         metadata.setNationalPrefixForParsing(
             validateRE(element.GetAttribute(NATIONAL_PREFIX_FOR_PARSING), true));
         if (element.HasAttribute(NATIONAL_PREFIX_TRANSFORM_RULE))
         {
             metadata.setNationalPrefixTransformRule(
                 validateRE(element.GetAttribute(NATIONAL_PREFIX_TRANSFORM_RULE)));
         }
     }
     if (nationalPrefix.Length != 0)
     {
         metadata.setNationalPrefix(nationalPrefix);
         if (!metadata.HasNationalPrefixForParsing())
         {
             metadata.setNationalPrefixForParsing(nationalPrefix);
         }
     }
     if (element.HasAttribute(PREFERRED_EXTN_PREFIX))
     {
         metadata.setPreferredExtnPrefix(element.GetAttribute(PREFERRED_EXTN_PREFIX));
     }
     if (element.HasAttribute(MAIN_COUNTRY_FOR_CODE))
     {
         metadata.setMainCountryForCode(true);
     }
     if (element.HasAttribute(LEADING_ZERO_POSSIBLE))
     {
         metadata.setLeadingZeroPossible(true);
     }
     if (element.HasAttribute(MOBILE_NUMBER_PORTABLE_REGION))
     {
         metadata.setMobileNumberPortableRegion(true);
     }
     return(metadata);
 }
Exemplo n.º 20
0
            override public void readExternal(ObjectInput objectInput)
            {
                int size = objectInput.readInt();

                for (int i = 0; i < size; i++)
                {
                    PhoneMetadata metadata = new PhoneMetadata();
                    metadata.readExternal(objectInput);
                    metadata_.add(metadata);
                }
            }
Exemplo n.º 21
0
        [TestMethod] public void testLoadNationalFormat()
        {
            String nationalFormat = "$1 $2";
            String xmlInput       = String.Format("<numberFormat><format>{0}</format></numberFormat>",
                                                  nationalFormat);
            XmlElement numberFormatElement = parseXmlString(xmlInput);

            PhoneMetadata.Builder metadata     = PhoneMetadata.newBuilder();
            NumberFormat.Builder  numberFormat = NumberFormat.newBuilder();
            BuildMetadataFromXml.loadNationalFormat(metadata, numberFormatElement, numberFormat);
            Assert.AreEqual(nationalFormat, numberFormat.getFormat());
        }
        public static bool IsNationalPrefixPresentIfRequired(PhoneNumber number, PhoneNumberUtil util)
        {
            // First, check how we deduced the country code. If it was written in international format, then
            // the national prefix is not required.
            if (number.CountryCodeSource != PhoneNumber.Types.CountryCodeSource.FROM_DEFAULT_COUNTRY)
            {
                return(true);
            }
            String phoneNumberRegion =
                util.GetRegionCodeForCountryCode(number.CountryCode);
            PhoneMetadata metadata = util.GetMetadataForRegion(phoneNumberRegion);

            if (metadata == null)
            {
                return(true);
            }
            // Check if a national prefix should be present when formatting this number.
            String       nationalNumber = util.GetNationalSignificantNumber(number);
            NumberFormat formatRule     =
                util.ChooseFormattingPatternForNumber(metadata.NumberFormatList, 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)
            {
                if (formatRule.NationalPrefixOptionalWhenFormatting)
                {
                    // The national-prefix is optional in these cases, so we don't need to check if it was
                    // present.
                    return(true);
                }
                // Remove the first-group symbol.
                String candidateNationalPrefixRule = formatRule.NationalPrefixFormattingRule;
                // We assume that the first-group symbol will never be _before_ the national prefix.
                candidateNationalPrefixRule =
                    candidateNationalPrefixRule.Substring(0, candidateNationalPrefixRule.IndexOf("${1}"));
                candidateNationalPrefixRule =
                    PhoneNumberUtil.NormalizeDigitsOnly(candidateNationalPrefixRule);
                if (candidateNationalPrefixRule.Length == 0)
                {
                    // National Prefix not needed for this number.
                    return(true);
                }
                // Normalize the remainder.
                String        rawInputCopy = PhoneNumberUtil.NormalizeDigitsOnly(number.RawInput);
                StringBuilder rawInput     = new StringBuilder(rawInputCopy);
                // Check if we found a national prefix and/or carrier code at the start of the raw input, and
                // return the result.
                return(util.MaybeStripNationalPrefixAndCarrierCode(rawInput, metadata, null));
            }
            return(true);
        }
Exemplo n.º 23
0
        [TestMethod] public void testLoadInternationalFormatDoesNotSetIntlFormatWhenNA()
        {
            String     xmlInput            = "<numberFormat><intlFormat>NA</intlFormat></numberFormat>";
            XmlElement numberFormatElement = parseXmlString(xmlInput);

            PhoneMetadata.Builder metadata       = PhoneMetadata.newBuilder();
            NumberFormat.Builder  nationalFormat = NumberFormat.newBuilder();
            nationalFormat.setFormat("$1 $2");

            BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
                                                         nationalFormat.build());
            Assert.AreEqual(0, metadata.IntlNumberFormatSize());
        }
Exemplo n.º 24
0
        // Tests loadInternationalFormat().
        [TestMethod] public void testLoadInternationalFormat()
        {
            String     intlFormat          = "$1 $2";
            String     xmlInput            = "<numberFormat><intlFormat>" + intlFormat + "</intlFormat></numberFormat>";
            XmlElement numberFormatElement = parseXmlString(xmlInput);

            PhoneMetadata.Builder metadata       = PhoneMetadata.newBuilder();
            NumberFormat          nationalFormat = NumberFormat.newBuilder().build();

            Assert.IsTrue(BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
                                                                       nationalFormat));
            Assert.AreEqual(intlFormat, metadata.getIntlNumberFormat(0).getFormat());
        }
        // The metadata needed by this class is the same for all regions sharing the same country calling
        // code. Therefore, we return the metadata for "main" region for this country calling code.
        private PhoneMetadata GetMetadataForRegion(String regionCode)
        {
            int           countryCallingCode = phoneUtil.GetCountryCodeForRegion(regionCode);
            String        mainCountry        = phoneUtil.GetRegionCodeForCountryCode(countryCallingCode);
            PhoneMetadata metadata           = phoneUtil.GetMetadataForRegion(mainCountry);

            if (metadata != null)
            {
                return(metadata);
            }
            // Set to a default instance of the metadata. This allows us to function with an incorrect
            // region code, even if formatting only works for numbers specified with "+".
            return(EMPTY_METADATA);
        }
Exemplo n.º 26
0
        [TestMethod] public void testLoadInternationalFormatCopiesNationalFormatData()
        {
            String     xmlInput            = "<numberFormat></numberFormat>";
            XmlElement numberFormatElement = parseXmlString(xmlInput);

            PhoneMetadata.Builder metadata       = PhoneMetadata.newBuilder();
            NumberFormat.Builder  nationalFormat = NumberFormat.newBuilder();
            nationalFormat.setFormat("$1-$2");
            nationalFormat.setNationalPrefixOptionalWhenFormatting(true);

            Assert.IsFalse(BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
                                                                        nationalFormat.build()));
            Assert.IsTrue(metadata.getIntlNumberFormat(0).isNationalPrefixOptionalWhenFormatting());
        }
Exemplo n.º 27
0
        [TestMethod] public void testLoadAvailableFormatsSetsProvidedNationalPrefixFormattingRule()
        {
            String xmlInput =
                "<territory>" +
                "  <availableFormats>" +
                "    <numberFormat><format>$1 $2 $3</format></numberFormat>" +
                "  </availableFormats>" +
                "</territory>";
            XmlElement element = parseXmlString(xmlInput);

            PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
            BuildMetadataFromXml.loadAvailableFormats(
                metadata, element, "", "($1)", false /* NP not optional */);
            Assert.AreEqual("($1)", metadata.getNumberFormat(0).getNationalPrefixFormattingRule());
        }
Exemplo n.º 28
0
        [TestMethod] public void testLoadAvailableFormatsClearsIntlFormat()
        {
            String xmlInput =
                "<territory>" +
                "  <availableFormats>" +
                "    <numberFormat><format>$1 $2 $3</format></numberFormat>" +
                "  </availableFormats>" +
                "</territory>";
            XmlElement element = parseXmlString(xmlInput);

            PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
            BuildMetadataFromXml.loadAvailableFormats(
                metadata, element, "0", "($1)", false /* NP not optional */);
            Assert.AreEqual(0, metadata.IntlNumberFormatSize());
        }
Exemplo n.º 29
0
        // Tests setRelevantDescPatterns().
        [TestMethod] public void testSetRelevantDescPatternsSetsSameMobileAndFixedLinePattern()
        {
            String xmlInput =
                "<territory countryCode=\"33\">" +
                "  <fixedLine><nationalNumberPattern>\\d{6}</nationalNumberPattern></fixedLine>" +
                "  <mobile><nationalNumberPattern>\\d{6}</nationalNumberPattern></mobile>" +
                "</territory>";
            XmlElement territoryElement = parseXmlString(xmlInput);

            PhoneMetadata.Builder metadata = PhoneMetadata.newBuilder();
            // Should set sameMobileAndFixedPattern to true.
            BuildMetadataFromXml.setRelevantDescPatterns(metadata, territoryElement, false /* liteBuild */,
                                                         false /* isShortNumberMetadata */);
            Assert.IsTrue(metadata.isSameMobileAndFixedLinePattern());
        }
Exemplo n.º 30
0
        [TestMethod] public void testLoadInternationalFormatUsesNationalFormatByDefault()
        {
            String     xmlInput            = "<numberFormat></numberFormat>";
            XmlElement numberFormatElement = parseXmlString(xmlInput);

            PhoneMetadata.Builder metadata       = PhoneMetadata.newBuilder();
            NumberFormat.Builder  nationalFormat = NumberFormat.newBuilder();
            String nationalPattern = "$1 $2 $3";

            nationalFormat.setFormat(nationalPattern);

            Assert.IsFalse(BuildMetadataFromXml.loadInternationalFormat(metadata, numberFormatElement,
                                                                        nationalFormat.build()));
            Assert.AreEqual(nationalPattern, metadata.getIntlNumberFormat(0).getFormat());
        }
 private static PhoneMetadata.Builder Update(PhoneMetadata p)
 {
     return new PhoneMetadata.Builder().MergeFrom(p);
 }
 public PhoneMetadataCollection addMetadata(PhoneMetadata value)
 {
     if (value == null) {
     throw new NullPointerException();
       }
       metadata_.add(value);
       return this;
 }
 public override void readExternal(ObjectInput objectInput)
 {
     int size = objectInput.readInt();
       for (int i = 0; i < size; i++) {
     PhoneMetadata metadata = new PhoneMetadata();
     metadata.readExternal(objectInput);
     metadata_.add(metadata);
       }
 }