/**
* 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 boolean attemptToExtractCountryCallingCode()
{
if (nationalNumber.length() == 0)
{
return(false);
}
StringBuilder numberWithoutCountryCallingCode = new StringBuilder();
int countryCode = phoneUtil.extractCountryCode(nationalNumber, numberWithoutCountryCallingCode);
if (countryCode == 0)
{
return(false);
}
nationalNumber.setLength(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 = Integer.toString(countryCode);
prefixBeforeNationalNumber.append(countryCodeString).append(SEPARATOR_BEFORE_NATIONAL_NUMBER);
return(true);
}
// Returns true if a new template is created as opposed to reusing the existing template.
private boolean maybeCreateNewTemplate()
{
// When there are multiple available formats, the formatter uses the first format where a
// formatting template could be created.
Iterator <NumberFormat> it = possibleFormats.iterator();
while (it.hasNext())
{
NumberFormat numberFormat = it.next();
String pattern = numberFormat.getPattern();
if (currentFormattingPattern.equals(pattern))
{
return(false);
}
if (createFormattingTemplate(numberFormat))
{
currentFormattingPattern = pattern;
shouldAddSpaceAfterNationalPrefix =
NATIONAL_PREFIX_SEPARATORS_PATTERN.matcher(
numberFormat.getNationalPrefixFormattingRule()).find();
// With a new formatting template, the matched position using the old template needs to be
// reset.
lastMatchPosition = 0;
return(true);
}
else // Remove the current number format from possibleFormats.
{
it.remove();
}
}
ableToFormat = false;
return(false);
}
/**
* Attempts to extract a match from {@code candidate} if the whole candidate does not qualify as a
* match.
*
* @param candidate the candidate text that might contain a phone number
* @param offset the current offset of {@code candidate} within {@link #text}
* @return the match found, null if none can be found
*/
private PhoneNumberMatch extractInnerMatch(String candidate, int offset)
{
// Try removing either the first or last "group" in the number and see if this gives a result.
// We consider white space to be a possible indication of the start or end of the phone number.
Matcher groupMatcher = GROUP_SEPARATOR.matcher(candidate);
if (groupMatcher.find())
{
// Try the first group by itself.
CharSequence firstGroupOnly = candidate.substring(0, groupMatcher.start());
firstGroupOnly = trimAfterFirstMatch(PhoneNumberUtil.UNWANTED_END_CHAR_PATTERN,
firstGroupOnly);
PhoneNumberMatch match = parseAndVerify(firstGroupOnly.toString(), offset);
if (match != null)
{
return(match);
}
maxTries--;
int withoutFirstGroupStart = groupMatcher.end();
// Try the rest of the candidate without the first group.
CharSequence withoutFirstGroup = candidate.substring(withoutFirstGroupStart);
withoutFirstGroup = trimAfterFirstMatch(PhoneNumberUtil.UNWANTED_END_CHAR_PATTERN,
withoutFirstGroup);
match = parseAndVerify(withoutFirstGroup.toString(), offset + withoutFirstGroupStart);
if (match != null)
{
return(match);
}
maxTries--;
if (maxTries > 0)
{
int lastGroupStart = withoutFirstGroupStart;
while (groupMatcher.find())
{
// Find the last group.
lastGroupStart = groupMatcher.start();
}
CharSequence withoutLastGroup = candidate.substring(0, lastGroupStart);
withoutLastGroup = trimAfterFirstMatch(PhoneNumberUtil.UNWANTED_END_CHAR_PATTERN,
withoutLastGroup);
if (withoutLastGroup.equals(firstGroupOnly))
{
// If there are only two groups, then the group "without the last group" is the same as
// the first group. In these cases, we don't want to re-check the number group, so we exit
// already.
return(null);
}
match = parseAndVerify(withoutLastGroup.toString(), offset);
if (match != null)
{
return(match);
}
maxTries--;
}
}
return(null);
}
// Some national prefixes are a substring of others. If extracting the shorter NDD doesn't result
// in a number we can format, we try to see if we can extract a longer version here.
private boolean ableToExtractLongerNdd()
{
if (nationalPrefixExtracted.length() > 0)
{
// Put the extracted NDD back to the national number before attempting to extract a new NDD.
nationalNumber.insert(0, nationalPrefixExtracted);
// Remove the previously extracted NDD from prefixBeforeNationalNumber. We cannot simply set
// it to empty string because people sometimes incorrectly enter national prefix after the
// country code, e.g. +44 (0)20-1234-5678.
int indexOfPreviousNdd = prefixBeforeNationalNumber.lastIndexOf(nationalPrefixExtracted);
prefixBeforeNationalNumber.setLength(indexOfPreviousNdd);
}
return(!nationalPrefixExtracted.equals(removeNationalPrefixFromNationalNumber()));
}
public boolean equals(Object obj)
{
if (this == obj)
{
return(true);
}
if (!(obj is PhoneNumberMatch))
{
return(false);
}
PhoneNumberMatch other = (PhoneNumberMatch)obj;
return(_rawString.equals(other._rawString) && (_start == other._start) &&
_number.equals(other._number));
}
public boolean exactlySameAs(PhoneNumber other)
{
if (other == null)
{
return(false);
}
if (this == other)
{
return(true);
}
return(countryCode_ == other.countryCode_ && nationalNumber_ == other.nationalNumber_ &&
extension_.equals(other.extension_) && italianLeadingZero_ == other.italianLeadingZero_ &&
rawInput_.equals(other.rawInput_) && countryCodeSource_ == other.countryCodeSource_ &&
preferredDomesticCarrierCode_.equals(other.preferredDomesticCarrierCode_) &&
hasPreferredDomesticCarrierCode() == other.hasPreferredDomesticCarrierCode());
}
public boolean exactlySameAs(PhoneNumberDesc other)
{
return(nationalNumberPattern_.equals(other.nationalNumberPattern_) &&
possibleNumberPattern_.equals(other.possibleNumberPattern_) &&
exampleNumber_.equals(other.exampleNumber_));
}
public Iterable<MemberInfo> getMembers(String identifier) {
if (identifier.equals("this")) {
return getMembers();
} else if (identifier.equals("super")) {
var type = typeInfos[typeInfos.size() - 1];
return getMembers(type.BaseType, false);
}
var members = new HashMap<String, MemberInfo>();
putTypeMembers(members);
var type = typeInfos[typeInfos.size() - 1];
foreach (var t in type.getBaseTypes().reverse()) {
putFields(t, members);
putProperties(t, members);
putNestedTypes(t, members);
}
putFields(type, members);
putProperties(type, members);
putNestedTypes(type, members);
putLocals(members);
var member = members[identifier];
if (member == null) {
return Query.empty();
}
return getMembers(member.Type, (member.MemberKind == MemberKind.Local) ? false : member.IsStatic);
}
public void visitInnerClass(String name, String outerName, String innerName, int access) {
if (!name.equals(classFileType.FullName)) {
// Inner classes with outerName == null are method classes: ignore them.
if (outerName != null && outerName.equals(classFileType.FullName)) {
var nestedType = (ClassFileType)classFileType.typeSystem.getType(name);
nestedType.nestedModifiers = access;
nestedType.declaringType = classFileType;
classFileType.nestedTypes.add(nestedType);
}
}
}
public static Iterable<MemberInfo> getMembers(Library typeSystem, TypeInfo type, String name) {
var result = new ArrayList<MemberInfo>();
foreach (var f in type.Fields) {
if (f.Name.equals(name)) {
result.add(MemberInfo.getInfo(f));
break;
}
}
MethodInfo getAccessor = null;
MethodInfo setAccessor = null;
foreach (var m in type.Methods) {
if (getAccessor == null || setAccessor == null) {
foreach (var annotation in BytecodeHelper.getAnnotations(typeSystem, m)) {
if (BytecodeHelper.isPropertyGet(annotation) && name.equals(BytecodeHelper.getPropertyGetName(m, annotation))) {
getAccessor = m;
break;
}
if (BytecodeHelper.isPropertySet(annotation) && name.equals(BytecodeHelper.getPropertySetName(m, annotation))) {
setAccessor = m;
break;
}
}
}
if (m.Name.equals(name)) {
result.add(MemberInfo.getInfo(m));
}
}
if (getAccessor != null || setAccessor != null) {
result.add(MemberInfo.getInfo(getAccessor, setAccessor, name));
}
foreach (var t in type.NestedTypes) {
if (name.equals(t.Name)) {
result.add(MemberInfo.getInfo(t));
break;
}
}
return result;
}
private boolean mayFallBackToEnglish(String lang)
{
// Don't fall back to English if the requested language is among the following:
// - Chinese
// - Japanese
// - Korean
return !lang.equals("zh") && !lang.equals("ja") && !lang.equals("ko");
}
/**
* Returns the customary display name in the given language for the given region.
*/
private String getRegionDisplayName(String regionCode, Locale language)
{
return (regionCode == null || regionCode.equals("ZZ") ||
regionCode.equals(PhoneNumberUtil.REGION_CODE_FOR_NON_GEO_ENTITY))
? "" : new Locale("", regionCode).getDisplayCountry(language);
}
/**
* As per {@link #getDescriptionForValidNumber(PhoneNumber, Locale)} but also considers the
* region of the user. If the phone number is from the same region as the user, only a lower-level
* description will be returned, if one exists. Otherwise, the phone number's region will be
* returned, with optionally some more detailed information.
*
* <p>For example, for a user from the region "US" (United States), we would show "Mountain View,
* CA" for a particular number, omitting the United States from the description. For a user from
* the United Kingdom (region "GB"), for the same number we may show "Mountain View, CA, United
* States" or even just "United States".
*
* <p>This method assumes the validity of the number passed in has already been checked.
*
* @param number the phone number for which we want to get a text description
* @param languageCode the language code for which the description should be written
* @param userRegion the region code for a given user. This region will be omitted from the
* description if the phone number comes from this region. It is a two-letter uppercase ISO
* country code as defined by ISO 3166-1.
* @return a text description for the given language code for the given phone number, or empty
* string if the number passed in is invalid
*/
public String getDescriptionForValidNumber(PhoneNumber number, Locale languageCode,
String userRegion)
{
// If the user region matches the number's region, then we just show the lower-level
// description, if one exists - if no description exists, we will show the region(country) name
// for the number.
String regionCode = phoneUtil.getRegionCodeForNumber(number);
if (userRegion.equals(regionCode)) {
return getDescriptionForValidNumber(number, languageCode);
}
// Otherwise, we just show the region(country) name for now.
return getRegionDisplayName(regionCode, languageCode);
// TODO: Concatenate the lower-level and country-name information in an appropriate
// way for each language.
}
