/**
* Parses a string and fills up the phoneNumber. This method is the same as the public
* parse() method, with the exception that it allows the default region to be null, for use by
* isNumberMatch(). checkRegion should be set to false if it is permitted for the default region
* to be null or unknown ("ZZ").
*/
private void ParseHelper(String numberToParse, String defaultRegion, bool keepRawInput,
bool checkRegion, PhoneNumber.Builder phoneNumber)
{
if (numberToParse == null)
throw new NumberParseException(ErrorType.NOT_A_NUMBER,
"The phone number supplied was null.");
else if (numberToParse.Length > MAX_INPUT_STRING_LENGTH)
throw new NumberParseException(ErrorType.TOO_LONG,
"The string supplied was too long to parse.");
StringBuilder nationalNumber = new StringBuilder();
BuildNationalNumberForParsing(numberToParse, nationalNumber);
if (!IsViablePhoneNumber(nationalNumber.ToString()))
throw new NumberParseException(ErrorType.NOT_A_NUMBER,
"The string supplied did not seem to be a phone number.");
// Check the region supplied is valid, or that the extracted number starts with some sort of +
// sign so the number's region can be determined.
if (checkRegion && !CheckRegionForParsing(nationalNumber.ToString(), defaultRegion))
throw new NumberParseException(ErrorType.INVALID_COUNTRY_CODE,
"Missing or invalid default region.");
if (keepRawInput)
phoneNumber.SetRawInput(numberToParse);
// Attempt to parse extension first, since it doesn't require region-specific data and we want
// to have the non-normalised number here.
String extension = MaybeStripExtension(nationalNumber);
if (extension.Length > 0)
phoneNumber.SetExtension(extension);
PhoneMetadata regionMetadata = GetMetadataForRegion(defaultRegion);
// Check to see if the number is given in international format so we know whether this number is
// from the default region or not.
StringBuilder normalizedNationalNumber = new StringBuilder();
int countryCode = 0;
try
{
// TODO: This method should really just take in the string buffer that has already
// been created, and just remove the prefix, rather than taking in a string and then
// outputting a string buffer.
countryCode = MaybeExtractCountryCode(nationalNumber.ToString(), regionMetadata,
normalizedNationalNumber, keepRawInput, phoneNumber);
}
catch (NumberParseException e)
{
var m = PLUS_CHARS_PATTERN.MatchBeginning(nationalNumber.ToString());
if (e.ErrorType == ErrorType.INVALID_COUNTRY_CODE &&
m.Success)
{
// Strip the plus-char, and try again.
countryCode = MaybeExtractCountryCode(
nationalNumber.ToString().Substring(m.Index + m.Length),
regionMetadata, normalizedNationalNumber,
keepRawInput, phoneNumber);
if (countryCode == 0)
{
throw new NumberParseException(ErrorType.INVALID_COUNTRY_CODE,
"Could not interpret numbers after plus-sign.");
}
}
else
{
throw new NumberParseException(e.ErrorType, e.Message);
}
}
if (countryCode != 0)
{
String phoneNumberRegion = GetRegionCodeForCountryCode(countryCode);
if (phoneNumberRegion != defaultRegion)
regionMetadata = GetMetadataForRegionOrCallingCode(countryCode, phoneNumberRegion);
}
else
{
// If no extracted country calling code, use the region supplied instead. The national number
// is just the normalized version of the number we were given to parse.
Normalize(nationalNumber);
normalizedNationalNumber.Append(nationalNumber);
if (defaultRegion != null)
{
countryCode = regionMetadata.CountryCode;
phoneNumber.SetCountryCode(countryCode);
}
else if (keepRawInput)
{
phoneNumber.ClearCountryCode();
}
}
if (normalizedNationalNumber.Length < MIN_LENGTH_FOR_NSN)
throw new NumberParseException(ErrorType.TOO_SHORT_NSN,
"The string supplied is too short to be a phone number.");
if (regionMetadata != null)
{
StringBuilder carrierCode = new StringBuilder();
MaybeStripNationalPrefixAndCarrierCode(normalizedNationalNumber, regionMetadata, carrierCode);
if (keepRawInput)
phoneNumber.SetPreferredDomesticCarrierCode(carrierCode.ToString());
}
int lengthOfNationalNumber = normalizedNationalNumber.Length;
if (lengthOfNationalNumber < MIN_LENGTH_FOR_NSN)
throw new NumberParseException(ErrorType.TOO_SHORT_NSN,
"The string supplied is too short to be a phone number.");
if (lengthOfNationalNumber > MAX_LENGTH_FOR_NSN)
throw new NumberParseException(ErrorType.TOO_LONG,
"The string supplied is too long to be a phone number.");
if (normalizedNationalNumber[0] == '0')
phoneNumber.SetItalianLeadingZero(true);
phoneNumber.SetNationalNumber(ulong.Parse(normalizedNationalNumber.ToString()));
}
/**
* Tries to extract a country calling code from a number. This method will return zero if no
* country calling code is considered to be present. Country calling codes are extracted in the
* following ways:
* <ul>
* <li> by stripping the international dialing prefix of the region the person is dialing from,
* if this is present in the number, and looking at the next digits
* <li> by stripping the '+' sign if present and then looking at the next digits
* <li> by comparing the start of the number and the country calling code of the default region.
* If the number is not considered possible for the numbering plan of the default region
* initially, but starts with the country calling code of this region, validation will be
* reattempted after stripping this country calling code. If this number is considered a
* possible number, then the first digits will be considered the country calling code and
* removed as such.
* </ul>
* It will throw a NumberParseException if the number starts with a '+' but the country calling
* code supplied after this does not match that of any known region.
*
* @param number non-normalized telephone number that we wish to extract a country calling
* code from - may begin with '+'
* @param defaultRegionMetadata metadata about the region this number may be from
* @param nationalNumber a string buffer to store the national significant number in, in the case
* that a country calling code was extracted. The number is appended to any existing contents.
* If no country calling code was extracted, this will be left unchanged.
* @param keepRawInput true if the country_code_source and preferred_carrier_code fields of
* phoneNumber should be populated.
* @param phoneNumber the PhoneNumber object where the country_code and country_code_source need
* to be populated. Note the country_code is always populated, whereas country_code_source is
* only populated when keepCountryCodeSource is true.
* @return the country calling code extracted or 0 if none could be extracted
*/
public int MaybeExtractCountryCode(String number, PhoneMetadata defaultRegionMetadata,
StringBuilder nationalNumber, bool keepRawInput, PhoneNumber.Builder phoneNumber)
{
if (number.Length == 0)
return 0;
StringBuilder fullNumber = new StringBuilder(number);
// Set the default prefix to be something that will never match.
String possibleCountryIddPrefix = "NonMatch";
if (defaultRegionMetadata != null)
{
possibleCountryIddPrefix = defaultRegionMetadata.InternationalPrefix;
}
CountryCodeSource countryCodeSource =
MaybeStripInternationalPrefixAndNormalize(fullNumber, possibleCountryIddPrefix);
if (keepRawInput)
{
phoneNumber.SetCountryCodeSource(countryCodeSource);
}
if (countryCodeSource != CountryCodeSource.FROM_DEFAULT_COUNTRY)
{
if (fullNumber.Length <= MIN_LENGTH_FOR_NSN)
{
throw new NumberParseException(ErrorType.TOO_SHORT_AFTER_IDD,
"Phone number had an IDD, but after this was not "
+ "long enough to be a viable phone number.");
}
int potentialCountryCode = ExtractCountryCode(fullNumber, nationalNumber);
if (potentialCountryCode != 0)
{
phoneNumber.SetCountryCode(potentialCountryCode);
return potentialCountryCode;
}
// If this fails, they must be using a strange country calling code that we don't recognize,
// or that doesn't exist.
throw new NumberParseException(ErrorType.INVALID_COUNTRY_CODE,
"Country calling code supplied was not recognised.");
}
else if (defaultRegionMetadata != null)
{
// Check to see if the number starts with the country calling code for the default region. If
// so, we remove the country calling code, and do some checks on the validity of the number
// before and after.
int defaultCountryCode = defaultRegionMetadata.CountryCode;
String defaultCountryCodeString = defaultCountryCode.ToString();
String normalizedNumber = fullNumber.ToString();
if (normalizedNumber.StartsWith(defaultCountryCodeString))
{
StringBuilder potentialNationalNumber =
new StringBuilder(normalizedNumber.Substring(defaultCountryCodeString.Length));
PhoneNumberDesc generalDesc = defaultRegionMetadata.GeneralDesc;
var validNumberPattern =
regexCache.GetPatternForRegex(generalDesc.NationalNumberPattern);
MaybeStripNationalPrefixAndCarrierCode(
potentialNationalNumber, defaultRegionMetadata, null /* Don't need the carrier code */);
var possibleNumberPattern =
regexCache.GetPatternForRegex(generalDesc.PossibleNumberPattern);
// If the number was not valid before but is valid now, or if it was too long before, we
// consider the number with the country calling code stripped to be a better result and
// keep that instead.
if ((!validNumberPattern.MatchAll(fullNumber.ToString()).Success && //XXX: ToString
validNumberPattern.MatchAll(potentialNationalNumber.ToString()).Success) || //XXX: ToString
TestNumberLengthAgainstPattern(possibleNumberPattern, fullNumber.ToString())
== ValidationResult.TOO_LONG)
{
nationalNumber.Append(potentialNationalNumber);
if (keepRawInput)
phoneNumber.SetCountryCodeSource(CountryCodeSource.FROM_NUMBER_WITHOUT_PLUS_SIGN);
phoneNumber.SetCountryCode(defaultCountryCode);
return defaultCountryCode;
}
}
}
// No country calling code present.
phoneNumber.SetCountryCode(0);
return 0;
}
