/** * Helper method to check a number against a particular pattern and determine whether it matches, * or is too short or too long. Currently, if a number pattern suggests that numbers of length 7 * and 10 are possible, and a number in between these possible lengths is entered, such as of * length 8, this will return TOO_LONG. * @param string $numberPattern * @param string $number * @return int ValidationResult */ private function testNumberLengthAgainstPattern($numberPattern, $number) { $numberMatcher = new Matcher($numberPattern, $number); if ($numberMatcher->matches()) { return ValidationResult::IS_POSSIBLE; } if ($numberMatcher->lookingAt()) { return ValidationResult::TOO_LONG; } else { return ValidationResult::TOO_SHORT; } }
/** * Returns whether the given national number (a string containing only decimal digits) matches * the national number pattern defined in the given {@code PhoneNumberDesc} message. * * @param string $nationalNumber * @param PhoneNumberDesc $numberDesc * @param boolean $allowPrefixMatch * @return boolean */ public function matchesNationalNumber($nationalNumber, PhoneNumberDesc $numberDesc, $allowPrefixMatch) { $nationalNumberPatternMatcher = new Matcher($numberDesc->getNationalNumberPattern(), $nationalNumber); return $nationalNumberPatternMatcher->matches() || $allowPrefixMatch && $nationalNumberPatternMatcher->lookingAt(); }
public function formatNsnUsingPattern($nationalNumber, NumberFormat $formattingPattern, $numberFormat, $carrierCode = NULL) { $numberFormatRule = $formattingPattern->getFormat(); $m = new Matcher($formattingPattern->getPattern(), $nationalNumber); if ($numberFormat == PhoneNumberFormat::NATIONAL && $carrierCode !== NULL && strlen($carrierCode) > 0 && strlen($formattingPattern->getDomesticCarrierCodeFormattingRule()) > 0) { // Replace the $CC in the formatting rule with the desired carrier code. $carrierCodeFormattingRule = $formattingPattern->getDomesticCarrierCodeFormattingRule(); $ccPatternMatcher = new Matcher(self::CC_PATTERN, $carrierCodeFormattingRule); $carrierCodeFormattingRule = $ccPatternMatcher->replaceFirst($carrierCode); // Now replace the $FG in the formatting rule with the first group and the carrier code // combined in the appropriate way. $firstGroupMatcher = new Matcher(self::FIRST_GROUP_PATTERN, $numberFormatRule); $numberFormatRule = $firstGroupMatcher->replaceFirst($carrierCodeFormattingRule); $formattedNationalNumber = $m->replaceAll($numberFormatRule); } else { // Use the national prefix formatting rule instead. $nationalPrefixFormattingRule = $formattingPattern->getNationalPrefixFormattingRule(); if ($numberFormat == PhoneNumberFormat::NATIONAL && $nationalPrefixFormattingRule !== NULL && strlen($nationalPrefixFormattingRule) > 0) { $firstGroupMatcher = new Matcher(self::FIRST_GROUP_PATTERN, $numberFormatRule); $formattedNationalNumber = $m->replaceAll($firstGroupMatcher->replaceFirst($nationalPrefixFormattingRule)); } else { $formattedNationalNumber = $m->replaceAll($numberFormatRule); } } if ($numberFormat == PhoneNumberFormat::RFC3966) { // Strip any leading punctuation. $matcher = new Matcher(self::$SEPARATOR_PATTERN, $formattedNationalNumber); if ($matcher->lookingAt()) { $formattedNationalNumber = $matcher->replaceFirst(""); } // Replace the rest with a dash between each number group. $formattedNationalNumber = $matcher->reset($formattedNationalNumber)->replaceAll("-"); } return $formattedNationalNumber; }
private function matchesEmergencyNumberHelper($number, $regionCode, $allowPrefixMatch) { $number = PhoneNumberUtil::extractPossibleNumber($number); $matcher = new Matcher(PhoneNumberUtil::$PLUS_CHARS_PATTERN, $number); if ($matcher->lookingAt()) { // Returns false if the number starts with a plus sign. WE don't believe dialling 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; } $metadata = $this->getMetadataForRegion($regionCode); if ($metadata === null || !$metadata->hasEmergency()) { return false; } $emergencyNumberPattern = $metadata->getEmergency()->getNationalNumberPattern(); $normalizedNumber = PhoneNumberUtil::normalizeDigitsOnly($number); $emergencyMatcher = new Matcher($emergencyNumberPattern, $normalizedNumber); return !$allowPrefixMatch || in_array($regionCode, self::$regionsWhereEmergencyNumbersMustBeExact) ? $emergencyMatcher->matches() : $emergencyMatcher->lookingAt(); }
/** * Strips any national prefix (such as 0, 1) present in the number provided. * * @param string $number the normalized telephone number that we wish to strip any national * dialing prefix from * @param PhoneMetadata $metadata the metadata for the region that we think this number is from * @param string $carrierCode a place to insert the carrier code if one is extracted * @return bool true if a national prefix or carrier code (or both) could be extracted. */ public function maybeStripNationalPrefixAndCarrierCode(&$number, PhoneMetadata $metadata, &$carrierCode) { $numberLength = mb_strlen($number); $possibleNationalPrefix = $metadata->getNationalPrefixForParsing(); if ($numberLength == 0 || $possibleNationalPrefix === null || mb_strlen($possibleNationalPrefix) == 0) { // Early return for numbers of zero length. return false; } // Attempt to parse the first digits as a national prefix. $prefixMatcher = new Matcher($possibleNationalPrefix, $number); if ($prefixMatcher->lookingAt()) { $nationalNumberRule = $metadata->getGeneralDesc()->getNationalNumberPattern(); // Check if the original number is viable. $nationalNumberRuleMatcher = new Matcher($nationalNumberRule, $number); $isViableOriginalNumber = $nationalNumberRuleMatcher->matches(); // $prefixMatcher->group($numOfGroups) === null implies nothing was captured by the capturing // groups in $possibleNationalPrefix; therefore, no transformation is necessary, and we just // remove the national prefix $numOfGroups = $prefixMatcher->groupCount(); $transformRule = $metadata->getNationalPrefixTransformRule(); if ($transformRule === null || mb_strlen($transformRule) == 0 || $prefixMatcher->group($numOfGroups - 1) === null) { // If the original number was viable, and the resultant number is not, we return. $matcher = new Matcher($nationalNumberRule, substr($number, $prefixMatcher->end())); if ($isViableOriginalNumber && !$matcher->matches()) { return false; } if ($carrierCode !== null && $numOfGroups > 0 && $prefixMatcher->group($numOfGroups) !== null) { $carrierCode .= $prefixMatcher->group(1); } $number = substr($number, $prefixMatcher->end()); return true; } else { // Check that the resultant number is still viable. If not, return. Check this by copying // the string and making the transformation on the copy first. $transformedNumber = $number; $transformedNumber = substr_replace($transformedNumber, $prefixMatcher->replaceFirst($transformRule), 0, $numberLength); $matcher = new Matcher($nationalNumberRule, $transformedNumber); if ($isViableOriginalNumber && !$matcher->matches()) { return false; } if ($carrierCode !== null && $numOfGroups > 1) { $carrierCode .= $prefixMatcher->group(1); } $number = substr_replace($number, $transformedNumber, 0, mb_strlen($number)); return true; } } return false; }