/**
  * Helper method to get the national-number part of a number, formatted without any national
  * prefix, and return it as a set of digit blocks that would be formatted together.
  */
 private static String[] GetNationalNumberGroups(PhoneNumberUtil util, PhoneNumber number,
                                                 NumberFormat formattingPattern)
 {
     if (formattingPattern == null)
     {
         // This will be in the format +CC-DG;ext=EXT where DG represents groups of digits.
         String rfc3966Format = util.Format(number, PhoneNumberFormat.RFC3966);
         // We remove the extension part from the formatted string before splitting it into different
         // groups.
         int endIndex = rfc3966Format.IndexOf(';');
         if (endIndex < 0)
         {
             endIndex = rfc3966Format.Length;
         }
         // The country-code will have a '-' following it.
         int startIndex = rfc3966Format.IndexOf('-') + 1;
         return(rfc3966Format.Substring(startIndex, endIndex - startIndex).Split(new [] { '-' }));
     }
     else
     {
         // We format the NSN only, and split that according to the separator.
         String nationalSignificantNumber = util.GetNationalSignificantNumber(number);
         return(util.FormatNsnUsingPattern(nationalSignificantNumber,
                                           formattingPattern, PhoneNumberFormat.RFC3966).Split(new [] { '-' }));
     }
 }
예제 #2
0
        private bool CreateFormattingTemplate(NumberFormat format)
        {
            string numberPattern = format.Pattern;

            // The formatter doesn't format numbers when numberPattern contains "|", e.g.
            // (20|3)\d{4}. In those cases we quickly return.
            if (numberPattern.IndexOf('|') != -1)
            {
                return(false);
            }

            // Replace anything in the form of [..] with \d
            numberPattern = CHARACTER_CLASS_PATTERN.Replace(numberPattern, "\\d");

            // Replace any standalone digit (not the one in d{}) with \d
            numberPattern             = STANDALONE_DIGIT_PATTERN.Replace(numberPattern, "\\d");
            formattingTemplate.Length = 0;
            string tempTemplate = GetFormattingTemplate(numberPattern, format.Format);

            if (tempTemplate.Length > 0)
            {
                formattingTemplate.Append(tempTemplate);
                return(true);
            }
            return(false);
        }
예제 #3
0
 // Returns true if a new template is created as opposed to reusing the existing template.
 private bool MaybeCreateNewTemplate()
 {
     // When there are multiple available formats, the formatter uses the first format where a
     // formatting template could be created.
     while (possibleFormats.Count > 0)
     {
         NumberFormat numberFormat = possibleFormats[0];
         string       pattern      = numberFormat.Pattern;
         if (currentFormattingPattern.Equals(pattern))
         {
             return(false);
         }
         if (CreateFormattingTemplate(numberFormat))
         {
             currentFormattingPattern = pattern;
             // With a new formatting template, the matched position using the old template needs to be
             // reset.
             lastMatchPosition = 0;
             return(true);
         }
         else
         {
             possibleFormats.RemoveAt(0);
         }
     }
     ableToFormat = false;
     return(false);
 }
예제 #4
0
        private bool CreateFormattingTemplate(NumberFormat format)
        {
            var numberPattern = format.Pattern;

            // The formatter doesn't format numbers when numberPattern contains "|", e.g.
            // (20|3)\d{4}. In those cases we quickly return.
            if (numberPattern.IndexOf('|') != -1)
            {
                return(false);
            }

            // Replace anything in the form of [..] with \d
            numberPattern = CharacterClassPattern.Replace(numberPattern, "\\d");

            // Replace any standalone digit (not the one in d{}) with \d
            numberPattern             = StandaloneDigitPattern.Replace(numberPattern, "\\d");
            formattingTemplate.Length = 0;
            var tempTemplate = GetFormattingTemplate(numberPattern, format.Format);

            if (tempTemplate.Length > 0)
            {
                formattingTemplate.Append(tempTemplate);
                return(true);
            }
            return(false);
        }
예제 #5
0
        /// <summary>
        /// Helper method to get the national-number part of a number, formatted without any national
        /// prefix, and return it as a set of digit blocks that should be formatted together according to
        /// the formatting pattern passed in.
        /// </summary>
        private static IList <string> GetNationalNumberGroups(PhoneNumberUtil util, PhoneNumber number,
                                                              NumberFormat formattingPattern)
        {
            // If a format is provided, we format the NSN only, and split that according to the separator.
            var nationalSignificantNumber = util.GetNationalSignificantNumber(number);

            return(util.FormatNsnUsingPattern(nationalSignificantNumber,
                                              formattingPattern, PhoneNumberFormat.RFC3966).Split('-'));
        }
        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);
        }
        private bool CreateFormattingTemplate(NumberFormat format)
        {
            var numberPattern = format.Pattern;

            formattingTemplate.Length = 0;
            var tempTemplate = GetFormattingTemplate(numberPattern, format.Format);

            if (tempTemplate.Length > 0)
            {
                formattingTemplate.Append(tempTemplate);
                return(true);
            }
            return(false);
        }
        private void NarrowDownPossibleFormats(String leadingDigits)
        {
            int indexOfLeadingDigitsPattern = leadingDigits.Length - MIN_LEADING_DIGITS_LENGTH;

            for (int i = 0; i != possibleFormats.Count;)
            {
                NumberFormat format = possibleFormats[i];
                if (format.LeadingDigitsPatternCount > indexOfLeadingDigitsPattern)
                {
                    var leadingDigitsPattern =
                        regexCache.GetPatternForRegex(
                            format.LeadingDigitsPatternList[indexOfLeadingDigitsPattern]);
                    var m = leadingDigitsPattern.MatchBeginning(leadingDigits);
                    if (!m.Success)
                    {
                        possibleFormats.RemoveAt(i);
                        continue;
                    }
                }
                // else the particular format has no more specific leadingDigitsPattern, and it should be
                // retained.
                ++i;
            }
        }
예제 #9
0
 public static Builder CreateBuilder(NumberFormat prototype)
 {
     return(new Builder().MergeFrom(prototype));
 }
 public Builder MergeFrom(NumberFormat other)
 {
     if (other == global::PhoneNumbers.NumberFormat.DefaultInstance) return this;
     if (other.HasPattern) {
       Pattern = other.Pattern;
     }
     if (other.HasFormat) {
       Format = other.Format;
     }
     if (other.leadingDigitsPattern_.Count != 0) {
        result.leadingDigitsPattern_.AddRange(other.leadingDigitsPattern_);
     }
     if (other.HasNationalPrefixFormattingRule) {
       NationalPrefixFormattingRule = other.NationalPrefixFormattingRule;
     }
     if (other.HasNationalPrefixOptionalWhenFormatting) {
       NationalPrefixOptionalWhenFormatting = other.NationalPrefixOptionalWhenFormatting;
     }
     if (other.HasDomesticCarrierCodeFormattingRule) {
       DomesticCarrierCodeFormattingRule = other.DomesticCarrierCodeFormattingRule;
     }
     return this;
 }
 public Builder Clear()
 {
     result = new NumberFormat();
     return this;
 }
            public NumberFormat BuildPartial()
            {
                if (result == null) {
                  throw new global::System.InvalidOperationException("build() has already been called on this Builder");
                }

                NumberFormat returnMe = result;
                result = null;
                return returnMe;
            }
 public static Builder CreateBuilder(NumberFormat prototype)
 {
     return (Builder) new Builder().MergeFrom(prototype);
 }
        private bool CreateFormattingTemplate(NumberFormat format)
        {
            String numberPattern = format.Pattern;

            // The formatter doesn't format numbers when numberPattern contains "|", e.g.
            // (20|3)\d{4}. In those cases we quickly return.
            if (numberPattern.IndexOf('|') != -1)
            {
                return false;
            }

            // Replace anything in the form of [..] with \d
            numberPattern = CHARACTER_CLASS_PATTERN.Replace(numberPattern, "\\d");

            // Replace any standalone digit (not the one in d{}) with \d
            numberPattern = STANDALONE_DIGIT_PATTERN.Replace(numberPattern, "\\d");
            formattingTemplate.Length = 0;
            String tempTemplate = GetFormattingTemplate(numberPattern, format.Format);
            if (tempTemplate.Length > 0)
            {
                formattingTemplate.Append(tempTemplate);
                return true;
            }
            return false;
        }
 public static void SetLeadingDigitsPatterns(XmlElement numberFormatElement, NumberFormat.Builder format)
 {
     foreach (XmlElement e in numberFormatElement.GetElementsByTagName(LEADING_DIGITS))
     {
         format.AddLeadingDigitsPattern(ValidateRE(e.InnerText, true));
     }
 }
        /**
         * Extracts the pattern for the national format.
         *
         * @throws  RuntimeException if multiple or no formats have been encountered.
         * @return  the national format string.
         */
        // @VisibleForTesting
        public static String LoadNationalFormat(PhoneMetadata.Builder metadata, XmlElement numberFormatElement,
                                         NumberFormat.Builder format)
        {
            SetLeadingDigitsPatterns(numberFormatElement, format);
            format.SetPattern(ValidateRE(numberFormatElement.GetAttribute(PATTERN)));

            var formatPattern = numberFormatElement.GetElementsByTagName(FORMAT);
            if (formatPattern.Count != 1)
            {
                //LOGGER.log(Level.SEVERE,
                //           "Only one format pattern for a numberFormat element should be defined.");
                throw new Exception("Invalid number of format patterns for country: " +
                                    metadata.Id);
            }
            String nationalFormat = formatPattern[0].InnerText;
            format.SetFormat(nationalFormat);
            return nationalFormat;
        }
 // Note that carrierCode is optional - if NULL or an empty string, no carrier code replacement
 // will take place.
 private String FormatNsnUsingPattern(String nationalNumber, NumberFormat formattingPattern,
     PhoneNumberFormat numberFormat, String carrierCode)
 {
     String numberFormatRule = formattingPattern.Format;
     var m = regexCache.GetPatternForRegex(formattingPattern.Pattern);
     String formattedNationalNumber = "";
     if (numberFormat == PhoneNumberFormat.NATIONAL &&
         carrierCode != null && carrierCode.Length > 0 &&
         formattingPattern.DomesticCarrierCodeFormattingRule.Length > 0)
     {
         // Replace the $CC in the formatting rule with the desired carrier code.
         var carrierCodeFormattingRule = formattingPattern.DomesticCarrierCodeFormattingRule;
         carrierCodeFormattingRule =
             CC_PATTERN.Replace(carrierCodeFormattingRule, carrierCode, 1);
         // Now replace the $FG in the formatting rule with the first group and the carrier code
         // combined in the appropriate way.
         var r = FIRST_GROUP_PATTERN.Replace(numberFormatRule, carrierCodeFormattingRule, 1);
         formattedNationalNumber = m.Replace(nationalNumber, r);
     }
     else
     {
         // Use the national prefix formatting rule instead.
         var nationalPrefixFormattingRule = formattingPattern.NationalPrefixFormattingRule;
         if (numberFormat == PhoneNumberFormat.NATIONAL &&
             nationalPrefixFormattingRule != null &&
             nationalPrefixFormattingRule.Length > 0)
         {
             var r = FIRST_GROUP_PATTERN.Replace(numberFormatRule,
                 nationalPrefixFormattingRule, 1);
             formattedNationalNumber = m.Replace(nationalNumber, r);
         }
         else
         {
             formattedNationalNumber = m.Replace(nationalNumber, numberFormatRule);
         }
     }
     if (numberFormat == PhoneNumberFormat.RFC3966)
     {
         // Strip any leading punctuation.
         if (SEPARATOR_PATTERN.MatchBeginning(formattedNationalNumber).Success)
         {
             formattedNationalNumber = SEPARATOR_PATTERN.Replace(formattedNationalNumber, "", 1);
         }
         // Replace the rest with a dash between each number group.
         formattedNationalNumber = SEPARATOR_PATTERN.Replace(formattedNationalNumber, "-");
     }
     return formattedNationalNumber;
 }
 // Simple wrapper of formatNsnUsingPattern for the common case of no carrier code.
 internal String FormatNsnUsingPattern(String nationalNumber,
     NumberFormat formattingPattern, PhoneNumberFormat numberFormat)
 {
     return FormatNsnUsingPattern(nationalNumber, formattingPattern, numberFormat, null);
 }