Project import
diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..d9a10c0 --- /dev/null +++ b/LICENSE
@@ -0,0 +1,176 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS
diff --git a/README.md b/README.md new file mode 100644 index 0000000..532bd0a --- /dev/null +++ b/README.md
@@ -0,0 +1,76 @@ +# libPhoneNumber for iOS (ARC) + +* NBPhoneNumber, NBNumberFormat, NBPhoneNumberDesc, NBPhoneMetaData (Metadata classes) + +* NBPhoneNumberUtil (from phonenumberutil.js) +* NBAsYouTypeFormatter + +## Install with CocoaPods +### Use [CocoaPods](http://cocoapods.org/?q=libPhoneNumber-iOS) + +## Install without CocoaPods +### Add source files to your projects from libPhoneNumber + - NBPhoneNumberUtil.h, .m + - NBAsYouTypeFormatter.h, .m + + - NBNumberFormat.h, .m + - NBPhoneNumber.h, .m + - NBPhoneNumberDesc.h, .m + - NBPhoneNumberDefines.h + + - NBPhoneNumberMetadata.h, .m + - NBPhoneNumberMetadataForTesting.h, .m + + - Add "NBPhoneNumberMetadata.plist" and "NBPhoneNumberMetadataForTesting.plist" to bundle resources + - Add "CoreTelephony.framework" + + See sample test code from "libPhoneNumber-iOS / libPhoneNumberTests / libPhoneNumberTests.m" + +## Sample Usage + NBPhoneNumberUtil *phoneUtil = [NBPhoneNumberUtil sharedInstance]; + + NSError *aError = nil; + NBPhoneNumber *myNumber = [phoneUtil parse:@"6766077303" defaultRegion:@"AT" error:&aError]; + + if (aError == nil) { + // Should check error + NSLog(@"isValidPhoneNumber ? [%@]", [phoneUtil isValidNumber:myNumber] ? @"YES":@"NO"); + NSLog(@"E164 : %@", [phoneUtil format:myNumber numberFormat:NBEPhoneNumberFormatE164 + error:&aError]); + NSLog(@"INTERNATIONAL : %@", [phoneUtil format:myNumber numberFormat:NBEPhoneNumberFormatINTERNATIONAL + error:&aError]); + NSLog(@"NATIONAL : %@", [phoneUtil format:myNumber numberFormat:NBEPhoneNumberFormatNATIONAL + error:&aError]); + NSLog(@"RFC3966 : %@", [phoneUtil format:myNumber numberFormat:NBEPhoneNumberFormatRFC3966 + error:&aError]); + } + else { + NSLog(@"Error : %@", [aError localizedDescription]); + } + + NSLog (@"extractCountryCode [%ld]", [phoneUtil extractCountryCode:@"823213123123" + nationalNumber:nil]); + + NSString *res = nil; + UInt32 dRes = [phoneUtil extractCountryCode:@"823213123123" nationalNumber:&res]; + + NSLog (@"extractCountryCode [%lu] [%@]", dRes, res); + + +### Visit http://code.google.com/p/libphonenumber/ for more information +#### or zen.isis@gmail.com + +## Metadata managing (updating metadata) +#### Step1. Fetch "metadata.js" and "metadatafortesting.js" from Repositories + svn checkout http://libphonenumber.googlecode.com/svn/trunk/ libphonenumber-read-only + +#### Step2. Convert Javascript Object to JSON using PHP scripts + Output - "PhoneNumberMetaData.json" and "PhoneNumberMetaDataForTesting.json" + +#### Step3. Generate binary file from NBPhoneMetaDataGenerator + Output - "NBPhoneNumberMetadata.plist" and "NBPhoneNumberMetadataForTesting.plist" + +#### Step4. Update exists "NBPhoneNumberMetadata.plist" and "NBPhoneNumberMetadataForTesting.plist" files + +## Porting Rules +* **Remain** javascript libPhonenumber code logic (and comments etc) as possible for maintenance with *.js
diff --git a/libPhoneNumber/NBAsYouTypeFormatter.h b/libPhoneNumber/NBAsYouTypeFormatter.h new file mode 100644 index 0000000..c994fd5 --- /dev/null +++ b/libPhoneNumber/NBAsYouTypeFormatter.h
@@ -0,0 +1,21 @@ +// +// NBAsYouTypeFormatter.h +// libPhoneNumber +// +// Created by ishtar on 13. 2. 25.. +// Copyright (c) 2013년 NHN. All rights reserved. +// + +#import <Foundation/Foundation.h> + +@interface NBAsYouTypeFormatter : NSObject + +- (id)initWithRegionCode:(NSString*)regionCode; +- (id)initWithRegionCodeForTest:(NSString*)regionCode; + +- (NSString*)inputDigit:(NSString*)nextChar; +- (NSString*)inputDigitAndRememberPosition:(NSString*)nextChar; +- (NSInteger)getRememberedPosition; +- (void)clear; + +@end
diff --git a/libPhoneNumber/NBAsYouTypeFormatter.m b/libPhoneNumber/NBAsYouTypeFormatter.m new file mode 100644 index 0000000..742199d --- /dev/null +++ b/libPhoneNumber/NBAsYouTypeFormatter.m
@@ -0,0 +1,1146 @@ +// +// NBAsYouTypeFormatter.m +// libPhoneNumber +// +// Created by ishtar on 13. 2. 25.. +// Copyright (c) 2013년 NHN. All rights reserved. +// + +#import "NBAsYouTypeFormatter.h" + +#import "NBPhoneNumberUtil.h" +#import "NBPhoneMetaData.h" +#import "NBNumberFormat.h" + + +@interface NBAsYouTypeFormatter () + +@property (nonatomic, strong, readwrite) NSString *DIGIT_PLACEHOLDER_; +@property (nonatomic, assign, readwrite) NSString *SEPARATOR_BEFORE_NATIONAL_NUMBER_; +@property (nonatomic, strong, readwrite) NSString *currentOutput_, *currentFormattingPattern_; +@property (nonatomic, strong, readwrite) NSString *defaultCountry_; +@property (nonatomic, strong, readwrite) NSString *nationalPrefixExtracted_; +@property (nonatomic, strong, readwrite) NSMutableString *formattingTemplate_, *accruedInput_, *prefixBeforeNationalNumber_, *accruedInputWithoutFormatting_, *nationalNumber_; +@property (nonatomic, strong, readwrite) NSRegularExpression *DIGIT_PATTERN_, *NATIONAL_PREFIX_SEPARATORS_PATTERN_, *CHARACTER_CLASS_PATTERN_, *STANDALONE_DIGIT_PATTERN_; +@property (nonatomic, strong, readwrite) NSRegularExpression *ELIGIBLE_FORMAT_PATTERN_; +@property (nonatomic, assign, readwrite) BOOL ableToFormat_, inputHasFormatting_, isCompleteNumber_, isExpectingCountryCallingCode_, shouldAddSpaceAfterNationalPrefix_; +@property (nonatomic, strong, readwrite) NBPhoneNumberUtil *phoneUtil_; +@property (nonatomic, assign, readwrite) NSUInteger lastMatchPosition_, originalPosition_, positionToRemember_; +@property (nonatomic, assign, readwrite) NSUInteger MIN_LEADING_DIGITS_LENGTH_; +@property (nonatomic, strong, readwrite) NSMutableArray *possibleFormats_; +@property (nonatomic, strong, readwrite) NBPhoneMetaData *currentMetaData_, *defaultMetaData_, *EMPTY_METADATA_; + +@end + + +@implementation NBAsYouTypeFormatter + +- (id)init +{ + self = [super init]; + + if (self) { + /** + * @type {i18n.phonenumbers.PhoneNumberUtil} + * @private + */ + self.phoneUtil_ = [NBPhoneNumberUtil sharedInstance]; + + /** + * The digits that have not been entered yet will be represented by a \u2008, + * the punctuation space. + * @const + * @type {string} + * @private + */ + self.DIGIT_PLACEHOLDER_ = @"\u2008"; + + /** + * Character used when appropriate to separate a prefix, such as a long NDD or a + * country calling code, from the national number. + * @const + * @type {string} + * @private + */ + self.SEPARATOR_BEFORE_NATIONAL_NUMBER_ = @" "; + + /** + * This is the minimum length of national number accrued that is required to + * trigger the formatter. The first element of the leadingDigitsPattern of + * each numberFormat contains a regular expression that matches up to this + * number of digits. + * @const + * @type {number} + * @private + */ + self.MIN_LEADING_DIGITS_LENGTH_ = 3; + + /** + * @type {string} + * @private + */ + self.currentOutput_ = @""; + + /** + * @type {!goog.string.StringBuffer} + * @private + */ + self.formattingTemplate_ = [NSMutableString stringWithString:@""]; + + NSError *aError = nil; + + /** + * @type {RegExp} + * @private + */ + self.DIGIT_PATTERN_ = [NSRegularExpression regularExpressionWithPattern:self.DIGIT_PLACEHOLDER_ options:0 error:&aError]; + + /** + * A set of characters that, if found in a national prefix formatting rules, are + * an indicator to us that we should separate the national prefix from the + * number when formatting. + * @const + * @type {RegExp} + * @private + */ + self.NATIONAL_PREFIX_SEPARATORS_PATTERN_ = [NSRegularExpression regularExpressionWithPattern:@"[- ]" options:0 error:&aError]; + + /** + * A pattern that is used to match character classes in regular expressions. + * An example of a character class is [1-4]. + * @const + * @type {RegExp} + * @private + */ + self.CHARACTER_CLASS_PATTERN_ = [NSRegularExpression regularExpressionWithPattern:@"\\[([^\\[\\]])*\\]" options:0 error:&aError]; + + /** + * Any digit in a regular expression that actually denotes a digit. For + * example, in the regular expression 80[0-2]\d{6,10}, the first 2 digits + * (8 and 0) are standalone digits, but the rest are not. + * Two look-aheads are needed because the number following \\d could be a + * two-digit number, since the phone number can be as long as 15 digits. + * @const + * @type {RegExp} + * @private + */ + self.STANDALONE_DIGIT_PATTERN_ = [NSRegularExpression regularExpressionWithPattern:@"\\d(?=[^,}][^,}])" options:0 error:&aError]; + + /** + * A pattern that is used to determine if a numberFormat under availableFormats + * is eligible to be used by the AYTF. It is eligible when the format element + * under numberFormat contains groups of the dollar sign followed by a single + * digit, separated by valid phone number punctuation. This prevents invalid + * punctuation (such as the star sign in Israeli star numbers) getting into the + * output of the AYTF. + * @const + * @type {RegExp} + * @private + */ + NSString *eligible_format = @"^[-x‐-―−ー－-／ ()（）［］.\\[\\]/~⁓∼～]*(\\$\\d[-x‐-―−ー－-／ ()（）［］.\\[\\]/~⁓∼～]*)+$"; + self.ELIGIBLE_FORMAT_PATTERN_ = [NSRegularExpression regularExpressionWithPattern:eligible_format options:0 error:&aError]; + + /** + * The pattern from numberFormat that is currently used to create + * formattingTemplate. + * @type {string} + * @private + */ + self.currentFormattingPattern_ = @""; + + /** + * @type {!goog.string.StringBuffer} + * @private + */ + self.accruedInput_ = [NSMutableString stringWithString:@""]; + + /** + * @type {!goog.string.StringBuffer} + * @private + */ + self.accruedInputWithoutFormatting_ = [NSMutableString stringWithString:@""]; + + /** + * This indicates whether AsYouTypeFormatter is currently doing the + * formatting. + * @type {BOOL} + * @private + */ + self.ableToFormat_ = YES; + + /** + * Set to YES when users enter their own formatting. AsYouTypeFormatter will + * do no formatting at all when this is set to YES. + * @type {BOOL} + * @private + */ + self.inputHasFormatting_ = NO; + + /** + * This is set to YES when we know the user is entering a full national + * significant number, since we have either detected a national prefix or an + * international dialing prefix. When this is YES, we will no longer use + * local number formatting patterns. + * @type {BOOL} + * @private + */ + self.isCompleteNumber_ = NO; + + /** + * @type {BOOL} + * @private + */ + self.isExpectingCountryCallingCode_ = NO; + + /** + * @type {number} + * @private + */ + self.lastMatchPosition_ = 0; + + /** + * The position of a digit upon which inputDigitAndRememberPosition is most + * recently invoked, as found in the original sequence of characters the user + * entered. + * @type {number} + * @private + */ + self.originalPosition_ = 0; + + /** + * The position of a digit upon which inputDigitAndRememberPosition is most + * recently invoked, as found in accruedInputWithoutFormatting. + * entered. + * @type {number} + * @private + */ + self.positionToRemember_ = 0; + + /** + * This contains anything that has been entered so far preceding the national + * significant number, and it is formatted (e.g. with space inserted). For + * example, this can contain IDD, country code, and/or NDD, etc. + * @type {!goog.string.StringBuffer} + * @private + */ + self.prefixBeforeNationalNumber_ = [NSMutableString stringWithString:@""]; + + /** + * @type {BOOL} + * @private + */ + self.shouldAddSpaceAfterNationalPrefix_ = NO; + + /** + * This contains the national prefix that has been extracted. It contains only + * digits without formatting. + * @type {string} + * @private + */ + self.nationalPrefixExtracted_ = @""; + + /** + * @type {!goog.string.StringBuffer} + * @private + */ + self.nationalNumber_ = [NSMutableString stringWithString:@""]; + + /** + * @type {Array.<i18n.phonenumbers.NumberFormat>} + * @private + */ + self.possibleFormats_ = [[NSMutableArray alloc] init]; + } + + return self; +} + +/** + * Constructs an AsYouTypeFormatter for the specific region. + * + * @param {string} regionCode the ISO 3166-1 two-letter region code that denotes + * the region where the phone number is being entered. + * @constructor + */ + +- (id)initWithRegionCode:(NSString*)regionCode +{ + self = [self init]; + + if (self) { + /** + * @type {string} + * @private + */ + self.defaultCountry_ = regionCode; + self.currentMetaData_ = [self getMetadataForRegion_:self.defaultCountry_]; + /** + * @type {i18n.phonenumbers.PhoneMetadata} + * @private + */ + self.defaultMetaData_ = self.currentMetaData_; + + /** + * @const + * @type {i18n.phonenumbers.PhoneMetadata} + * @private + */ + self.EMPTY_METADATA_ = [[NBPhoneMetaData alloc] init]; + [self.EMPTY_METADATA_ setInternationalPrefix:@"NA"]; + } + + return self; +} + +- (id)initWithRegionCodeForTest:(NSString*)regionCode +{ + self = [self init]; + + if (self) { + self.phoneUtil_ = [NBPhoneNumberUtil sharedInstanceForTest]; + + self.defaultCountry_ = regionCode; + self.currentMetaData_ = [self getMetadataForRegion_:self.defaultCountry_]; + self.defaultMetaData_ = self.currentMetaData_; + self.EMPTY_METADATA_ = [[NBPhoneMetaData alloc] init]; + [self.EMPTY_METADATA_ setInternationalPrefix:@"NA"]; + } + + return self; +} + +/** + * 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. + * @param {string} regionCode an ISO 3166-1 two-letter region code. + * @return {i18n.phonenumbers.PhoneMetadata} main metadata for this region. + * @private + */ +- (NBPhoneMetaData*)getMetadataForRegion_:(NSString*)regionCode +{ + + /** @type {number} */ + NSNumber *countryCallingCode = [self.phoneUtil_ getCountryCodeForRegion:regionCode]; + /** @type {string} */ + NSString *mainCountry = [self.phoneUtil_ getRegionCodeForCountryCode:countryCallingCode]; + /** @type {i18n.phonenumbers.PhoneMetadata} */ + NBPhoneMetaData *metadata = [self.phoneUtil_ getMetadataForRegion:mainCountry]; + if (metadata != nil) { + 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 self.EMPTY_METADATA_; +}; + + +/** + * @return {BOOL} YES 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. + /** @type {number} */ + NSUInteger possibleFormatsLength = [self.possibleFormats_ count]; + for (NSUInteger i = 0; i < possibleFormatsLength; ++i) + { + /** @type {i18n.phonenumbers.NumberFormat} */ + NBNumberFormat *numberFormat = [self.possibleFormats_ safeObjectAtIndex:i]; + /** @type {string} */ + NSString *pattern = numberFormat.pattern; + + if ([self.currentFormattingPattern_ isEqualToString:pattern]) { + return NO; + } + + if ([self createFormattingTemplate_:numberFormat ]) + { + self.currentFormattingPattern_ = pattern; + NSRange nationalPrefixRange = NSMakeRange(0, [numberFormat.nationalPrefixFormattingRule length]); + if (nationalPrefixRange.length > 0) { + NSTextCheckingResult *matchResult = + [self.NATIONAL_PREFIX_SEPARATORS_PATTERN_ firstMatchInString:numberFormat.nationalPrefixFormattingRule + options:0 + range:nationalPrefixRange]; + self.shouldAddSpaceAfterNationalPrefix_ = (matchResult != nil); + } else { + self.shouldAddSpaceAfterNationalPrefix_ = NO; + } + // With a new formatting template, the matched position using the old + // template needs to be reset. + self.lastMatchPosition_ = 0; + return YES; + } + } + self.ableToFormat_ = NO; + return NO; +}; + + +/** + * @param {string} leadingThreeDigits first three digits of entered number. + * @private + */ +- (void)getAvailableFormats_:(NSString*)leadingThreeDigits +{ + /** @type {Array.<i18n.phonenumbers.NumberFormat>} */ + BOOL isIntlNumberFormats = (self.isCompleteNumber_ && self.currentMetaData_.intlNumberFormats.count > 0); + NSMutableArray *formatList = isIntlNumberFormats ? self.currentMetaData_.intlNumberFormats : self.currentMetaData_.numberFormats; + + /** @type {number} */ + NSUInteger formatListLength = formatList.count; + + for (NSUInteger i = 0; i < formatListLength; ++i) + { + /** @type {i18n.phonenumbers.NumberFormat} */ + NBNumberFormat *format = [formatList safeObjectAtIndex:i]; + /** @type {BOOL} */ + BOOL nationalPrefixIsUsedByCountry = (self.currentMetaData_.nationalPrefix && self.currentMetaData_.nationalPrefix.length > 0); + + if (!nationalPrefixIsUsedByCountry || self.isCompleteNumber_ || format.nationalPrefixOptionalWhenFormatting || + [self.phoneUtil_ formattingRuleHasFirstGroupOnly:format.nationalPrefixFormattingRule]) + { + if ([self isFormatEligible_:format.format]) { + [self.possibleFormats_ addObject:format]; + } + } + } + + [self narrowDownPossibleFormats_:leadingThreeDigits]; +}; + + +/** + * @param {string} format + * @return {BOOL} + * @private + */ +- (BOOL)isFormatEligible_:(NSString*)format +{ + NSTextCheckingResult *matchResult = + [self.ELIGIBLE_FORMAT_PATTERN_ firstMatchInString:format options:0 range:NSMakeRange(0, [format length])]; + return (matchResult != nil); +}; + + +/** + * @param {string} leadingDigits + * @private + */ +- (void)narrowDownPossibleFormats_:(NSString *)leadingDigits +{ + /** @type {Array.<i18n.phonenumbers.NumberFormat>} */ + NSMutableArray *possibleFormats = [[NSMutableArray alloc] init]; + /** @type {number} */ + NSUInteger indexOfLeadingDigitsPattern = leadingDigits.length - self.MIN_LEADING_DIGITS_LENGTH_; + /** @type {number} */ + NSUInteger possibleFormatsLength = self.possibleFormats_.count; + for (NSUInteger i = 0; i < possibleFormatsLength; ++i) + { + /** @type {i18n.phonenumbers.NumberFormat} */ + NBNumberFormat *format = [self.possibleFormats_ safeObjectAtIndex:i]; + if (format.leadingDigitsPatterns.count > indexOfLeadingDigitsPattern) + { + /** @type {string} */ + NSString *leadingDigitsPattern = [format.leadingDigitsPatterns safeObjectAtIndex:indexOfLeadingDigitsPattern]; + + if ([self.phoneUtil_ stringPositionByRegex:leadingDigits regex:leadingDigitsPattern] == 0) + { + [possibleFormats addObject:format]; + } + } else { + // else the particular format has no more specific leadingDigitsPattern, + // and it should be retained. + [possibleFormats addObject:[self.possibleFormats_ safeObjectAtIndex:i]]; + } + } + self.possibleFormats_ = possibleFormats; +}; + + +/** + * @param {i18n.phonenumbers.NumberFormat} format + * @return {BOOL} + * @private + */ +- (BOOL)createFormattingTemplate_:(NBNumberFormat*)format +{ + /** @type {string} */ + NSString *numberPattern = format.pattern; + + // The formatter doesn't format numbers when numberPattern contains '|', e.g. + // (20|3)\d{4}. In those cases we quickly return. + NSRange stringRange = [numberPattern rangeOfString:@"|"]; + if (stringRange.location != NSNotFound) { + return NO; + } + + // Replace anything in the form of [..] with \d + numberPattern = [self.CHARACTER_CLASS_PATTERN_ stringByReplacingMatchesInString:numberPattern + options:0 range:NSMakeRange(0, [numberPattern length]) + withTemplate:@"\\\\d"]; + + // Replace any standalone digit (not the one in d{}) with \d + numberPattern = [self.STANDALONE_DIGIT_PATTERN_ stringByReplacingMatchesInString:numberPattern + options:0 range:NSMakeRange(0, [numberPattern length]) + withTemplate:@"\\\\d"]; + self.formattingTemplate_ = [NSMutableString stringWithString:@""]; + + /** @type {string} */ + NSString *tempTemplate = [self getFormattingTemplate_:numberPattern numberFormat:format.format]; + if (tempTemplate.length > 0) { + [self.formattingTemplate_ appendString:tempTemplate]; + return YES; + } + return NO; +}; + + +/** + * Gets a formatting template which can be used to efficiently format a + * partial number where digits are added one by one. + * + * @param {string} numberPattern + * @param {string} numberFormat + * @return {string} + * @private + */ +- (NSString*)getFormattingTemplate_:(NSString*)numberPattern numberFormat:(NSString*)numberFormat +{ + // Creates a phone number consisting only of the digit 9 that matches the + // numberPattern by applying the pattern to the longestPhoneNumber string. + /** @type {string} */ + NSString *longestPhoneNumber = @"999999999999999"; + + /** @type {Array.<string>} */ + NSArray *m = [self.phoneUtil_ matchedStringByRegex:longestPhoneNumber regex:numberPattern]; + + // this match will always succeed + /** @type {string} */ + NSString *aPhoneNumber = [m safeObjectAtIndex:0]; + // No formatting template can be created if the number of digits entered so + // far is longer than the maximum the current formatting rule can accommodate. + if (aPhoneNumber.length < self.nationalNumber_.length) { + return @""; + } + // Formats the number according to numberFormat + /** @type {string} */ + NSString *template = [self.phoneUtil_ replaceStringByRegex:aPhoneNumber regex:numberPattern withTemplate:numberFormat]; + + // Replaces each digit with character DIGIT_PLACEHOLDER + template = [self.phoneUtil_ replaceStringByRegex:template regex:@"9" withTemplate:self.DIGIT_PLACEHOLDER_]; + return template; +}; + + +/** + * Clears the internal state of the formatter, so it can be reused. + */ +- (void)clear +{ + self.currentOutput_ = @""; + self.accruedInput_ = [NSMutableString stringWithString:@""]; + self.accruedInputWithoutFormatting_ = [NSMutableString stringWithString:@""]; + self.formattingTemplate_ = [NSMutableString stringWithString:@""]; + self.lastMatchPosition_ = 0; + self.currentFormattingPattern_ = @""; + self.prefixBeforeNationalNumber_ = [NSMutableString stringWithString:@""]; + self.nationalPrefixExtracted_ = @""; + self.nationalNumber_ = [NSMutableString stringWithString:@""]; + self.ableToFormat_ = YES; + self.inputHasFormatting_ = NO; + self.positionToRemember_ = 0; + self.originalPosition_ = 0; + self.isCompleteNumber_ = NO; + self.isExpectingCountryCallingCode_ = NO; + [self.possibleFormats_ removeAllObjects]; + self.shouldAddSpaceAfterNationalPrefix_ = NO; + + if (self.currentMetaData_ != self.defaultMetaData_) { + self.currentMetaData_ = [self getMetadataForRegion_:self.defaultCountry_]; + } +} + + +/** + * Formats a phone number on-the-fly as each digit is entered. + * + * @param {string} nextChar the most recently entered digit of a phone number. + * Formatting characters are allowed, but as soon as they are encountered + * this method formats the number as entered and not 'as you type' anymore. + * Full width digits and Arabic-indic digits are allowed, and will be shown + * as they are. + * @return {string} the partially formatted phone number. + */ +- (NSString*)inputDigit:(NSString*)nextChar +{ + self.currentOutput_ = [self inputDigitWithOptionToRememberPosition_:nextChar rememberPosition:NO]; + return self.currentOutput_; +} + + +/** + * Same as {@link #inputDigit}, but remembers the position where + * {@code nextChar} is inserted, so that it can be retrieved later by using + * {@link #getRememberedPosition}. The remembered position will be automatically + * adjusted if additional formatting characters are later inserted/removed in + * front of {@code nextChar}. + * + * @param {string} nextChar + * @return {string} + */ +- (NSString*)inputDigitAndRememberPosition:(NSString*)nextChar +{ + self.currentOutput_ = [self inputDigitWithOptionToRememberPosition_:nextChar rememberPosition:YES]; + return self.currentOutput_; +}; + + +/** + * @param {string} nextChar + * @param {BOOL} rememberPosition + * @return {string} + * @private + */ +- (NSString*)inputDigitWithOptionToRememberPosition_:(NSString*)nextChar rememberPosition:(BOOL)rememberPosition +{ + [self.accruedInput_ appendString:nextChar]; + + if (rememberPosition) { + self.originalPosition_ = self.accruedInput_.length; + } + + // We do formatting on-the-fly only when each character entered is either a + // digit, or a plus sign (accepted at the start of the number only). + if (![self isDigitOrLeadingPlusSign_:nextChar]) + { + self.ableToFormat_ = NO; + self.inputHasFormatting_ = YES; + } else { + nextChar = [self normalizeAndAccrueDigitsAndPlusSign_:nextChar rememberPosition:rememberPosition]; + } + + if (!self.ableToFormat_) { + // When we are unable to format because of reasons other than that + // formatting chars have been entered, it can be due to really long IDDs or + // NDDs. If that is the case, we might be able to do formatting again after + // extracting them. + if (self.inputHasFormatting_) { + return [NSString stringWithString:self.accruedInput_]; + } + else if ([self attemptToExtractIdd_]) { + if ([self attemptToExtractCountryCallingCode_]) { + return [self attemptToChoosePatternWithPrefixExtracted_]; + } + } + else if ([self ableToExtractLongerNdd_]) { + // Add an additional space to separate long NDD and national significant + // number for readability. We don't set shouldAddSpaceAfterNationalPrefix_ + // to YES, since we don't want this to change later when we choose + // formatting templates. + [self.prefixBeforeNationalNumber_ appendString:[NSString stringWithFormat: @"%@", self.SEPARATOR_BEFORE_NATIONAL_NUMBER_]]; + return [self attemptToChoosePatternWithPrefixExtracted_]; + } + return self.accruedInput_; + } + + // We start to attempt to format only when at least MIN_LEADING_DIGITS_LENGTH + // digits (the plus sign is counted as a digit as well for this purpose) have + // been entered. + switch (self.accruedInputWithoutFormatting_.length) + { + case 0: + case 1: + case 2: + return self.accruedInput_; + case 3: + if ([self attemptToExtractIdd_]) { + self.isExpectingCountryCallingCode_ = YES; + } else { + // No IDD or plus sign is found, might be entering in national format. + self.nationalPrefixExtracted_ = [self removeNationalPrefixFromNationalNumber_]; + return [self attemptToChooseFormattingPattern_]; + } + default: + if (self.isExpectingCountryCallingCode_) { + if ([self attemptToExtractCountryCallingCode_]) { + self.isExpectingCountryCallingCode_ = NO; + } + return [NSString stringWithFormat:@"%@%@", self.prefixBeforeNationalNumber_, self.nationalNumber_]; + } + + if (self.possibleFormats_.count > 0) { + // The formatting pattern is already chosen. + /** @type {string} */ + NSString *tempNationalNumber = [self inputDigitHelper_:nextChar]; + // See if the accrued digits can be formatted properly already. If not, + // use the results from inputDigitHelper, which does formatting based on + // the formatting pattern chosen. + /** @type {string} */ + NSString *formattedNumber = [self attemptToFormatAccruedDigits_]; + if (formattedNumber.length > 0) { + return formattedNumber; + } + + [self narrowDownPossibleFormats_:self.nationalNumber_]; + + if ([self maybeCreateNewTemplate_]) { + return [self inputAccruedNationalNumber_]; + } + + return self.ableToFormat_ ? [self appendNationalNumber_:tempNationalNumber] : self.accruedInput_; + } + else { + return [self attemptToChooseFormattingPattern_]; + } + } +}; + + +/** + * @return {string} + * @private + */ +- (NSString*)attemptToChoosePatternWithPrefixExtracted_ +{ + self.ableToFormat_ = YES; + self.isExpectingCountryCallingCode_ = NO; + [self.possibleFormats_ removeAllObjects]; + return [self attemptToChooseFormattingPattern_]; +}; + + +/** + * 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. + * @return {BOOL} + * @private + */ +- (BOOL)ableToExtractLongerNdd_ +{ + if (self.nationalPrefixExtracted_.length > 0) + { + // Put the extracted NDD back to the national number before attempting to + // extract a new NDD. + /** @type {string} */ + NSString *nationalNumberStr = [NSString stringWithString:self.nationalNumber_]; + self.nationalNumber_ = [NSMutableString stringWithString:@""]; + [self.nationalNumber_ appendString:self.nationalPrefixExtracted_]; + [self.nationalNumber_ appendString:nationalNumberStr]; + // 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. + /** @type {string} */ + NSString *prefixBeforeNationalNumberStr = [NSString stringWithString:self.prefixBeforeNationalNumber_]; + NSRange lastRange = [prefixBeforeNationalNumberStr rangeOfString:self.nationalPrefixExtracted_ options:NSBackwardsSearch]; + /** @type {number} */ + NSUInteger indexOfPreviousNdd = lastRange.location; + self.prefixBeforeNationalNumber_ = [NSMutableString stringWithString:@""]; + [self.prefixBeforeNationalNumber_ appendString:[prefixBeforeNationalNumberStr substringWithRange:NSMakeRange(0, indexOfPreviousNdd)]]; + } + + return self.nationalPrefixExtracted_ != [self removeNationalPrefixFromNationalNumber_]; +}; + + +/** + * @param {string} nextChar + * @return {BOOL} + * @private + */ +- (BOOL)isDigitOrLeadingPlusSign_:(NSString*)nextChar +{ + NSString *digitPattern = [NSString stringWithFormat:@"([%@])", [self.phoneUtil_ VALID_DIGITS_STRING]]; + NSString *plusPattern = [NSString stringWithFormat:@"[%@]+", [self.phoneUtil_ PLUS_CHARS_]]; + + BOOL isDigitPattern = [[self.phoneUtil_ matchesByRegex:nextChar regex:digitPattern] count] > 0; + BOOL isPlusPattern = [[self.phoneUtil_ matchesByRegex:nextChar regex:plusPattern] count] > 0; + + return isDigitPattern || (self.accruedInput_.length == 1 && isPlusPattern); +}; + + +/** + * Check to see if there is an exact pattern match for these digits. If so, we + * should use this instead of any other formatting template whose + * leadingDigitsPattern also matches the input. + * @return {string} + * @private + */ +- (NSString*)attemptToFormatAccruedDigits_ +{ + /** @type {string} */ + NSString *nationalNumber = [NSString stringWithString:self.nationalNumber_]; + + /** @type {number} */ + NSUInteger possibleFormatsLength = self.possibleFormats_.count; + for (NSUInteger i = 0; i < possibleFormatsLength; ++i) + { + /** @type {i18n.phonenumbers.NumberFormat} */ + NBNumberFormat *numberFormat = self.possibleFormats_[i]; + /** @type {string} */ + NSString * pattern = numberFormat.pattern; + /** @type {RegExp} */ + NSString *patternRegExp = [NSString stringWithFormat:@"^(?:%@)$", pattern]; + BOOL isPatternRegExp = [[self.phoneUtil_ matchesByRegex:nationalNumber regex:patternRegExp] count] > 0; + if (isPatternRegExp) { + if (numberFormat.nationalPrefixFormattingRule.length > 0) { + NSArray *matches = [self.NATIONAL_PREFIX_SEPARATORS_PATTERN_ matchesInString:numberFormat.nationalPrefixFormattingRule + options:0 + range:NSMakeRange(0, numberFormat.nationalPrefixFormattingRule.length)]; + self.shouldAddSpaceAfterNationalPrefix_ = [matches count] > 0; + } else { + self.shouldAddSpaceAfterNationalPrefix_ = NO; + } + + /** @type {string} */ + NSString *formattedNumber = [self.phoneUtil_ replaceStringByRegex:nationalNumber + regex:pattern + withTemplate:numberFormat.format]; + return [self appendNationalNumber_:formattedNumber]; + } + } + return @""; +}; + + +/** + * Combines the national number with any prefix (IDD/+ and country code or + * national prefix) that was collected. A space will be inserted between them if + * the current formatting template indicates this to be suitable. + * @param {string} nationalNumber The number to be appended. + * @return {string} The combined number. + * @private + */ +- (NSString*)appendNationalNumber_:(NSString*)nationalNumber +{ + /** @type {number} */ + NSUInteger prefixBeforeNationalNumberLength = self.prefixBeforeNationalNumber_.length; + unichar blank_char = [self.SEPARATOR_BEFORE_NATIONAL_NUMBER_ characterAtIndex:0]; + if (self.shouldAddSpaceAfterNationalPrefix_ && prefixBeforeNationalNumberLength > 0 && + [self.prefixBeforeNationalNumber_ characterAtIndex:prefixBeforeNationalNumberLength - 1] != blank_char) + { + // We want to add a space after the national prefix if the national prefix + // formatting rule indicates that this would normally be done, with the + // exception of the case where we already appended a space because the NDD + // was surprisingly long. + + return [NSString stringWithFormat:@"%@%@%@", self.prefixBeforeNationalNumber_, self.SEPARATOR_BEFORE_NATIONAL_NUMBER_, nationalNumber]; + } else { + return [NSString stringWithFormat:@"%@%@", self.prefixBeforeNationalNumber_, nationalNumber]; + } +}; + + +/** + * Returns the current position in the partially formatted phone number of the + * character which was previously passed in as the parameter of + * {@link #inputDigitAndRememberPosition}. + * + * @return {number} + */ +- (NSInteger)getRememberedPosition +{ + if (!self.ableToFormat_) { + return self.originalPosition_; + } + /** @type {number} */ + NSUInteger accruedInputIndex = 0; + /** @type {number} */ + NSUInteger currentOutputIndex = 0; + /** @type {string} */ + NSString *accruedInputWithoutFormatting = self.accruedInputWithoutFormatting_; + /** @type {string} */ + NSString *currentOutput = self.currentOutput_; + + while (accruedInputIndex < self.positionToRemember_ && currentOutputIndex < currentOutput.length) + { + if ([accruedInputWithoutFormatting characterAtIndex:accruedInputIndex] == [currentOutput characterAtIndex:currentOutputIndex]) + { + accruedInputIndex++; + } + currentOutputIndex++; + } + return currentOutputIndex; +}; + + +/** + * Attempts to set the formatting template and returns a string which contains + * the formatted version of the digits entered so far. + * + * @return {string} + * @private + */ +- (NSString*)attemptToChooseFormattingPattern_ +{ + /** @type {string} */ + NSString *nationalNumber = [self.nationalNumber_ copy]; + // We start to attempt to format only when as least MIN_LEADING_DIGITS_LENGTH + // digits of national number (excluding national prefix) have been entered. + if (nationalNumber.length >= self.MIN_LEADING_DIGITS_LENGTH_) { + [self getAvailableFormats_:[nationalNumber substringWithRange:NSMakeRange(0, self.MIN_LEADING_DIGITS_LENGTH_)]]; + return [self maybeCreateNewTemplate_] ? [self inputAccruedNationalNumber_] : self.accruedInput_; + } else { + return [self appendNationalNumber_:nationalNumber]; + } +} + + +/** + * Invokes inputDigitHelper on each digit of the national number accrued, and + * returns a formatted string in the end. + * + * @return {string} + * @private + */ +- (NSString*)inputAccruedNationalNumber_ +{ + /** @type {string} */ + NSString *nationalNumber = [self.nationalNumber_ copy]; + /** @type {number} */ + NSUInteger lengthOfNationalNumber = nationalNumber.length; + if (lengthOfNationalNumber > 0) { + /** @type {string} */ + NSString *tempNationalNumber = @""; + for (NSUInteger i = 0; i < lengthOfNationalNumber; i++) + { + tempNationalNumber = [self inputDigitHelper_:[NSString stringWithFormat: @"%C", [nationalNumber characterAtIndex:i]]]; + } + return self.ableToFormat_ ? [self appendNationalNumber_:tempNationalNumber] : self.accruedInput_; + } else { + return self.prefixBeforeNationalNumber_; + } +}; + + +/** + * @return {BOOL} YES if the current country is a NANPA country and the + * national number begins with the national prefix. + * @private + */ +- (BOOL)isNanpaNumberWithNationalPrefix_ +{ + // For NANPA numbers beginning with 1[2-9], treat the 1 as the national + // prefix. The reason is that national significant numbers in NANPA always + // start with [2-9] after the national prefix. Numbers beginning with 1[01] + // can only be short/emergency numbers, which don't need the national prefix. + if (![self.currentMetaData_.countryCode isEqualToNumber:@1]) { + return NO; + } + + /** @type {string} */ + NSString *nationalNumber = [self.nationalNumber_ copy]; + return ([nationalNumber characterAtIndex:0] == '1') && ([nationalNumber characterAtIndex:1] != '0') && + ([nationalNumber characterAtIndex:1] != '1'); +}; + + +/** + * Returns the national prefix extracted, or an empty string if it is not + * present. + * @return {string} + * @private + */ +- (NSString*)removeNationalPrefixFromNationalNumber_ +{ + /** @type {string} */ + NSString *nationalNumber = [self.nationalNumber_ copy]; + /** @type {number} */ + NSUInteger startOfNationalNumber = 0; + + if ([self isNanpaNumberWithNationalPrefix_]) { + startOfNationalNumber = 1; + [self.prefixBeforeNationalNumber_ appendString:@"1"]; + [self.prefixBeforeNationalNumber_ appendFormat:@"%@", self.SEPARATOR_BEFORE_NATIONAL_NUMBER_]; + self.isCompleteNumber_ = YES; + } + else if (self.currentMetaData_.nationalPrefixForParsing != nil && self.currentMetaData_.nationalPrefixForParsing.length > 0) + { + /** @type {RegExp} */ + NSString *nationalPrefixForParsing = [NSString stringWithFormat:@"^(?:%@)", self.currentMetaData_.nationalPrefixForParsing]; + /** @type {Array.<string>} */ + NSArray *m = [self.phoneUtil_ matchedStringByRegex:nationalNumber regex:nationalPrefixForParsing]; + NSString *firstString = [m safeObjectAtIndex:0]; + if (m != nil && firstString != nil && firstString.length > 0) { + // When the national prefix is detected, we use international formatting + // rules instead of national ones, because national formatting rules could + // contain local formatting rules for numbers entered without area code. + self.isCompleteNumber_ = YES; + startOfNationalNumber = firstString.length; + [self.prefixBeforeNationalNumber_ appendString:[nationalNumber substringWithRange:NSMakeRange(0, startOfNationalNumber)]]; + } + } + + self.nationalNumber_ = [NSMutableString stringWithString:@""]; + [self.nationalNumber_ appendString:[nationalNumber substringFromIndex:startOfNationalNumber]]; + return [nationalNumber substringWithRange:NSMakeRange(0, startOfNationalNumber)]; +}; + + +/** + * Extracts IDD and plus sign to prefixBeforeNationalNumber when they are + * available, and places the remaining input into nationalNumber. + * + * @return {BOOL} YES when accruedInputWithoutFormatting begins with the + * plus sign or valid IDD for defaultCountry. + * @private + */ +- (BOOL)attemptToExtractIdd_ +{ + /** @type {string} */ + NSString *accruedInputWithoutFormatting = [self.accruedInputWithoutFormatting_ copy]; + /** @type {RegExp} */ + NSString *internationalPrefix = [NSString stringWithFormat:@"^(?:\\+|%@)", self.currentMetaData_.internationalPrefix]; + /** @type {Array.<string>} */ + NSArray *m = [self.phoneUtil_ matchedStringByRegex:accruedInputWithoutFormatting regex:internationalPrefix]; + + NSString *firstString = [m safeObjectAtIndex:0]; + + if (m != nil && firstString != nil && firstString.length > 0) { + self.isCompleteNumber_ = YES; + /** @type {number} */ + NSUInteger startOfCountryCallingCode = firstString.length; + self.nationalNumber_ = [NSMutableString stringWithString:@""]; + [self.nationalNumber_ appendString:[accruedInputWithoutFormatting substringFromIndex:startOfCountryCallingCode]]; + self.prefixBeforeNationalNumber_ = [NSMutableString stringWithString:@""]; + [self.prefixBeforeNationalNumber_ appendString:[accruedInputWithoutFormatting substringWithRange:NSMakeRange(0, startOfCountryCallingCode)]]; + + if ([accruedInputWithoutFormatting characterAtIndex:0] != '+') + { + [self.prefixBeforeNationalNumber_ appendString:[NSString stringWithFormat: @"%@", self.SEPARATOR_BEFORE_NATIONAL_NUMBER_]]; + } + return YES; + } + return NO; +}; + + +/** + * Extracts the country calling code from the beginning of nationalNumber to + * prefixBeforeNationalNumber when they are available, and places the remaining + * input into nationalNumber. + * + * @return {BOOL} YES when a valid country calling code can be found. + * @private + */ +- (BOOL)attemptToExtractCountryCallingCode_ +{ + if (self.nationalNumber_.length == 0) { + return NO; + } + + /** @type {!goog.string.StringBuffer} */ + NSString *numberWithoutCountryCallingCode = @""; + + /** @type {number} */ + NSNumber *countryCode = [self.phoneUtil_ extractCountryCode:self.nationalNumber_ nationalNumber:&numberWithoutCountryCallingCode]; + + if ([countryCode isEqualToNumber:@0]) { + return NO; + } + + self.nationalNumber_ = [NSMutableString stringWithString:@""]; + [self.nationalNumber_ appendString:numberWithoutCountryCallingCode]; + + /** @type {string} */ + NSString *newRegionCode = [self.phoneUtil_ getRegionCodeForCountryCode:countryCode]; + + if ([[self.phoneUtil_ REGION_CODE_FOR_NON_GEO_ENTITY] isEqualToString:newRegionCode]) { + self.currentMetaData_ = [self.phoneUtil_ getMetadataForNonGeographicalRegion:countryCode]; + } else if (newRegionCode != self.defaultCountry_) + { + self.currentMetaData_ = [self getMetadataForRegion_:newRegionCode]; + } + + /** @type {string} */ + NSString *countryCodeString = [NSString stringWithFormat:@"%@", countryCode]; + [self.prefixBeforeNationalNumber_ appendString:countryCodeString]; + [self.prefixBeforeNationalNumber_ appendString:[NSString stringWithFormat: @"%@", self.SEPARATOR_BEFORE_NATIONAL_NUMBER_]]; + return YES; +}; + + +/** + * Accrues digits and the plus sign to accruedInputWithoutFormatting for later + * use. If nextChar contains a digit in non-ASCII format (e.g. the full-width + * version of digits), it is first normalized to the ASCII version. The return + * value is nextChar itself, or its normalized version, if nextChar is a digit + * in non-ASCII format. This method assumes its input is either a digit or the + * plus sign. + * + * @param {string} nextChar + * @param {BOOL} rememberPosition + * @return {string} + * @private + */ +- (NSString*)normalizeAndAccrueDigitsAndPlusSign_:(NSString *)nextChar rememberPosition:(BOOL)rememberPosition +{ + /** @type {string} */ + NSString *normalizedChar; + + if ([nextChar isEqualToString:@"+"]) { + normalizedChar = nextChar; + [self.accruedInputWithoutFormatting_ appendString:nextChar]; + } else { + normalizedChar = [[self.phoneUtil_ DIGIT_MAPPINGS] objectForKey:nextChar]; + [self.accruedInputWithoutFormatting_ appendString:normalizedChar]; + [self.nationalNumber_ appendString:normalizedChar]; + } + + if (rememberPosition) { + self.positionToRemember_ = self.accruedInputWithoutFormatting_.length; + } + + return normalizedChar; +}; + + +/** + * @param {string} nextChar + * @return {string} + * @private + */ +- (NSString*)inputDigitHelper_:(NSString *)nextChar +{ + /** @type {string} */ + NSString *formattingTemplate = [self.formattingTemplate_ copy]; + NSString *subedString = @""; + + if (formattingTemplate.length > self.lastMatchPosition_) { + subedString = [formattingTemplate substringFromIndex:self.lastMatchPosition_]; + } + + if ([self.phoneUtil_ stringPositionByRegex:subedString regex:self.DIGIT_PLACEHOLDER_] >= 0) { + /** @type {number} */ + NSUInteger digitPatternStart = [self.phoneUtil_ stringPositionByRegex:formattingTemplate regex:self.DIGIT_PLACEHOLDER_]; + + /** @type {string} */ + NSRange tempRange = [formattingTemplate rangeOfString:self.DIGIT_PLACEHOLDER_]; + NSString *tempTemplate = [formattingTemplate stringByReplacingOccurrencesOfString:self.DIGIT_PLACEHOLDER_ + withString:nextChar + options:NSLiteralSearch + range:tempRange]; + self.formattingTemplate_ = [NSMutableString stringWithString:@""]; + [self.formattingTemplate_ appendString:tempTemplate]; + self.lastMatchPosition_ = digitPatternStart; + return [tempTemplate substringWithRange:NSMakeRange(0, self.lastMatchPosition_ + 1)]; + } else { + if (self.possibleFormats_.count == 1) + { + // More digits are entered than we could handle, and there are no other + // valid patterns to try. + self.ableToFormat_ = NO; + } // else, we just reset the formatting pattern. + self.currentFormattingPattern_ = @""; + return self.accruedInput_; + } +}; + +@end
diff --git a/libPhoneNumber/NBNumberFormat.h b/libPhoneNumber/NBNumberFormat.h new file mode 100644 index 0000000..d2e8749 --- /dev/null +++ b/libPhoneNumber/NBNumberFormat.h
@@ -0,0 +1,22 @@ +// +// NBPhoneNumberFormat.h +// libPhoneNumber +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#import <Foundation/Foundation.h> + +@interface NBNumberFormat : NSObject + +// from phonemetadata.pb.js +/* 1 */ @property (nonatomic, strong, readwrite) NSString *pattern; +/* 2 */ @property (nonatomic, strong, readwrite) NSString *format; +/* 3 */ @property (nonatomic, strong, readwrite) NSMutableArray *leadingDigitsPatterns; +/* 4 */ @property (nonatomic, strong, readwrite) NSString *nationalPrefixFormattingRule; +/* 6 */ @property (nonatomic, assign, readwrite) BOOL nationalPrefixOptionalWhenFormatting; +/* 5 */ @property (nonatomic, strong, readwrite) NSString *domesticCarrierCodeFormattingRule; + +- (id)initWithData:(id)data; + +@end
diff --git a/libPhoneNumber/NBNumberFormat.m b/libPhoneNumber/NBNumberFormat.m new file mode 100644 index 0000000..5f261a7 --- /dev/null +++ b/libPhoneNumber/NBNumberFormat.m
@@ -0,0 +1,139 @@ +// +// NBPhoneNumberFormat.m +// libPhoneNumber +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#import "NBNumberFormat.h" +#import "NBPhoneNumberDefines.h" + +@implementation NBNumberFormat + +@synthesize pattern, format, leadingDigitsPatterns, nationalPrefixFormattingRule, nationalPrefixOptionalWhenFormatting, domesticCarrierCodeFormattingRule; + + +- (id)initWithData:(id)data +{ + self = [self init]; + + if (self && data != nil && [data isKindOfClass:[NSArray class]]) + { + /* 1 */ self.pattern = [data safeObjectAtIndex:1]; + /* 2 */ self.format = [data safeObjectAtIndex:2]; + /* 3 */ self.leadingDigitsPatterns = [self stringArrayFromData:[data safeObjectAtIndex:3]]; // NSString array + /* 4 */ self.nationalPrefixFormattingRule = [data safeObjectAtIndex:4]; + /* 6 */ self.nationalPrefixOptionalWhenFormatting = [[data safeObjectAtIndex:6] boolValue]; + /* 5 */ self.domesticCarrierCodeFormattingRule = [data safeObjectAtIndex:5]; + } + + return self; +} + + +- (id)init +{ + self = [super init]; + + if (self) + { + self.nationalPrefixOptionalWhenFormatting = NO; + self.leadingDigitsPatterns = [[NSMutableArray alloc] init]; + } + + return self; +} + + +- (NSMutableArray*)stringArrayFromData:(id)data +{ + NSMutableArray *resArray = [[NSMutableArray alloc] init]; + if (data != nil && [data isKindOfClass:[NSArray class]]) + { + for (id numFormat in data) + { + if ([numFormat isKindOfClass:[NSString class]]) + { + [resArray addObject:numFormat]; + } + else + { + [resArray addObject:[numFormat stringValue]]; + } + } + } + + return resArray; +} + + +- (NSString *)description +{ + return [NSString stringWithFormat:@"[pattern:%@, format:%@, leadingDigitsPattern:%@, nationalPrefixFormattingRule:%@, nationalPrefixOptionalWhenFormatting:%@, domesticCarrierCodeFormattingRule:%@]", + self.pattern, self.format, self.leadingDigitsPatterns, self.nationalPrefixFormattingRule, self.nationalPrefixOptionalWhenFormatting?@"Y":@"N", self.domesticCarrierCodeFormattingRule]; +} + + +- (id)copyWithZone:(NSZone *)zone +{ + NBNumberFormat *phoneFormatCopy = [[NBNumberFormat allocWithZone:zone] init]; + + /* + 1 @property (nonatomic, strong, readwrite) NSString *pattern; + 2 @property (nonatomic, strong, readwrite) NSString *format; + 3 @property (nonatomic, strong, readwrite) NSString *leadingDigitsPattern; + 4 @property (nonatomic, strong, readwrite) NSString *nationalPrefixFormattingRule; + 6 @property (nonatomic, assign, readwrite) BOOL nationalPrefixOptionalWhenFormatting; + 5 @property (nonatomic, strong, readwrite) NSString *domesticCarrierCodeFormattingRule; + */ + + phoneFormatCopy.pattern = [self.pattern copy]; + phoneFormatCopy.format = [self.format copy]; + phoneFormatCopy.leadingDigitsPatterns = [self.leadingDigitsPatterns copy]; + phoneFormatCopy.nationalPrefixFormattingRule = [self.nationalPrefixFormattingRule copy]; + phoneFormatCopy.nationalPrefixOptionalWhenFormatting = self.nationalPrefixOptionalWhenFormatting; + phoneFormatCopy.domesticCarrierCodeFormattingRule = [self.domesticCarrierCodeFormattingRule copy]; + + return phoneFormatCopy; +} + + +- (id)initWithCoder:(NSCoder*)coder +{ + if (self = [super init]) + { + self.pattern = [coder decodeObjectForKey:@"pattern"]; + self.format = [coder decodeObjectForKey:@"format"]; + self.leadingDigitsPatterns = [coder decodeObjectForKey:@"leadingDigitsPatterns"]; + self.nationalPrefixFormattingRule = [coder decodeObjectForKey:@"nationalPrefixFormattingRule"]; + self.nationalPrefixOptionalWhenFormatting = [[coder decodeObjectForKey:@"nationalPrefixOptionalWhenFormatting"] boolValue]; + self.domesticCarrierCodeFormattingRule = [coder decodeObjectForKey:@"domesticCarrierCodeFormattingRule"]; + } + return self; +} + + +- (void)encodeWithCoder:(NSCoder*)coder +{ + [coder encodeObject:self.pattern forKey:@"pattern"]; + [coder encodeObject:self.format forKey:@"format"]; + [coder encodeObject:self.leadingDigitsPatterns forKey:@"leadingDigitsPatterns"]; + [coder encodeObject:self.nationalPrefixFormattingRule forKey:@"nationalPrefixFormattingRule"]; + [coder encodeObject:[NSNumber numberWithBool:self.nationalPrefixOptionalWhenFormatting] forKey:@"nationalPrefixOptionalWhenFormatting"]; + [coder encodeObject:self.domesticCarrierCodeFormattingRule forKey:@"domesticCarrierCodeFormattingRule"]; +} + + +- (void)setData:(id)data +{ + if ([data isKindOfClass:[NSArray class]] || [data isKindOfClass:[NSMutableArray class]]) + { + + } + else if ([data isKindOfClass:[NSDictionary class]] || [data isKindOfClass:[NSMutableDictionary class]]) + { + + } +} + +@end
diff --git a/libPhoneNumber/NBPhoneMetaData.h b/libPhoneNumber/NBPhoneMetaData.h new file mode 100644 index 0000000..6767492 --- /dev/null +++ b/libPhoneNumber/NBPhoneMetaData.h
@@ -0,0 +1,45 @@ +// +// M2PhoneMetaData.h +// libPhoneNumber +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#import <Foundation/Foundation.h> + +@class NBPhoneNumberDesc, NBNumberFormat; + +@interface NBPhoneMetaData : NSObject + +// from phonemetadata.pb.js +/* 1 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *generalDesc; +/* 2 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *fixedLine; +/* 3 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *mobile; +/* 4 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *tollFree; +/* 5 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *premiumRate; +/* 6 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *sharedCost; +/* 7 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *personalNumber; +/* 8 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *voip; +/* 21 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *pager; +/* 25 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *uan; +/* 27 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *emergency; +/* 28 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *voicemail; +/* 24 */ @property (nonatomic, strong, readwrite) NBPhoneNumberDesc *noInternationalDialling; +/* 9 */ @property (nonatomic, strong, readwrite) NSString *codeID; +/* 10 */ @property (nonatomic, strong, readwrite) NSNumber *countryCode; +/* 11 */ @property (nonatomic, strong, readwrite) NSString *internationalPrefix; +/* 17 */ @property (nonatomic, strong, readwrite) NSString *preferredInternationalPrefix; +/* 12 */ @property (nonatomic, strong, readwrite) NSString *nationalPrefix; +/* 13 */ @property (nonatomic, strong, readwrite) NSString *preferredExtnPrefix; +/* 15 */ @property (nonatomic, strong, readwrite) NSString *nationalPrefixForParsing; +/* 16 */ @property (nonatomic, strong, readwrite) NSString *nationalPrefixTransformRule; +/* 18 */ @property (nonatomic, assign, readwrite) BOOL sameMobileAndFixedLinePattern; +/* 19 */ @property (nonatomic, strong, readwrite) NSMutableArray *numberFormats; +/* 20 */ @property (nonatomic, strong, readwrite) NSMutableArray *intlNumberFormats; +/* 22 */ @property (nonatomic, assign, readwrite) BOOL mainCountryForCode; +/* 23 */ @property (nonatomic, strong, readwrite) NSString *leadingDigits; +/* 26 */ @property (nonatomic, assign, readwrite) BOOL leadingZeroPossible; + +- (void)buildData:(id)data; + +@end
diff --git a/libPhoneNumber/NBPhoneMetaData.m b/libPhoneNumber/NBPhoneMetaData.m new file mode 100644 index 0000000..8aa30d8 --- /dev/null +++ b/libPhoneNumber/NBPhoneMetaData.m
@@ -0,0 +1,458 @@ +// +// NBPhoneMetaData.m +// libPhoneNumber +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#import "NBPhoneMetaData.h" +#import "NBPhoneNumberDesc.h" +#import "NBNumberFormat.h" +#import "NBPhoneNumberDefines.h" + +@implementation NBPhoneMetaData + +@synthesize generalDesc, fixedLine, mobile, tollFree, premiumRate, sharedCost, personalNumber, voip, pager, uan, emergency, voicemail, noInternationalDialling; +@synthesize codeID, countryCode; +@synthesize internationalPrefix, preferredInternationalPrefix, nationalPrefix, preferredExtnPrefix, nationalPrefixForParsing, nationalPrefixTransformRule, sameMobileAndFixedLinePattern, numberFormats, intlNumberFormats, mainCountryForCode, leadingDigits, leadingZeroPossible; + +- (id)init +{ + self = [super init]; + + if (self) + { + [self setNumberFormats:[[NSMutableArray alloc] init]]; + [self setIntlNumberFormats:[[NSMutableArray alloc] init]]; + + self.leadingZeroPossible = NO; + self.mainCountryForCode = NO; + } + + return self; +} + + +- (NSString *)description +{ + return [NSString stringWithFormat:@"* codeID[%@] countryCode[%@] generalDesc[%@] fixedLine[%@] mobile[%@] tollFree[%@] premiumRate[%@] sharedCost[%@] personalNumber[%@] voip[%@] pager[%@] uan[%@] emergency[%@] voicemail[%@] noInternationalDialling[%@] internationalPrefix[%@] preferredInternationalPrefix[%@] nationalPrefix[%@] preferredExtnPrefix[%@] nationalPrefixForParsing[%@] nationalPrefixTransformRule[%@] sameMobileAndFixedLinePattern[%@] numberFormats[%@] intlNumberFormats[%@] mainCountryForCode[%@] leadingDigits[%@] leadingZeroPossible[%@]", + self.codeID, self.countryCode, self.generalDesc, self.fixedLine, self.mobile, self.tollFree, self.premiumRate, self.sharedCost, self.personalNumber, self.voip, self.pager, self.uan, self.emergency, self.voicemail, self.noInternationalDialling, self.internationalPrefix, self.preferredInternationalPrefix, self.nationalPrefix, self.preferredExtnPrefix, self.nationalPrefixForParsing, self.nationalPrefixTransformRule, self.sameMobileAndFixedLinePattern?@"Y":@"N", self.numberFormats, self.intlNumberFormats, self.mainCountryForCode?@"Y":@"N", self.leadingDigits, self.leadingZeroPossible?@"Y":@"N"]; +} + + +- (void)buildData:(id)data +{ + if (data != nil && [data isKindOfClass:[NSArray class]] ) + { + /* 1 */ self.generalDesc = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:1]]; + /* 2 */ self.fixedLine = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:2]]; + /* 3 */ self.mobile = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:3]]; + /* 4 */ self.tollFree = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:4]]; + /* 5 */ self.premiumRate = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:5]]; + /* 6 */ self.sharedCost = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:6]]; + /* 7 */ self.personalNumber = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:7]]; + /* 8 */ self.voip = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:8]]; + /* 21 */ self.pager = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:21]]; + /* 25 */ self.uan = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:25]]; + /* 27 */ self.emergency = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:27]]; + /* 28 */ self.voicemail = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:28]]; + /* 24 */ self.noInternationalDialling = [[NBPhoneNumberDesc alloc] initWithData:[data safeObjectAtIndex:24]]; + /* 9 */ self.codeID = [data safeObjectAtIndex:9]; + /* 10 */ self.countryCode = [data safeObjectAtIndex:10]; + /* 11 */ self.internationalPrefix = [data safeObjectAtIndex:11]; + /* 17 */ self.preferredInternationalPrefix = [data safeObjectAtIndex:17]; + /* 12 */ self.nationalPrefix = [data safeObjectAtIndex:12]; + /* 13 */ self.preferredExtnPrefix = [data safeObjectAtIndex:13]; + /* 15 */ self.nationalPrefixForParsing = [data safeObjectAtIndex:15]; + /* 16 */ self.nationalPrefixTransformRule = [data safeObjectAtIndex:16]; + /* 18 */ self.sameMobileAndFixedLinePattern = [[data safeObjectAtIndex:18] boolValue]; + /* 19 */ self.numberFormats = [self numberFormatArrayFromData:[data safeObjectAtIndex:19]]; // NBNumberFormat array + /* 20 */ self.intlNumberFormats = [self numberFormatArrayFromData:[data safeObjectAtIndex:20]]; // NBNumberFormat array + /* 22 */ self.mainCountryForCode = [[data safeObjectAtIndex:22] boolValue]; + /* 23 */ self.leadingDigits = [data safeObjectAtIndex:23]; + /* 26 */ self.leadingZeroPossible = [[data safeObjectAtIndex:26] boolValue]; + } + else + { + NSLog(@"nil data or wrong data type"); + } +} + + +- (id)initWithCoder:(NSCoder*)coder +{ + if (self = [super init]) + { + self.generalDesc = [coder decodeObjectForKey:@"generalDesc"]; + self.fixedLine = [coder decodeObjectForKey:@"fixedLine"]; + self.mobile = [coder decodeObjectForKey:@"mobile"]; + self.tollFree = [coder decodeObjectForKey:@"tollFree"]; + self.premiumRate = [coder decodeObjectForKey:@"premiumRate"]; + self.sharedCost = [coder decodeObjectForKey:@"sharedCost"]; + self.personalNumber = [coder decodeObjectForKey:@"personalNumber"]; + self.voip = [coder decodeObjectForKey:@"voip"]; + self.pager = [coder decodeObjectForKey:@"pager"]; + self.uan = [coder decodeObjectForKey:@"uan"]; + self.emergency = [coder decodeObjectForKey:@"emergency"]; + self.voicemail = [coder decodeObjectForKey:@"voicemail"]; + self.noInternationalDialling = [coder decodeObjectForKey:@"noInternationalDialling"]; + self.codeID = [coder decodeObjectForKey:@"codeID"]; + self.countryCode = [coder decodeObjectForKey:@"countryCode"]; + self.internationalPrefix = [coder decodeObjectForKey:@"internationalPrefix"]; + self.preferredInternationalPrefix = [coder decodeObjectForKey:@"preferredInternationalPrefix"]; + self.nationalPrefix = [coder decodeObjectForKey:@"nationalPrefix"]; + self.preferredExtnPrefix = [coder decodeObjectForKey:@"preferredExtnPrefix"]; + self.nationalPrefixForParsing = [coder decodeObjectForKey:@"nationalPrefixForParsing"]; + self.nationalPrefixTransformRule = [coder decodeObjectForKey:@"nationalPrefixTransformRule"]; + self.sameMobileAndFixedLinePattern = [[coder decodeObjectForKey:@"sameMobileAndFixedLinePattern"] boolValue]; + self.numberFormats = [coder decodeObjectForKey:@"numberFormats"]; + self.intlNumberFormats = [coder decodeObjectForKey:@"intlNumberFormats"]; + self.mainCountryForCode = [[coder decodeObjectForKey:@"mainCountryForCode"] boolValue]; + self.leadingDigits = [coder decodeObjectForKey:@"leadingDigits"]; + self.leadingZeroPossible = [[coder decodeObjectForKey:@"leadingZeroPossible"] boolValue]; + } + return self; +} + + +- (void)encodeWithCoder:(NSCoder*)coder +{ + [coder encodeObject:self.generalDesc forKey:@"generalDesc"]; + [coder encodeObject:self.fixedLine forKey:@"fixedLine"]; + [coder encodeObject:self.mobile forKey:@"mobile"]; + [coder encodeObject:self.tollFree forKey:@"tollFree"]; + [coder encodeObject:self.premiumRate forKey:@"premiumRate"]; + [coder encodeObject:self.sharedCost forKey:@"sharedCost"]; + [coder encodeObject:self.personalNumber forKey:@"personalNumber"]; + [coder encodeObject:self.voip forKey:@"voip"]; + [coder encodeObject:self.pager forKey:@"pager"]; + [coder encodeObject:self.uan forKey:@"uan"]; + [coder encodeObject:self.emergency forKey:@"emergency"]; + [coder encodeObject:self.voicemail forKey:@"voicemail"]; + [coder encodeObject:self.noInternationalDialling forKey:@"noInternationalDialling"]; + [coder encodeObject:self.codeID forKey:@"codeID"]; + [coder encodeObject:self.countryCode forKey:@"countryCode"]; + [coder encodeObject:self.internationalPrefix forKey:@"internationalPrefix"]; + [coder encodeObject:self.preferredInternationalPrefix forKey:@"preferredInternationalPrefix"]; + [coder encodeObject:self.nationalPrefix forKey:@"nationalPrefix"]; + [coder encodeObject:self.preferredExtnPrefix forKey:@"preferredExtnPrefix"]; + [coder encodeObject:self.nationalPrefixForParsing forKey:@"nationalPrefixForParsing"]; + [coder encodeObject:self.nationalPrefixTransformRule forKey:@"nationalPrefixTransformRule"]; + [coder encodeObject:[NSNumber numberWithBool:self.sameMobileAndFixedLinePattern] forKey:@"sameMobileAndFixedLinePattern"]; + [coder encodeObject:self.numberFormats forKey:@"numberFormats"]; + [coder encodeObject:self.intlNumberFormats forKey:@"intlNumberFormats"]; + [coder encodeObject:[NSNumber numberWithBool:self.mainCountryForCode] forKey:@"mainCountryForCode"]; + [coder encodeObject:self.leadingDigits forKey:@"leadingDigits"]; + [coder encodeObject:[NSNumber numberWithBool:self.leadingZeroPossible] forKey:@"leadingZeroPossible"]; +} + + +- (NSMutableArray*)numberFormatArrayFromData:(id)data +{ + NSMutableArray *resArray = [[NSMutableArray alloc] init]; + if (data != nil && [data isKindOfClass:[NSArray class]]) + { + for (id numFormat in data) + { + NBNumberFormat *newNumberFormat = [[NBNumberFormat alloc] initWithData:numFormat]; + [resArray addObject:newNumberFormat]; + } + } + + return resArray; +} + +/* +- (NSString*)getNormalizedNationalPrefixFormattingRule +{ + NSString *replacedFormattingRule = [self.nationalPrefixFormattingRule stringByReplacingOccurrencesOfString:@"$NP" withString:self.nationalPrefix]; + return replacedFormattingRule; +} + + +- (BOOL)sameMobileAndFixedLinePattern +{ + if ([self.mobile isEqual:self.fixedLine]) return YES; + return NO; +} + + +- (NBPhoneNumberDesc*)inheriteValues:(NBPhoneNumberDesc*)targetDesc +{ + if (targetDesc == nil) + { + targetDesc = [[NBPhoneNumberDesc alloc] init]; + } + + if (self.generalDesc != nil) + { + if (targetDesc.nationalNumberPattern == nil) + { + if (self.generalDesc.nationalNumberPattern != nil) + targetDesc.nationalNumberPattern = [self.generalDesc.nationalNumberPattern copy]; + } + + if (targetDesc.possibleNumberPattern == nil) + { + if (self.generalDesc.possibleNumberPattern != nil) + targetDesc.possibleNumberPattern = [self.generalDesc.possibleNumberPattern copy]; + } + + if (targetDesc.exampleNumber == nil) + { + if (self.generalDesc.exampleNumber != nil) + targetDesc.exampleNumber = [self.generalDesc.exampleNumber copy]; + } + } + + return targetDesc; +} + + +- (void)updateDescriptions +{ + self.fixedLine = [[self inheriteValues:self.fixedLine] copy]; + self.mobile = [[self inheriteValues:self.mobile] copy]; + self.tollFree = [[self inheriteValues:self.tollFree] copy]; + self.premiumRate = [[self inheriteValues:self.premiumRate] copy]; + self.sharedCost = [[self inheriteValues:self.sharedCost] copy]; + self.personalNumber = [[self inheriteValues:self.personalNumber] copy]; + self.voip = [[self inheriteValues:self.voip] copy]; + self.pager = [[self inheriteValues:self.pager] copy]; + self.uan = [[self inheriteValues:self.uan] copy]; + self.emergency = [[self inheriteValues:self.emergency] copy]; + self.voicemail = [[self inheriteValues:self.voicemail] copy]; + self.noInternationalDialling = [[self inheriteValues:self.noInternationalDialling] copy]; +} + + +- (void)setAttributes:(NSDictionary*)data +{ + NSString *attributeName = [data valueForKey:@"attributeName"]; + id attributeContent = [data valueForKey:@"nodeContent"]; + + if ([attributeContent isKindOfClass:[NSString class]] && [attributeContent length] > 0) + attributeContent = [NBPhoneNumberManager stringByTrimming:attributeContent]; + + if (attributeName && [attributeName isKindOfClass:[NSString class]] && [attributeName length] > 0 && [attributeName isEqualToString:@"id"] && + attributeContent && [attributeContent isKindOfClass:[NSString class]] && [attributeContent length] > 0) + { + [self setCodeID:attributeContent]; + } + else if (attributeName && [attributeName isKindOfClass:[NSString class]] && [attributeName length] > 0 && attributeContent && [attributeContent isKindOfClass:[NSString class]] && [attributeContent length] > 0) + { + @try { + if ([[attributeContent lowercaseString] isEqualToString:@"true"]) + { + [self setValue:[NSNumber numberWithBool:YES] forKey:attributeName]; + } + else if ([[attributeContent lowercaseString] isEqualToString:@"false"]) + { + [self setValue:[NSNumber numberWithBool:NO] forKey:attributeName]; + } + else + { + [self setValue:attributeContent forKey:attributeName]; + } + } + @catch (NSException *ex) { + NSLog(@"setAttributes setValue:%@ forKey:%@ error [%@]", attributeContent, attributeName, [attributeContent class]); + } + } +} + + +- (BOOL)setChilds:(id)data +{ + if (data && [data isKindOfClass:[NSDictionary class]]) + { + NSString *nodeName = [data valueForKey:@"nodeName"]; + id nodeContent = [data valueForKey:@"nodeContent"]; + + if ([nodeContent isKindOfClass:[NSString class]] && [nodeContent length] > 0) + nodeContent = [NBPhoneNumberManager stringByTrimming:nodeContent]; + + // [TYPE] PhoneNumberDesc + if ([nodeName isEqualToString:@"generalDesc"] || [nodeName isEqualToString:@"fixedLine"] || [nodeName isEqualToString:@"mobile"] || [nodeName isEqualToString:@"shortCode"] || [nodeName isEqualToString:@"emergency"] || [nodeName isEqualToString:@"voip"] || [nodeName isEqualToString:@"voicemail"] || [nodeName isEqualToString:@"uan"] || [nodeName isEqualToString:@"premiumRate"] || [nodeName isEqualToString:@"nationalNumberPattern"] || [nodeName isEqualToString:@"sharedCost"] || [nodeName isEqualToString:@"tollFree"] || [nodeName isEqualToString:@"noInternationalDialling"] || [nodeName isEqualToString:@"personalNumber"] || [nodeName isEqualToString:@"pager"] || [nodeName isEqualToString:@"areaCodeOptional"]) + { + [self setNumberDescData:data]; + return YES; + } + else if ([nodeName isEqualToString:@"availableFormats"]) + { + [self setNumberFormatsData:data]; + return YES; + } + else if ([nodeName isEqualToString:@"comment"] == NO && [nodeContent isKindOfClass:[NSString class]]) + { + [self setValue:nodeContent forKey:nodeName]; + return YES; + } + else if ([nodeName isEqualToString:@"comment"]) + { + return YES; + } + } + + return NO; +} + + +- (void)setNumberFormatsData:(id)data +{ + NSArray *nodeChildArray = [data valueForKey:@"nodeChildArray"]; + + for (id childNumberFormat in nodeChildArray) + { + NSArray *nodeChildAttributeNumberFormatArray = [childNumberFormat valueForKey:@"nodeAttributeArray"]; + NSArray *nodeChildNodeNumberFormatArray = [childNumberFormat valueForKey:@"nodeChildArray"]; + + NSString *nodeName = [childNumberFormat valueForKey:@"nodeName"]; + + if ([nodeName isEqualToString:@"numberFormat"]) + { + NBNumberFormat *newNumberFormat = [[NBNumberFormat alloc] init]; + + for (id childAttribute in nodeChildAttributeNumberFormatArray) + { + NSString *childNodeName = [childAttribute valueForKey:@"attributeName"]; + NSString *childNodeContent = nil; + + if ([childNodeName isEqualToString:@"comment"]) + { + continue; + } + + childNodeContent = [NBPhoneNumberManager stringByTrimming:[childAttribute valueForKey:@"nodeContent"]]; + + @try { + [newNumberFormat setValue:childNodeContent forKey:childNodeName]; + } + @catch (NSException *ex) { + NSLog(@"nodeChildAttributeArray setValue:%@ forKey:%@ error [%@] %@", childNodeContent, childNodeName, [childNodeContent class], childAttribute); + } + } + + for (id childNode in nodeChildNodeNumberFormatArray) + { + NSString *childNodeName = [childNode valueForKey:@"nodeName"]; + NSString *childNodeContent = nil; + + if ([childNodeName isEqualToString:@"comment"]) + { + continue; + } + + childNodeContent = [NBPhoneNumberManager stringByTrimming:[childNode valueForKey:@"nodeContent"]]; + + @try { + if ([childNodeName isEqualToString:@"leadingDigits"]) + { + [newNumberFormat.leadingDigitsPattern addObject:childNodeContent]; + } + else + { + if ([[childNodeContent lowercaseString] isEqualToString:@"true"]) + { + [newNumberFormat setValue:[NSNumber numberWithBool:YES] forKey:childNodeName]; + } + else if ([[childNodeContent lowercaseString] isEqualToString:@"false"]) + { + [newNumberFormat setValue:[NSNumber numberWithBool:NO] forKey:childNodeName]; + } + else + { + [newNumberFormat setValue:childNodeContent forKey:childNodeName]; + } + } + } + @catch (NSException *ex) { + NSLog(@"nodeChildArray setValue:%@ forKey:%@ error [%@] %@", childNodeContent, childNodeName, [childNodeContent class], childNode); + } + } + [self.numberFormats addObject:newNumberFormat]; + } + else if ([nodeName isEqualToString:@"comment"] == NO) + { + NSLog(@"process ========== %@", childNumberFormat); + } + } +} + + +- (void)setNumberDescData:(id)data +{ + NSString *nodeName = [data valueForKey:@"nodeName"]; + NSArray *nodeChildArray = [data valueForKey:@"nodeChildArray"]; + + NBPhoneNumberDesc *newNumberDesc = [[NBPhoneNumberDesc alloc] init]; + + for (id childNode in nodeChildArray) + { + NSString *childNodeName = [childNode valueForKey:@"nodeName"]; + NSString *childNodeContent = [NBPhoneNumberManager stringByTrimming:[childNode valueForKey:@"nodeContent"]]; + + if ([childNodeName isEqualToString:@"comment"]) + { + continue; + } + + @try { + if (childNodeContent && childNodeContent.length > 0) + { + [newNumberDesc setValue:childNodeContent forKey:childNodeName]; + } + } + @catch (NSException *ex) { + NSLog(@"setNumberDesc setValue:%@ forKey:%@ error [%@]", childNodeContent, childNodeName, [childNodeContent class]); + } + } + + nodeName = [nodeName lowercaseString]; + + if ([nodeName isEqualToString:[@"generalDesc" lowercaseString]]) + self.generalDesc = newNumberDesc; + + if ([nodeName isEqualToString:[@"fixedLine" lowercaseString]]) + self.fixedLine = newNumberDesc; + + if ([nodeName isEqualToString:[@"mobile" lowercaseString]]) + self.mobile = newNumberDesc; + + if ([nodeName isEqualToString:[@"tollFree" lowercaseString]]) { + [self setTollFree:newNumberDesc]; + } + + if ([nodeName isEqualToString:[@"premiumRate" lowercaseString]]) + self.premiumRate = newNumberDesc; + + if ([nodeName isEqualToString:[@"sharedCost" lowercaseString]]) { + self.sharedCost = newNumberDesc; + } + + if ([nodeName isEqualToString:[@"personalNumber" lowercaseString]]) + self.personalNumber = newNumberDesc; + + if ([nodeName isEqualToString:[@"voip" lowercaseString]]) + self.voip = newNumberDesc; + + if ([nodeName isEqualToString:[@"pager" lowercaseString]]) + self.pager = newNumberDesc; + + if ([nodeName isEqualToString:[@"uan" lowercaseString]]) + self.uan = newNumberDesc; + + if ([nodeName isEqualToString:[@"emergency" lowercaseString]]) + self.emergency = newNumberDesc; + + if ([nodeName isEqualToString:[@"voicemail" lowercaseString]]) + self.voicemail = newNumberDesc; + + if ([nodeName isEqualToString:[@"noInternationalDialling" lowercaseString]]) + self.noInternationalDialling = newNumberDesc; + + [self updateDescriptions]; +} +*/ + +@end \ No newline at end of file
diff --git a/libPhoneNumber/NBPhoneNumber.h b/libPhoneNumber/NBPhoneNumber.h new file mode 100644 index 0000000..dfa3b17 --- /dev/null +++ b/libPhoneNumber/NBPhoneNumber.h
@@ -0,0 +1,25 @@ +// +// NBPhoneNumber.h +// libPhoneNumber +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#import <Foundation/Foundation.h> +#import "NBPhoneNumberDefines.h" + +@interface NBPhoneNumber : NSObject <NSCopying> + +// from phonemetadata.pb.js +/* 1 */ @property (nonatomic, strong, readwrite) NSNumber *countryCode; +/* 2 */ @property (nonatomic, strong, readwrite) NSNumber *nationalNumber; +/* 3 */ @property (nonatomic, strong, readwrite) NSString *extension; +/* 4 */ @property (nonatomic, assign, readwrite) BOOL italianLeadingZero; +/* 5 */ @property (nonatomic, strong, readwrite) NSString *rawInput; +/* 6 */ @property (nonatomic, strong, readwrite) NSNumber *countryCodeSource; +/* 7 */ @property (nonatomic, strong, readwrite) NSString *preferredDomesticCarrierCode; + +- (void)clearCountryCodeSource; +- (NBECountryCodeSource)getCountryCodeSourceOrDefault; + +@end \ No newline at end of file
diff --git a/libPhoneNumber/NBPhoneNumber.m b/libPhoneNumber/NBPhoneNumber.m new file mode 100644 index 0000000..cd79761 --- /dev/null +++ b/libPhoneNumber/NBPhoneNumber.m
@@ -0,0 +1,121 @@ +// +// NBPhoneNumber.m +// libPhoneNumber +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#import "NBPhoneNumber.h" +#import "NBPhoneNumberDefines.h" + +@implementation NBPhoneNumber + +@synthesize countryCode, nationalNumber, extension, italianLeadingZero, rawInput, countryCodeSource, preferredDomesticCarrierCode; + +- (id)init +{ + self = [super init]; + + if (self) + { + self.countryCodeSource = nil; + self.italianLeadingZero = NO; + self.nationalNumber = @-1; + self.countryCode = @-1; + } + + return self; +} + + +- (void)clearCountryCodeSource +{ + [self setCountryCodeSource:nil]; +} + + +- (NBECountryCodeSource)getCountryCodeSourceOrDefault +{ + if (self.countryCodeSource == nil) + return NBECountryCodeSourceFROM_NUMBER_WITH_PLUS_SIGN; + + return [self.countryCodeSource intValue]; +} + + +- (BOOL)isEqualToObject:(NBPhoneNumber*)otherObj +{ + return [self isEqual:otherObj]; +} + + +- (NSUInteger)hash +{ + NSData *selfObject = [NSKeyedArchiver archivedDataWithRootObject:self]; + return [selfObject hash]; +} + + +- (BOOL)isEqual:(id)object +{ + if ([object isKindOfClass:[NBPhoneNumber class]] == NO) + return NO; + + NBPhoneNumber *other = object; + return ([self.countryCode isEqualToNumber: other.countryCode]) && ([self.nationalNumber isEqualToNumber: other.nationalNumber]) && + (self.italianLeadingZero == other.italianLeadingZero) && + ((self.extension == nil && other.extension == nil) || [self.extension isEqualToString:other.extension]); +} + + +- (id)copyWithZone:(NSZone *)zone +{ + NBPhoneNumber *phoneNumberCopy = [[NBPhoneNumber allocWithZone:zone] init]; + + phoneNumberCopy.countryCode = [self.countryCode copy]; + phoneNumberCopy.nationalNumber = [self.nationalNumber copy]; + phoneNumberCopy.extension = [self.extension copy]; + phoneNumberCopy.italianLeadingZero = self.italianLeadingZero; + phoneNumberCopy.rawInput = [self.rawInput copy]; + phoneNumberCopy.countryCodeSource = [self.countryCodeSource copy]; + phoneNumberCopy.preferredDomesticCarrierCode = [self.preferredDomesticCarrierCode copy]; + + return phoneNumberCopy; +} + + +- (id)initWithCoder:(NSCoder*)coder +{ + if (self = [super init]) + { + self.countryCode = [coder decodeObjectForKey:@"countryCode"]; + self.nationalNumber = [coder decodeObjectForKey:@"nationalNumber"]; + self.extension = [coder decodeObjectForKey:@"extension"]; + self.italianLeadingZero = [[coder decodeObjectForKey:@"italianLeadingZero"] boolValue]; + self.rawInput = [coder decodeObjectForKey:@"rawInput"]; + self.countryCodeSource = [coder decodeObjectForKey:@"countryCodeSource"]; + self.preferredDomesticCarrierCode = [coder decodeObjectForKey:@"preferredDomesticCarrierCode"]; + } + return self; +} + + +- (void)encodeWithCoder:(NSCoder*)coder +{ + [coder encodeObject:self.countryCode forKey:@"countryCode"]; + [coder encodeObject:self.nationalNumber forKey:@"nationalNumber"]; + [coder encodeObject:self.extension forKey:@"extension"]; + [coder encodeObject:[NSNumber numberWithBool:self.italianLeadingZero] forKey:@"italianLeadingZero"]; + [coder encodeObject:self.rawInput forKey:@"rawInput"]; + [coder encodeObject:self.countryCodeSource forKey:@"countryCodeSource"]; + [coder encodeObject:self.preferredDomesticCarrierCode forKey:@"preferredDomesticCarrierCode"]; +} + + + +- (NSString *)description +{ + return [NSString stringWithFormat:@" - countryCode[%@], nationalNumber[%@], extension[%@], italianLeadingZero[%@], rawInput[%@] countryCodeSource[%d] preferredDomesticCarrierCode[%@]", self.countryCode, self.nationalNumber, self.extension, self.italianLeadingZero?@"Y":@"N", self.rawInput, [self.countryCodeSource intValue], self.preferredDomesticCarrierCode]; +} + +@end
diff --git a/libPhoneNumber/NBPhoneNumberDefines.h b/libPhoneNumber/NBPhoneNumberDefines.h new file mode 100644 index 0000000..f7c9bf8 --- /dev/null +++ b/libPhoneNumber/NBPhoneNumberDefines.h
@@ -0,0 +1,107 @@ +// +// NBPhoneNumberDefines.h +// libPhoneNumber +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#ifndef libPhoneNumber_NBPhoneNumberDefines_h +#define libPhoneNumber_NBPhoneNumberDefines_h + +#define NB_YES [NSNumber numberWithBool:YES] +#define NB_NO [NSNumber numberWithBool:NO] + +#pragma mark - Enum - + +typedef enum { + NBEPhoneNumberFormatE164 = 0, + NBEPhoneNumberFormatINTERNATIONAL = 1, + NBEPhoneNumberFormatNATIONAL = 2, + NBEPhoneNumberFormatRFC3966 = 3 +} NBEPhoneNumberFormat; + + +typedef enum { + NBEPhoneNumberTypeFIXED_LINE = 0, + NBEPhoneNumberTypeMOBILE = 1, + // In some regions (e.g. the USA), it is impossible to distinguish between + // fixed-line and mobile numbers by looking at the phone number itself. + NBEPhoneNumberTypeFIXED_LINE_OR_MOBILE = 2, + // Freephone lines + NBEPhoneNumberTypeTOLL_FREE = 3, + NBEPhoneNumberTypePREMIUM_RATE = 4, + // The cost of this call is shared between the caller and the recipient, and + // is hence typically less than PREMIUM_RATE calls. See + // http://en.wikipedia.org/wiki/Shared_Cost_Service for more information. + NBEPhoneNumberTypeSHARED_COST = 5, + // Voice over IP numbers. This includes TSoIP (Telephony Service over IP). + NBEPhoneNumberTypeVOIP = 6, + // A personal number is associated with a particular person, and may be routed + // to either a MOBILE or FIXED_LINE number. Some more information can be found + // here = http://en.wikipedia.org/wiki/Personal_Numbers + NBEPhoneNumberTypePERSONAL_NUMBER = 7, + NBEPhoneNumberTypePAGER = 8, + // Used for 'Universal Access Numbers' or 'Company Numbers'. They may be + // further routed to specific offices, but allow one number to be used for a + // company. + NBEPhoneNumberTypeUAN = 9, + // Used for 'Voice Mail Access Numbers'. + NBEPhoneNumberTypeVOICEMAIL = 10, + // A phone number is of type UNKNOWN when it does not fit any of the known + // patterns for a specific region. + NBEPhoneNumberTypeUNKNOWN = -1 +} NBEPhoneNumberType; + + +typedef enum { + NBEMatchTypeNOT_A_NUMBER = 0, + NBEMatchTypeNO_MATCH = 1, + NBEMatchTypeSHORT_NSN_MATCH = 2, + NBEMatchTypeNSN_MATCH = 3, + NBEMatchTypeEXACT_MATCH = 4 +} NBEMatchType; + + +typedef enum { + NBEValidationResultIS_POSSIBLE = 0, + NBEValidationResultINVALID_COUNTRY_CODE = 1, + NBEValidationResultTOO_SHORT = 2, + NBEValidationResultTOO_LONG = 3 +} NBEValidationResult; + + +typedef enum { + NBECountryCodeSourceFROM_NUMBER_WITH_PLUS_SIGN = 1, + NBECountryCodeSourceFROM_NUMBER_WITH_IDD = 5, + NBECountryCodeSourceFROM_NUMBER_WITHOUT_PLUS_SIGN = 10, + NBECountryCodeSourceFROM_DEFAULT_COUNTRY = 20 +} NBECountryCodeSource; + + +@interface NSArray (NBAdditions) + +- (id)safeObjectAtIndex:(NSUInteger)index; + +@end + + +@implementation NSArray (NBAdditions) + +- (id)safeObjectAtIndex:(NSUInteger)index +{ + @synchronized(self) + { + if(index >= [self count]) return nil; + + id res = [self objectAtIndex:index]; + + if (res == nil || (NSNull*)res == [NSNull null]) + return nil; + + return res; + } +} + +@end + +#endif
diff --git a/libPhoneNumber/NBPhoneNumberDesc.h b/libPhoneNumber/NBPhoneNumberDesc.h new file mode 100644 index 0000000..288727c --- /dev/null +++ b/libPhoneNumber/NBPhoneNumberDesc.h
@@ -0,0 +1,19 @@ +// +// NBPhoneNumberDesc.h +// libPhoneNumber +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#import <Foundation/Foundation.h> + +@interface NBPhoneNumberDesc : NSObject + +// from phonemetadata.pb.js +/* 2 */ @property (nonatomic, strong, readwrite) NSString *nationalNumberPattern; +/* 3 */ @property (nonatomic, strong, readwrite) NSString *possibleNumberPattern; +/* 6 */ @property (nonatomic, strong, readwrite) NSString *exampleNumber; + +- (id)initWithData:(id)data; + +@end
diff --git a/libPhoneNumber/NBPhoneNumberDesc.m b/libPhoneNumber/NBPhoneNumberDesc.m new file mode 100644 index 0000000..f698103 --- /dev/null +++ b/libPhoneNumber/NBPhoneNumberDesc.m
@@ -0,0 +1,90 @@ +// +// NBPhoneNumberDesc.m +// libPhoneNumber +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#import "NBPhoneNumberDesc.h" +#import "NBPhoneNumberDefines.h" + +@implementation NBPhoneNumberDesc + +@synthesize nationalNumberPattern, possibleNumberPattern, exampleNumber; + + +- (id)initWithData:(id)data +{ + self = [self init]; + + if (self && data != nil && [data isKindOfClass:[NSArray class]]) + { + /* 2 */ self.nationalNumberPattern = [data safeObjectAtIndex:2]; + /* 3 */ self.possibleNumberPattern = [data safeObjectAtIndex:3]; + /* 6 */ self.exampleNumber = [data safeObjectAtIndex:6]; + } + + return self; +} + + +- (id)init +{ + self = [super init]; + + if (self) + { + } + + return self; +} + + +- (id)initWithCoder:(NSCoder*)coder +{ + if (self = [super init]) + { + self.nationalNumberPattern = [coder decodeObjectForKey:@"nationalNumberPattern"]; + self.possibleNumberPattern = [coder decodeObjectForKey:@"possibleNumberPattern"]; + self.exampleNumber = [coder decodeObjectForKey:@"exampleNumber"]; + } + return self; +} + + +- (void)encodeWithCoder:(NSCoder*)coder +{ + [coder encodeObject:self.nationalNumberPattern forKey:@"nationalNumberPattern"]; + [coder encodeObject:self.possibleNumberPattern forKey:@"possibleNumberPattern"]; + [coder encodeObject:self.exampleNumber forKey:@"exampleNumber"]; +} + + +- (NSString *)description +{ + return [NSString stringWithFormat:@"nationalNumberPattern[%@] possibleNumberPattern[%@] exampleNumber[%@]", self.nationalNumberPattern, self.possibleNumberPattern, self.exampleNumber]; +} + +- (id)copyWithZone:(NSZone *)zone +{ + NBPhoneNumberDesc *phoneDescCopy = [[NBPhoneNumberDesc allocWithZone:zone] init]; + + phoneDescCopy.nationalNumberPattern = [self.nationalNumberPattern copy]; + phoneDescCopy.possibleNumberPattern = [self.possibleNumberPattern copy]; + phoneDescCopy.exampleNumber = [self.exampleNumber copy]; + + return phoneDescCopy; +} + +- (BOOL)isEqual:(id)object +{ + if ([object isKindOfClass:[NBPhoneNumberDesc class]] == NO) + return NO; + + NBPhoneNumberDesc *other = object; + return [self.nationalNumberPattern isEqual:other.nationalNumberPattern] && + [self.possibleNumberPattern isEqual:other.possibleNumberPattern] && + [self.exampleNumber isEqual:other.exampleNumber]; +} + +@end
diff --git a/libPhoneNumber/NBPhoneNumberMetadata.plist b/libPhoneNumber/NBPhoneNumberMetadata.plist new file mode 100644 index 0000000..8cd2d03 --- /dev/null +++ b/libPhoneNumber/NBPhoneNumberMetadata.plist Binary files differ
diff --git a/libPhoneNumber/NBPhoneNumberUtil.h b/libPhoneNumber/NBPhoneNumberUtil.h new file mode 100644 index 0000000..e9e13ec --- /dev/null +++ b/libPhoneNumber/NBPhoneNumberUtil.h
@@ -0,0 +1,108 @@ +// +// NBPhoneNumberUtil.h +// Band +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#import <Foundation/Foundation.h> +#import "NBPhoneNumberDefines.h" + +@class NBPhoneMetaData, NBPhoneNumber; + +@interface NBPhoneNumberUtil : NSObject + ++ (NBPhoneNumberUtil*)sharedInstance; ++ (NBPhoneNumberUtil*)sharedInstanceForTest; + +// regular expressions +- (NSArray*)matchesByRegex:(NSString*)sourceString regex:(NSString*)pattern; +- (NSArray*)matchedStringByRegex:(NSString*)sourceString regex:(NSString*)pattern; +- (NSString*)replaceStringByRegex:(NSString*)sourceString regex:(NSString*)pattern withTemplate:(NSString*)templateString; +- (NSInteger)stringPositionByRegex:(NSString*)sourceString regex:(NSString*)pattern; + + ++ (NSString*)stringByTrimming:(NSString*)aString; + +//- (NSString*)numbersOnly:(NSString*)phoneNumber; +- (NSArray*)regionCodeFromCountryCode:(NSNumber *)countryCodeNumber; +- (NSString*)countryCodeFromRegionCode:(NSString*)regionCode; + + +// libPhoneNumber Util functions +- (NSString*)convertAlphaCharactersInNumber:(NSString*)number; + +- (NSString*)normalizePhoneNumber:(NSString*)phoneNumber; +- (NSString*)normalizeDigitsOnly:(NSString*)number; + +- (BOOL)isNumberGeographical:(NBPhoneNumber*)phoneNumber; + +- (NSString*)extractPossibleNumber:(NSString*)phoneNumber; +- (NSNumber*)extractCountryCode:(NSString*)fullNumber nationalNumber:(NSString**)nationalNumber; + +- (NSString*)getNddPrefixForRegion:(NSString*)regionCode stripNonDigits:(BOOL)stripNonDigits; +- (NSString*)getNationalSignificantNumber:(NBPhoneNumber*)phoneNumber; + +- (NBEPhoneNumberType)getNumberType:(NBPhoneNumber*)phoneNumber; + +- (NSNumber*)getCountryCodeForRegion:(NSString*)regionCode; + +- (NSString*)getRegionCodeForCountryCode:(NSNumber*)countryCallingCode; +- (NSArray*)getRegionCodesForCountryCode:(NSNumber*)countryCallingCode; +- (NSString*)getRegionCodeForNumber:(NBPhoneNumber*)phoneNumber; + +- (NBPhoneNumber*)getExampleNumber:(NSString*)regionCode error:(NSError**)error; +- (NBPhoneNumber*)getExampleNumberForType:(NSString*)regionCode type:(NBEPhoneNumberType)type error:(NSError**)error; +- (NBPhoneNumber*)getExampleNumberForNonGeoEntity:(NSNumber*)countryCallingCode error:(NSError**)error; + +- (NBPhoneMetaData*)getMetadataForNonGeographicalRegion:(NSNumber*)countryCallingCode; +- (NBPhoneMetaData*)getMetadataForRegion:(NSString*)regionCode; + +- (BOOL)canBeInternationallyDialled:(NBPhoneNumber*)number error:(NSError**)error; + +- (BOOL)truncateTooLongNumber:(NBPhoneNumber*)number error:(NSError**)error; + +- (BOOL)isValidNumber:(NBPhoneNumber*)number; +- (BOOL)isViablePhoneNumber:(NSString*)phoneNumber; +- (BOOL)isAlphaNumber:(NSString*)number; +- (BOOL)isValidNumberForRegion:(NBPhoneNumber*)number regionCode:(NSString*)regionCode; +- (BOOL)isNANPACountry:(NSString*)regionCode; +- (BOOL)isLeadingZeroPossible:(NSNumber*)countryCallingCode; + +- (NBEValidationResult)isPossibleNumberWithReason:(NBPhoneNumber*)number error:(NSError**)error; + +- (BOOL)isPossibleNumber:(NBPhoneNumber*)number error:(NSError**)error; +- (BOOL)isPossibleNumberString:(NSString*)number regionDialingFrom:(NSString*)regionDialingFrom error:(NSError**)error; + +- (NBEMatchType)isNumberMatch:(id)firstNumberIn second:(id)secondNumberIn error:(NSError**)error; + +- (NSUInteger)getLengthOfGeographicalAreaCode:(NBPhoneNumber*)phoneNumber error:(NSError**)error; +- (NSUInteger)getLengthOfNationalDestinationCode:(NBPhoneNumber*)phoneNumber error:(NSError**)error; + +- (BOOL)maybeStripNationalPrefixAndCarrierCode:(NSString**)numberStr metadata:(NBPhoneMetaData*)metadata carrierCode:(NSString**)carrierCode error:(NSError**)error; +- (NBECountryCodeSource)maybeStripInternationalPrefixAndNormalize:(NSString**)numberStr possibleIddPrefix:(NSString*)possibleIddPrefix error:(NSError**)error; +- (NSNumber*)maybeExtractCountryCode:(NSString*)number metadata:(NBPhoneMetaData*)defaultRegionMetadata + nationalNumber:(NSString**)nationalNumber keepRawInput:(BOOL)keepRawInput phoneNumber:(NBPhoneNumber**)phoneNumber error:(NSError**)error; + +- (NBPhoneNumber*)parse:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion error:(NSError**)error; +- (NBPhoneNumber*)parseAndKeepRawInput:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion error:(NSError**)error; +- (NBPhoneNumber*)parseWithPhoneCarrierRegion:(NSString*)numberToParse error:(NSError**)error; + +- (NSString*)format:(NBPhoneNumber*)phoneNumber numberFormat:(NBEPhoneNumberFormat)numberFormat error:(NSError**)error; +- (NSString*)formatByPattern:(NBPhoneNumber*)number numberFormat:(NBEPhoneNumberFormat)numberFormat userDefinedFormats:(NSArray*)userDefinedFormats error:(NSError**)error; +- (NSString*)formatNumberForMobileDialing:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom withFormatting:(BOOL)withFormatting error:(NSError**)error; +- (NSString*)formatOutOfCountryCallingNumber:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom error:(NSError**)error; +- (NSString*)formatOutOfCountryKeepingAlphaChars:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom error:(NSError**)error; +- (NSString*)formatNationalNumberWithCarrierCode:(NBPhoneNumber*)number carrierCode:(NSString*)carrierCode error:(NSError**)error; +- (NSString*)formatInOriginalFormat:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom error:(NSError**)error; +- (NSString*)formatNationalNumberWithPreferredCarrierCode:(NBPhoneNumber*)number fallbackCarrierCode:(NSString*)fallbackCarrierCode error:(NSError**)error; + +- (BOOL)formattingRuleHasFirstGroupOnly:(NSString*)nationalPrefixFormattingRule; + +@property (nonatomic, readonly) NSString *VALID_PUNCTUATION; +@property (nonatomic, readonly) NSString *VALID_DIGITS_STRING; +@property (nonatomic, readonly) NSString *PLUS_CHARS_; +@property (nonatomic, readonly) NSString *REGION_CODE_FOR_NON_GEO_ENTITY; +@property (nonatomic, readonly) NSDictionary *DIGIT_MAPPINGS; + +@end
diff --git a/libPhoneNumber/NBPhoneNumberUtil.m b/libPhoneNumber/NBPhoneNumberUtil.m new file mode 100644 index 0000000..bfb95c9 --- /dev/null +++ b/libPhoneNumber/NBPhoneNumberUtil.m
@@ -0,0 +1,4305 @@ +// +// NBPhoneNumberUtil.m +// Band +// +// Created by NHN Corp. Last Edited by BAND dev team (band_dev@nhn.com) +// + +#import "NBPhoneNumberUtil.h" +#import "NBPhoneNumber.h" +#import "NBNumberFormat.h" +#import "NBPhoneNumberDesc.h" +#import "NBPhoneMetaData.h" +#import "math.h" + +#import <CoreTelephony/CTTelephonyNetworkInfo.h> +#import <CoreTelephony/CTCarrier.h> + + +#pragma mark - Static Int variables - +const static NSUInteger NANPA_COUNTRY_CODE_ = 1; +const static NSUInteger MIN_LENGTH_FOR_NSN_ = 2; +const static NSUInteger MAX_LENGTH_FOR_NSN_ = 16; +const static NSUInteger MAX_LENGTH_COUNTRY_CODE_ = 3; +const static NSUInteger MAX_INPUT_STRING_LENGTH_ = 250; + + +#pragma mark - Static String variables - +NSString *INVALID_COUNTRY_CODE_STR = @"Invalid country calling code"; +NSString *NOT_A_NUMBER_STR = @"The string supplied did not seem to be a phone number"; +NSString *TOO_SHORT_AFTER_IDD_STR = @"Phone number too short after IDD"; +NSString *TOO_SHORT_NSN_STR = @"The string supplied is too short to be a phone number"; +NSString *TOO_LONG_STR = @"The string supplied is too long to be a phone number"; + +NSString *UNKNOWN_REGION_ = @"ZZ"; +NSString *COLOMBIA_MOBILE_TO_FIXED_LINE_PREFIX_ = @"3"; +NSString *PLUS_SIGN = @"+"; +NSString *STAR_SIGN_ = @"*"; +NSString *RFC3966_EXTN_PREFIX_ = @";ext="; +NSString *RFC3966_PREFIX_ = @"tel:"; +NSString *RFC3966_PHONE_CONTEXT_ = @";phone-context="; +NSString *RFC3966_ISDN_SUBADDRESS_ = @";isub="; +NSString *DEFAULT_EXTN_PREFIX_ = @" ext. "; +NSString *VALID_ALPHA_ = @"A-Za-z"; + +#pragma mark - Static regular expression strings - +NSString *NON_DIGITS_PATTERN_ = @"\\D+"; +NSString *CC_PATTERN_ = @"\\$CC"; +NSString *FIRST_GROUP_PATTERN_ = @"(\\$\\d)"; +NSString *FIRST_GROUP_ONLY_PREFIX_PATTERN_ = @"^\\(?\\$1\\)?"; +NSString *NP_PATTERN_ = @"\\$NP"; +NSString *FG_PATTERN_ = @"\\$FG"; +NSString *VALID_ALPHA_PHONE_PATTERN_STRING = @"(?:.*?[A-Za-z]){3}.*"; +NSString *UNIQUE_INTERNATIONAL_PREFIX_ = @"[\\d]+(?:[~\\u2053\\u223C\\uFF5E][\\d]+)?"; + + +#pragma mark - NBPhoneNumberUtil interface - +@interface NBPhoneNumberUtil () + +/* + Terminologies + - Country Number (CN) = Country code for i18n calling + - Country Code (CC) : ISO country codes (2 chars) + Ref. site (countrycode.org) + */ +@property (nonatomic, readonly) NSDictionary *coreMetaData; +@property (nonatomic, readonly) NSRegularExpression *PLUS_CHARS_PATTERN, *CAPTURING_DIGIT_PATTERN, *VALID_ALPHA_PHONE_PATTERN_; +@property (nonatomic, readonly) NSString *LEADING_PLUS_CHARS_PATTERN_, *EXTN_PATTERN_, *SEPARATOR_PATTERN_, *VALID_PHONE_NUMBER_PATTERN_, *VALID_START_CHAR_PATTERN_, *UNWANTED_END_CHAR_PATTERN_, *SECOND_NUMBER_START_PATTERN_; + +@property (nonatomic, readonly) NSDictionary *ALPHA_MAPPINGS_, *ALL_NORMALIZATION_MAPPINGS_, *DIALLABLE_CHAR_MAPPINGS_, *ALL_PLUS_NUMBER_GROUPING_SYMBOLS_; + +@property (nonatomic, strong, readwrite) NSMutableDictionary *mapCCode2CN; +@property (nonatomic, strong, readwrite) NSMutableDictionary *mapCN2CCode; + +@property (nonatomic, strong, readwrite) NSMutableDictionary *i18nNumberFormat; +@property (nonatomic, strong, readwrite) NSMutableDictionary *i18nPhoneNumberDesc; +@property (nonatomic, strong, readwrite) NSMutableDictionary *i18nPhoneMetadata; + +@end + + +@implementation NBPhoneNumberUtil + ++ (NBPhoneNumberUtil*)sharedInstance +{ + static NBPhoneNumberUtil *sharedOnceInstance = nil; + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ sharedOnceInstance = [[self alloc] init]; }); + return sharedOnceInstance; +} + + ++ (NBPhoneNumberUtil*)sharedInstanceForTest +{ + static NBPhoneNumberUtil *sharedOnceInstanceForTest = nil; + static dispatch_once_t onceToken; + dispatch_once(&onceToken, ^{ sharedOnceInstanceForTest = [[self alloc] initForTest]; }); + return sharedOnceInstanceForTest; +} + + ++ (NSString*)stringByTrimming:(NSString*)aString +{ + NSString *aRes = @""; + NSArray *newlines = [aString componentsSeparatedByCharactersInSet:[NSCharacterSet newlineCharacterSet]]; + for (NSString *line in newlines) + { + NSString *performedString = [line stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]]; + + if (performedString.length > 0) + aRes = [aRes stringByAppendingString:performedString]; + } + + if (newlines.count <= 0) + return aString; + + return aRes; +} + + +#pragma mark - Regular expression Utilities - +- (BOOL)hasValue:(NSString*)string +{ + if (string == nil || [string stringByTrimmingCharactersInSet:[NSCharacterSet whitespaceAndNewlineCharacterSet]].length <= 0) + { + return NO; + } + + return YES; +} + + +- (NSMutableArray*)componentsSeparatedByRegex:(NSString*)sourceString regex:(NSString*)pattern +{ + NSString *replacedString = [self replaceStringByRegex:sourceString regex:pattern withTemplate:@"<SEP>"]; + NSMutableArray *resArray = [[replacedString componentsSeparatedByString:@"<SEP>"] mutableCopy]; + [resArray removeObject:@""]; + return resArray; +} + + +- (NSInteger)stringPositionByRegex:(NSString*)sourceString regex:(NSString*)pattern +{ + if (sourceString == nil || sourceString.length <= 0 || pattern == nil || pattern.length <= 0) { + return -1; + } + + NSError *error = nil; + NSRegularExpression *currentPattern = [NSRegularExpression regularExpressionWithPattern:pattern options:0 error:&error]; + NSArray *matches = [currentPattern matchesInString:sourceString options:0 range:NSMakeRange(0, sourceString.length)]; + + NSInteger foundPosition = -1; + + if (matches.count > 0) + { + NSTextCheckingResult *match = [matches objectAtIndex:0]; + return match.range.location; + } + + return foundPosition; +} + + +- (NSInteger)indexOfStringByString:(NSString*)sourceString target:(NSString*)targetString +{ + NSRange finded = [sourceString rangeOfString:targetString]; + if (finded.location != NSNotFound) + { + return finded.location; + } + + return -1; +} + + +- (NSString*)replaceFirstStringByRegex:(NSString*)sourceString regex:(NSString*)pattern withTemplate:(NSString*)templateString +{ + NSString *replacementResult = [sourceString copy]; + NSError *error = nil; + + NSRegularExpression *currentPattern = [NSRegularExpression regularExpressionWithPattern:pattern options:0 error:&error]; + NSRange replaceRange = [currentPattern rangeOfFirstMatchInString:sourceString options:0 range:NSMakeRange(0, sourceString.length)]; + + if (replaceRange.location != NSNotFound) + { + replacementResult = [currentPattern stringByReplacingMatchesInString:[sourceString mutableCopy] options:0 + range:replaceRange + withTemplate:templateString]; + } + + return replacementResult; +} + + +- (NSString*)replaceStringByRegex:(NSString*)sourceString regex:(NSString*)pattern withTemplate:(NSString*)templateString +{ + NSString *replacementResult = [sourceString copy]; + NSError *error = nil; + + NSRegularExpression *currentPattern = [NSRegularExpression regularExpressionWithPattern:pattern options:0 error:&error]; + NSArray *matches = [currentPattern matchesInString:sourceString options:0 range:NSMakeRange(0, sourceString.length)]; + + if ([matches count] == 1) + { + NSRange replaceRange = [currentPattern rangeOfFirstMatchInString:sourceString options:0 range:NSMakeRange(0, sourceString.length)]; + + if (replaceRange.location != NSNotFound) + { + replacementResult = [currentPattern stringByReplacingMatchesInString:[sourceString mutableCopy] options:0 + range:replaceRange + withTemplate:templateString]; + } + return replacementResult; + } + + if ([matches count] > 1) + { + replacementResult = [currentPattern stringByReplacingMatchesInString:[replacementResult mutableCopy] options:0 + range:NSMakeRange(0, sourceString.length) withTemplate:templateString]; + return replacementResult; + } + + return replacementResult; +} + + +- (NSTextCheckingResult*)matcheFirstByRegex:(NSString*)sourceString regex:(NSString*)pattern +{ + NSError *error = nil; + NSRegularExpression *currentPattern = [NSRegularExpression regularExpressionWithPattern:pattern options:0 error:&error]; + NSArray *matches = [currentPattern matchesInString:sourceString options:0 range:NSMakeRange(0, sourceString.length)]; + if ([matches count] > 0) + return [matches objectAtIndex:0]; + return nil; +} + + +- (NSArray*)matchesByRegex:(NSString*)sourceString regex:(NSString*)pattern +{ + NSError *error = nil; + NSRegularExpression *currentPattern = [NSRegularExpression regularExpressionWithPattern:pattern options:0 error:&error]; + NSArray *matches = [currentPattern matchesInString:sourceString options:0 range:NSMakeRange(0, sourceString.length)]; + return matches; +} + + +- (NSArray*)matchedStringByRegex:(NSString*)sourceString regex:(NSString*)pattern +{ + NSArray *matches = [self matchesByRegex:sourceString regex:pattern]; + NSMutableArray *matchString = [[NSMutableArray alloc] init]; + + for (NSTextCheckingResult *match in matches) + { + NSString *curString = [sourceString substringWithRange:match.range]; + [matchString addObject:curString]; + } + + return matchString; +} + + +- (BOOL)isStartingStringByRegex:(NSString*)sourceString regex:(NSString*)pattern +{ + NSError *error = nil; + NSRegularExpression *currentPattern = [NSRegularExpression regularExpressionWithPattern:pattern options:0 error:&error]; + NSArray *matches = [currentPattern matchesInString:sourceString options:0 range:NSMakeRange(0, sourceString.length)]; + + for (NSTextCheckingResult *match in matches) + { + if (match.range.location == 0) + { + return YES; + } + } + + return NO; +} + + +- (NSString*)stringByReplacingOccurrencesString:(NSString *)sourceString withMap:(NSDictionary *)dicMap removeNonMatches:(BOOL)bRemove +{ + NSMutableString *targetString = [[NSMutableString alloc] initWithString:@""]; + + for(NSUInteger i=0; i<sourceString.length; i++) + { + unichar oneChar = [sourceString characterAtIndex:i]; + NSString *keyString = [NSString stringWithCharacters:&oneChar length:1]; + NSString *mappedValue = [dicMap objectForKey:keyString]; + if (mappedValue != nil) + { + [targetString appendString:mappedValue]; + } + else + { + if (bRemove == NO) + { + [targetString appendString:keyString]; + } + } + } + + return targetString; +} + + +- (BOOL)isNaN:(NSString*)sourceString +{ + NSCharacterSet *alphaNums = [NSCharacterSet decimalDigitCharacterSet]; + NSCharacterSet *inStringSet = [NSCharacterSet characterSetWithCharactersInString:sourceString]; + BOOL hasNumberOnly = [alphaNums isSupersetOfSet:inStringSet]; + + return !hasNumberOnly; +} + +/* + - (NSString*)numbersOnly:(NSString*)phoneNumber + { + NSMutableString *strippedString = [NSMutableString stringWithCapacity:phoneNumber.length]; + + NSScanner *scanner = [NSScanner scannerWithString:phoneNumber]; + NSCharacterSet *numbers = [NSCharacterSet characterSetWithCharactersInString:@"0123456789"]; + + while ([scanner isAtEnd] == NO) { + NSString *buffer; + if ([scanner scanCharactersFromSet:numbers intoString:&buffer]) { + [strippedString appendString:buffer]; + + } else { + [scanner setScanLocation:([scanner scanLocation] + 1)]; + } + } + + return strippedString; + } + */ + + +- (NSString*)getNationalSignificantNumber:(NBPhoneNumber*)phoneNumber +{ + if (phoneNumber.italianLeadingZero) + { + return [NSString stringWithFormat:@"0%@", phoneNumber.nationalNumber]; + } + + return [NSString stringWithFormat:@"%@", phoneNumber.nationalNumber]; +} + + +- (NSArray*)regionCodeFromCountryCode:(NSNumber *)countryCodeNumber +{ + if (self.mapCN2CCode == nil || [self.mapCN2CCode count] <= 0) + { + return nil; + } + + id res = [self.mapCN2CCode objectForKey:[NSString stringWithFormat:@"%@", countryCodeNumber]]; + + if (res && [res isKindOfClass:[NSArray class]] && [((NSArray*)res) count] > 0) + { + return res; + } + + return nil; +} + + +- (NSString*)countryCodeFromRegionCode:(NSString*)regionCode +{ + if (self.mapCCode2CN == nil || [self.mapCCode2CN count] <= 0) + { + return nil; + } + + id res = [self.mapCCode2CN objectForKey:regionCode]; + + if (res) + { + return res; + } + + return nil; +} + + +#pragma mark - Initializations - +- (id)init +{ + self = [super init]; + if (self) + { + [self initRegularExpressionSet]; + [self initNormalizationMappings]; + + NSDictionary *resData = [self loadMetadata:@"NBPhoneNumberMetadata"]; + _coreMetaData = [resData objectForKey:@"countryToMetadata"]; + _mapCN2CCode = [resData objectForKey:@"countryCodeToRegionCodeMap"]; + + [self initCC2CN]; + } + + return self; +} + + +- (id)initForTest +{ + self = [super init]; + if (self) + { + [self initRegularExpressionSet]; + [self initNormalizationMappings]; + + NSDictionary *resData = [self loadMetadata:@"NBPhoneNumberMetadataForTesting"]; + _coreMetaData = [resData objectForKey:@"countryToMetadata"]; + _mapCN2CCode = [resData objectForKey:@"countryCodeToRegionCodeMap"]; + + [self initCC2CN]; + } + + return self; +} + + +- (NSDictionary*)loadMetadata:(NSString*)name +{ + NSDictionary *unarchiveData = nil; + + @try { + NSString *filePath = [[NSBundle mainBundle] pathForResource:name ofType:@"plist"]; + NSData *fileData = [NSData dataWithContentsOfFile:filePath]; + unarchiveData = [NSKeyedUnarchiver unarchiveObjectWithData:fileData]; + } + @catch (NSException *exception) { + return unarchiveData; + } + + return unarchiveData; +} + +/* + - (NSDictionary*)generateMetadata:(id)metaClass + { + NSMutableDictionary *resMedata = [[NSMutableDictionary alloc] init]; + NSDictionary *srcMedata = nil; + + if ([metaClass isKindOfClass:[NBPhoneNumberMetadataForTesting class]]) + { + srcMedata = ((NBPhoneNumberMetadataForTesting*)metaClass).metadata; + } + else if ([metaClass isKindOfClass:[NBPhoneNumberMetadata class]]) + { + srcMedata = ((NBPhoneNumberMetadata*)metaClass).metadata; + } + else + { + return resMedata; + } + + NSDictionary *countryCodeToRegionCodeMap = [srcMedata objectForKey:@"countryCodeToRegionCodeMap"]; + NSDictionary *countryToMetadata = [srcMedata objectForKey:@"countryToMetadata"]; + NSLog(@"- countryCodeToRegionCodeMap count [%d]", [countryCodeToRegionCodeMap count]); + NSLog(@"- countryToMetadata count [%d]", [countryToMetadata count]); + + NSMutableDictionary *genetatedMetaData = [[NSMutableDictionary alloc] init]; + + for (id key in [countryToMetadata allKeys]) + { + id metaData = [countryToMetadata objectForKey:key]; + + NBPhoneMetaData *newMetaData = [[NBPhoneMetaData alloc] init]; + [newMetaData buildData:metaData]; + + [genetatedMetaData setObject:newMetaData forKey:key]; + } + + [resMedata setObject:countryCodeToRegionCodeMap forKey:@"countryCodeToRegionCodeMap"]; + [resMedata setObject:genetatedMetaData forKey:@"countryToMetadata"]; + + return resMedata; + } + */ + + +- (void)initRegularExpressionSet +{ + _VALID_PUNCTUATION = @"-x‐-―−ー－-／ ()（）［］.\\[\\]/~⁓∼～"; + _VALID_DIGITS_STRING = @"0-9０-９٠-٩۰-۹"; + _PLUS_CHARS_ = @"+＋"; + _REGION_CODE_FOR_NON_GEO_ENTITY = @"001"; + + NSString *EXTN_PATTERNS_FOR_PARSING_ = @"(?:;ext=([0-9０-９٠-٩۰-۹]{1,7})|[ \\t,]*(?:e?xt(?:ensi(?:ó?|ó))?n?|ｅ?ｘｔｎ?|[,xｘX#＃~～]|int|anexo|ｉｎｔ)[:\\.．]?[ \\t,-]*([0-9０-９٠-٩۰-۹]{1,7})#?|[- ]+([0-9０-９٠-٩۰-۹]{1,5})#)$"; + + NSError *error = nil; + + _PLUS_CHARS_PATTERN = + [NSRegularExpression regularExpressionWithPattern:[NSString stringWithFormat:@"[%@]+", _PLUS_CHARS_] options:0 error:&error]; + + _LEADING_PLUS_CHARS_PATTERN_ = [NSString stringWithFormat:@"^[%@]+", _PLUS_CHARS_]; + + _CAPTURING_DIGIT_PATTERN = + [NSRegularExpression regularExpressionWithPattern:[NSString stringWithFormat:@"([%@])", _VALID_DIGITS_STRING] options:0 error:&error]; + + _VALID_START_CHAR_PATTERN_ = [NSString stringWithFormat:@"[%@%@]", _PLUS_CHARS_, _VALID_DIGITS_STRING]; + + _SECOND_NUMBER_START_PATTERN_ = @"[\\\\\\/] *x"; + + _VALID_ALPHA_PHONE_PATTERN_ = [NSRegularExpression regularExpressionWithPattern:VALID_ALPHA_PHONE_PATTERN_STRING options:0 error:&error]; + + _UNWANTED_END_CHAR_PATTERN_ = [NSString stringWithFormat:@"[^%@%@#]+$", _VALID_DIGITS_STRING, VALID_ALPHA_]; + + _EXTN_PATTERN_ = [NSString stringWithFormat:@"(?:%@)$", EXTN_PATTERNS_FOR_PARSING_]; + + + _SEPARATOR_PATTERN_ = [NSString stringWithFormat:@"[%@]+", _VALID_PUNCTUATION]; + + _VALID_PHONE_NUMBER_PATTERN_ = @"^[0-9０-９٠-٩۰-۹]{2}$|^[+＋]*(?:[-x‐-―−ー－-／ ()（）［］.\\[\\]/~⁓∼～*]*[0-9０-９٠-٩۰-۹]){3,}[-x‐-―−ー－-／ ()（）［］.\\[\\]/~⁓∼～*A-Za-z0-9０-９٠-٩۰-۹]*(?:;ext=([0-9０-９٠-٩۰-۹]{1,7})|[ \\t,]*(?:e?xt(?:ensi(?:ó?|ó))?n?|ｅ?ｘｔｎ?|[,xｘ#＃~～]|int|anexo|ｉｎｔ)[:\\.．]?[ \\t,-]*([0-9０-９٠-٩۰-۹]{1,7})#?|[- ]+([0-9０-９٠-٩۰-۹]{1,5})#)?$"; +} + + +- (void)dealloc +{ + [self clearCC2CN]; + [self clearCN2CC]; +} + + +- (void)clearCC2CN +{ + if (self.mapCCode2CN != nil) + { + [self.mapCCode2CN removeAllObjects]; + self.mapCCode2CN = nil; + } +} + + +- (void)clearCN2CC +{ + if (self.mapCN2CCode != nil) + { + [self.mapCN2CCode removeAllObjects]; + self.mapCN2CCode = nil; + } +} + + +- (void)initNormalizationMappings +{ + _DIGIT_MAPPINGS = [NSMutableDictionary dictionaryWithObjectsAndKeys: + @"0", @"0", @"1", @"1", @"2", @"2", @"3", @"3", @"4", @"4", @"5", @"5", @"6", @"6", @"7", @"7", @"8", @"8", @"9", @"9", + // Fullwidth digit 0 to 9 + @"0", @"\uFF10", @"1", @"\uFF11", @"2", @"\uFF12", @"3", @"\uFF13", @"4", @"\uFF14", @"5", @"\uFF15", @"6", @"\uFF16", @"7", @"\uFF17", @"8", @"\uFF18", @"9", @"\uFF19", + // Arabic-indic digit 0 to 9 + @"0", @"\u0660", @"1", @"\u0661", @"2", @"\u0662", @"3", @"\u0663", @"4", @"\u0664", @"5", @"\u0665", @"6", @"\u0666", @"7", @"\u0667", @"8", @"\u0668", @"9", @"\u0669", + // Eastern-Arabic digit 0 to 9 + @"0", @"\u06F0", @"1", @"\u06F1", @"2", @"\u06F2", @"3", @"\u06F3", @"4", @"\u06F4", @"5", @"\u06F5", @"6", @"\u06F6", @"7", @"\u06F7", @"8", @"\u06F8", @"9", @"\u06F9", nil]; + + _DIALLABLE_CHAR_MAPPINGS_ = [NSMutableDictionary dictionaryWithObjectsAndKeys: + @"0", @"0", @"1", @"1", @"2", @"2", @"3", @"3", @"4", @"4", @"5", @"5", @"6", @"6", @"7", @"7", @"8", @"8", @"9", @"9", + @"+", @"+", @"*", @"*", nil]; + + _ALPHA_MAPPINGS_ = [NSMutableDictionary dictionaryWithObjectsAndKeys: + @"2", @"A", @"2", @"B", @"2", @"C", @"3", @"D", @"3", @"E", @"3", @"F", @"4", @"G", @"4", @"H", @"4", @"I", @"5", @"J", + @"5", @"K", @"5", @"L", @"6", @"M", @"6", @"N", @"6", @"O", @"7", @"P", @"7", @"Q", @"7", @"R", @"7", @"S", @"8", @"T", + @"8", @"U", @"8", @"V", @"9", @"W", @"9", @"X", @"9", @"Y", @"9", @"Z", nil]; + + _ALL_NORMALIZATION_MAPPINGS_ = [NSMutableDictionary dictionaryWithObjectsAndKeys: + @"0", @"0", @"1", @"1", @"2", @"2", @"3", @"3", @"4", @"4", @"5", @"5", @"6", @"6", @"7", @"7", @"8", @"8", @"9", @"9", + // Fullwidth digit 0 to 9 + @"0", @"\uFF10", @"1", @"\uFF11", @"2", @"\uFF12", @"3", @"\uFF13", @"4", @"\uFF14", @"5", @"\uFF15", @"6", @"\uFF16", @"7", @"\uFF17", @"8", @"\uFF18", @"9", @"\uFF19", + // Arabic-indic digit 0 to 9 + @"0", @"\u0660", @"1", @"\u0661", @"2", @"\u0662", @"3", @"\u0663", @"4", @"\u0664", @"5", @"\u0665", @"6", @"\u0666", @"7", @"\u0667", @"8", @"\u0668", @"9", @"\u0669", + // Eastern-Arabic digit 0 to 9 + @"0", @"\u06F0", @"1", @"\u06F1", @"2", @"\u06F2", @"3", @"\u06F3", @"4", @"\u06F4", @"5", @"\u06F5", @"6", @"\u06F6", @"7", @"\u06F7", @"8", @"\u06F8", @"9", @"\u06F9", + @"2", @"A", @"2", @"B", @"2", @"C", @"3", @"D", @"3", @"E", @"3", @"F", @"4", @"G", @"4", @"H", @"4", @"I", @"5", @"J", + @"5", @"K", @"5", @"L", @"6", @"M", @"6", @"N", @"6", @"O", @"7", @"P", @"7", @"Q", @"7", @"R", @"7", @"S", @"8", @"T", + @"8", @"U", @"8", @"V", @"9", @"W", @"9", @"X", @"9", @"Y", @"9", @"Z", nil]; + + _ALL_PLUS_NUMBER_GROUPING_SYMBOLS_ = [NSMutableDictionary dictionaryWithObjectsAndKeys: + @"0", @"0", @"1", @"1", @"2", @"2", @"3", @"3", @"4", @"4", @"5", @"5", @"6", @"6", @"7", @"7", @"8", @"8", @"9", @"9", + @"A", @"A", @"B", @"B", @"C", @"C", @"D", @"D", @"E", @"E", @"F", @"F", @"G", @"G", @"H", @"H", @"I", @"I", @"J", @"J", + @"K", @"K", @"L", @"L", @"M", @"M", @"N", @"N", @"O", @"O", @"P", @"P", @"Q", @"Q", @"R", @"R", @"S", @"S", @"T", @"T", + @"U", @"U", @"V", @"V", @"W", @"W", @"X", @"X", @"Y", @"Y", @"Z", @"Z", @"A", @"a", @"B", @"b", @"C", @"c", @"D", @"d", + @"E", @"e", @"F", @"f", @"G", @"g", @"H", @"h", @"I", @"i", @"J", @"j", @"K", @"k", @"L", @"l", @"M", @"m", @"N", @"n", + @"O", @"o", @"P", @"p", @"Q", @"q", @"R", @"r", @"S", @"s", @"T", @"t", @"U", @"u", @"V", @"v", @"W", @"w", @"X", @"x", + @"Y", @"y", @"Z", @"z", @"-", @"-", @"-", @"\uFF0D", @"-", @"\u2010", @"-", @"\u2011", @"-", @"\u2012", @"-", @"\u2013", @"-", @"\u2014", @"-", @"\u2015", + @"-", @"\u2212", @"/", @"/", @"/", @"\uFF0F", @" ", @" ", @" ", @"\u3000", @" ", @"\u2060", @".", @".", @".", @"\uFF0E", nil]; + +} + + +- (void)initCC2CN +{ + [self clearCC2CN]; + _mapCCode2CN = [NSMutableDictionary dictionaryWithObjectsAndKeys: + @"1", @"US", @"1", @"AG", @"1", @"AI", @"1", @"AS", @"1", @"BB", @"1", @"BM", @"1", @"BS", @"1", @"CA", @"1", @"DM", @"1", @"DO", + @"1", @"GD", @"1", @"GU", @"1", @"JM", @"1", @"KN", @"1", @"KY", @"1", @"LC", @"1", @"MP", @"1", @"MS", @"1", @"PR", @"1", @"SX", + @"1", @"TC", @"1", @"TT", @"1", @"VC", @"1", @"VG", @"1", @"VI", @"7", @"RU", @"7", @"KZ", + @"20", @"EG", @"27", @"ZA", + @"30", @"GR", @"31", @"NL", @"32", @"BE", @"33", @"FR", @"34", @"ES", @"36", @"HU", @"39", @"IT", + @"40", @"RO", @"41", @"CH", @"43", @"AT", @"44", @"GB", @"44", @"GG", @"44", @"IM", @"44", @"JE", @"45", @"DK", @"46", @"SE", @"47", @"NO", @"47", @"SJ", @"48", @"PL", @"49", @"DE", + @"51", @"PE", @"52", @"MX", @"53", @"CU", @"54", @"AR", @"55", @"BR", @"56", @"CL", @"57", @"CO", @"58", @"VE", + @"60", @"MY", @"61", @"AU", @"61", @"CC", @"61", @"CX", @"62", @"ID", @"63", @"PH", @"64", @"NZ", @"65", @"SG", @"66", @"TH", + @"81", @"JP", @"82", @"KR", @"84", @"VN", @"86", @"CN", + @"90", @"TR", @"91", @"IN", @"92", @"PK", @"93", @"AF", @"94", @"LK", @"95", @"MM", @"98", @"IR", + @"211", @"SS", @"212", @"MA", @"212", @"EH", @"213", @"DZ", @"216", @"TN", @"218", @"LY", + @"220", @"GM", @"221", @"SN", @"222", @"MR", @"223", @"ML", @"224", @"GN", @"225", @"CI", @"226", @"BF", @"227", @"NE", @"228", @"TG", @"229", @"BJ", + @"230", @"MU", @"231", @"LR", @"232", @"SL", @"233", @"GH", @"234", @"NG", @"235", @"TD", @"236", @"CF", @"237", @"CM", @"238", @"CV", @"239", @"ST", + @"240", @"GQ", @"241", @"GA", @"242", @"CG", @"243", @"CD", @"244", @"AO", @"245", @"GW", @"246", @"IO", @"247", @"AC", @"248", @"SC", @"249", @"SD", + @"250", @"RW", @"251", @"ET", @"252", @"SO", @"253", @"DJ", @"254", @"KE", @"255", @"TZ", @"256", @"UG", @"257", @"BI", @"258", @"MZ", + @"260", @"ZM", @"261", @"MG", @"262", @"RE", @"262", @"YT", @"263", @"ZW", @"264", @"NA", @"265", @"MW", @"266", @"LS", @"267", @"BW", @"268", @"SZ", @"269", @"KM", + @"290", @"SH", @"291", @"ER", @"297", @"AW", @"298", @"FO", @"299", @"GL", + @"350", @"GI", @"351", @"PT", @"352", @"LU", @"353", @"IE", @"354", @"IS", @"355", @"AL", @"356", @"MT", @"357", @"CY", @"358", @"FI",@"358", @"AX", @"359", @"BG", + @"370", @"LT", @"371", @"LV", @"372", @"EE", @"373", @"MD", @"374", @"AM", @"375", @"BY", @"376", @"AD", @"377", @"MC", @"378", @"SM", @"379", @"VA", + @"380", @"UA", @"381", @"RS", @"382", @"ME", @"385", @"HR", @"386", @"SI", @"387", @"BA", @"389", @"MK", + @"420", @"CZ", @"421", @"SK", @"423", @"LI", + @"500", @"FK", @"501", @"BZ", @"502", @"GT", @"503", @"SV", @"504", @"HN", @"505", @"NI", @"506", @"CR", @"507", @"PA", @"508", @"PM", @"509", @"HT", + @"590", @"GP", @"590", @"BL", @"590", @"MF", @"591", @"BO", @"592", @"GY", @"593", @"EC", @"594", @"GF", @"595", @"PY", @"596", @"MQ", @"597", @"SR", @"598", @"UY", @"599", @"CW", @"599", @"BQ", + @"670", @"TL", @"672", @"NF", @"673", @"BN", @"674", @"NR", @"675", @"PG", @"676", @"TO", @"677", @"SB", @"678", @"VU", @"679", @"FJ", + @"680", @"PW", @"681", @"WF", @"682", @"CK", @"683", @"NU", @"685", @"WS", @"686", @"KI", @"687", @"NC", @"688", @"TV", @"689", @"PF", + @"690", @"TK", @"691", @"FM", @"692", @"MH", + @"800", @"001", @"808", @"001", + @"850", @"KP", @"852", @"HK", @"853", @"MO", @"855", @"KH", @"856", @"LA", + @"870", @"001", @"878", @"001", + @"880", @"BD", @"881", @"001", @"882", @"001", @"883", @"001", @"886", @"TW", @"888", @"001", + @"960", @"MV", @"961", @"LB", @"962", @"JO", @"963", @"SY", @"964", @"IQ", @"965", @"KW", @"966", @"SA", @"967", @"YE", @"968", @"OM", + @"970", @"PS", @"971", @"AE", @"972", @"IL", @"973", @"BH", @"974", @"QA", @"975", @"BT", @"976", @"MN", @"977", @"NP", @"979", @"001", + @"992", @"TJ", @"993", @"TM", @"994", @"AZ", @"995", @"GE", @"996", @"KG", @"998", @"UZ", + nil]; +} + +/* + - (void)initCN2CC + { + [self clearCN2CC]; + _mapCN2CCode = [NSMutableDictionary dictionaryWithObjectsAndKeys: + @[@"US", @"AG", @"AI", @"AS", @"BB", @"BM", @"BS", @"CA", @"DM", @"DO", @"GD", @"GU", @"JM", @"KN", @"KY", @"LC", @"MP", @"MS", @"PR", @"SX", @"TC", @"TT", @"VC", @"VG", @"VI"], @"1", @[@"RU", @"KZ"], @"7", + @[@"EG"], @"20", @[@"ZA"], @"27", + @[@"GR"], @"30", @[@"NL"], @"31", @[@"BE"], @"32", @[@"FR"], @"33", @[@"ES"], @"34", @[@"HU"], @"36", @[@"IT"], @"39", + @[@"RO"], @"40", @[@"CH"], @"41", @[@"AT"], @"43", @[@"GB", @"GG", @"IM", @"JE"], @"44", @[@"DK"], @"45", @[@"SE"], @"46", @[@"NO", @"SJ"], @"47", @[@"PL"], @"48", @[@"DE"], @"49", + @[@"PE"], @"51", @[@"MX"], @"52", @[@"CU"], @"53", @[@"AR"], @"54", @[@"BR"], @"55", @[@"CL"], @"56", @[@"CO"], @"57", @[@"VE"], @"58", + @[@"MY"], @"60", @[@"AU", @"CC", @"CX"], @"61", @[@"ID"], @"62", @[@"PH"], @"63", @[@"NZ"], @"64", @[@"SG"], @"65", @[@"TH"], @"66", + @[@"JP"], @"81", @[@"KR"], @"82", @[@"VN"], @"84", @[@"CN"], @"86", + @[@"TR"], @"90", @[@"IN"], @"91", @[@"PK"], @"92", @[@"AF"], @"93", @[@"LK"], @"94", @[@"MM"], @"95", @[@"IR"], @"98", + @[@"SS"], @"211", @[@"MA", @"EH"], @"212", @[@"DZ"], @"213", @[@"TN"], @"216", @[@"LY"], @"218", + @[@"GM"], @"220", @[@"SN"], @"221", @[@"MR"], @"222", @[@"ML"], @"223", @[@"GN"], @"224", @[@"CI"], @"225", @[@"BF"], @"226", @[@"NE"], @"227", @[@"TG"], @"228", @[@"BJ"], @"229", + @[@"MU"], @"230", @[@"LR"], @"231", @[@"SL"], @"232", @[@"GH"], @"233", @[@"NG"], @"234", @[@"TD"], @"235", @[@"CF"], @"236", @[@"CM"], @"237", @[@"CV"], @"238", @[@"ST"], @"239", + @[@"GQ"], @"240", @[@"GA"], @"241", @[@"CG"], @"242", @[@"CD"], @"243", @[@"AO"], @"244", @[@"GW"], @"245", @[@"IO"], @"246", @[@"AC"], @"247", @[@"SC"], @"248", @[@"SD"], @"249", + @[@"RW"], @"250", @[@"ET"], @"251", @[@"SO"], @"252", @[@"DJ"], @"253", @[@"KE"], @"254", @[@"TZ"], @"255", @[@"UG"], @"256", @[@"BI"], @"257", @[@"MZ"], @"258", + @[@"ZM"], @"260", @[@"MG"], @"261", @[@"RE", @"YT"], @"262", @[@"ZW"], @"263", @[@"NA"], @"264", @[@"MW"], @"265", @[@"LS"], @"266", @[@"BW"], @"267", @[@"SZ"], @"268", @[@"KM"], @"269", + @[@"SH"], @"290", @[@"ER"], @"291", @[@"AW"], @"297", @[@"FO"], @"298", @[@"GL"], @"299", + @[@"GI"], @"350", @[@"PT"], @"351", @[@"LU"], @"352", @[@"IE"], @"353", @[@"IS"], @"354", @[@"AL"], @"355", @[@"MT"], @"356", @[@"CY"], @"357", @[@"FI", @"AX"], @"358", @[@"BG"], @"359", + @[@"LT"], @"370", @[@"LV"], @"371", @[@"EE"], @"372", @[@"MD"], @"373", @[@"AM"], @"374", @[@"BY"], @"375", @[@"AD"], @"376", @[@"MC"], @"377", @[@"SM"], @"378", @[@"VA"], @"379", + @[@"UA"], @"380", @[@"RS"], @"381", @[@"ME"], @"382", @[@"HR"], @"385", @[@"SI"], @"386", @[@"BA"], @"387", @[@"MK"], @"389", + @[@"CZ"], @"420", @[@"SK"], @"421", @[@"LI"], @"423", + @[@"FK"], @"500", @[@"BZ"], @"501", @[@"GT"], @"502", @[@"SV"], @"503", @[@"HN"], @"504", @[@"NI"], @"505", @[@"CR"], @"506", @[@"PA"], @"507", @[@"PM"], @"508", @[@"HT"], @"509", + @[@"GP", @"BL", @"MF"], @"590", @[@"BO"], @"591", @[@"GY"], @"592", @[@"EC"], @"593", @[@"GF"], @"594", @[@"PY"], @"595", @[@"MQ"], @"596", @[@"SR"], @"597", @[@"UY"], @"598", @[@"CW", @"BQ"], @"599", + @[@"TL"], @"670", @[@"NF"], @"672", @[@"BN"], @"673", @[@"NR"], @"674", @[@"PG"], @"675", @[@"TO"], @"676", @[@"SB"], @"677", @[@"VU"], @"678", @[@"FJ"], @"679", + @[@"PW"], @"680", @[@"WF"], @"681", @[@"CK"], @"682", @[@"NU"], @"683", @[@"WS"], @"685", @[@"KI"], @"686", @[@"NC"], @"687", @[@"TV"], @"688", @[@"PF"], @"689", + @[@"TK"], @"690", @[@"FM"], @"691", @[@"MH"], @"692", + @[@"001"], @"800", @[@"001"], @"808", + @[@"KP"], @"850", @[@"HK"], @"852", @[@"MO"], @"853", @[@"KH"], @"855", @[@"LA"], @"856", + @[@"001"], @"870", @[@"001"], @"878", + @[@"BD"], @"880", @[@"001"], @"881", @[@"001"], @"882", @[@"001"], @"883", @[@"TW"], @"886", @[@"001"], @"888", + @[@"MV"], @"960", @[@"LB"], @"961", @[@"JO"], @"962", @[@"SY"], @"963", @[@"IQ"], @"964", @[@"KW"], @"965", @[@"SA"], @"966", @[@"YE"], @"967", @[@"OM"], @"968", + @[@"PS"], @"970", @[@"AE"], @"971", @[@"IL"], @"972", @[@"BH"], @"973", @[@"QA"], @"974", @[@"BT"], @"975", @[@"MN"], @"976", @[@"NP"], @"977", @[@"001"], @"979", + @[@"TJ"], @"992", @[@"TM"], @"993", @[@"AZ"], @"994", @[@"GE"], @"995", @[@"KG"], @"996", @[@"UZ"], @"998", nil]; + } + */ + + +#pragma mark - Metadata manager (phonenumberutil.js) functions - +/** + * Attempts to extract a possible number from the string passed in. This + * currently strips all leading characters that cannot be used to start a phone + * number. Characters that can be used to start a phone number are defined in + * the VALID_START_CHAR_PATTERN. If none of these characters are found in the + * number passed in, an empty string is returned. This function also attempts to + * strip off any alternative extensions or endings if two or more are present, + * such as in the case of: (530) 583-6985 x302/x2303. The second extension here + * makes this actually two phone numbers, (530) 583-6985 x302 and (530) 583-6985 + * x2303. We remove the second extension so that the first number is parsed + * correctly. + * + * @param {string} number the string that might contain a phone number. + * @return {string} the number, stripped of any non-phone-number prefix (such as + * 'Tel:') or an empty string if no character used to start phone numbers + * (such as + or any digit) is found in the number. + */ +- (NSString*)extractPossibleNumber:(NSString*)number +{ + NSString *possibleNumber = @""; + NSInteger start = [self stringPositionByRegex:number regex:self.VALID_START_CHAR_PATTERN_]; + + if (start >= 0) + { + possibleNumber = [number substringFromIndex:start]; + // Remove trailing non-alpha non-numerical characters. + possibleNumber = [self replaceStringByRegex:possibleNumber regex:self.UNWANTED_END_CHAR_PATTERN_ withTemplate:@""]; + + // Check for extra numbers at the end. + NSInteger secondNumberStart = [self stringPositionByRegex:number regex:self.SECOND_NUMBER_START_PATTERN_]; + if (secondNumberStart >= 0) + { + possibleNumber = [possibleNumber substringWithRange:NSMakeRange(0, secondNumberStart - 1)]; + } + } + else + { + possibleNumber = @""; + } + + return possibleNumber; + + /* + NSString *possibleNumber = @""; + NSRegularExpression *currentPattern = self.VALID_START_CHAR_PATTERN_; + int sourceLength = phoneNumber.length; + + NSArray *matches = [currentPattern matchesInString:phoneNumber options:0 range:NSMakeRange(0, sourceLength)]; + if (matches && [matches count] > 0) + { + NSRange rangeOfFirstMatch = ((NSTextCheckingResult*)[matches objectAtIndex:0]).range; + possibleNumber = [phoneNumber substringFromIndex:rangeOfFirstMatch.location]; + + // Remove trailing non-alpha non-numerical characters. + currentPattern = self.UNWANTED_END_CHAR_PATTERN_; + possibleNumber = [currentPattern stringByReplacingMatchesInString:possibleNumber options:0 + range:NSMakeRange(0, [possibleNumber length]) withTemplate:@""]; + // Check for extra numbers at the end. + currentPattern = self.SECOND_NUMBER_START_PATTERN_; + matches = [currentPattern matchesInString:possibleNumber options:0 + range:NSMakeRange(0, [possibleNumber length])]; + if (matches && [matches count] > 0) + { + NSRange rangeOfSecondMatch = ((NSTextCheckingResult*)[matches objectAtIndex:0]).range; + possibleNumber = [possibleNumber substringWithRange:NSMakeRange(0, rangeOfSecondMatch.location)]; + } + } + + return possibleNumber; + */ +} + + +/** + * Checks to see if the string of characters could possibly be a phone number at + * all. At the moment, checks to see that the string begins with at least 2 + * digits, ignoring any punctuation commonly found in phone numbers. This method + * does not require the number to be normalized in advance - but does assume + * that leading non-number symbols have been removed, such as by the method + * extractPossibleNumber. + * + * @param {string} number string to be checked for viability as a phone number. + * @return {boolean} NO if the number could be a phone number of some sort, + * otherwise NO. + */ +- (BOOL)isViablePhoneNumber:(NSString*)phoneNumber +{ + if (phoneNumber.length < MIN_LENGTH_FOR_NSN_) + { + return NO; + } + + return [self matchesEntirely:self.VALID_PHONE_NUMBER_PATTERN_ string:phoneNumber]; +} + + +/** + * Normalizes a string of characters representing a phone number. This performs + * the following conversions: + * Punctuation is stripped. + * For ALPHA/VANITY numbers: + * Letters are converted to their numeric representation on a telephone + * keypad. The keypad used here is the one defined in ITU Recommendation + * E.161. This is only done if there are 3 or more letters in the number, + * to lessen the risk that such letters are typos. + * For other numbers: + * Wide-ascii digits are converted to normal ASCII (European) digits. + * Arabic-Indic numerals are converted to European numerals. + * Spurious alpha characters are stripped. + * + * @param {string} number a string of characters representing a phone number. + * @return {string} the normalized string version of the phone number. + */ +- (NSString*)normalizePhoneNumber:(NSString*)number +{ + if ([self matchesEntirely:VALID_ALPHA_PHONE_PATTERN_STRING string:number]) + { + return [self normalizeHelper:number normalizationReplacements:self.ALL_NORMALIZATION_MAPPINGS_ removeNonMatches:true]; + } + else + { + return [self normalizeDigitsOnly:number]; + } + + return nil; +} + + +/** + * Normalizes a string of characters representing a phone number. This is a + * wrapper for normalize(String number) but does in-place normalization of the + * StringBuffer provided. + * + * @param {!goog.string.StringBuffer} number a StringBuffer of characters + * representing a phone number that will be normalized in place. + * @private + */ + +- (void)normalizeSB:(NSString**)number +{ + if (number == NULL) + { + return; + } + + (*number) = [self normalizePhoneNumber:(*number)]; +} + + +/** + * Normalizes a string of characters representing a phone number. This converts + * wide-ascii and arabic-indic numerals to European numerals, and strips + * punctuation and alpha characters. + * + * @param {string} number a string of characters representing a phone number. + * @return {string} the normalized string version of the phone number. + */ +- (NSString*)normalizeDigitsOnly:(NSString*)number +{ + return [self stringByReplacingOccurrencesString:number + withMap:self.DIGIT_MAPPINGS removeNonMatches:YES]; +} + + +/** + * Converts all alpha characters in a number to their respective digits on a + * keypad, but retains existing formatting. Also converts wide-ascii digits to + * normal ascii digits, and converts Arabic-Indic numerals to European numerals. + * + * @param {string} number a string of characters representing a phone number. + * @return {string} the normalized string version of the phone number. + */ +- (NSString*)convertAlphaCharactersInNumber:(NSString*)number +{ + return [self stringByReplacingOccurrencesString:number + withMap:self.ALL_NORMALIZATION_MAPPINGS_ removeNonMatches:NO]; +} + + +/** + * Gets the length of the geographical area code from the + * {@code national_number} field of the PhoneNumber object passed in, so that + * clients could use it to split a national significant number into geographical + * area code and subscriber number. It works in such a way that the resultant + * subscriber number should be diallable, at least on some devices. An example + * of how this could be used: + * + * <pre> + * var phoneUtil = getInstance(); + * var number = phoneUtil.parse('16502530000', 'US'); + * var nationalSignificantNumber = + * phoneUtil.getNationalSignificantNumber(number); + * var areaCode; + * var subscriberNumber; + * + * var areaCodeLength = phoneUtil.getLengthOfGeographicalAreaCode(number); + * if (areaCodeLength > 0) { + * areaCode = nationalSignificantNumber.substring(0, areaCodeLength); + * subscriberNumber = nationalSignificantNumber.substring(areaCodeLength); + * } else { + * areaCode = ''; + * subscriberNumber = nationalSignificantNumber; + * } + * </pre> + * + * N.B.: area code is a very ambiguous concept, so the I18N team generally + * recommends against using it for most purposes, but recommends using the more + * general {@code national_number} instead. Read the following carefully before + * deciding to use this method: + * <ul> + * <li> geographical area codes change over time, and this method honors those + * changes; therefore, it doesn't guarantee the stability of the result it + * produces. + * <li> subscriber numbers may not be diallable from all devices (notably + * mobile devices, which typically requires the full national_number to be + * dialled in most regions). + * <li> most non-geographical numbers have no area codes, including numbers + * from non-geographical entities. + * <li> some geographical numbers have no area codes. + * </ul> + * + * @param {i18n.phonenumbers.PhoneNumber} number the PhoneNumber object for + * which clients want to know the length of the area code. + * @return {number} the length of area code of the PhoneNumber object passed in. + */ +- (NSUInteger)getLengthOfGeographicalAreaCode:(NBPhoneNumber*)phoneNumber error:(NSError **)error +{ + NSUInteger res = 0; + @try { + res = [self getLengthOfGeographicalAreaCode:phoneNumber]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + { + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + } + return res; +} + + +- (NSUInteger)getLengthOfGeographicalAreaCode:(NBPhoneNumber*)phoneNumber +{ + NSString *regionCode = [self getRegionCodeForNumber:phoneNumber]; + NBPhoneMetaData *metadata = [self getMetadataForRegion:regionCode]; + + if (metadata == nil) + { + return 0; + } + // If a country doesn't use a national prefix, and this number doesn't have + // an Italian leading zero, we assume it is a closed dialling plan with no + // area codes. + if (metadata.nationalPrefix == nil && phoneNumber.italianLeadingZero == NO) + { + return 0; + } + + if ([self isNumberGeographical:phoneNumber] == NO) + { + return 0; + } + + return [self getLengthOfNationalDestinationCode:phoneNumber]; +} + + +/** + * Gets the length of the national destination code (NDC) from the PhoneNumber + * object passed in, so that clients could use it to split a national + * significant number into NDC and subscriber number. The NDC of a phone number + * is normally the first group of digit(s) right after the country calling code + * when the number is formatted in the international format, if there is a + * subscriber number part that follows. An example of how this could be used: + * + * <pre> + * var phoneUtil = getInstance(); + * var number = phoneUtil.parse('18002530000', 'US'); + * var nationalSignificantNumber = + * phoneUtil.getNationalSignificantNumber(number); + * var nationalDestinationCode; + * var subscriberNumber; + * + * var nationalDestinationCodeLength = + * phoneUtil.getLengthOfNationalDestinationCode(number); + * if (nationalDestinationCodeLength > 0) { + * nationalDestinationCode = + * nationalSignificantNumber.substring(0, nationalDestinationCodeLength); + * subscriberNumber = + * nationalSignificantNumber.substring(nationalDestinationCodeLength); + * } else { + * nationalDestinationCode = ''; + * subscriberNumber = nationalSignificantNumber; + * } + * </pre> + * + * Refer to the unittests to see the difference between this function and + * {@link #getLengthOfGeographicalAreaCode}. + * + * @param {i18n.phonenumbers.PhoneNumber} number the PhoneNumber object for + * which clients want to know the length of the NDC. + * @return {number} the length of NDC of the PhoneNumber object passed in. + */ +- (NSUInteger)getLengthOfNationalDestinationCode:(NBPhoneNumber*)phoneNumber error:(NSError **)error +{ + NSUInteger res = 0; + + @try { + res = [self getLengthOfNationalDestinationCode:phoneNumber]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + { + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + } + + return res; +} + + +- (NSUInteger)getLengthOfNationalDestinationCode:(NBPhoneNumber*)phoneNumber +{ + NBPhoneNumber *copiedProto = nil; + if ([self hasValue:phoneNumber.extension]) + { + copiedProto = [phoneNumber copy]; + copiedProto.extension = nil; + } + else + { + copiedProto = phoneNumber; + } + + NSString *nationalSignificantNumber = [self format:copiedProto numberFormat:NBEPhoneNumberFormatINTERNATIONAL]; + NSMutableArray *numberGroups = [[self componentsSeparatedByRegex:nationalSignificantNumber regex:NON_DIGITS_PATTERN_] mutableCopy]; + + // The pattern will start with '+COUNTRY_CODE ' so the first group will always + // be the empty string (before the + symbol) and the second group will be the + // country calling code. The third group will be area code if it is not the + // last group. + // NOTE: On IE the first group that is supposed to be the empty string does + // not appear in the array of number groups... so make the result on non-IE + // browsers to be that of IE. + if ([numberGroups count] > 0 && ((NSString*)[numberGroups objectAtIndex:0]).length <= 0) + { + [numberGroups removeObjectAtIndex:0]; + } + + if ([numberGroups count] <= 2) + { + return 0; + } + + NSArray *regionCodes = [self regionCodeFromCountryCode:phoneNumber.countryCode]; + BOOL isExists = NO; + + for (NSString *regCode in regionCodes) + { + if ([regCode isEqualToString:@"AR"]) + { + isExists = YES; + break; + } + } + + if (isExists && [self getNumberType:phoneNumber] == NBEPhoneNumberTypeMOBILE) + { + // Argentinian mobile numbers, when formatted in the international format, + // are in the form of +54 9 NDC XXXX.... As a result, we take the length of + // the third group (NDC) and add 1 for the digit 9, which also forms part of + // the national significant number. + // + // TODO: Investigate the possibility of better modeling the metadata to make + // it easier to obtain the NDC. + return ((NSString*)[numberGroups objectAtIndex:2]).length + 1; + } + + return ((NSString*)[numberGroups objectAtIndex:1]).length; +} + + +/** + * Normalizes a string of characters representing a phone number by replacing + * all characters found in the accompanying map with the values therein, and + * stripping all other characters if removeNonMatches is NO. + * + * @param {string} number a string of characters representing a phone number. + * @param {!Object.<string, string>} normalizationReplacements a mapping of + * characters to what they should be replaced by in the normalized version + * of the phone number. + * @param {boolean} removeNonMatches indicates whether characters that are not + * able to be replaced should be stripped from the number. If this is NO, + * they will be left unchanged in the number. + * @return {string} the normalized string version of the phone number. + * @private + */ +- (NSString*)normalizeHelper:(NSString*)sourceString normalizationReplacements:(NSDictionary*)normalizationReplacements + removeNonMatches:(BOOL)removeNonMatches +{ + NSMutableString *normalizedNumber = [[NSMutableString alloc] init]; + unichar character = 0; + NSString *newDigit = @""; + NSUInteger numberLength = sourceString.length; + + for (NSUInteger i = 0; i<numberLength; ++i) + { + character = [sourceString characterAtIndex:i]; + newDigit = [normalizationReplacements objectForKey:[[NSString stringWithFormat: @"%C", character] uppercaseString]]; + if (newDigit != nil) + { + [normalizedNumber appendString:newDigit]; + } + else if (removeNonMatches == NO) + { + [normalizedNumber appendString:[NSString stringWithFormat: @"%C", character]]; + } + // If neither of the above are NO, we remove this character. + + //NSLog(@"[%@]", normalizedNumber); + } + + return normalizedNumber; +} + + +/** + * Helper function to check if the national prefix formatting rule has the first + * group only, i.e., does not start with the national prefix. + * + * @param {string} nationalPrefixFormattingRule The formatting rule for the + * national prefix. + * @return {boolean} NO if the national prefix formatting rule has the first + * group only. + */ +- (BOOL)formattingRuleHasFirstGroupOnly:(NSString*)nationalPrefixFormattingRule +{ + BOOL hasFound = NO; + if ([self stringPositionByRegex:nationalPrefixFormattingRule regex:FIRST_GROUP_ONLY_PREFIX_PATTERN_] >= 0) + { + hasFound = YES; + } + + return (([nationalPrefixFormattingRule length] == 0) || hasFound); +} + + +/** + * Tests whether a phone number has a geographical association. It checks if + * the number is associated to a certain region in the country where it belongs + * to. Note that this doesn't verify if the number is actually in use. + * + * @param {i18n.phonenumbers.PhoneNumber} phoneNumber The phone number to test. + * @return {boolean} NO if the phone number has a geographical association. + * @private + */ +- (BOOL)isNumberGeographical:(NBPhoneNumber*)phoneNumber +{ + NBEPhoneNumberType numberType = [self getNumberType:phoneNumber]; + // TODO: Include mobile phone numbers from countries like Indonesia, which + // has some mobile numbers that are geographical. + return numberType == NBEPhoneNumberTypeFIXED_LINE || numberType == NBEPhoneNumberTypeFIXED_LINE_OR_MOBILE; +} + + +/** + * Helper function to check region code is not unknown or nil. + * + * @param {?string} regionCode the ISO 3166-1 two-letter region code. + * @return {boolean} NO if region code is valid. + * @private + */ +- (BOOL)isValidRegionCode:(NSString*)regionCode +{ + // In Java we check whether the regionCode is contained in supportedRegions + // that is built out of all the values of countryCallingCodeToRegionCodeMap + // (countryCodeToRegionCodeMap in JS) minus REGION_CODE_FOR_NON_GEO_ENTITY. + // In JS we check whether the regionCode is contained in the keys of + // countryToMetadata but since for non-geographical country calling codes + // (e.g. +800) we use the country calling codes instead of the region code as + // key in the map we have to make sure regionCode is not a number to prevent + // returning NO for non-geographical country calling codes. + return [self hasValue:regionCode] && [self isNaN:regionCode] && [self getMetadataForRegion:regionCode.uppercaseString] != nil; +} + + +/** + * Helper function to check the country calling code is valid. + * + * @param {number} countryCallingCode the country calling code. + * @return {boolean} NO if country calling code code is valid. + * @private + */ +- (BOOL)hasValidCountryCallingCode:(NSNumber *)countryCallingCode +{ + id res = [self regionCodeFromCountryCode:countryCallingCode]; + if (res != nil) + { + return YES; + } + + return NO; +} + + +/** + * Formats a phone number in the specified format using default rules. Note that + * this does not promise to produce a phone number that the user can dial from + * where they are - although we do format in either 'national' or + * 'international' format depending on what the client asks for, we do not + * currently support a more abbreviated format, such as for users in the same + * 'area' who could potentially dial the number without area code. Note that if + * the phone number has a country calling code of 0 or an otherwise invalid + * country calling code, we cannot work out which formatting rules to apply so + * we return the national significant number with no formatting applied. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number to be + * formatted. + * @param {i18n.phonenumbers.PhoneNumberFormat} numberFormat the format the + * phone number should be formatted into. + * @return {string} the formatted phone number. + */ +- (NSString*)format:(NBPhoneNumber*)phoneNumber numberFormat:(NBEPhoneNumberFormat)numberFormat error:(NSError**)error; +{ + NSString *res = nil; + @try { + res = [self format:phoneNumber numberFormat:numberFormat]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + +- (NSString*)format:(NBPhoneNumber*)phoneNumber numberFormat:(NBEPhoneNumberFormat)numberFormat +{ + if ([phoneNumber.nationalNumber isEqualToNumber:@0] && [self hasValue:phoneNumber.rawInput]) + { + // Unparseable numbers that kept their raw input just use that. + // This is the only case where a number can be formatted as E164 without a + // leading '+' symbol (but the original number wasn't parseable anyway). + // TODO: Consider removing the 'if' above so that unparseable strings + // without raw input format to the empty string instead of "+00" + /** @type {string} */ + NSString *rawInput = phoneNumber.rawInput; + if ([self hasValue:rawInput]) { + return rawInput; + } + } + + NSNumber *countryCallingCode = phoneNumber.countryCode; + NSString *nationalSignificantNumber = [self getNationalSignificantNumber:phoneNumber]; + + if (numberFormat == NBEPhoneNumberFormatE164) + { + // Early exit for E164 case (even if the country calling code is invalid) + // since no formatting of the national number needs to be applied. + // Extensions are not formatted. + return [self prefixNumberWithCountryCallingCode:countryCallingCode phoneNumberFormat:NBEPhoneNumberFormatE164 + formattedNationalNumber:nationalSignificantNumber formattedExtension:@""]; + } + + if ([self hasValidCountryCallingCode:countryCallingCode] == NO) + { + return nationalSignificantNumber; + } + + // Note getRegionCodeForCountryCode() is used because formatting information + // for regions which share a country calling code is contained by only one + // region for performance reasons. For example, for NANPA regions it will be + // contained in the metadata for US. + NSArray *regionCodeArray = [self regionCodeFromCountryCode:countryCallingCode]; + NSString *regionCode = [regionCodeArray objectAtIndex:0]; + + // Metadata cannot be nil because the country calling code is valid (which + // means that the region code cannot be ZZ and must be one of our supported + // region codes). + NBPhoneMetaData *metadata = [self getMetadataForRegionOrCallingCode:countryCallingCode regionCode:regionCode]; + NSString *formattedExtension = [self maybeGetFormattedExtension:phoneNumber metadata:metadata numberFormat:numberFormat]; + NSString *formattedNationalNumber = [self formatNsn:nationalSignificantNumber metadata:metadata phoneNumberFormat:numberFormat carrierCode:nil]; + + return [self prefixNumberWithCountryCallingCode:countryCallingCode phoneNumberFormat:numberFormat + formattedNationalNumber:formattedNationalNumber formattedExtension:formattedExtension]; +} + + +/** + * Formats a phone number in the specified format using client-defined + * formatting rules. Note that if the phone number has a country calling code of + * zero or an otherwise invalid country calling code, we cannot work out things + * like whether there should be a national prefix applied, or how to format + * extensions, so we return the national significant number with no formatting + * applied. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number to be + * formatted. + * @param {i18n.phonenumbers.PhoneNumberFormat} numberFormat the format the + * phone number should be formatted into. + * @param {Array.<i18n.phonenumbers.NumberFormat>} userDefinedFormats formatting + * rules specified by clients. + * @return {string} the formatted phone number. + */ +- (NSString*)formatByPattern:(NBPhoneNumber*)number numberFormat:(NBEPhoneNumberFormat)numberFormat userDefinedFormats:(NSArray*)userDefinedFormats error:(NSError**)error +{ + NSString *res = nil; + @try { + res = [self formatByPattern:number numberFormat:numberFormat userDefinedFormats:userDefinedFormats]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (NSString*)formatByPattern:(NBPhoneNumber*)number numberFormat:(NBEPhoneNumberFormat)numberFormat userDefinedFormats:(NSArray*)userDefinedFormats +{ + NSNumber *countryCallingCode = number.countryCode; + NSString *nationalSignificantNumber = [self getNationalSignificantNumber:number]; + + if ([self hasValidCountryCallingCode:countryCallingCode] == NO) + { + return nationalSignificantNumber; + } + + // Note getRegionCodeForCountryCode() is used because formatting information + // for regions which share a country calling code is contained by only one + // region for performance reasons. For example, for NANPA regions it will be + // contained in the metadata for US. + NSArray *regionCodes = [self regionCodeFromCountryCode:countryCallingCode]; + NSString *regionCode = nil; + if (regionCodes != nil && regionCodes.count > 0) + { + regionCode = [regionCodes objectAtIndex:0]; + } + + // Metadata cannot be nil because the country calling code is valid + /** @type {i18n.phonenumbers.PhoneMetadata} */ + NBPhoneMetaData *metadata = [self getMetadataForRegionOrCallingCode:countryCallingCode regionCode:regionCode]; + + NSString *formattedNumber = @""; + NBNumberFormat *formattingPattern = [self chooseFormattingPatternForNumber:userDefinedFormats nationalNumber:nationalSignificantNumber]; + if (formattingPattern == nil) + { + // If no pattern above is matched, we format the number as a whole. + formattedNumber = nationalSignificantNumber; + } + else + { + // Before we do a replacement of the national prefix pattern $NP with the + // national prefix, we need to copy the rule so that subsequent replacements + // for different numbers have the appropriate national prefix. + NBNumberFormat *numFormatCopy = [formattingPattern copy]; + NSString *nationalPrefixFormattingRule = formattingPattern.nationalPrefixFormattingRule; + + if (nationalPrefixFormattingRule.length > 0) + { + NSString *nationalPrefix = metadata.nationalPrefix; + if (nationalPrefix.length > 0) + { + // Replace $NP with national prefix and $FG with the first group ($1). + nationalPrefixFormattingRule = [self replaceStringByRegex:nationalPrefixFormattingRule regex:NP_PATTERN_ withTemplate:nationalPrefix]; + nationalPrefixFormattingRule = [self replaceStringByRegex:nationalPrefixFormattingRule regex:FG_PATTERN_ withTemplate:@"\\$1"]; + numFormatCopy.nationalPrefixFormattingRule = nationalPrefixFormattingRule; + } + else + { + // We don't want to have a rule for how to format the national prefix if + // there isn't one. + numFormatCopy.nationalPrefixFormattingRule = @""; + } + } + + formattedNumber = [self formatNsnUsingPattern:nationalSignificantNumber + formattingPattern:numFormatCopy numberFormat:numberFormat carrierCode:nil]; + } + + NSString *formattedExtension = [self maybeGetFormattedExtension:number metadata:metadata numberFormat:numberFormat]; + + //NSLog(@"!@# prefixNumberWithCountryCallingCode called [%@]", formattedExtension); + return [self prefixNumberWithCountryCallingCode:countryCallingCode + phoneNumberFormat:numberFormat + formattedNationalNumber:formattedNumber + formattedExtension:formattedExtension]; +} + + +/** + * Formats a phone number in national format for dialing using the carrier as + * specified in the {@code carrierCode}. The {@code carrierCode} will always be + * used regardless of whether the phone number already has a preferred domestic + * carrier code stored. If {@code carrierCode} contains an empty string, returns + * the number in national format without any carrier code. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number to be + * formatted. + * @param {string} carrierCode the carrier selection code to be used. + * @return {string} the formatted phone number in national format for dialing + * using the carrier as specified in the {@code carrierCode}. + */ +- (NSString*)formatNationalNumberWithCarrierCode:(NBPhoneNumber*)number carrierCode:(NSString*)carrierCode error:(NSError **)error +{ + NSString *res = nil; + @try { + res = [self formatNationalNumberWithCarrierCode:number carrierCode:carrierCode]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (NSString*)formatNationalNumberWithCarrierCode:(NBPhoneNumber*)number carrierCode:(NSString*)carrierCode +{ + NSNumber *countryCallingCode = number.countryCode; + NSString *nationalSignificantNumber = [self getNationalSignificantNumber:number]; + if ([self hasValidCountryCallingCode:countryCallingCode] == NO) + { + return nationalSignificantNumber; + } + + // Note getRegionCodeForCountryCode() is used because formatting information + // for regions which share a country calling code is contained by only one + // region for performance reasons. For example, for NANPA regions it will be + // contained in the metadata for US. + NSString *regionCode = [self getRegionCodeForCountryCode:countryCallingCode]; + // Metadata cannot be nil because the country calling code is valid. + NBPhoneMetaData *metadata = [self getMetadataForRegionOrCallingCode:countryCallingCode regionCode:regionCode]; + NSString *formattedExtension = [self maybeGetFormattedExtension:number metadata:metadata numberFormat:NBEPhoneNumberFormatNATIONAL]; + NSString *formattedNationalNumber = [self formatNsn:nationalSignificantNumber metadata:metadata phoneNumberFormat:NBEPhoneNumberFormatNATIONAL carrierCode:carrierCode]; + return [self prefixNumberWithCountryCallingCode:countryCallingCode phoneNumberFormat:NBEPhoneNumberFormatNATIONAL formattedNationalNumber:formattedNationalNumber formattedExtension:formattedExtension]; +} + + +/** + * @param {number} countryCallingCode + * @param {?string} regionCode + * @return {i18n.phonenumbers.PhoneMetadata} + * @private + */ +- (NBPhoneMetaData*)getMetadataForRegionOrCallingCode:(NSNumber*)countryCallingCode regionCode:(NSString*)regionCode +{ + return [_REGION_CODE_FOR_NON_GEO_ENTITY isEqualToString:regionCode] ? + [self getMetadataForNonGeographicalRegion:countryCallingCode] : [self getMetadataForRegion:regionCode]; +} + + +/** + * Formats a phone number in national format for dialing using the carrier as + * specified in the preferred_domestic_carrier_code field of the PhoneNumber + * object passed in. If that is missing, use the {@code fallbackCarrierCode} + * passed in instead. If there is no {@code preferred_domestic_carrier_code}, + * and the {@code fallbackCarrierCode} contains an empty string, return the + * number in national format without any carrier code. + * + * <p>Use {@link #formatNationalNumberWithCarrierCode} instead if the carrier + * code passed in should take precedence over the number's + * {@code preferred_domestic_carrier_code} when formatting. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number to be + * formatted. + * @param {string} fallbackCarrierCode the carrier selection code to be used, if + * none is found in the phone number itself. + * @return {string} the formatted phone number in national format for dialing + * using the number's preferred_domestic_carrier_code, or the + * {@code fallbackCarrierCode} passed in if none is found. + */ +- (NSString*)formatNationalNumberWithPreferredCarrierCode:(NBPhoneNumber*)number + fallbackCarrierCode:(NSString*)fallbackCarrierCode error:(NSError **)error +{ + NSString *res = nil; + @try { + res = [self formatNationalNumberWithCarrierCode:number carrierCode:fallbackCarrierCode]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + + return res; +} + + +- (NSString*)formatNationalNumberWithPreferredCarrierCode:(NBPhoneNumber*)number fallbackCarrierCode:(NSString*)fallbackCarrierCode +{ + NSString *domesticCarrierCode = number.preferredDomesticCarrierCode != nil ? number.preferredDomesticCarrierCode : fallbackCarrierCode; + return [self formatNationalNumberWithCarrierCode:number carrierCode:domesticCarrierCode]; +} + + +/** + * Returns a number formatted in such a way that it can be dialed from a mobile + * phone in a specific region. If the number cannot be reached from the region + * (e.g. some countries block toll-free numbers from being called outside of the + * country), the method returns an empty string. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number to be + * formatted. + * @param {string} regionCallingFrom the region where the call is being placed. + * @param {boolean} withFormatting whether the number should be returned with + * formatting symbols, such as spaces and dashes. + * @return {string} the formatted phone number. + */ +- (NSString*)formatNumberForMobileDialing:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom withFormatting:(BOOL)withFormatting error:(NSError**)error +{ + NSString *res = nil; + @try { + res = [self formatNumberForMobileDialing:number regionCallingFrom:regionCallingFrom withFormatting:withFormatting]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (NSString*)formatNumberForMobileDialing:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom withFormatting:(BOOL)withFormatting +{ + NSNumber *countryCallingCode = number.countryCode; + if ([self hasValidCountryCallingCode:countryCallingCode] == NO) + { + return [self hasValue:number.rawInput] ? number.rawInput : @""; + } + + NSString *formattedNumber = @""; + // Clear the extension, as that part cannot normally be dialed together with + // the main number. + NBPhoneNumber *numberNoExt = [number copy]; + numberNoExt.extension = @""; + + NSString *regionCode = [self getRegionCodeForCountryCode:countryCallingCode]; + if ([regionCallingFrom isEqualToString:regionCode]) + { + NBEPhoneNumberType numberType = [self getNumberType:numberNoExt]; + BOOL isFixedLineOrMobile = (numberType == NBEPhoneNumberTypeFIXED_LINE) || (numberType == NBEPhoneNumberTypeMOBILE) || (numberType == NBEPhoneNumberTypeFIXED_LINE_OR_MOBILE); + // Carrier codes may be needed in some countries. We handle this here. + if ([regionCode isEqualToString:@"CO"] && numberType == NBEPhoneNumberTypeFIXED_LINE) + { + formattedNumber = [self formatNationalNumberWithCarrierCode:numberNoExt + carrierCode:COLOMBIA_MOBILE_TO_FIXED_LINE_PREFIX_]; + } + else if ([regionCode isEqualToString:@"BR"] && isFixedLineOrMobile) + { + formattedNumber = [self hasValue:numberNoExt.preferredDomesticCarrierCode] ? + [self formatNationalNumberWithPreferredCarrierCode:numberNoExt fallbackCarrierCode:@""] : @""; + // Brazilian fixed line and mobile numbers need to be dialed with a + // carrier code when called within Brazil. Without that, most of the + // carriers won't connect the call. Because of that, we return an + // empty string here. + } + else + { + // For NANPA countries, non-geographical countries, and Mexican fixed + // line and mobile numbers, we output international format for numbersi + // that can be dialed internationally as that always works. + if (([countryCallingCode isEqualToNumber:@(NANPA_COUNTRY_CODE_)] || + [regionCode isEqualToString:_REGION_CODE_FOR_NON_GEO_ENTITY] || + // MX fixed line and mobile numbers should always be formatted in + // international format, even when dialed within MX. For national + // format to work, a carrier code needs to be used, and the correct + // carrier code depends on if the caller and callee are from the + // same local area. It is trickier to get that to work correctly than + // using international format, which is tested to work fine on all + // carriers. + ([regionCode isEqualToString:@"MX"] && isFixedLineOrMobile)) && [self canBeInternationallyDialled:numberNoExt]) + { + formattedNumber = [self format:numberNoExt numberFormat:NBEPhoneNumberFormatINTERNATIONAL]; + } + else + { + formattedNumber = [self format:numberNoExt numberFormat:NBEPhoneNumberFormatNATIONAL]; + } + } + } + else if ([self canBeInternationallyDialled:numberNoExt]) + { + return withFormatting ? [self format:numberNoExt numberFormat:NBEPhoneNumberFormatINTERNATIONAL] : + [self format:numberNoExt numberFormat:NBEPhoneNumberFormatE164]; + } + + return withFormatting ? + formattedNumber : [self normalizeHelper:formattedNumber normalizationReplacements:self.DIALLABLE_CHAR_MAPPINGS_ removeNonMatches:YES]; +} + + +/** + * Formats a phone number for out-of-country dialing purposes. If no + * regionCallingFrom is supplied, we format the number in its INTERNATIONAL + * format. If the country calling code is the same as that of the region where + * the number is from, then NATIONAL formatting will be applied. + * + * <p>If the number itself has a country calling code of zero or an otherwise + * invalid country calling code, then we return the number with no formatting + * applied. + * + * <p>Note this function takes care of the case for calling inside of NANPA and + * between Russia and Kazakhstan (who share the same country calling code). In + * those cases, no international prefix is used. For regions which have multiple + * international prefixes, the number in its INTERNATIONAL format will be + * returned instead. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number to be + * formatted. + * @param {string} regionCallingFrom the region where the call is being placed. + * @return {string} the formatted phone number. + */ +- (NSString*)formatOutOfCountryCallingNumber:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom error:(NSError**)error +{ + NSString *res = nil; + @try { + res = [self formatOutOfCountryCallingNumber:number regionCallingFrom:regionCallingFrom]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + + return res; +} + +- (NSString*)formatOutOfCountryCallingNumber:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom +{ + if ([self isValidRegionCode:regionCallingFrom] == NO) + { + return [self format:number numberFormat:NBEPhoneNumberFormatINTERNATIONAL]; + } + + NSNumber *countryCallingCode = number.countryCode; + NSString *nationalSignificantNumber = [self getNationalSignificantNumber:number]; + if ([self hasValidCountryCallingCode:countryCallingCode] == NO) + { + return nationalSignificantNumber; + } + + if ([countryCallingCode isEqualToNumber: @(NANPA_COUNTRY_CODE_)]) + { + if ([self isNANPACountry:regionCallingFrom]) + { + // For NANPA regions, return the national format for these regions but + // prefix it with the country calling code. + return [NSString stringWithFormat:@"%@ %@", countryCallingCode, [self format:number numberFormat:NBEPhoneNumberFormatNATIONAL]]; + } + } + else if ([countryCallingCode isEqualToNumber: [self getCountryCodeForValidRegion:regionCallingFrom]]) + { + // If regions share a country calling code, the country calling code need + // not be dialled. This also applies when dialling within a region, so this + // if clause covers both these cases. Technically this is the case for + // dialling from La Reunion to other overseas departments of France (French + // Guiana, Martinique, Guadeloupe), but not vice versa - so we don't cover + // this edge case for now and for those cases return the version including + // country calling code. Details here: + // http://www.petitfute.com/voyage/225-info-pratiques-reunion + return [self format:number numberFormat:NBEPhoneNumberFormatNATIONAL]; + } + // Metadata cannot be nil because we checked 'isValidRegionCode()' above. + NBPhoneMetaData *metadataForRegionCallingFrom = [self getMetadataForRegion:regionCallingFrom]; + NSString *internationalPrefix = metadataForRegionCallingFrom.internationalPrefix; + + // For regions that have multiple international prefixes, the international + // format of the number is returned, unless there is a preferred international + // prefix. + NSString *internationalPrefixForFormatting = @""; + if ([self matchesEntirely:UNIQUE_INTERNATIONAL_PREFIX_ string:internationalPrefix]) + { + internationalPrefixForFormatting = internationalPrefix; + } + else if ([self hasValue:metadataForRegionCallingFrom.preferredInternationalPrefix]) + { + internationalPrefixForFormatting = metadataForRegionCallingFrom.preferredInternationalPrefix; + } + + NSString *regionCode = [self getRegionCodeForCountryCode:countryCallingCode]; + // Metadata cannot be nil because the country calling code is valid. + NBPhoneMetaData *metadataForRegion = [self getMetadataForRegionOrCallingCode:countryCallingCode regionCode:regionCode]; + NSString *formattedNationalNumber = [self formatNsn:nationalSignificantNumber metadata:metadataForRegion + phoneNumberFormat:NBEPhoneNumberFormatINTERNATIONAL carrierCode:nil]; + NSString *formattedExtension = [self maybeGetFormattedExtension:number metadata:metadataForRegion numberFormat:NBEPhoneNumberFormatINTERNATIONAL]; + + NSString *hasLenth = [NSString stringWithFormat:@"%@ %@ %@%@", internationalPrefixForFormatting, countryCallingCode, formattedNationalNumber, formattedExtension]; + NSString *hasNotLength = [self prefixNumberWithCountryCallingCode:countryCallingCode phoneNumberFormat:NBEPhoneNumberFormatINTERNATIONAL + formattedNationalNumber:formattedNationalNumber formattedExtension:formattedExtension]; + + return internationalPrefixForFormatting.length > 0 ? hasLenth:hasNotLength; +} + + +/** + * A helper function that is used by format and formatByPattern. + * + * @param {number} countryCallingCode the country calling code. + * @param {i18n.phonenumbers.PhoneNumberFormat} numberFormat the format the + * phone number should be formatted into. + * @param {string} formattedNationalNumber + * @param {string} formattedExtension + * @return {string} the formatted phone number. + * @private + */ +- (NSString*)prefixNumberWithCountryCallingCode:(NSNumber*)countryCallingCode phoneNumberFormat:(NBEPhoneNumberFormat)numberFormat + formattedNationalNumber:(NSString*)formattedNationalNumber + formattedExtension:(NSString*)formattedExtension +{ + switch (numberFormat) + { + case NBEPhoneNumberFormatE164: + return [NSString stringWithFormat:@"+%@%@%@", countryCallingCode, formattedNationalNumber, formattedExtension]; + case NBEPhoneNumberFormatINTERNATIONAL: + return [NSString stringWithFormat:@"+%@ %@%@", countryCallingCode, formattedNationalNumber, formattedExtension]; + case NBEPhoneNumberFormatRFC3966: + return [NSString stringWithFormat:@"%@+%@-%@%@", RFC3966_PREFIX_, countryCallingCode, formattedNationalNumber, formattedExtension]; + case NBEPhoneNumberFormatNATIONAL: + default: + return [NSString stringWithFormat:@"%@%@", formattedNationalNumber, formattedExtension]; + } +} + + +/** + * Formats a phone number using the original phone number format that the number + * is parsed from. The original format is embedded in the country_code_source + * field of the PhoneNumber object passed in. If such information is missing, + * the number will be formatted into the NATIONAL format by default. When the + * number contains a leading zero and this is unexpected for this country, or we + * don't have a formatting pattern for the number, the method returns the raw + * input when it is available. + * + * Note this method guarantees no digit will be inserted, removed or modified as + * a result of formatting. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number that needs to + * be formatted in its original number format. + * @param {string} regionCallingFrom the region whose IDD needs to be prefixed + * if the original number has one. + * @return {string} the formatted phone number in its original number format. + */ +- (NSString*)formatInOriginalFormat:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom error:(NSError **)error +{ + NSString *res = nil; + @try { + res = [self formatInOriginalFormat:number regionCallingFrom:regionCallingFrom]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + + return res; +} + + +- (NSString*)formatInOriginalFormat:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom +{ + if ([self hasValue:number.rawInput] && ([self hasUnexpectedItalianLeadingZero:number] || [self hasFormattingPatternForNumber:number] == NO)) + { + // We check if we have the formatting pattern because without that, we might + // format the number as a group without national prefix. + return number.rawInput; + } + + if (number.countryCodeSource == nil) + { + return [self format:number numberFormat:NBEPhoneNumberFormatNATIONAL]; + } + + NSString *formattedNumber = @""; + + switch ([number.countryCodeSource intValue]) + { + case NBECountryCodeSourceFROM_NUMBER_WITH_PLUS_SIGN: + formattedNumber = [self format:number numberFormat:NBEPhoneNumberFormatINTERNATIONAL]; + break; + case NBECountryCodeSourceFROM_NUMBER_WITH_IDD: + formattedNumber = [self formatOutOfCountryCallingNumber:number regionCallingFrom:regionCallingFrom]; + break; + case NBECountryCodeSourceFROM_NUMBER_WITHOUT_PLUS_SIGN: + formattedNumber = [[self format:number numberFormat:NBEPhoneNumberFormatINTERNATIONAL] substringFromIndex:1]; + break; + case NBECountryCodeSourceFROM_DEFAULT_COUNTRY: + // Fall-through to default case. + default: + { + NSString *regionCode = [self getRegionCodeForCountryCode:number.countryCode]; + // We strip non-digits from the NDD here, and from the raw input later, + // so that we can compare them easily. + NSString *nationalPrefix = [self getNddPrefixForRegion:regionCode stripNonDigits:YES]; + NSString *nationalFormat = [self format:number numberFormat:NBEPhoneNumberFormatNATIONAL]; + if (nationalPrefix == nil || nationalPrefix.length == 0) + { + // If the region doesn't have a national prefix at all, we can safely + // return the national format without worrying about a national prefix + // being added. + formattedNumber = nationalFormat; + break; + } + // Otherwise, we check if the original number was entered with a national + // prefix. + if ([self rawInputContainsNationalPrefix:number.rawInput nationalPrefix:nationalPrefix regionCode:regionCode]) + { + // If so, we can safely return the national format. + formattedNumber = nationalFormat; + break; + } + // Metadata cannot be nil here because getNddPrefixForRegion() (above) + // returns nil if there is no metadata for the region. + NBPhoneMetaData *metadata = [self getMetadataForRegion:regionCode]; + NSString *nationalNumber = [self getNationalSignificantNumber:number]; + NBNumberFormat *formatRule = [self chooseFormattingPatternForNumber:metadata.numberFormats nationalNumber:nationalNumber]; + // The format rule could still be nil here if the national number was 0 + // and there was no raw input (this should not be possible for numbers + // generated by the phonenumber library as they would also not have a + // country calling code and we would have exited earlier). + if (formatRule == nil) + { + formattedNumber = nationalFormat; + break; + } + // When the format we apply to this number doesn't contain national + // prefix, we can just return the national format. + // TODO: Refactor the code below with the code in + // isNationalPrefixPresentIfRequired. + NSString *candidateNationalPrefixRule = formatRule.nationalPrefixFormattingRule; + // We assume that the first-group symbol will never be _before_ the + // national prefix. + NSRange firstGroupRange = [candidateNationalPrefixRule rangeOfString:@"$1"]; + if (firstGroupRange.location == NSNotFound) + { + formattedNumber = nationalFormat; + break; + } + + if (firstGroupRange.location <= 0) + { + formattedNumber = nationalFormat; + break; + } + candidateNationalPrefixRule = [candidateNationalPrefixRule substringWithRange:NSMakeRange(0, firstGroupRange.location)]; + candidateNationalPrefixRule = [self normalizeDigitsOnly:candidateNationalPrefixRule]; + if (candidateNationalPrefixRule.length == 0) + { + // National prefix not used when formatting this number. + formattedNumber = nationalFormat; + break; + } + // Otherwise, we need to remove the national prefix from our output. + NBNumberFormat *numFormatCopy = [formatRule copy]; + numFormatCopy.nationalPrefixFormattingRule = nil; + formattedNumber = [self formatByPattern:number numberFormat:NBEPhoneNumberFormatNATIONAL userDefinedFormats:@[numFormatCopy]]; + break; + } + } + + NSString *rawInput = number.rawInput; + // If no digit is inserted/removed/modified as a result of our formatting, we + // return the formatted phone number; otherwise we return the raw input the + // user entered. + if (formattedNumber != nil && rawInput.length > 0) + { + NSString *normalizedFormattedNumber = [self normalizeHelper:formattedNumber normalizationReplacements:_DIALLABLE_CHAR_MAPPINGS_ removeNonMatches:YES]; + /** @type {string} */ + NSString *normalizedRawInput =[self normalizeHelper:rawInput normalizationReplacements:_DIALLABLE_CHAR_MAPPINGS_ removeNonMatches:YES]; + + if ([normalizedFormattedNumber isEqualToString:normalizedRawInput] == NO) + { + formattedNumber = rawInput; + } + } + return formattedNumber; +} + + +/** + * Check if rawInput, which is assumed to be in the national format, has a + * national prefix. The national prefix is assumed to be in digits-only form. + * @param {string} rawInput + * @param {string} nationalPrefix + * @param {string} regionCode + * @return {boolean} + * @private + */ +- (BOOL)rawInputContainsNationalPrefix:(NSString*)rawInput nationalPrefix:(NSString*)nationalPrefix regionCode:(NSString*)regionCode +{ + NSString *normalizedNationalNumber = [self normalizeDigitsOnly:rawInput]; + if ([self isStartingStringByRegex:normalizedNationalNumber regex:nationalPrefix]) + { + @try { + // Some Japanese numbers (e.g. 00777123) might be mistaken to contain the + // national prefix when written without it (e.g. 0777123) if we just do + // prefix matching. To tackle that, we check the validity of the number if + // the assumed national prefix is removed (777123 won't be valid in + // Japan). + NSString *subString = [normalizedNationalNumber substringFromIndex:nationalPrefix.length]; + return [self isValidNumber:[self parse:subString defaultRegion:regionCode]]; + } + @catch (NSException *ex) { + return NO; + } + } + return NO; +} + + +/** + * Returns NO if a number is from a region whose national significant number + * couldn't contain a leading zero, but has the italian_leading_zero field set + * to NO. + * @param {i18n.phonenumbers.PhoneNumber} number + * @return {boolean} + * @private + */ +- (BOOL)hasUnexpectedItalianLeadingZero:(NBPhoneNumber*)number +{ + return number.italianLeadingZero && [self isLeadingZeroPossible:number.countryCode] == NO; +} + + +/** + * @param {i18n.phonenumbers.PhoneNumber} number + * @return {boolean} + * @private + */ +- (BOOL)hasFormattingPatternForNumber:(NBPhoneNumber*)number +{ + NSNumber *countryCallingCode = number.countryCode; + NSString *phoneNumberRegion = [self getRegionCodeForCountryCode:countryCallingCode]; + NBPhoneMetaData *metadata = [self getMetadataForRegionOrCallingCode:countryCallingCode regionCode:phoneNumberRegion]; + + if (metadata == nil) + { + return NO; + } + + NSString *nationalNumber = [self getNationalSignificantNumber:number]; + NBNumberFormat *formatRule = [self chooseFormattingPatternForNumber:metadata.numberFormats nationalNumber:nationalNumber]; + return formatRule != nil; +} + + +/** + * Formats a phone number for out-of-country dialing purposes. + * + * Note that in this version, if the number was entered originally using alpha + * characters and this version of the number is stored in raw_input, this + * representation of the number will be used rather than the digit + * representation. Grouping information, as specified by characters such as '-' + * and ' ', will be retained. + * + * <p><b>Caveats:</b></p> + * <ul> + * <li>This will not produce good results if the country calling code is both + * present in the raw input _and_ is the start of the national number. This is + * not a problem in the regions which typically use alpha numbers. + * <li>This will also not produce good results if the raw input has any grouping + * information within the first three digits of the national number, and if the + * function needs to strip preceding digits/words in the raw input before these + * digits. Normally people group the first three digits together so this is not + * a huge problem - and will be fixed if it proves to be so. + * </ul> + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number that needs to + * be formatted. + * @param {string} regionCallingFrom the region where the call is being placed. + * @return {string} the formatted phone number. + */ +- (NSString*)formatOutOfCountryKeepingAlphaChars:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom error:(NSError **)error +{ + NSString *res = nil; + @try { + res = [self formatOutOfCountryKeepingAlphaChars:number regionCallingFrom:regionCallingFrom]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (NSString*)formatOutOfCountryKeepingAlphaChars:(NBPhoneNumber*)number regionCallingFrom:(NSString*)regionCallingFrom +{ + NSString *rawInput = number.rawInput; + // If there is no raw input, then we can't keep alpha characters because there + // aren't any. In this case, we return formatOutOfCountryCallingNumber. + if (rawInput == nil || rawInput.length == 0) + { + return [self formatOutOfCountryCallingNumber:number regionCallingFrom:regionCallingFrom]; + } + + NSNumber *countryCode = number.countryCode; + if ([self hasValidCountryCallingCode:countryCode] == NO) + { + return rawInput; + } + // Strip any prefix such as country calling code, IDD, that was present. We do + // this by comparing the number in raw_input with the parsed number. To do + // this, first we normalize punctuation. We retain number grouping symbols + // such as ' ' only. + rawInput = [self normalizeHelper:rawInput normalizationReplacements:_ALL_PLUS_NUMBER_GROUPING_SYMBOLS_ removeNonMatches:NO]; + //NSLog(@"---- formatOutOfCountryKeepingAlphaChars normalizeHelper rawInput [%@]", rawInput); + // Now we trim everything before the first three digits in the parsed number. + // We choose three because all valid alpha numbers have 3 digits at the start + // - if it does not, then we don't trim anything at all. Similarly, if the + // national number was less than three digits, we don't trim anything at all. + NSString *nationalNumber = [self getNationalSignificantNumber:number]; + if (nationalNumber.length > 3) + { + NSInteger firstNationalNumberDigit = [self indexOfStringByString:rawInput target:[nationalNumber substringWithRange:NSMakeRange(0, 3)]]; + if (firstNationalNumberDigit != -1) + { + rawInput = [rawInput substringFromIndex:firstNationalNumberDigit]; + } + } + + NBPhoneMetaData *metadataForRegionCallingFrom = [self getMetadataForRegion:regionCallingFrom]; + if ([countryCode isEqualToNumber: @(NANPA_COUNTRY_CODE_)]) + { + if ([self isNANPACountry:regionCallingFrom]) + { + return [NSString stringWithFormat:@"%@ %@", countryCode, rawInput]; + } + } + else if (metadataForRegionCallingFrom != nil && [countryCode isEqualToNumber: [self getCountryCodeForValidRegion:regionCallingFrom]]) + { + NBNumberFormat *formattingPattern = [self chooseFormattingPatternForNumber:metadataForRegionCallingFrom.numberFormats + nationalNumber:nationalNumber]; + if (formattingPattern == nil) + { + // If no pattern above is matched, we format the original input. + return rawInput; + } + + NBNumberFormat *newFormat = [formattingPattern copy]; + // The first group is the first group of digits that the user wrote + // together. + newFormat.pattern = @"(\\d+)(.*)"; + // Here we just concatenate them back together after the national prefix + // has been fixed. + newFormat.format = @"$1$2"; + // Now we format using this pattern instead of the default pattern, but + // with the national prefix prefixed if necessary. + // This will not work in the cases where the pattern (and not the leading + // digits) decide whether a national prefix needs to be used, since we have + // overridden the pattern to match anything, but that is not the case in the + // metadata to date. + + return [self formatNsnUsingPattern:rawInput formattingPattern:newFormat numberFormat:NBEPhoneNumberFormatNATIONAL carrierCode:nil]; + } + + NSString *internationalPrefixForFormatting = @""; + // If an unsupported region-calling-from is entered, or a country with + // multiple international prefixes, the international format of the number is + // returned, unless there is a preferred international prefix. + if (metadataForRegionCallingFrom != nil) + { + NSString *internationalPrefix = metadataForRegionCallingFrom.internationalPrefix; + internationalPrefixForFormatting = + [self matchesEntirely:UNIQUE_INTERNATIONAL_PREFIX_ string:internationalPrefix] ? internationalPrefix : metadataForRegionCallingFrom.preferredInternationalPrefix; + } + + NSString *regionCode = [self getRegionCodeForCountryCode:countryCode]; + // Metadata cannot be nil because the country calling code is valid. + NBPhoneMetaData *metadataForRegion = [self getMetadataForRegionOrCallingCode:countryCode regionCode:regionCode]; + NSString *formattedExtension = [self maybeGetFormattedExtension:number metadata:metadataForRegion numberFormat:NBEPhoneNumberFormatINTERNATIONAL]; + if (internationalPrefixForFormatting.length > 0) + { + return [NSString stringWithFormat:@"%@ %@ %@%@", internationalPrefixForFormatting, countryCode, rawInput, formattedExtension]; + } + else + { + // Invalid region entered as country-calling-from (so no metadata was found + // for it) or the region chosen has multiple international dialling + // prefixes. + return [self prefixNumberWithCountryCallingCode:countryCode phoneNumberFormat:NBEPhoneNumberFormatINTERNATIONAL formattedNationalNumber:rawInput formattedExtension:formattedExtension]; + } +} + + +/** + * Note in some regions, the national number can be written in two completely + * different ways depending on whether it forms part of the NATIONAL format or + * INTERNATIONAL format. The numberFormat parameter here is used to specify + * which format to use for those cases. If a carrierCode is specified, this will + * be inserted into the formatted string to replace $CC. + * + * @param {string} number a string of characters representing a phone number. + * @param {i18n.phonenumbers.PhoneMetadata} metadata the metadata for the + * region that we think this number is from. + * @param {i18n.phonenumbers.PhoneNumberFormat} numberFormat the format the + * phone number should be formatted into. + * @param {string=} opt_carrierCode + * @return {string} the formatted phone number. + * @private + */ +- (NSString*)formatNsn:(NSString*)phoneNumber metadata:(NBPhoneMetaData*)metadata phoneNumberFormat:(NBEPhoneNumberFormat)numberFormat carrierCode:(NSString*)opt_carrierCode +{ + NSMutableArray *intlNumberFormats = metadata.intlNumberFormats; + // When the intlNumberFormats exists, we use that to format national number + // for the INTERNATIONAL format instead of using the numberDesc.numberFormats. + NSArray *availableFormats = ([intlNumberFormats count] <= 0 || numberFormat == NBEPhoneNumberFormatNATIONAL) ? metadata.numberFormats : intlNumberFormats; + NBNumberFormat *formattingPattern = [self chooseFormattingPatternForNumber:availableFormats nationalNumber:phoneNumber]; + + if (formattingPattern == nil) + { + return phoneNumber; + } + + return [self formatNsnUsingPattern:phoneNumber formattingPattern:formattingPattern numberFormat:numberFormat carrierCode:opt_carrierCode]; +} + + +/** + * @param {Array.<i18n.phonenumbers.NumberFormat>} availableFormats the + * available formats the phone number could be formatted into. + * @param {string} nationalNumber a string of characters representing a phone + * number. + * @return {i18n.phonenumbers.NumberFormat} + * @private + */ +- (NBNumberFormat*)chooseFormattingPatternForNumber:(NSArray*)availableFormats nationalNumber:(NSString*)nationalNumber +{ + for (NBNumberFormat *numFormat in availableFormats) + { + NSUInteger size = [numFormat.leadingDigitsPatterns count]; + // We always use the last leading_digits_pattern, as it is the most detailed. + if (size == 0 || [self stringPositionByRegex:nationalNumber regex:[numFormat.leadingDigitsPatterns lastObject]] == 0) + { + if ([self matchesEntirely:numFormat.pattern string:nationalNumber]) + { + return numFormat; + } + } + } + + return nil; +} + + +/** + * Note that carrierCode is optional - if nil or an empty string, no carrier + * code replacement will take place. + * + * @param {string} nationalNumber a string of characters representing a phone + * number. + * @param {i18n.phonenumbers.NumberFormat} formattingPattern the formatting rule + * the phone number should be formatted into. + * @param {i18n.phonenumbers.PhoneNumberFormat} numberFormat the format the + * phone number should be formatted into. + * @param {string=} opt_carrierCode + * @return {string} the formatted phone number. + * @private + */ +- (NSString*)formatNsnUsingPattern:(NSString*)nationalNumber formattingPattern:(NBNumberFormat*)formattingPattern numberFormat:(NBEPhoneNumberFormat)numberFormat carrierCode:(NSString*)opt_carrierCode +{ + NSString *numberFormatRule = formattingPattern.format; + NSString *domesticCarrierCodeFormattingRule = formattingPattern.domesticCarrierCodeFormattingRule; + NSString *formattedNationalNumber = @""; + + if (numberFormat == NBEPhoneNumberFormatNATIONAL && [self hasValue:opt_carrierCode] && domesticCarrierCodeFormattingRule.length > 0) + { + // Replace the $CC in the formatting rule with the desired carrier code. + NSString *carrierCodeFormattingRule = [self replaceStringByRegex:domesticCarrierCodeFormattingRule regex:CC_PATTERN_ withTemplate:opt_carrierCode]; + // Now replace the $FG in the formatting rule with the first group and + // the carrier code combined in the appropriate way. + numberFormatRule = [self replaceFirstStringByRegex:numberFormatRule regex:FIRST_GROUP_PATTERN_ + withTemplate:carrierCodeFormattingRule]; + formattedNationalNumber = [self replaceStringByRegex:nationalNumber regex:formattingPattern.pattern withTemplate:numberFormatRule]; + } + else + { + // Use the national prefix formatting rule instead. + NSString *nationalPrefixFormattingRule = formattingPattern.nationalPrefixFormattingRule; + if (numberFormat == NBEPhoneNumberFormatNATIONAL && [self hasValue:nationalPrefixFormattingRule]) + { + NSString *replacePattern = [self replaceFirstStringByRegex:numberFormatRule regex:FIRST_GROUP_PATTERN_ withTemplate:nationalPrefixFormattingRule]; + formattedNationalNumber = [self replaceStringByRegex:nationalNumber regex:formattingPattern.pattern withTemplate:replacePattern]; + } + else + { + formattedNationalNumber = [self replaceStringByRegex:nationalNumber regex:formattingPattern.pattern withTemplate:numberFormatRule]; + } + } + + if (numberFormat == NBEPhoneNumberFormatRFC3966) + { + // Strip any leading punctuation. + formattedNationalNumber = [self replaceStringByRegex:formattedNationalNumber regex:[NSString stringWithFormat:@"^%@", self.SEPARATOR_PATTERN_] withTemplate:@""]; + + // Replace the rest with a dash between each number group. + formattedNationalNumber = [self replaceStringByRegex:formattedNationalNumber regex:self.SEPARATOR_PATTERN_ withTemplate:@"-"]; + } + return formattedNationalNumber; +} + + +/** + * Gets a valid number for the specified region. + * + * @param {string} regionCode the region for which an example number is needed. + * @return {i18n.phonenumbers.PhoneNumber} a valid fixed-line number for the + * specified region. Returns nil when the metadata does not contain such + * information, or the region 001 is passed in. For 001 (representing non- + * geographical numbers), call {@link #getExampleNumberForNonGeoEntity} + * instead. + */ +- (NBPhoneNumber*)getExampleNumber:(NSString*)regionCode error:(NSError *__autoreleasing *)error +{ + NBPhoneNumber *res = nil; + @try { + res = [self getExampleNumber:regionCode]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (NBPhoneNumber*)getExampleNumber:(NSString*)regionCode +{ + return [self getExampleNumberForType:regionCode type:NBEPhoneNumberTypeFIXED_LINE]; +} + + +/** + * Gets a valid number for the specified region and number type. + * + * @param {string} regionCode the region for which an example number is needed. + * @param {i18n.phonenumbers.PhoneNumberType} type the type of number that is + * needed. + * @return {i18n.phonenumbers.PhoneNumber} a valid number for the specified + * region and type. Returns nil when the metadata does not contain such + * information or if an invalid region or region 001 was entered. + * For 001 (representing non-geographical numbers), call + * {@link #getExampleNumberForNonGeoEntity} instead. + */ +- (NBPhoneNumber*)getExampleNumberForType:(NSString*)regionCode type:(NBEPhoneNumberType)type error:(NSError *__autoreleasing *)error +{ + NBPhoneNumber *res = nil; + @try { + res = [self getExampleNumberForType:regionCode type:type]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (NBPhoneNumber*)getExampleNumberForType:(NSString*)regionCode type:(NBEPhoneNumberType)type +{ + // Check the region code is valid. + if ([self isValidRegionCode:regionCode] == NO) + { + return nil; + } + + NBPhoneNumberDesc *desc = [self getNumberDescByType:[self getMetadataForRegion:regionCode] type:type]; + + @try { + if ([self hasValue:desc.exampleNumber ]) + { + return [self parse:desc.exampleNumber defaultRegion:regionCode]; + } + } + @catch (NSException *e) + { + } + + return nil; +} + + +/** + * Gets a valid number for the specified country calling code for a + * non-geographical entity. + * + * @param {number} countryCallingCode the country calling code for a + * non-geographical entity. + * @return {i18n.phonenumbers.PhoneNumber} a valid number for the + * non-geographical entity. Returns nil when the metadata does not contain + * such information, or the country calling code passed in does not belong + * to a non-geographical entity. + */ +- (NBPhoneNumber*)getExampleNumberForNonGeoEntity:(NSNumber*)countryCallingCode error:(NSError *__autoreleasing *)error +{ + NBPhoneNumber *res = nil; + @try { + res = [self getExampleNumberForNonGeoEntity:countryCallingCode]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (NBPhoneNumber*)getExampleNumberForNonGeoEntity:(NSNumber*)countryCallingCode +{ + NBPhoneMetaData *metadata = [self getMetadataForNonGeographicalRegion:countryCallingCode]; + + if (metadata != nil) + { + NBPhoneNumberDesc *desc = metadata.generalDesc; + @try { + if ([self hasValue:desc.exampleNumber]) + { + NSString *callCode = [NSString stringWithFormat:@"+%@%@", countryCallingCode, desc.exampleNumber]; + return [self parse:callCode defaultRegion:UNKNOWN_REGION_]; + } + } + @catch (NSException *e) { + } + } + return nil; +} + + +/** + * Gets the formatted extension of a phone number, if the phone number had an + * extension specified. If not, it returns an empty string. + * + * @param {i18n.phonenumbers.PhoneNumber} number the PhoneNumber that might have + * an extension. + * @param {i18n.phonenumbers.PhoneMetadata} metadata the metadata for the + * region that we think this number is from. + * @param {i18n.phonenumbers.PhoneNumberFormat} numberFormat the format the + * phone number should be formatted into. + * @return {string} the formatted extension if any. + * @private + */ +- (NSString*)maybeGetFormattedExtension:(NBPhoneNumber*)number metadata:(NBPhoneMetaData*)metadata numberFormat:(NBEPhoneNumberFormat)numberFormat +{ + if ([self hasValue:number.extension] == NO) + { + return @""; + } + else + { + if (numberFormat == NBEPhoneNumberFormatRFC3966) + { + return [NSString stringWithFormat:@"%@%@", RFC3966_EXTN_PREFIX_, number.extension]; + } + else + { + if ([self hasValue:metadata.preferredExtnPrefix]) + { + return [NSString stringWithFormat:@"%@%@", metadata.preferredExtnPrefix, number.extension]; + } + else + { + return [NSString stringWithFormat:@"%@%@", DEFAULT_EXTN_PREFIX_, number.extension]; + } + } + } +} + + +/** + * @param {i18n.phonenumbers.PhoneMetadata} metadata + * @param {i18n.phonenumbers.PhoneNumberType} type + * @return {i18n.phonenumbers.PhoneNumberDesc} + * @private + */ +- (NBPhoneNumberDesc*)getNumberDescByType:(NBPhoneMetaData*)metadata type:(NBEPhoneNumberType)type +{ + switch (type) + { + case NBEPhoneNumberTypePREMIUM_RATE: + return metadata.premiumRate; + case NBEPhoneNumberTypeTOLL_FREE: + return metadata.tollFree; + case NBEPhoneNumberTypeMOBILE: + if (metadata.mobile == nil) return metadata.generalDesc; + return metadata.mobile; + case NBEPhoneNumberTypeFIXED_LINE: + case NBEPhoneNumberTypeFIXED_LINE_OR_MOBILE: + if (metadata.fixedLine == nil) return metadata.generalDesc; + return metadata.fixedLine; + case NBEPhoneNumberTypeSHARED_COST: + return metadata.sharedCost; + case NBEPhoneNumberTypeVOIP: + return metadata.voip; + case NBEPhoneNumberTypePERSONAL_NUMBER: + return metadata.personalNumber; + case NBEPhoneNumberTypePAGER: + return metadata.pager; + case NBEPhoneNumberTypeUAN: + return metadata.uan; + case NBEPhoneNumberTypeVOICEMAIL: + return metadata.voicemail; + default: + return metadata.generalDesc; + } +} + +/** + * Gets the type of a phone number. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number that we want + * to know the type. + * @return {i18n.phonenumbers.PhoneNumberType} the type of the phone number. + */ +- (NBEPhoneNumberType)getNumberType:(NBPhoneNumber*)phoneNumber +{ + NSString *regionCode = [self getRegionCodeForNumber:phoneNumber]; + NBPhoneMetaData *metadata = [self getMetadataForRegionOrCallingCode:phoneNumber.countryCode regionCode:regionCode]; + if (metadata == nil) + { + return NBEPhoneNumberTypeUNKNOWN; + } + + NSString *nationalSignificantNumber = [self getNationalSignificantNumber:phoneNumber]; + return [self getNumberTypeHelper:nationalSignificantNumber metadata:metadata]; +} + + +/** + * @param {string} nationalNumber + * @param {i18n.phonenumbers.PhoneMetadata} metadata + * @return {i18n.phonenumbers.PhoneNumberType} + * @private + */ +- (NBEPhoneNumberType)getNumberTypeHelper:(NSString*)nationalNumber metadata:(NBPhoneMetaData*)metadata +{ + NBPhoneNumberDesc *generalNumberDesc = metadata.generalDesc; + + //NSLog(@"getNumberTypeHelper - UNKNOWN 1"); + if ([self hasValue:generalNumberDesc.nationalNumberPattern] == NO || + [self isNumberMatchingDesc:nationalNumber numberDesc:generalNumberDesc] == NO) + { + //NSLog(@"getNumberTypeHelper - UNKNOWN 2"); + return NBEPhoneNumberTypeUNKNOWN; + } + + //NSLog(@"getNumberTypeHelper - PREMIUM_RATE 1"); + if ([self isNumberMatchingDesc:nationalNumber numberDesc:metadata.premiumRate]) + { + //NSLog(@"getNumberTypeHelper - PREMIUM_RATE 2"); + return NBEPhoneNumberTypePREMIUM_RATE; + } + + //NSLog(@"getNumberTypeHelper - TOLL_FREE 1"); + if ([self isNumberMatchingDesc:nationalNumber numberDesc:metadata.tollFree]) + { + //NSLog(@"getNumberTypeHelper - TOLL_FREE 2"); + return NBEPhoneNumberTypeTOLL_FREE; + } + + //NSLog(@"getNumberTypeHelper - SHARED_COST 1"); + if ([self isNumberMatchingDesc:nationalNumber numberDesc:metadata.sharedCost]) + { + //NSLog(@"getNumberTypeHelper - SHARED_COST 2"); + return NBEPhoneNumberTypeSHARED_COST; + } + + //NSLog(@"getNumberTypeHelper - VOIP 1"); + if ([self isNumberMatchingDesc:nationalNumber numberDesc:metadata.voip]) + { + //NSLog(@"getNumberTypeHelper - VOIP 2"); + return NBEPhoneNumberTypeVOIP; + } + + //NSLog(@"getNumberTypeHelper - PERSONAL_NUMBER 1"); + if ([self isNumberMatchingDesc:nationalNumber numberDesc:metadata.personalNumber]) + { + //NSLog(@"getNumberTypeHelper - PERSONAL_NUMBER 2"); + return NBEPhoneNumberTypePERSONAL_NUMBER; + } + + //NSLog(@"getNumberTypeHelper - PAGER 1"); + if ([self isNumberMatchingDesc:nationalNumber numberDesc:metadata.pager]) + { + //NSLog(@"getNumberTypeHelper - PAGER 2"); + return NBEPhoneNumberTypePAGER; + } + + //NSLog(@"getNumberTypeHelper - UAN 1"); + if ([self isNumberMatchingDesc:nationalNumber numberDesc:metadata.uan]) + { + //NSLog(@"getNumberTypeHelper - UAN 2"); + return NBEPhoneNumberTypeUAN; + } + + //NSLog(@"getNumberTypeHelper - VOICEMAIL 1"); + if ([self isNumberMatchingDesc:nationalNumber numberDesc:metadata.voicemail]) + { + //NSLog(@"getNumberTypeHelper - VOICEMAIL 2"); + return NBEPhoneNumberTypeVOICEMAIL; + } + + if ([self isNumberMatchingDesc:nationalNumber numberDesc:metadata.fixedLine]) + { + if (metadata.sameMobileAndFixedLinePattern) + { + //NSLog(@"getNumberTypeHelper - FIXED_LINE_OR_MOBILE"); + return NBEPhoneNumberTypeFIXED_LINE_OR_MOBILE; + } + else if ([self isNumberMatchingDesc:nationalNumber numberDesc:metadata.mobile]) + { + //NSLog(@"getNumberTypeHelper - FIXED_LINE_OR_MOBILE"); + return NBEPhoneNumberTypeFIXED_LINE_OR_MOBILE; + } + //NSLog(@"getNumberTypeHelper - FIXED_LINE"); + return NBEPhoneNumberTypeFIXED_LINE; + } + + // Otherwise, test to see if the number is mobile. Only do this if certain + // that the patterns for mobile and fixed line aren't the same. + if ([metadata sameMobileAndFixedLinePattern] == NO && [self isNumberMatchingDesc:nationalNumber numberDesc:metadata.mobile]) + { + return NBEPhoneNumberTypeMOBILE; + } + + return NBEPhoneNumberTypeUNKNOWN; +} + + +/** + * Returns the metadata for the given region code or {@code nil} if the region + * code is invalid or unknown. + * + * @param {?string} regionCode + * @return {i18n.phonenumbers.PhoneMetadata} + */ +- (NBPhoneMetaData*)getMetadataForRegion:(NSString*)regionCode +{ + if ([self hasValue:regionCode] == NO) + { + return nil; + } + + regionCode = [regionCode uppercaseString]; + + NBPhoneMetaData *metadata = [self.coreMetaData objectForKey:regionCode]; + + return metadata; +} + + +/** + * @param {number} countryCallingCode + * @return {i18n.phonenumbers.PhoneMetadata} + */ +- (NBPhoneMetaData*)getMetadataForNonGeographicalRegion:(NSNumber*)countryCallingCode +{ + NSString *countryCallingCodeStr = [NSString stringWithFormat:@"%@", countryCallingCode]; + return [self getMetadataForRegion:countryCallingCodeStr]; +} + + +/** + * @param {string} nationalNumber + * @param {i18n.phonenumbers.PhoneNumberDesc} numberDesc + * @return {boolean} + * @private + */ +- (BOOL)isNumberMatchingDesc:(NSString*)nationalNumber numberDesc:(NBPhoneNumberDesc*)numberDesc +{ + if (numberDesc == nil) + return NO; + + if ([self hasValue:numberDesc.possibleNumberPattern] == NO || [numberDesc.possibleNumberPattern isEqual:@"NA"]) + return [self matchesEntirely:numberDesc.nationalNumberPattern string:nationalNumber]; + + if ([self hasValue:numberDesc.nationalNumberPattern] == NO || [numberDesc.nationalNumberPattern isEqual:@"NA"]) + return [self matchesEntirely:numberDesc.possibleNumberPattern string:nationalNumber]; + + return [self matchesEntirely:numberDesc.possibleNumberPattern string:nationalNumber] && + [self matchesEntirely:numberDesc.nationalNumberPattern string:nationalNumber]; +} + + +/** + * Tests whether a phone number matches a valid pattern. Note this doesn't + * verify the number is actually in use, which is impossible to tell by just + * looking at a number itself. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number that we want + * to validate. + * @return {boolean} a boolean that indicates whether the number is of a valid + * pattern. + */ +- (BOOL)isValidNumber:(NBPhoneNumber*)number +{ + NSString *regionCode = [self getRegionCodeForNumber:number]; + return [self isValidNumberForRegion:number regionCode:regionCode]; +} + + +/** + * Tests whether a phone number is valid for a certain region. Note this doesn't + * verify the number is actually in use, which is impossible to tell by just + * looking at a number itself. If the country calling code is not the same as + * the country calling code for the region, this immediately exits with NO. + * After this, the specific number pattern rules for the region are examined. + * This is useful for determining for example whether a particular number is + * valid for Canada, rather than just a valid NANPA number. + * Warning: In most cases, you want to use {@link #isValidNumber} instead. For + * example, this method will mark numbers from British Crown dependencies such + * as the Isle of Man as invalid for the region "GB" (United Kingdom), since it + * has its own region code, "IM", which may be undesirable. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number that we want + * to validate. + * @param {?string} regionCode the region that we want to validate the phone + * number for. + * @return {boolean} a boolean that indicates whether the number is of a valid + * pattern. + */ +- (BOOL)isValidNumberForRegion:(NBPhoneNumber*)number regionCode:(NSString*)regionCode +{ + NSNumber *countryCode = number.countryCode; + + NBPhoneMetaData *metadata = [self getMetadataForRegionOrCallingCode:countryCode regionCode:regionCode]; + if (metadata == nil || + ([_REGION_CODE_FOR_NON_GEO_ENTITY isEqualToString:regionCode] == NO && + ![countryCode isEqualToNumber: [self getCountryCodeForValidRegion:regionCode]])) + { + // Either the region code was invalid, or the country calling code for this + // number does not match that of the region code. + return NO; + } + + NBPhoneNumberDesc *generalNumDesc = metadata.generalDesc; + NSString *nationalSignificantNumber = [self getNationalSignificantNumber:number]; + + // For regions where we don't have metadata for PhoneNumberDesc, we treat any + // number passed in as a valid number if its national significant number is + // between the minimum and maximum lengths defined by ITU for a national + // significant number. + if ([self hasValue:generalNumDesc.nationalNumberPattern] == NO) + { + NSUInteger numberLength = nationalSignificantNumber.length; + return numberLength > MIN_LENGTH_FOR_NSN_ && numberLength <= MAX_LENGTH_FOR_NSN_; + } + + return [self getNumberTypeHelper:nationalSignificantNumber metadata:metadata] != NBEPhoneNumberTypeUNKNOWN; +} + + +/** + * Returns the region where a phone number is from. This could be used for + * geocoding at the region level. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone number whose origin + * we want to know. + * @return {?string} the region where the phone number is from, or nil + * if no region matches this calling code. + */ +- (NSString*)getRegionCodeForNumber:(NBPhoneNumber*)phoneNumber +{ + if (phoneNumber == nil) + { + return nil; + } + + NSArray *regionCodes = [self regionCodeFromCountryCode:phoneNumber.countryCode]; + if (regionCodes == nil || [regionCodes count] <= 0) + { + return nil; + } + + if ([regionCodes count] == 1) + { + return [regionCodes objectAtIndex:0]; + } + else + { + return [self getRegionCodeForNumberFromRegionList:phoneNumber regionCodes:regionCodes]; + } +} + + +/** + * @param {i18n.phonenumbers.PhoneNumber} number + * @param {Array.<string>} regionCodes + * @return {?string} + * @private + + */ +- (NSString*)getRegionCodeForNumberFromRegionList:(NBPhoneNumber*)phoneNumber regionCodes:(NSArray*)regionCodes +{ + NSString *nationalNumber = [self getNationalSignificantNumber:phoneNumber]; + NSUInteger regionCodesCount = [regionCodes count]; + + for (NSUInteger i = 0; i<regionCodesCount; i++) + { + NSString *regionCode = [regionCodes objectAtIndex:i]; + NBPhoneMetaData *metadata = [self getMetadataForRegion:regionCode]; + + if ([self hasValue:metadata.leadingDigits]) + { + if ([self stringPositionByRegex:nationalNumber regex:metadata.leadingDigits] == 0) + { + return regionCode; + } + } + else if ([self getNumberTypeHelper:nationalNumber metadata:metadata] != NBEPhoneNumberTypeUNKNOWN) + { + return regionCode; + } + } + + return nil; +} + + +/** + * Returns the region code that matches the specific country calling code. In + * the case of no region code being found, ZZ will be returned. In the case of + * multiple regions, the one designated in the metadata as the 'main' region for + * this calling code will be returned. + * + * @param {number} countryCallingCode the country calling code. + * @return {string} + */ +- (NSString*)getRegionCodeForCountryCode:(NSNumber*)countryCallingCode +{ + NSArray *regionCodes = [self regionCodeFromCountryCode:countryCallingCode]; + return regionCodes == nil ? UNKNOWN_REGION_ : [regionCodes objectAtIndex:0]; +} + + +/** + * Returns a list with the region codes that match the specific country calling + * code. For non-geographical country calling codes, the region code 001 is + * returned. Also, in the case of no region code being found, an empty list is + * returned. + * + * @param {number} countryCallingCode the country calling code. + * @return {Array.<string>} + */ +- (NSArray*)getRegionCodesForCountryCode:(NSNumber*)countryCallingCode +{ + NSArray *regionCodes = [self regionCodeFromCountryCode:countryCallingCode]; + return regionCodes == nil ? nil : regionCodes; +} + + +/** + * Returns the country calling code for a specific region. For example, this + * would be 1 for the United States, and 64 for New Zealand. + * + * @param {?string} regionCode the region that we want to get the country + * calling code for. + * @return {number} the country calling code for the region denoted by + * regionCode. + */ +- (NSNumber*)getCountryCodeForRegion:(NSString*)regionCode +{ + if ([self isValidRegionCode:regionCode] == NO) + { + return @0; + } + + NSError *error = nil; + NSNumber *res = [self getCountryCodeForValidRegion:regionCode error:&error]; + if (error != nil) + return @0; + return res; +} + + +/** + * Returns the country calling code for a specific region. For example, this + * would be 1 for the United States, and 64 for New Zealand. Assumes the region + * is already valid. + * + * @param {?string} regionCode the region that we want to get the country + * calling code for. + * @return {number} the country calling code for the region denoted by + * regionCode. + * @throws {string} if the region is invalid + * @private + */ +- (NSNumber *)getCountryCodeForValidRegion:(NSString*)regionCode error:(NSError**)error +{ + NSNumber * res = nil; + @try { + res = [self getCountryCodeForValidRegion:regionCode]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + +- (NSNumber *)getCountryCodeForValidRegion:(NSString*)regionCode +{ + NBPhoneMetaData *metadata = [self getMetadataForRegion:regionCode]; + if (metadata == nil) + { + NSException* metaException = [NSException exceptionWithName:@"INVALID_REGION_CODE" + reason:[NSString stringWithFormat:@"Invalid region code:%@", regionCode] + userInfo:nil]; + @throw metaException; + } + return metadata.countryCode; +} + + +/** + * Returns the national dialling prefix for a specific region. For example, this + * would be 1 for the United States, and 0 for New Zealand. Set stripNonDigits + * to NO to strip symbols like '~' (which indicates a wait for a dialling + * tone) from the prefix returned. If no national prefix is present, we return + * nil. + * + * <p>Warning: Do not use this method for do-your-own formatting - for some + * regions, the national dialling prefix is used only for certain types of + * numbers. Use the library's formatting functions to prefix the national prefix + * when required. + * + * @param {?string} regionCode the region that we want to get the dialling + * prefix for. + * @param {boolean} stripNonDigits NO to strip non-digits from the national + * dialling prefix. + * @return {?string} the dialling prefix for the region denoted by + * regionCode. + */ +- (NSString*)getNddPrefixForRegion:(NSString*)regionCode stripNonDigits:(BOOL)stripNonDigits +{ + NBPhoneMetaData *metadata = [self getMetadataForRegion:regionCode]; + if (metadata == nil) + { + return nil; + } + + NSString *nationalPrefix = metadata.nationalPrefix; + // If no national prefix was found, we return nil. + if (nationalPrefix.length == 0) + { + return nil; + } + + if (stripNonDigits) + { + // Note: if any other non-numeric symbols are ever used in national + // prefixes, these would have to be removed here as well. + nationalPrefix = [nationalPrefix stringByReplacingOccurrencesOfString:@"~" withString:@""]; + } + return nationalPrefix; +} + + +/** + * Checks if this is a region under the North American Numbering Plan + * Administration (NANPA). + * + * @param {?string} regionCode the ISO 3166-1 two-letter region code. + * @return {boolean} NO if regionCode is one of the regions under NANPA. + */ +- (BOOL)isNANPACountry:(NSString*)regionCode +{ + BOOL isExists = NO; + + NSArray *res = [self regionCodeFromCountryCode:@(NANPA_COUNTRY_CODE_)]; + for (NSString *inRegionCode in res) + { + if ([inRegionCode isEqualToString:regionCode.uppercaseString]) + { + isExists = YES; + } + } + + return regionCode != nil && isExists; +} + + +/** + * Checks whether countryCode represents the country calling code from a region + * whose national significant number could contain a leading zero. An example of + * such a region is Italy. Returns NO if no metadata for the country is + * found. + * + * @param {number} countryCallingCode the country calling code. + * @return {boolean} + */ +- (BOOL)isLeadingZeroPossible:(NSNumber*)countryCallingCode +{ + NBPhoneMetaData *mainMetadataForCallingCode = [self getMetadataForRegionOrCallingCode:countryCallingCode + regionCode:[self getRegionCodeForCountryCode:countryCallingCode]]; + + return mainMetadataForCallingCode != nil && mainMetadataForCallingCode.leadingZeroPossible; +} + + +/** + * Checks if the number is a valid vanity (alpha) number such as 800 MICROSOFT. + * A valid vanity number will start with at least 3 digits and will have three + * or more alpha characters. This does not do region-specific checks - to work + * out if this number is actually valid for a region, it should be parsed and + * methods such as {@link #isPossibleNumberWithReason} and + * {@link #isValidNumber} should be used. + * + * @param {string} number the number that needs to be checked. + * @return {boolean} NO if the number is a valid vanity number. + */ +- (BOOL)isAlphaNumber:(NSString*)number +{ + if ([self isViablePhoneNumber:number] == NO) + { + // Number is too short, or doesn't match the basic phone number pattern. + return NO; + } + + /** @type {!goog.string.StringBuffer} */ + NSString *strippedNumber = [number copy]; + [self maybeStripExtension:&strippedNumber]; + + return [self matchesEntirely:VALID_ALPHA_PHONE_PATTERN_STRING string:strippedNumber]; +} + + +/** + * Convenience wrapper around {@link #isPossibleNumberWithReason}. Instead of + * returning the reason for failure, this method returns a boolean value. + * + * @param {i18n.phonenumbers.PhoneNumber} number the number that needs to be + * checked. + * @return {boolean} NO if the number is possible. + */ +- (BOOL)isPossibleNumber:(NBPhoneNumber*)number error:(NSError**)error +{ + BOOL res = NO; + @try { + res = [self isPossibleNumber:number]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (BOOL)isPossibleNumber:(NBPhoneNumber*)number +{ + return [self isPossibleNumberWithReason:number] == NBEValidationResultIS_POSSIBLE; +} + + +/** + * 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 {ValidationResult} + * @private + */ +- (NBEValidationResult)testNumberLengthAgainstPattern:(NSString*)numberPattern number:(NSString*)number +{ + if ([self matchesEntirely:numberPattern string:number]) + { + return NBEValidationResultIS_POSSIBLE; + } + + if ([self stringPositionByRegex:number regex:numberPattern] == 0) + { + return NBEValidationResultTOO_LONG; + } + else + { + return NBEValidationResultTOO_SHORT; + } +} + + +/** + * Check whether a phone number is a possible number. It provides a more lenient + * check than {@link #isValidNumber} in the following sense: + * <ol> + * <li>It only checks the length of phone numbers. In particular, it doesn't + * check starting digits of the number. + * <li>It doesn't attempt to figure out the type of the number, but uses general + * rules which applies to all types of phone numbers in a region. Therefore, it + * is much faster than isValidNumber. + * <li>For fixed line numbers, many regions have the concept of area code, which + * together with subscriber number constitute the national significant number. + * It is sometimes okay to dial the subscriber number only when dialing in the + * same area. This function will return NO if the subscriber-number-only + * version is passed in. On the other hand, because isValidNumber validates + * using information on both starting digits (for fixed line numbers, that would + * most likely be area codes) and length (obviously includes the length of area + * codes for fixed line numbers), it will return NO for the + * subscriber-number-only version. + * </ol> + * + * @param {i18n.phonenumbers.PhoneNumber} number the number that needs to be + * checked. + * @return {ValidationResult} a + * ValidationResult object which indicates whether the number is possible. + */ +- (NBEValidationResult)isPossibleNumberWithReason:(NBPhoneNumber*)number error:(NSError *__autoreleasing *)error +{ + NBEValidationResult res = -1; + @try { + res = [self isPossibleNumberWithReason:number]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + + return res; +} + + +- (NBEValidationResult)isPossibleNumberWithReason:(NBPhoneNumber*)number +{ + NSString *nationalNumber = [self getNationalSignificantNumber:number]; + NSNumber *countryCode = number.countryCode; + // Note: For Russian Fed and NANPA numbers, we just use the rules from the + // default region (US or Russia) since the getRegionCodeForNumber will not + // work if the number is possible but not valid. This would need to be + // revisited if the possible number pattern ever differed between various + // regions within those plans. + if ([self hasValidCountryCallingCode:countryCode] == NO) + { + return NBEValidationResultINVALID_COUNTRY_CODE; + } + + NSString *regionCode = [self getRegionCodeForCountryCode:countryCode]; + // Metadata cannot be nil because the country calling code is valid. + NBPhoneMetaData *metadata = [self getMetadataForRegionOrCallingCode:countryCode regionCode:regionCode]; + NBPhoneNumberDesc *generalNumDesc = metadata.generalDesc; + + // Handling case of numbers with no metadata. + if ([self hasValue:generalNumDesc.nationalNumberPattern] == NO) + { + NSUInteger numberLength = nationalNumber.length; + + if (numberLength < MIN_LENGTH_FOR_NSN_) + { + return NBEValidationResultTOO_SHORT; + } + else if (numberLength > MAX_LENGTH_FOR_NSN_) + { + return NBEValidationResultTOO_LONG; + } + else + { + return NBEValidationResultIS_POSSIBLE; + } + } + + NSString *possibleNumberPattern = generalNumDesc.possibleNumberPattern; + return [self testNumberLengthAgainstPattern:possibleNumberPattern number:nationalNumber]; +} + + +/** + * Check whether a phone number is a possible number given a number in the form + * of a string, and the region where the number could be dialed from. It + * provides a more lenient check than {@link #isValidNumber}. See + * {@link #isPossibleNumber} for details. + * + * <p>This method first parses the number, then invokes + * {@link #isPossibleNumber} with the resultant PhoneNumber object. + * + * @param {string} number the number that needs to be checked, in the form of a + * string. + * @param {string} regionDialingFrom the region that we are expecting the number + * to be dialed from. + * Note this is different from the region where the number belongs. + * For example, the number +1 650 253 0000 is a number that belongs to US. + * When written in this form, it can be dialed from any region. When it is + * written as 00 1 650 253 0000, it can be dialed from any region which uses + * an international dialling prefix of 00. When it is written as + * 650 253 0000, it can only be dialed from within the US, and when written + * as 253 0000, it can only be dialed from within a smaller area in the US + * (Mountain View, CA, to be more specific). + * @return {boolean} NO if the number is possible. + */ +- (BOOL)isPossibleNumberString:(NSString*)number regionDialingFrom:(NSString*)regionDialingFrom error:(NSError**)error +{ + BOOL res = NO; + @try { + res = [self isPossibleNumberString:number regionDialingFrom:regionDialingFrom]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (BOOL)isPossibleNumberString:(NSString*)number regionDialingFrom:(NSString*)regionDialingFrom +{ + @try { + return [self isPossibleNumber:[self parse:number defaultRegion:regionDialingFrom]]; + } + @catch (NSException *e) { + return NO; + } +} + + +/** + * Attempts to extract a valid number from a phone number that is too long to be + * valid, and resets the PhoneNumber object passed in to that valid version. If + * no valid number could be extracted, the PhoneNumber object passed in will not + * be modified. + * @param {i18n.phonenumbers.PhoneNumber} number a PhoneNumber object which + * contains a number that is too long to be valid. + * @return {boolean} NO if a valid phone number can be successfully extracted. + */ +- (BOOL)truncateTooLongNumber:(NBPhoneNumber*)number error:(NSError**)error +{ + BOOL res = NO; + @try { + res = [self truncateTooLongNumber:number]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (BOOL)truncateTooLongNumber:(NBPhoneNumber*)number +{ + if ([self isValidNumber:number]) + { + return YES; + } + + NBPhoneNumber *numberCopy = [number copy]; + NSNumber *nationalNumber = number.nationalNumber; + do { + nationalNumber = [NSNumber numberWithLongLong:(long long)floor(nationalNumber.unsignedLongLongValue / 10)]; + numberCopy.nationalNumber = [nationalNumber copy]; + if ([nationalNumber isEqualToNumber:@0] || [self isPossibleNumberWithReason:numberCopy] == NBEValidationResultTOO_SHORT) { + return NO; + } + } + while ([self isValidNumber:numberCopy] == NO); + + number.nationalNumber = nationalNumber; + return YES; +} + + +/** + * Extracts country calling code from fullNumber, returns it and places the + * remaining number in nationalNumber. It assumes that the leading plus sign or + * IDD has already been removed. Returns 0 if fullNumber doesn't start with a + * valid country calling code, and leaves nationalNumber unmodified. + * + * @param {!goog.string.StringBuffer} fullNumber + * @param {!goog.string.StringBuffer} nationalNumber + * @return {number} + */ +- (NSNumber*)extractCountryCode:(NSString*)fullNumber nationalNumber:(NSString**)nationalNumber +{ + if ((fullNumber.length == 0) || ([[fullNumber substringToIndex:1] isEqualToString:@"0"])) + { + // Country codes do not begin with a '0'. + return @0; + } + + NSUInteger numberLength = fullNumber.length; + + for (NSUInteger i = 1; i <= MAX_LENGTH_COUNTRY_CODE_ && i <= numberLength; ++i) + { + NSString *subNumber = [fullNumber substringWithRange:NSMakeRange(0, i)]; + NSNumber *potentialCountryCode = [NSNumber numberWithInteger:[subNumber integerValue]]; + + NSArray *regionCodes = [self regionCodeFromCountryCode:potentialCountryCode]; + if (regionCodes != nil && regionCodes.count > 0) + { + if (nationalNumber != NULL) + { + if ((*nationalNumber) == nil) + (*nationalNumber) = [NSString stringWithFormat:@"%@", [fullNumber substringFromIndex:i]]; + else + (*nationalNumber) = [NSString stringWithFormat:@"%@%@", (*nationalNumber), [fullNumber substringFromIndex:i]]; + } + return potentialCountryCode; + } + } + + return @0; +} + + +/** + * 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 i18n.phonenumbers.Error if the number starts with a '+' but + * the country calling code supplied after this does not match that of any known + * region. + * + * @param {string} number non-normalized telephone number that we wish to + * extract a country calling code from - may begin with '+'. + * @param {i18n.phonenumbers.PhoneMetadata} defaultRegionMetadata metadata + * about the region this number may be from. + * @param {!goog.string.StringBuffer} 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 {boolean} keepRawInput NO if the country_code_source and + * preferred_carrier_code fields of phoneNumber should be populated. + * @param {i18n.phonenumbers.PhoneNumber} 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 NO. + * @return {number} the country calling code extracted or 0 if none could be + * extracted. + * @throws {i18n.phonenumbers.Error} + */ +- (NSNumber*)maybeExtractCountryCode:(NSString*)number metadata:(NBPhoneMetaData*)defaultRegionMetadata + nationalNumber:(NSString**)nationalNumber keepRawInput:(BOOL)keepRawInput + phoneNumber:(NBPhoneNumber**)phoneNumber error:(NSError**)error +{ + if (nationalNumber == NULL || phoneNumber == NULL) + { + return @0; + } + + NSNumber *res = @0; + @try { + res = [self maybeExtractCountryCode:number metadata:defaultRegionMetadata + nationalNumber:nationalNumber keepRawInput:keepRawInput phoneNumber:phoneNumber]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + + return res; +} + +- (NSNumber*)maybeExtractCountryCode:(NSString*)number metadata:(NBPhoneMetaData*)defaultRegionMetadata + nationalNumber:(NSString**)nationalNumber keepRawInput:(BOOL)keepRawInput + phoneNumber:(NBPhoneNumber**)phoneNumber +{ + if (nationalNumber == NULL || phoneNumber == NULL || number.length <= 0) + { + return @0; + } + + NSString *fullNumber = [number copy]; + // Set the default prefix to be something that will never match. + NSString *possibleCountryIddPrefix = @""; + if (defaultRegionMetadata != nil) + { + possibleCountryIddPrefix = defaultRegionMetadata.internationalPrefix; + } + + if (possibleCountryIddPrefix == nil) + { + possibleCountryIddPrefix = @"NonMatch"; + } + + /** @type {i18n.phonenumbers.PhoneNumber.CountryCodeSource} */ + NBECountryCodeSource countryCodeSource = [self maybeStripInternationalPrefixAndNormalize:&fullNumber + possibleIddPrefix:possibleCountryIddPrefix]; + + if (keepRawInput) + { + (*phoneNumber).countryCodeSource = [NSNumber numberWithInt:countryCodeSource]; + } + + if (countryCodeSource != NBECountryCodeSourceFROM_DEFAULT_COUNTRY) + { + if (fullNumber.length <= MIN_LENGTH_FOR_NSN_) + { + @throw [NSException exceptionWithName:@"TOO_SHORT_AFTER_IDD" + reason:[NSString stringWithFormat:@"TOO_SHORT_AFTER_IDD:%@", fullNumber] + userInfo:nil]; + } + + NSNumber *potentialCountryCode = [self extractCountryCode:fullNumber nationalNumber:nationalNumber]; + + if (![potentialCountryCode isEqualToNumber:@0]) + { + (*phoneNumber).countryCode = 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 [NSException exceptionWithName:@"INVALID_COUNTRY_CODE" + reason:[NSString stringWithFormat:@"INVALID_COUNTRY_CODE:%@", potentialCountryCode] + userInfo:nil]; + } + else if (defaultRegionMetadata != nil) + { + // 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. + NSNumber *defaultCountryCode = defaultRegionMetadata.countryCode; + NSString *defaultCountryCodeString = [NSString stringWithFormat:@"%@", defaultCountryCode]; + NSString *normalizedNumber = [fullNumber copy]; + + if ([normalizedNumber hasPrefix:defaultCountryCodeString]) + { + NSString *potentialNationalNumber = [normalizedNumber substringFromIndex:defaultCountryCodeString.length]; + NBPhoneNumberDesc *generalDesc = defaultRegionMetadata.generalDesc; + + NSString *validNumberPattern = generalDesc.nationalNumberPattern; + // Passing null since we don't need the carrier code. + [self maybeStripNationalPrefixAndCarrierCode:&potentialNationalNumber metadata:defaultRegionMetadata carrierCode:nil]; + + NSString *potentialNationalNumberStr = [potentialNationalNumber copy]; + NSString *possibleNumberPattern = 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 ((![self matchesEntirely:validNumberPattern string:fullNumber] && + [self matchesEntirely:validNumberPattern string:potentialNationalNumberStr]) || + [self testNumberLengthAgainstPattern:possibleNumberPattern number:fullNumber] == NBEValidationResultTOO_LONG) + { + (*nationalNumber) = [(*nationalNumber) stringByAppendingString:potentialNationalNumberStr]; + if (keepRawInput) + { + (*phoneNumber).countryCodeSource = [NSNumber numberWithInt:NBECountryCodeSourceFROM_NUMBER_WITHOUT_PLUS_SIGN]; + } + (*phoneNumber).countryCode = defaultCountryCode; + return defaultCountryCode; + } + } + } + // No country calling code present. + (*phoneNumber).countryCode = @0; + return @0; +} + + +/** + * Strips the IDD from the start of the number if present. Helper function used + * by maybeStripInternationalPrefixAndNormalize. + * + * @param {!RegExp} iddPattern the regular expression for the international + * prefix. + * @param {!goog.string.StringBuffer} number the phone number that we wish to + * strip any international dialing prefix from. + * @return {boolean} NO if an international prefix was present. + * @private + */ +- (BOOL)parsePrefixAsIdd:(NSString*)iddPattern sourceString:(NSString**)number +{ + if (number == NULL) + { + return NO; + } + + NSString *numberStr = [(*number) copy]; + + if ([self stringPositionByRegex:numberStr regex:iddPattern] == 0) + { + NSTextCheckingResult *matched = [[self matchesByRegex:numberStr regex:iddPattern] objectAtIndex:0]; + NSString *matchedString = [numberStr substringWithRange:matched.range]; + NSUInteger matchEnd = matchedString.length; + NSString *remainString = [numberStr substringFromIndex:matchEnd]; + + NSRegularExpression *currentPattern = self.CAPTURING_DIGIT_PATTERN; + NSArray *matchedGroups = [currentPattern matchesInString:remainString options:0 range:NSMakeRange(0, remainString.length)]; + + if (matchedGroups && [matchedGroups count] > 0 && [matchedGroups objectAtIndex:0] != nil) + { + NSString *digitMatched = [remainString substringWithRange:((NSTextCheckingResult*)[matchedGroups objectAtIndex:0]).range]; + if (digitMatched.length > 0) + { + NSString *normalizedGroup = [self normalizeDigitsOnly:digitMatched]; + if ([normalizedGroup isEqualToString:@"0"]) { + return NO; + } + } + } + + (*number) = [remainString copy]; + return YES; + } + + return NO; +} + + +/** + * Strips any international prefix (such as +, 00, 011) present in the number + * provided, normalizes the resulting number, and indicates if an international + * prefix was present. + * + * @param {!goog.string.StringBuffer} number the non-normalized telephone number + * that we wish to strip any international dialing prefix from. + * @param {string} possibleIddPrefix the international direct dialing prefix + * from the region we think this number may be dialed in. + * @return {CountryCodeSource} the corresponding + * CountryCodeSource if an international dialing prefix could be removed + * from the number, otherwise CountryCodeSource.FROM_DEFAULT_COUNTRY if + * the number did not seem to be in international format. + */ +- (NBECountryCodeSource)maybeStripInternationalPrefixAndNormalize:(NSString**)numberStr possibleIddPrefix:(NSString*)possibleIddPrefix error:(NSError**)error +{ + if (numberStr == NULL) + { + return 0; + } + + NBECountryCodeSource res = 0; + @try { + res = [self maybeStripInternationalPrefixAndNormalize:numberStr possibleIddPrefix:possibleIddPrefix]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + +- (NBECountryCodeSource)maybeStripInternationalPrefixAndNormalize:(NSString**)numberStr possibleIddPrefix:(NSString*)possibleIddPrefix +{ + if (numberStr == NULL || (*numberStr).length == 0) + { + return NBECountryCodeSourceFROM_DEFAULT_COUNTRY; + } + + // Check to see if the number begins with one or more plus signs. + if ([self isStartingStringByRegex:(*numberStr) regex:self.LEADING_PLUS_CHARS_PATTERN_]) + { + (*numberStr) = [self replaceStringByRegex:(*numberStr) regex:self.LEADING_PLUS_CHARS_PATTERN_ withTemplate:@""]; + // Can now normalize the rest of the number since we've consumed the '+' + // sign at the start. + (*numberStr) = [self normalizePhoneNumber:(*numberStr)]; + return NBECountryCodeSourceFROM_NUMBER_WITH_PLUS_SIGN; + } + + // Attempt to parse the first digits as an international prefix. + NSString *iddPattern = [possibleIddPrefix copy]; + [self normalizeSB:numberStr]; + + return [self parsePrefixAsIdd:iddPattern sourceString:numberStr] ? NBECountryCodeSourceFROM_NUMBER_WITH_IDD : NBECountryCodeSourceFROM_DEFAULT_COUNTRY; +} + + +/** + * Strips any national prefix (such as 0, 1) present in the number provided. + * + * @param {!goog.string.StringBuffer} number the normalized telephone number + * that we wish to strip any national dialing prefix from. + * @param {i18n.phonenumbers.PhoneMetadata} metadata the metadata for the + * region that we think this number is from. + * @param {goog.string.StringBuffer} carrierCode a place to insert the carrier + * code if one is extracted. + * @return {boolean} NO if a national prefix or carrier code (or both) could + * be extracted. + */ +- (BOOL)maybeStripNationalPrefixAndCarrierCode:(NSString**)number metadata:(NBPhoneMetaData*)metadata carrierCode:(NSString**)carrierCode error:(NSError**)error +{ + if (number == NULL) + { + return NO; + } + + BOOL res = NO; + @try { + res = [self maybeStripNationalPrefixAndCarrierCode:number metadata:metadata carrierCode:carrierCode]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + + +- (BOOL)maybeStripNationalPrefixAndCarrierCode:(NSString**)number metadata:(NBPhoneMetaData*)metadata carrierCode:(NSString**)carrierCode +{ + if (number == NULL) + { + return NO; + } + + NSString *numberStr = [(*number) copy]; + NSUInteger numberLength = numberStr.length; + NSString *possibleNationalPrefix = metadata.nationalPrefixForParsing; + + if (numberLength == 0 || [self hasValue:possibleNationalPrefix] == NO) + { + // Early return for numbers of zero length. + return NO; + } + + // Attempt to parse the first digits as a national prefix. + NSString *prefixPattern = [NSString stringWithFormat:@"^(?:%@)", possibleNationalPrefix]; + NSError *error = nil; + NSRegularExpression *currentPattern = [NSRegularExpression regularExpressionWithPattern:prefixPattern + options:0 error:&error]; + + NSArray *prefixMatcher = [currentPattern matchesInString:numberStr options:0 range:NSMakeRange(0, numberLength)]; + if (prefixMatcher && [prefixMatcher count] > 0) + { + NSString *nationalNumberRule = metadata.generalDesc.nationalNumberPattern; + NSTextCheckingResult *firstMatch = [prefixMatcher objectAtIndex:0]; + NSString *firstMatchString = [numberStr substringWithRange:firstMatch.range]; + + // prefixMatcher[numOfGroups] == null implies nothing was captured by the + // capturing groups in possibleNationalPrefix; therefore, no transformation + // is necessary, and we just remove the national prefix. + NSUInteger numOfGroups = firstMatch.numberOfRanges - 1; + NSString *transformRule = metadata.nationalPrefixTransformRule; + NSString *transformedNumber = @""; + NSRange firstRange = [firstMatch rangeAtIndex:numOfGroups]; + NSString *firstMatchStringWithGroup = (firstRange.location != NSNotFound && firstRange.location < numberStr.length) ? [numberStr substringWithRange:firstRange] : nil; + BOOL noTransform = (transformRule == nil || transformRule.length == 0 || [self hasValue:firstMatchStringWithGroup] == NO); + + if (noTransform) + { + transformedNumber = [numberStr substringFromIndex:firstMatchString.length]; + } + else + { + transformedNumber = [self replaceFirstStringByRegex:numberStr regex:prefixPattern withTemplate:transformRule]; + } + // If the original number was viable, and the resultant number is not, + // we return. + if ([self hasValue:nationalNumberRule ] && [self matchesEntirely:nationalNumberRule string:numberStr] && + [self matchesEntirely:nationalNumberRule string:transformedNumber] == NO) + { + return NO; + } + + if ((noTransform && numOfGroups > 0 && [self hasValue:firstMatchStringWithGroup]) || (!noTransform && numOfGroups > 1)) + { + if (carrierCode != NULL && (*carrierCode) != nil) + { + (*carrierCode) = [(*carrierCode) stringByAppendingString:firstMatchStringWithGroup]; + } + } + else if ((noTransform && numOfGroups > 0 && [self hasValue:firstMatchString]) || (!noTransform && numOfGroups > 1)) + { + if (carrierCode != NULL && (*carrierCode) != nil) + { + (*carrierCode) = [(*carrierCode) stringByAppendingString:firstMatchString]; + } + } + + (*number) = transformedNumber; + return YES; + } + return NO; +} + + +/** + * Strips any extension (as in, the part of the number dialled after the call is + * connected, usually indicated with extn, ext, x or similar) from the end of + * the number, and returns it. + * + * @param {!goog.string.StringBuffer} number the non-normalized telephone number + * that we wish to strip the extension from. + * @return {string} the phone extension. + */ +- (NSString*)maybeStripExtension:(NSString**)number +{ + if (number == NULL) + { + return @""; + } + + NSString *numberStr = [(*number) copy]; + NSInteger mStart = [self stringPositionByRegex:numberStr regex:self.EXTN_PATTERN_]; + + // If we find a potential extension, and the number preceding this is a viable + // number, we assume it is an extension. + if (mStart >= 0 && [self isViablePhoneNumber:[numberStr substringWithRange:NSMakeRange(0, mStart)]]) + { + // The numbers are captured into groups in the regular expression. + NSTextCheckingResult *firstMatch = [self matcheFirstByRegex:numberStr regex:self.EXTN_PATTERN_]; + NSUInteger matchedGroupsLength = [firstMatch numberOfRanges]; + for (NSUInteger i=1; i<matchedGroupsLength; i++) + { + NSRange curRange = [firstMatch rangeAtIndex:i]; + if (curRange.location != NSNotFound && curRange.location < numberStr.length) + { + NSString *matchString = [(*number) substringWithRange:curRange]; + // We go through the capturing groups until we find one that captured + // some digits. If none did, then we will return the empty string. + NSString *tokenedString = [numberStr substringWithRange:NSMakeRange(0, mStart)]; + (*number) = @""; + (*number) = [(*number) stringByAppendingString:tokenedString]; + + return matchString; + } + } + } + + return @""; +} + + +/** + * Checks to see that the region code used is valid, or if it is not valid, that + * the number to parse starts with a + symbol so that we can attempt to infer + * the region from the number. + * @param {string} numberToParse number that we are attempting to parse. + * @param {?string} defaultRegion region that we are expecting the number to be + * from. + * @return {boolean} NO if it cannot use the region provided and the region + * cannot be inferred. + * @private + */ +- (BOOL)checkRegionForParsing:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion +{ + // If the number is nil or empty, we can't infer the region. + return [self isValidRegionCode:defaultRegion] || + (numberToParse != nil && numberToParse.length > 0 && [self isStartingStringByRegex:numberToParse regex:self.LEADING_PLUS_CHARS_PATTERN_]); +} + + +/** + * Parses a string and returns it in proto buffer format. This method will throw + * a {@link i18n.phonenumbers.Error} if the number is not considered to be a + * possible number. Note that validation of whether the number is actually a + * valid number for a particular region is not performed. This can be done + * separately with {@link #isValidNumber}. + * + * @param {?string} numberToParse number that we are attempting to parse. This + * can contain formatting such as +, ( and -, as well as a phone number + * extension. It can also be provided in RFC3966 format. + * @param {?string} defaultRegion region that we are expecting the number to be + * from. This is only used if the number being parsed is not written in + * international format. The country_code for the number in this case would + * be stored as that of the default region supplied. If the number is + * guaranteed to start with a '+' followed by the country calling code, then + * 'ZZ' or nil can be supplied. + * @return {i18n.phonenumbers.PhoneNumber} a phone number proto buffer filled + * with the parsed number. + * @throws {i18n.phonenumbers.Error} if the string is not considered to be a + * viable phone number or if no default region was supplied and the number + * is not in international format (does not start with +). + */ +- (NBPhoneNumber*)parse:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion +{ + return [self parseHelper:numberToParse defaultRegion:defaultRegion keepRawInput:NO checkRegion:YES]; +} + + +- (NBPhoneNumber*)parse:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion error:(NSError**)error +{ + NBPhoneNumber *phoneNumber = nil; + + @try { + phoneNumber = [self parseHelper:numberToParse defaultRegion:defaultRegion keepRawInput:NO checkRegion:YES]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + + return phoneNumber; +} + +/** + * Parses a string using the phone's carrier region (when available, ZZ otherwise). + * This uses the country the sim card in the phone is registered with. + * For example if you have an AT&T sim card but are in Europe, this will parse the + * number using +1 (AT&T is a US Carrier) as the default country code. + * This also works for CDMA phones which don't have a sim card. + */ +- (NBPhoneNumber*)parseWithPhoneCarrierRegion:(NSString*)numberToParse error:(NSError**)error +{ + NSString *(^ISOCountryCodeByCarrier)() = ^() { + CTTelephonyNetworkInfo *networkInfo = [[CTTelephonyNetworkInfo alloc] init]; + CTCarrier *carrier = [networkInfo subscriberCellularProvider]; + return [carrier isoCountryCode]; + }; + NSString *isoCode = ISOCountryCodeByCarrier(); + + if (!isoCode) { + isoCode = @"ZZ"; + } + + return [self parse:numberToParse defaultRegion:isoCode]; +} + + +/** + * Parses a string and returns it in proto buffer format. This method differs + * from {@link #parse} in that it always populates the raw_input field of the + * protocol buffer with numberToParse as well as the country_code_source field. + * + * @param {string} numberToParse number that we are attempting to parse. This + * can contain formatting such as +, ( and -, as well as a phone number + * extension. + * @param {?string} defaultRegion region that we are expecting the number to be + * from. This is only used if the number being parsed is not written in + * international format. The country calling code for the number in this + * case would be stored as that of the default region supplied. + * @return {i18n.phonenumbers.PhoneNumber} a phone number proto buffer filled + * with the parsed number. + * @throws {i18n.phonenumbers.Error} if the string is not considered to be a + * viable phone number or if no default region was supplied. + */ +- (NBPhoneNumber*)parseAndKeepRawInput:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion error:(NSError**)error +{ + NBPhoneNumber *res = nil; + @try { + res = [self parseAndKeepRawInput:numberToParse defaultRegion:defaultRegion]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + +- (NBPhoneNumber*)parseAndKeepRawInput:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion +{ + if ([self isValidRegionCode:defaultRegion] == NO) + { + if (numberToParse.length > 0 && [numberToParse hasPrefix:@"+"] == NO) + { + NSException* metaException = [NSException exceptionWithName:@"INVALID_COUNTRY_CODE" + reason:[NSString stringWithFormat:@"Invalid country code:%@", numberToParse] + userInfo:nil]; + @throw metaException; + } + } + return [self parseHelper:numberToParse defaultRegion:defaultRegion keepRawInput:YES checkRegion:YES]; +} + + +/** + * Parses a string and returns it in proto buffer format. This method is the + * same as the public {@link #parse} method, with the exception that it allows + * the default region to be nil, for use by {@link #isNumberMatch}. + * + * @param {?string} numberToParse number that we are attempting to parse. This + * can contain formatting such as +, ( and -, as well as a phone number + * extension. + * @param {?string} defaultRegion region that we are expecting the number to be + * from. This is only used if the number being parsed is not written in + * international format. The country calling code for the number in this + * case would be stored as that of the default region supplied. + * @param {boolean} keepRawInput whether to populate the raw_input field of the + * phoneNumber with numberToParse. + * @param {boolean} checkRegion should be set to NO if it is permitted for + * the default coregion to be nil or unknown ('ZZ'). + * @return {i18n.phonenumbers.PhoneNumber} a phone number proto buffer filled + * with the parsed number. + * @throws {i18n.phonenumbers.Error} + * @private + */ +- (NBPhoneNumber*)parseHelper:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion + keepRawInput:(BOOL)keepRawInput checkRegion:(BOOL)checkRegion error:(NSError**)error +{ + NBPhoneNumber *res = nil; + @try { + res = [self parseHelper:numberToParse defaultRegion:defaultRegion keepRawInput:keepRawInput checkRegion:checkRegion]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + +- (NBPhoneNumber*)parseHelper:(NSString*)numberToParse defaultRegion:(NSString*)defaultRegion + keepRawInput:(BOOL)keepRawInput checkRegion:(BOOL)checkRegion +{ + if (numberToParse == nil) + { + @throw [NSException exceptionWithName:@"NOT_A_NUMBER" reason:[NSString stringWithFormat:@"NOT_A_NUMBER:%@", numberToParse] userInfo:nil]; + } + else if (numberToParse.length > MAX_INPUT_STRING_LENGTH_) + { + @throw [NSException exceptionWithName:@"TOO_LONG" reason:[NSString stringWithFormat:@"TOO_LONG:%@", numberToParse] userInfo:nil]; + } + + NSString *nationalNumber = @""; + [self buildNationalNumberForParsing:numberToParse nationalNumber:&nationalNumber]; + + if ([self isViablePhoneNumber:nationalNumber] == NO) + { + @throw [NSException exceptionWithName:@"NOT_A_NUMBER" reason:[NSString stringWithFormat:@"NOT_A_NUMBER:%@", nationalNumber] userInfo:nil]; + } + + // 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 && [self checkRegionForParsing:nationalNumber defaultRegion:defaultRegion] == NO) + { + @throw [NSException exceptionWithName:@"INVALID_COUNTRY_CODE" reason:[NSString stringWithFormat:@"INVALID_COUNTRY_CODE:%@", defaultRegion] userInfo:nil]; + } + + NBPhoneNumber *phoneNumber = [[NBPhoneNumber alloc] init]; + if (keepRawInput) + { + phoneNumber.rawInput = [numberToParse copy]; + } + // Attempt to parse extension first, since it doesn't require region-specific + // data and we want to have the non-normalised number here. + NSString *extension = [self maybeStripExtension:&nationalNumber]; + if (extension.length > 0) + { + phoneNumber.extension = [extension copy]; + } + + NBPhoneMetaData *regionMetadata = [self 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. + NSString *normalizedNationalNumber = @""; + NSNumber *countryCode = @0; + NSString *nationalNumberStr = [nationalNumber copy]; + @try { + countryCode = [self maybeExtractCountryCode:nationalNumberStr + metadata:regionMetadata + nationalNumber:&normalizedNationalNumber + keepRawInput:keepRawInput + phoneNumber:&phoneNumber]; + } + @catch (NSException *e) { + if ([e.name isEqualToString:@"INVALID_COUNTRY_CODE"] && [self stringPositionByRegex:nationalNumberStr + regex:self.LEADING_PLUS_CHARS_PATTERN_] >= 0) + { + // Strip the plus-char, and try again. + nationalNumberStr = [self replaceStringByRegex:nationalNumberStr regex:self.LEADING_PLUS_CHARS_PATTERN_ withTemplate:@""]; + countryCode = [self maybeExtractCountryCode:nationalNumberStr + metadata:regionMetadata + nationalNumber:&normalizedNationalNumber + keepRawInput:keepRawInput + phoneNumber:&phoneNumber]; + if ([countryCode isEqualToNumber:@0]) + { + @throw [NSException exceptionWithName:e.name + reason:[NSString stringWithFormat:@"%@:%@", e.name, nationalNumberStr] + userInfo:nil]; + } + } + else + { + @throw e; + } + } + + if (![countryCode isEqualToNumber:@0]) + { + NSString *phoneNumberRegion = [self getRegionCodeForCountryCode:countryCode]; + if (phoneNumberRegion != defaultRegion) + { + // Metadata cannot be nil because the country calling code is valid. + regionMetadata = [self getMetadataForRegionOrCallingCode:countryCode regionCode: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. + [self normalizeSB:&nationalNumber]; + normalizedNationalNumber = [normalizedNationalNumber stringByAppendingString:nationalNumber]; + + if (defaultRegion != nil) + { + countryCode = regionMetadata.countryCode; + phoneNumber.countryCode = countryCode; + } + else if (keepRawInput) + { + [phoneNumber clearCountryCodeSource]; + } + } + + if (normalizedNationalNumber.length < MIN_LENGTH_FOR_NSN_) + { + @throw [NSException exceptionWithName:@"TOO_SHORT_NSN" + reason:[NSString stringWithFormat:@"TOO_SHORT_NSN:%@", normalizedNationalNumber] + userInfo:nil]; + } + + if (regionMetadata != nil) + { + NSString *carrierCode = @""; + [self maybeStripNationalPrefixAndCarrierCode:&normalizedNationalNumber metadata:regionMetadata carrierCode:&carrierCode]; + + if (keepRawInput) + { + phoneNumber.PreferredDomesticCarrierCode = [carrierCode copy]; + } + } + + NSString *normalizedNationalNumberStr = [normalizedNationalNumber copy]; + + NSUInteger lengthOfNationalNumber = normalizedNationalNumberStr.length; + if (lengthOfNationalNumber < MIN_LENGTH_FOR_NSN_) + { + @throw [NSException exceptionWithName:@"TOO_SHORT_NSN" + reason:[NSString stringWithFormat:@"TOO_SHORT_NSN:%@", normalizedNationalNumberStr] + userInfo:nil]; + } + + if (lengthOfNationalNumber > MAX_LENGTH_FOR_NSN_) + { + @throw [NSException exceptionWithName:@"TOO_LONG" + reason:[NSString stringWithFormat:@"TOO_LONG:%@", normalizedNationalNumberStr] + userInfo:nil]; + } + + if ([normalizedNationalNumberStr hasPrefix:@"0"]) + { + phoneNumber.italianLeadingZero = YES; + } + + phoneNumber.nationalNumber = [NSNumber numberWithLongLong:(UInt64)[normalizedNationalNumberStr longLongValue]]; + return phoneNumber; +} + + +/** + * Converts numberToParse to a form that we can parse and write it to + * nationalNumber if it is written in RFC3966; otherwise extract a possible + * number out of it and write to nationalNumber. + * + * @param {?string} numberToParse number that we are attempting to parse. This + * can contain formatting such as +, ( and -, as well as a phone number + * extension. + * @param {!goog.string.StringBuffer} nationalNumber a string buffer for storing + * the national significant number. + * @private + */ +- (void)buildNationalNumberForParsing:(NSString*)numberToParse nationalNumber:(NSString**)nationalNumber +{ + if (nationalNumber == NULL) + return; + + NSInteger indexOfPhoneContext = [self indexOfStringByString:numberToParse target:RFC3966_PHONE_CONTEXT_]; + if (indexOfPhoneContext > 0) + { + NSUInteger phoneContextStart = indexOfPhoneContext + RFC3966_PHONE_CONTEXT_.length; + // If the phone context contains a phone number prefix, we need to capture + // it, whereas domains will be ignored. + if ([numberToParse characterAtIndex:phoneContextStart] == '+') + { + // Additional parameters might follow the phone context. If so, we will + // remove them here because the parameters after phone context are not + // important for parsing the phone number. + NSRange foundRange = [numberToParse rangeOfString:@";" options:NSLiteralSearch range:NSMakeRange(phoneContextStart, numberToParse.length - phoneContextStart)]; + if (foundRange.location != NSNotFound) + { + NSRange subRange = NSMakeRange(phoneContextStart, foundRange.location - phoneContextStart); + (*nationalNumber) = [(*nationalNumber) stringByAppendingString:[numberToParse substringWithRange:subRange]]; + } + else + { + (*nationalNumber) = [(*nationalNumber) stringByAppendingString:[numberToParse substringFromIndex:phoneContextStart]]; + } + } + + // Now append everything between the "tel:" prefix and the phone-context. + // This should include the national number, an optional extension or + // isdn-subaddress component. + NSUInteger rfc3966Start = [self indexOfStringByString:numberToParse target:RFC3966_PREFIX_] + RFC3966_PREFIX_.length; + NSString *subString = [numberToParse substringWithRange:NSMakeRange(rfc3966Start, indexOfPhoneContext - rfc3966Start)]; + (*nationalNumber) = [(*nationalNumber) stringByAppendingString:subString]; + } + else + { + // Extract a possible number from the string passed in (this strips leading + // characters that could not be the start of a phone number.) + (*nationalNumber) = [(*nationalNumber) stringByAppendingString:[self extractPossibleNumber:numberToParse]]; + } + + // Delete the isdn-subaddress and everything after it if it is present. + // Note extension won't appear at the same time with isdn-subaddress + // according to paragraph 5.3 of the RFC3966 spec, + NSString *nationalNumberStr = [(*nationalNumber) copy]; + NSInteger indexOfIsdn = [self indexOfStringByString:nationalNumberStr target:RFC3966_ISDN_SUBADDRESS_]; + if (indexOfIsdn > 0) + { + (*nationalNumber) = @""; + (*nationalNumber) = [(*nationalNumber) stringByAppendingString:[nationalNumberStr substringWithRange:NSMakeRange(0, indexOfIsdn)]]; + } + // If both phone context and isdn-subaddress are absent but other + // parameters are present, the parameters are left in nationalNumber. This + // is because we are concerned about deleting content from a potential + // number string when there is no strong evidence that the number is + // actually written in RFC3966. +} + + +/** + * Takes two phone numbers and compares them for equality. + * + * <p>Returns EXACT_MATCH if the country_code, NSN, presence of a leading zero + * for Italian numbers and any extension present are the same. Returns NSN_MATCH + * if either or both has no region specified, and the NSNs and extensions are + * the same. Returns SHORT_NSN_MATCH if either or both has no region specified, + * or the region specified is the same, and one NSN could be a shorter version + * of the other number. This includes the case where one has an extension + * specified, and the other does not. Returns NO_MATCH otherwise. For example, + * the numbers +1 345 657 1234 and 657 1234 are a SHORT_NSN_MATCH. The numbers + * +1 345 657 1234 and 345 657 are a NO_MATCH. + * + * @param {i18n.phonenumbers.PhoneNumber|string} firstNumberIn first number to + * compare. If it is a string it can contain formatting, and can have + * country calling code specified with + at the start. + * @param {i18n.phonenumbers.PhoneNumber|string} secondNumberIn second number to + * compare. If it is a string it can contain formatting, and can have + * country calling code specified with + at the start. + * @return {MatchType} NOT_A_NUMBER, NO_MATCH, + * SHORT_NSN_MATCH, NSN_MATCH or EXACT_MATCH depending on the level of + * equality of the two numbers, described in the method definition. + */ +- (NBEMatchType)isNumberMatch:(id)firstNumberIn second:(id)secondNumberIn error:(NSError**)error +{ + NBEMatchType res = 0; + @try { + res = [self isNumberMatch:firstNumberIn second:secondNumberIn]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + +- (NBEMatchType)isNumberMatch:(id)firstNumberIn second:(id)secondNumberIn +{ + + // If the input arguements are strings parse them to a proto buffer format. + // Else make copies of the phone numbers so that the numbers passed in are not + // edited. + /** @type {i18n.phonenumbers.PhoneNumber} */ + NBPhoneNumber *firstNumber = nil, *secondNumber = nil; + if ([firstNumberIn isKindOfClass:[NSString class]]) + { + // First see if the first number has an implicit country calling code, by + // attempting to parse it. + @try { + firstNumber = [self parse:firstNumberIn defaultRegion:UNKNOWN_REGION_]; + } + @catch (NSException *e) { + if ([e.name isEqualToString:@"INVALID_COUNTRY_CODE"] == NO) + { + return NBEMatchTypeNOT_A_NUMBER; + } + // The first number has no country calling code. EXACT_MATCH is no longer + // possible. We parse it as if the region was the same as that for the + // second number, and if EXACT_MATCH is returned, we replace this with + // NSN_MATCH. + if ([secondNumberIn isKindOfClass:[NSString class]] == NO) + { + NSString *secondNumberRegion = [self getRegionCodeForCountryCode:((NBPhoneNumber*)secondNumberIn).countryCode]; + if (secondNumberRegion != UNKNOWN_REGION_) + { + @try { + firstNumber = [self parse:firstNumberIn defaultRegion:secondNumberRegion]; + } + @catch (NSException *e2) { + return NBEMatchTypeNOT_A_NUMBER; + } + + NBEMatchType match = [self isNumberMatch:firstNumber second:secondNumberIn]; + if (match == NBEMatchTypeEXACT_MATCH) + { + return NBEMatchTypeNSN_MATCH; + } + return match; + } + } + // If the second number is a string or doesn't have a valid country + // calling code, we parse the first number without country calling code. + @try { + firstNumber = [self parseHelper:firstNumberIn defaultRegion:nil keepRawInput:NO checkRegion:NO]; + } + @catch (NSException *e2) { + return NBEMatchTypeNOT_A_NUMBER; + } + } + } + else + { + firstNumber = [firstNumberIn copy]; + } + + if ([secondNumberIn isKindOfClass:[NSString class]]) + { + @try { + secondNumber = [self parse:secondNumberIn defaultRegion:UNKNOWN_REGION_]; + return [self isNumberMatch:firstNumberIn second:secondNumber]; + } + @catch (NSException *e2) { + if ([e2.name isEqualToString:@"INVALID_COUNTRY_CODE"] == NO) + { + return NBEMatchTypeNOT_A_NUMBER; + } + return [self isNumberMatch:secondNumberIn second:firstNumber]; + } + } + else + { + secondNumber = [secondNumberIn copy]; + } + + // First clear raw_input, country_code_source and + // preferred_domestic_carrier_code fields and any empty-string extensions so + // that we can use the proto-buffer equality method. + firstNumber.rawInput = @""; + [firstNumber clearCountryCodeSource]; + firstNumber.PreferredDomesticCarrierCode = @""; + + secondNumber.rawInput = @""; + [secondNumber clearCountryCodeSource]; + secondNumber.PreferredDomesticCarrierCode = @""; + + if (firstNumber.extension != nil && firstNumber.extension.length == 0) + { + firstNumber.extension = nil; + } + + if (secondNumber.extension != nil && secondNumber.extension.length == 0) + { + secondNumber.extension = nil; + } + + // Early exit if both had extensions and these are different. + if ([self hasValue:firstNumber.extension] && [self hasValue:secondNumber.extension] && + [firstNumber.extension isEqualToString:secondNumber.extension] == NO) + { + return NBEMatchTypeNO_MATCH; + } + + NSNumber *firstNumberCountryCode = firstNumber.countryCode; + NSNumber *secondNumberCountryCode = secondNumber.countryCode; + + // Both had country_code specified. + if (![firstNumberCountryCode isEqualToNumber:@0] && ![secondNumberCountryCode isEqualToNumber:@0]) + { + if ([firstNumber isEqual:secondNumber]) + { + return NBEMatchTypeEXACT_MATCH; + } + else if ([firstNumberCountryCode isEqualToNumber:secondNumberCountryCode] && [self isNationalNumberSuffixOfTheOther:firstNumber second:secondNumber]) + { + // A SHORT_NSN_MATCH occurs if there is a difference because of the + // presence or absence of an 'Italian leading zero', the presence or + // absence of an extension, or one NSN being a shorter variant of the + // other. + return NBEMatchTypeSHORT_NSN_MATCH; + } + // This is not a match. + return NBEMatchTypeNO_MATCH; + } + // Checks cases where one or both country_code fields were not specified. To + // make equality checks easier, we first set the country_code fields to be + // equal. + firstNumber.countryCode = @0; + secondNumber.countryCode = @0; + // If all else was the same, then this is an NSN_MATCH. + if ([firstNumber isEqual:secondNumber]) + { + return NBEMatchTypeNSN_MATCH; + } + + if ([self isNationalNumberSuffixOfTheOther:firstNumber second:secondNumber]) + { + return NBEMatchTypeSHORT_NSN_MATCH; + } + return NBEMatchTypeNO_MATCH; +} + + +/** + * Returns NO when one national number is the suffix of the other or both are + * the same. + * + * @param {i18n.phonenumbers.PhoneNumber} firstNumber the first PhoneNumber + * object. + * @param {i18n.phonenumbers.PhoneNumber} secondNumber the second PhoneNumber + * object. + * @return {boolean} NO if one PhoneNumber is the suffix of the other one. + * @private + */ +- (BOOL)isNationalNumberSuffixOfTheOther:(NBPhoneNumber*)firstNumber second:(NBPhoneNumber*)secondNumber +{ + NSString *firstNumberNationalNumber = [NSString stringWithFormat:@"%@", firstNumber.nationalNumber]; + NSString *secondNumberNationalNumber = [NSString stringWithFormat:@"%@", secondNumber.nationalNumber]; + + // Note that endsWith returns NO if the numbers are equal. + return [firstNumberNationalNumber hasSuffix:secondNumberNationalNumber] || + [secondNumberNationalNumber hasSuffix:firstNumberNationalNumber]; +} + + +/** + * Returns NO if the number can be dialled from outside the region, or + * unknown. If the number can only be dialled from within the region, returns + * NO. Does not check the number is a valid number. + * TODO: Make this method public when we have enough metadata to make it + * worthwhile. Currently visible for testing purposes only. + * + * @param {i18n.phonenumbers.PhoneNumber} number the phone-number for which we + * want to know whether it is diallable from outside the region. + * @return {boolean} NO if the number can only be dialled from within the + * country. + */ +- (BOOL)canBeInternationallyDialled:(NBPhoneNumber*)number error:(NSError**)error +{ + BOOL res = NO; + @try { + res = [self canBeInternationallyDialled:number]; + } + @catch (NSException *exception) { + NSDictionary *userInfo = [NSDictionary dictionaryWithObject:exception.reason + forKey:NSLocalizedDescriptionKey]; + if (error != NULL) + (*error) = [NSError errorWithDomain:exception.name code:0 userInfo:userInfo]; + } + return res; +} + +- (BOOL)canBeInternationallyDialled:(NBPhoneNumber*)number +{ + NBPhoneMetaData *metadata = [self getMetadataForRegion:[self getRegionCodeForNumber:number]]; + if (metadata == nil) + { + // Note numbers belonging to non-geographical entities (e.g. +800 numbers) + // are always internationally diallable, and will be caught here. + return YES; + } + NSString *nationalSignificantNumber = [self getNationalSignificantNumber:number]; + return [self isNumberMatchingDesc:nationalSignificantNumber numberDesc:metadata.noInternationalDialling] == NO; +} + + +/** + * Check whether the entire input sequence can be matched against the regular + * expression. + * + * @param {!RegExp|string} regex the regular expression to match against. + * @param {string} str the string to test. + * @return {boolean} NO if str can be matched entirely against regex. + * @private + */ +- (BOOL)matchesEntirely:(NSString*)regex string:(NSString*)str +{ + if ([regex rangeOfString:@"^"].location == NSNotFound) + { + regex = [NSString stringWithFormat:@"^(?:%@)$", regex]; + } + + NSError *error = nil; + NSRegularExpression *currentPattern = [NSRegularExpression regularExpressionWithPattern:regex options:0 error:&error]; + NSTextCheckingResult *matchResult = [currentPattern firstMatchInString:str options:0 range:NSMakeRange(0, str.length)]; + + if (matchResult != nil) + { + NSString *founds = [str substringWithRange:matchResult.range]; + + if ([founds isEqualToString:str]) + { + return YES; + } + } + + return NO; +} + + +@end