_ZN4i18n12phonenumbers10scoped_ptrIKNS0_21AbstractRegExpFactoryENS0_14DefaultDeleterIS3_EEEC2EPS3_: 225| 2| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIKNS0_21AbstractRegExpFactoryENS0_14DefaultDeleterIS3_EEEC2EPS3_: 101| 2| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIKNS0_21AbstractRegExpFactoryENS0_14DefaultDeleterIS3_EEE4DataC2EPS3_: 188| 2| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterIKNS0_21AbstractRegExpFactoryEEC2Ev: 35| 2| DefaultDeleter() {} _ZNK4i18n12phonenumbers10scoped_ptrIKNS0_21AbstractRegExpFactoryENS0_14DefaultDeleterIS3_EEE3getEv: 276| 1| element_type* get() const { return impl_.get(); } _ZNK4i18n12phonenumbers15scoped_ptr_implIKNS0_21AbstractRegExpFactoryENS0_14DefaultDeleterIS3_EEE3getEv: 159| 1.57M| T* get() const { return data_.ptr; } _ZN4i18n12phonenumbers10scoped_ptrINS0_11RegExpCacheENS0_14DefaultDeleterIS2_EEEC2EPS2_: 225| 2| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINS0_11RegExpCacheENS0_14DefaultDeleterIS2_EEEC2EPS2_: 101| 2| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINS0_11RegExpCacheENS0_14DefaultDeleterIS2_EEE4DataC2EPS2_: 188| 2| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterINS0_11RegExpCacheEEC2Ev: 35| 2| DefaultDeleter() {} _ZN4i18n12phonenumbers10scoped_ptrIKNS0_6RegExpENS0_14DefaultDeleterIS3_EEEC2EPS3_: 225| 14| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIKNS0_6RegExpENS0_14DefaultDeleterIS3_EEEC2EPS3_: 101| 14| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIKNS0_6RegExpENS0_14DefaultDeleterIS3_EEE4DataC2EPS3_: 188| 14| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterIKNS0_6RegExpEEC2Ev: 35| 14| DefaultDeleter() {} _ZN4i18n12phonenumbers15scoped_ptr_implINS0_11RegExpInputENS0_14DefaultDeleterIS2_EEED2Ev: 125| 786k| ~scoped_ptr_impl() { 126| 786k| if (data_.ptr != NULL) { ------------------ | Branch (126:9): [True: 786k, False: 0] ------------------ 127| | // Not using get_deleter() saves one function call in non-optimized 128| | // builds. 129| 786k| static_cast(data_)(data_.ptr); 130| 786k| } 131| 786k| } _ZNK4i18n12phonenumbers14DefaultDeleterINS0_11RegExpInputEEclEPS2_: 54| 786k| inline void operator()(T* ptr) const { 55| 786k| enum { type_must_be_complete = sizeof(T) }; 56| 786k| delete ptr; 57| 786k| } _ZNK4i18n12phonenumbers10scoped_ptrINS0_6LoggerENS0_14DefaultDeleterIS2_EEE3getEv: 276| 1| element_type* get() const { return impl_.get(); } _ZNK4i18n12phonenumbers15scoped_ptr_implINS0_6LoggerENS0_14DefaultDeleterIS2_EEE3getEv: 159| 1| T* get() const { return data_.ptr; } _ZNK4i18n12phonenumbers10scoped_ptrIKNS0_21AbstractRegExpFactoryENS0_14DefaultDeleterIS3_EEEptEv: 272| 786k| element_type* operator->() const { 273| 786k| assert(impl_.get() != NULL); 274| 786k| return impl_.get(); 275| 786k| } _ZN4i18n12phonenumbers10scoped_ptrINS0_6LoggerENS0_14DefaultDeleterIS2_EEEC2EPS2_: 225| 1| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINS0_6LoggerENS0_14DefaultDeleterIS2_EEEC2EPS2_: 101| 1| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINS0_6LoggerENS0_14DefaultDeleterIS2_EEE4DataC2EPS2_: 188| 1| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterINS0_6LoggerEEC2Ev: 35| 1| DefaultDeleter() {} _ZN4i18n12phonenumbers10scoped_ptrINS0_10MatcherApiENS0_14DefaultDeleterIS2_EEEC2EPS2_: 225| 1| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINS0_10MatcherApiENS0_14DefaultDeleterIS2_EEEC2EPS2_: 101| 1| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINS0_10MatcherApiENS0_14DefaultDeleterIS2_EEE4DataC2EPS2_: 188| 1| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterINS0_10MatcherApiEEC2Ev: 35| 1| DefaultDeleter() {} _ZN4i18n12phonenumbers10scoped_ptrINS0_29PhoneNumberRegExpsAndMappingsENS0_14DefaultDeleterIS2_EEEC2EPS2_: 225| 1| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINS0_29PhoneNumberRegExpsAndMappingsENS0_14DefaultDeleterIS2_EEEC2EPS2_: 101| 1| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINS0_29PhoneNumberRegExpsAndMappingsENS0_14DefaultDeleterIS2_EEE4DataC2EPS2_: 188| 1| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterINS0_29PhoneNumberRegExpsAndMappingsEEC2Ev: 35| 1| DefaultDeleter() {} _ZN4i18n12phonenumbers10scoped_ptrINSt3__16vectorINS2_4pairIiPNS2_4listINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS9_ISB_EEEEEENS9_ISF_EEEENS0_14DefaultDeleterISH_EEEC2EPSH_: 225| 1| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINSt3__16vectorINS2_4pairIiPNS2_4listINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS9_ISB_EEEEEENS9_ISF_EEEENS0_14DefaultDeleterISH_EEEC2EPSH_: 101| 1| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINSt3__16vectorINS2_4pairIiPNS2_4listINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS9_ISB_EEEEEENS9_ISF_EEEENS0_14DefaultDeleterISH_EEE4DataC2EPSH_: 188| 1| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterINSt3__16vectorINS2_4pairIiPNS2_4listINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS9_ISB_EEEEEENS9_ISF_EEEEEC2Ev: 35| 1| DefaultDeleter() {} _ZN4i18n12phonenumbers10scoped_ptrIN4absl12lts_2022062313node_hash_setINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS3_18container_internal10StringHashENSC_8StringEqENS9_ISB_EEEENS0_14DefaultDeleterISG_EEEC2EPSG_: 225| 1| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIN4absl12lts_2022062313node_hash_setINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS3_18container_internal10StringHashENSC_8StringEqENS9_ISB_EEEENS0_14DefaultDeleterISG_EEEC2EPSG_: 101| 1| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIN4absl12lts_2022062313node_hash_setINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS3_18container_internal10StringHashENSC_8StringEqENS9_ISB_EEEENS0_14DefaultDeleterISG_EEE4DataC2EPSG_: 188| 1| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterIN4absl12lts_2022062313node_hash_setINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS3_18container_internal10StringHashENSC_8StringEqENS9_ISB_EEEEEC2Ev: 35| 1| DefaultDeleter() {} _ZN4i18n12phonenumbers10scoped_ptrIN4absl12lts_2022062313node_hash_mapINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_13PhoneMetadataENS3_18container_internal10StringHashENSD_8StringEqENS9_INS5_4pairIKSB_SC_EEEEEENS0_14DefaultDeleterISK_EEEC2EPSK_: 225| 1| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIN4absl12lts_2022062313node_hash_mapINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_13PhoneMetadataENS3_18container_internal10StringHashENSD_8StringEqENS9_INS5_4pairIKSB_SC_EEEEEENS0_14DefaultDeleterISK_EEEC2EPSK_: 101| 1| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIN4absl12lts_2022062313node_hash_mapINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_13PhoneMetadataENS3_18container_internal10StringHashENSD_8StringEqENS9_INS5_4pairIKSB_SC_EEEEEENS0_14DefaultDeleterISK_EEE4DataC2EPSK_: 188| 1| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterIN4absl12lts_2022062313node_hash_mapINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_13PhoneMetadataENS3_18container_internal10StringHashENSD_8StringEqENS9_INS5_4pairIKSB_SC_EEEEEEEC2Ev: 35| 1| DefaultDeleter() {} _ZN4i18n12phonenumbers10scoped_ptrIN4absl12lts_2022062313node_hash_mapIiNS0_13PhoneMetadataENS3_13hash_internal4HashIiEENSt3__18equal_toIiEENS9_9allocatorINS9_4pairIKiS5_EEEEEENS0_14DefaultDeleterISH_EEEC2EPSH_: 225| 1| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIN4absl12lts_2022062313node_hash_mapIiNS0_13PhoneMetadataENS3_13hash_internal4HashIiEENSt3__18equal_toIiEENS9_9allocatorINS9_4pairIKiS5_EEEEEENS0_14DefaultDeleterISH_EEEC2EPSH_: 101| 1| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIN4absl12lts_2022062313node_hash_mapIiNS0_13PhoneMetadataENS3_13hash_internal4HashIiEENSt3__18equal_toIiEENS9_9allocatorINS9_4pairIKiS5_EEEEEENS0_14DefaultDeleterISH_EEE4DataC2EPSH_: 188| 1| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterIN4absl12lts_2022062313node_hash_mapIiNS0_13PhoneMetadataENS3_13hash_internal4HashIiEENSt3__18equal_toIiEENS9_9allocatorINS9_4pairIKiS5_EEEEEEEC2Ev: 35| 1| DefaultDeleter() {} _ZNK4i18n12phonenumbers10scoped_ptrIN4absl12lts_2022062313node_hash_mapIiNS0_13PhoneMetadataENS3_13hash_internal4HashIiEENSt3__18equal_toIiEENS9_9allocatorINS9_4pairIKiS5_EEEEEENS0_14DefaultDeleterISH_EEEptEv: 272| 34.1k| element_type* operator->() const { 273| 34.1k| assert(impl_.get() != NULL); 274| 34.1k| return impl_.get(); 275| 34.1k| } _ZNK4i18n12phonenumbers15scoped_ptr_implIN4absl12lts_2022062313node_hash_mapIiNS0_13PhoneMetadataENS3_13hash_internal4HashIiEENSt3__18equal_toIiEENS9_9allocatorINS9_4pairIKiS5_EEEEEENS0_14DefaultDeleterISH_EEE3getEv: 159| 68.3k| T* get() const { return data_.ptr; } _ZNK4i18n12phonenumbers10scoped_ptrIN4absl12lts_2022062313node_hash_mapINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_13PhoneMetadataENS3_18container_internal10StringHashENSD_8StringEqENS9_INS5_4pairIKSB_SC_EEEEEENS0_14DefaultDeleterISK_EEEptEv: 272| 3.98M| element_type* operator->() const { 273| 3.98M| assert(impl_.get() != NULL); 274| 3.98M| return impl_.get(); 275| 3.98M| } _ZNK4i18n12phonenumbers15scoped_ptr_implIN4absl12lts_2022062313node_hash_mapINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS0_13PhoneMetadataENS3_18container_internal10StringHashENSD_8StringEqENS9_INS5_4pairIKSB_SC_EEEEEENS0_14DefaultDeleterISK_EEE3getEv: 159| 7.96M| T* get() const { return data_.ptr; } _ZNK4i18n12phonenumbers10scoped_ptrIN4absl12lts_2022062313node_hash_setINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS3_18container_internal10StringHashENSC_8StringEqENS9_ISB_EEEENS0_14DefaultDeleterISG_EEEptEv: 272| 20.9k| element_type* operator->() const { 273| 20.9k| assert(impl_.get() != NULL); 274| 20.9k| return impl_.get(); 275| 20.9k| } _ZNK4i18n12phonenumbers15scoped_ptr_implIN4absl12lts_2022062313node_hash_setINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENS3_18container_internal10StringHashENSC_8StringEqENS9_ISB_EEEENS0_14DefaultDeleterISG_EEE3getEv: 159| 41.8k| T* get() const { return data_.ptr; } _ZNK4i18n12phonenumbers10scoped_ptrINSt3__16vectorINS2_4pairIiPNS2_4listINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS9_ISB_EEEEEENS9_ISF_EEEENS0_14DefaultDeleterISH_EEEptEv: 272| 554k| element_type* operator->() const { 273| 554k| assert(impl_.get() != NULL); 274| 554k| return impl_.get(); 275| 554k| } _ZNK4i18n12phonenumbers15scoped_ptr_implINSt3__16vectorINS2_4pairIiPNS2_4listINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS9_ISB_EEEEEENS9_ISF_EEEENS0_14DefaultDeleterISH_EEE3getEv: 159| 1.10M| T* get() const { return data_.ptr; } _ZNK4i18n12phonenumbers10scoped_ptrINS0_29PhoneNumberRegExpsAndMappingsENS0_14DefaultDeleterIS2_EEEptEv: 272| 1.92M| element_type* operator->() const { 273| 1.92M| assert(impl_.get() != NULL); 274| 1.92M| return impl_.get(); 275| 1.92M| } _ZNK4i18n12phonenumbers15scoped_ptr_implINS0_29PhoneNumberRegExpsAndMappingsENS0_14DefaultDeleterIS2_EEE3getEv: 159| 3.84M| T* get() const { return data_.ptr; } _ZN4i18n12phonenumbers10scoped_ptrINS0_11RegExpInputENS0_14DefaultDeleterIS2_EEEC2EPS2_: 225| 786k| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINS0_11RegExpInputENS0_14DefaultDeleterIS2_EEEC2EPS2_: 101| 786k| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINS0_11RegExpInputENS0_14DefaultDeleterIS2_EEE4DataC2EPS2_: 188| 786k| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterINS0_11RegExpInputEEC2Ev: 35| 786k| DefaultDeleter() {} _ZNK4i18n12phonenumbers10scoped_ptrIKNS0_6RegExpENS0_14DefaultDeleterIS3_EEEptEv: 272| 481k| element_type* operator->() const { 273| 481k| assert(impl_.get() != NULL); 274| 481k| return impl_.get(); 275| 481k| } _ZNK4i18n12phonenumbers15scoped_ptr_implIKNS0_6RegExpENS0_14DefaultDeleterIS3_EEE3getEv: 159| 962k| T* get() const { return data_.ptr; } _ZNK4i18n12phonenumbers10scoped_ptrINS0_11RegExpInputENS0_14DefaultDeleterIS2_EEE3getEv: 276| 815k| element_type* get() const { return impl_.get(); } _ZNK4i18n12phonenumbers15scoped_ptr_implINS0_11RegExpInputENS0_14DefaultDeleterIS2_EEE3getEv: 159| 828k| T* get() const { return data_.ptr; } _ZNK4i18n12phonenumbers10scoped_ptrINS0_11RegExpCacheENS0_14DefaultDeleterIS2_EEEptEv: 272| 813k| element_type* operator->() const { 273| 813k| assert(impl_.get() != NULL); 274| 813k| return impl_.get(); 275| 813k| } _ZNK4i18n12phonenumbers15scoped_ptr_implINS0_11RegExpCacheENS0_14DefaultDeleterIS2_EEE3getEv: 159| 1.62M| T* get() const { return data_.ptr; } _ZNK4i18n12phonenumbers10scoped_ptrINS0_11RegExpInputENS0_14DefaultDeleterIS2_EEEptEv: 272| 6.51k| element_type* operator->() const { 273| 6.51k| assert(impl_.get() != NULL); 274| 6.51k| return impl_.get(); 275| 6.51k| } _ZNK4i18n12phonenumbers10scoped_ptrINS0_10MatcherApiENS0_14DefaultDeleterIS2_EEEdeEv: 268| 152k| element_type& operator*() const { 269| 152k| assert(impl_.get() != NULL); 270| 152k| return *impl_.get(); 271| 152k| } _ZNK4i18n12phonenumbers15scoped_ptr_implINS0_10MatcherApiENS0_14DefaultDeleterIS2_EEE3getEv: 159| 304k| T* get() const { return data_.ptr; } _ZNK4i18n12phonenumbers10scoped_ptrIKNS0_21AbstractRegExpFactoryENS0_14DefaultDeleterIS3_EEEdeEv: 268| 1| element_type& operator*() const { 269| 1| assert(impl_.get() != NULL); 270| 1| return *impl_.get(); 271| 1| } _ZN4i18n12phonenumbers10scoped_ptrINSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKNS0_6RegExpENS2_4lessIS9_EENS7_INS2_4pairIKS9_SC_EEEEEENS0_14DefaultDeleterISJ_EEEC2EPSJ_: 225| 2| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKNS0_6RegExpENS2_4lessIS9_EENS7_INS2_4pairIKS9_SC_EEEEEENS0_14DefaultDeleterISJ_EEEC2EPSJ_: 101| 2| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implINSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKNS0_6RegExpENS2_4lessIS9_EENS7_INS2_4pairIKS9_SC_EEEEEENS0_14DefaultDeleterISJ_EEE4DataC2EPSJ_: 188| 2| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterINSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKNS0_6RegExpENS2_4lessIS9_EENS7_INS2_4pairIKS9_SC_EEEEEEEC2Ev: 35| 2| DefaultDeleter() {} _ZNK4i18n12phonenumbers10scoped_ptrINSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKNS0_6RegExpENS2_4lessIS9_EENS7_INS2_4pairIKS9_SC_EEEEEENS0_14DefaultDeleterISJ_EEEptEv: 272| 1.63M| element_type* operator->() const { 273| 1.63M| assert(impl_.get() != NULL); 274| 1.63M| return impl_.get(); 275| 1.63M| } _ZNK4i18n12phonenumbers15scoped_ptr_implINSt3__13mapINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPKNS0_6RegExpENS2_4lessIS9_EENS7_INS2_4pairIKS9_SC_EEEEEENS0_14DefaultDeleterISJ_EEE3getEv: 159| 3.26M| T* get() const { return data_.ptr; } _ZN4i18n12phonenumbers10scoped_ptrIN6icu_6612RegexPatternENS0_14DefaultDeleterIS3_EEEC2Ev: 222| 6.31k| scoped_ptr() : impl_(NULL) { } _ZN4i18n12phonenumbers15scoped_ptr_implIN6icu_6612RegexPatternENS0_14DefaultDeleterIS3_EEEC2EPS3_: 101| 6.31k| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIN6icu_6612RegexPatternENS0_14DefaultDeleterIS3_EEE4DataC2EPS3_: 188| 6.31k| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterIN6icu_6612RegexPatternEEC2Ev: 35| 6.31k| DefaultDeleter() {} _ZN4i18n12phonenumbers10scoped_ptrIN6icu_6612RegexPatternENS0_14DefaultDeleterIS3_EEE5resetEPS3_: 264| 8.77k| void reset(element_type* p = NULL) { impl_.reset(p); } _ZN4i18n12phonenumbers15scoped_ptr_implIN6icu_6612RegexPatternENS0_14DefaultDeleterIS3_EEE5resetEPS3_: 133| 8.77k| void reset(T* p) { 134| | // This is a self-reset, which is no longer allowed: http://crbug.com/162971 135| 8.77k| if (p != NULL && p == data_.ptr) ------------------ | Branch (135:9): [True: 3.86k, False: 4.91k] | Branch (135:22): [True: 0, False: 3.86k] ------------------ 136| 0| abort(); 137| | 138| | // Note that running data_.ptr = p can lead to undefined behavior if 139| | // get_deleter()(get()) deletes this. In order to pevent this, reset() 140| | // should update the stored pointer before deleting its old value. 141| | // 142| | // However, changing reset() to use that behavior may cause current code to 143| | // break in unexpected ways. If the destruction of the owned object 144| | // dereferences the scoped_ptr when it is destroyed by a call to reset(), 145| | // then it will incorrectly dispatch calls to |p| rather than the original 146| | // value of |data_.ptr|. 147| | // 148| | // During the transition period, set the stored pointer to NULL while 149| | // deleting the object. Eventually, this safety check will be removed to 150| | // prevent the scenario initially described from occuring and 151| | // http://crbug.com/176091 can be closed. 152| 8.77k| T* old = data_.ptr; 153| 8.77k| data_.ptr = NULL; 154| 8.77k| if (old != NULL) ------------------ | Branch (154:9): [True: 0, False: 8.77k] ------------------ 155| 0| static_cast(data_)(old); 156| 8.77k| data_.ptr = p; 157| 8.77k| } _ZNK4i18n12phonenumbers10scoped_ptrIN6icu_6612RegexPatternENS0_14DefaultDeleterIS3_EEE3getEv: 276| 1.43M| element_type* get() const { return impl_.get(); } _ZNK4i18n12phonenumbers15scoped_ptr_implIN6icu_6612RegexPatternENS0_14DefaultDeleterIS3_EEE3getEv: 159| 4.29M| T* get() const { return data_.ptr; } _ZNK4i18n12phonenumbers10scoped_ptrIN6icu_6612RegexPatternENS0_14DefaultDeleterIS3_EEEptEv: 272| 1.42M| element_type* operator->() const { 273| 1.42M| assert(impl_.get() != NULL); 274| 1.42M| return impl_.get(); 275| 1.42M| } _ZN4i18n12phonenumbers10scoped_ptrIN6icu_6612RegexMatcherENS0_14DefaultDeleterIS3_EEEC2EPS3_: 225| 1.42M| explicit scoped_ptr(element_type* p) : impl_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIN6icu_6612RegexMatcherENS0_14DefaultDeleterIS3_EEEC2EPS3_: 101| 1.42M| explicit scoped_ptr_impl(T* p) : data_(p) { } _ZN4i18n12phonenumbers15scoped_ptr_implIN6icu_6612RegexMatcherENS0_14DefaultDeleterIS3_EEE4DataC2EPS3_: 188| 1.42M| explicit Data(T* ptr_in) : ptr(ptr_in) {} _ZN4i18n12phonenumbers14DefaultDeleterIN6icu_6612RegexMatcherEEC2Ev: 35| 1.42M| DefaultDeleter() {} _ZNK4i18n12phonenumbers10scoped_ptrIN6icu_6612RegexMatcherENS0_14DefaultDeleterIS3_EEEptEv: 272| 1.85M| element_type* operator->() const { 273| 1.85M| assert(impl_.get() != NULL); 274| 1.85M| return impl_.get(); 275| 1.85M| } _ZNK4i18n12phonenumbers15scoped_ptr_implIN6icu_6612RegexMatcherENS0_14DefaultDeleterIS3_EEE3getEv: 159| 3.70M| T* get() const { return data_.ptr; } _ZN4i18n12phonenumbers15scoped_ptr_implIN6icu_6612RegexMatcherENS0_14DefaultDeleterIS3_EEED2Ev: 125| 1.42M| ~scoped_ptr_impl() { 126| 1.42M| if (data_.ptr != NULL) { ------------------ | Branch (126:9): [True: 1.42M, False: 0] ------------------ 127| | // Not using get_deleter() saves one function call in non-optimized 128| | // builds. 129| 1.42M| static_cast(data_)(data_.ptr); 130| 1.42M| } 131| 1.42M| } _ZNK4i18n12phonenumbers14DefaultDeleterIN6icu_6612RegexMatcherEEclEPS3_: 54| 1.42M| inline void operator()(T* ptr) const { 55| 1.42M| enum { type_must_be_complete = sizeof(T) }; 56| 1.42M| delete ptr; 57| 1.42M| } _ZN4i18n12phonenumbers9SingletonINS0_15PhoneNumberUtilEE11GetInstanceEv: 30| 9.65k| static T* GetInstance() { 31| 9.65k| const int ret = pthread_once(&once_control_, &Init); 32| 9.65k| (void) ret; 33| 9.65k| DCHECK_EQ(0, ret); ------------------ | | 30| 9.65k|#define DCHECK_EQ(X, Y) CHECK_EQ((X), (Y)) | | ------------------ | | | | 25| 9.65k|#define CHECK_EQ(X, Y) assert((X) == (Y)) | | ------------------ ------------------ 34| 9.65k| return instance_; 35| 9.65k| } _ZN4i18n12phonenumbers9SingletonINS0_15PhoneNumberUtilEE4InitEv: 38| 1| static void Init() { 39| 1| instance_ = new T(); 40| 1| } _ZN4i18n12phonenumbers8AutoLockC2ERNS0_4LockE: 40| 813k| AutoLock(Lock& lock) : lock_(lock) { 41| 813k| lock_.Acquire(); 42| 813k| } _ZN4i18n12phonenumbers8AutoLockD2Ev: 44| 813k| ~AutoLock() { 45| 813k| lock_.Release(); 46| 813k| } _ZN4i18n12phonenumbers4LockC2Ev: 30| 2| Lock() { 31| 2| const int ret = pthread_mutex_init(&mutex_, NULL); 32| 2| (void) ret; 33| 2| DCHECK_EQ(0, ret); ------------------ | | 30| 2|#define DCHECK_EQ(X, Y) CHECK_EQ((X), (Y)) | | ------------------ | | | | 25| 2|#define CHECK_EQ(X, Y) assert((X) == (Y)) | | ------------------ ------------------ 34| 2| } _ZNK4i18n12phonenumbers4Lock7AcquireEv: 46| 813k| void Acquire() const { 47| 813k| int ret = pthread_mutex_lock(&mutex_); 48| 813k| (void) ret; 49| 813k| DCHECK_EQ(0, ret); ------------------ | | 30| 813k|#define DCHECK_EQ(X, Y) CHECK_EQ((X), (Y)) | | ------------------ | | | | 25| 813k|#define CHECK_EQ(X, Y) assert((X) == (Y)) | | ------------------ ------------------ 50| 813k| } _ZNK4i18n12phonenumbers4Lock7ReleaseEv: 52| 813k| void Release() const { 53| 813k| int ret = pthread_mutex_unlock(&mutex_); 54| 813k| (void) ret; 55| 813k| DCHECK_EQ(0, ret); ------------------ | | 30| 813k|#define DCHECK_EQ(X, Y) CHECK_EQ((X), (Y)) | | ------------------ | | | | 25| 813k|#define CHECK_EQ(X, Y) assert((X) == (Y)) | | ------------------ ------------------ 56| 813k| } _ZN4i18n12phonenumbers13LoggerHandlerC2EPNS0_6LoggerE: 56| 200k| LoggerHandler(Logger* impl) : impl_(impl) {} _ZN4i18n12phonenumbers13LoggerHandlerD2Ev: 58| 200k| ~LoggerHandler() { 59| 200k| if (impl_) { ------------------ | Branch (59:9): [True: 2.45k, False: 198k] ------------------ 60| 2.45k| impl_->WriteMessage("\n"); 61| 2.45k| } 62| 200k| } _ZN4i18n12phonenumbers3LOGEi: 76| 200k|inline LoggerHandler LOG(int n) { 77| 200k| Logger* const logger_impl = Logger::mutable_logger_impl(); 78| 200k| if (logger_impl->level() < n) { ------------------ | Branch (78:7): [True: 198k, False: 2.45k] ------------------ 79| 198k| return LoggerHandler(NULL); 80| 198k| } 81| 2.45k| logger_impl->WriteLevel(); 82| 2.45k| return LoggerHandler(logger_impl); 83| 200k|} _ZN4i18n12phonenumbers4VLOGEi: 85| 178k|inline LoggerHandler VLOG(int n) { 86| | // VLOG(1) is the next logging level after LOG(DEBUG). 87| 178k| n += LOG_DEBUG; 88| 178k| return LOG(n); 89| 178k|} _ZN4i18n12phonenumbers13LoggerHandlerlsIA29_cEERS1_RKT_: 65| 43| LoggerHandler& operator<<(const T& value) { 66| 43| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 43] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 43| return *this; 70| 43| } _ZN4i18n12phonenumbers13LoggerHandlerlsINSt3__112basic_stringIcNS3_11char_traitsIcEENS3_9allocatorIcEEEEEERS1_RKT_: 65| 58.8k| LoggerHandler& operator<<(const T& value) { 66| 58.8k| if (impl_) { ------------------ | Branch (66:9): [True: 2.45k, False: 56.3k] ------------------ 67| 2.45k| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 2.45k| } 69| 58.8k| return *this; 70| 58.8k| } _ZN4i18n12phonenumbers15ConvertToStringINSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEE6DoWorkERKS8_: 38| 2.45k| static inline string DoWork(const T& s) { 39| 2.45k| return string(s); 40| 2.45k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIiEERS1_RKT_: 65| 20.3k| LoggerHandler& operator<<(const T& value) { 66| 20.3k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 20.3k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 20.3k| return *this; 70| 20.3k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA33_cEERS1_RKT_: 65| 6.89k| LoggerHandler& operator<<(const T& value) { 66| 6.89k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 6.89k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 6.89k| return *this; 70| 6.89k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA12_cEERS1_RKT_: 65| 6.89k| LoggerHandler& operator<<(const T& value) { 66| 6.89k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 6.89k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 6.89k| return *this; 70| 6.89k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA45_cEERS1_RKT_: 65| 1.72k| LoggerHandler& operator<<(const T& value) { 66| 1.72k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 1.72k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 1.72k| return *this; 70| 1.72k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA36_cEERS1_RKT_: 65| 10.6k| LoggerHandler& operator<<(const T& value) { 66| 10.6k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 10.6k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 10.6k| return *this; 70| 10.6k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA46_cEERS1_RKT_: 65| 2.25k| LoggerHandler& operator<<(const T& value) { 66| 2.25k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 2.25k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 2.25k| return *this; 70| 2.25k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA39_cEERS1_RKT_: 65| 14.4k| LoggerHandler& operator<<(const T& value) { 66| 14.4k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 14.4k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 14.4k| return *this; 70| 14.4k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA2_cEERS1_RKT_: 65| 10.7k| LoggerHandler& operator<<(const T& value) { 66| 10.7k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 10.7k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 10.7k| return *this; 70| 10.7k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA31_cEERS1_RKT_: 65| 17.5k| LoggerHandler& operator<<(const T& value) { 66| 17.5k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 17.5k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 17.5k| return *this; 70| 17.5k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA51_cEERS1_RKT_: 65| 9.62k| LoggerHandler& operator<<(const T& value) { 66| 9.62k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 9.62k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 9.62k| return *this; 70| 9.62k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA55_cEERS1_RKT_: 65| 30.6k| LoggerHandler& operator<<(const T& value) { 66| 30.6k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 30.6k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 30.6k| return *this; 70| 30.6k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA54_cEERS1_RKT_: 65| 279| LoggerHandler& operator<<(const T& value) { 66| 279| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 279] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 279| return *this; 70| 279| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA60_cEERS1_RKT_: 65| 49.1k| LoggerHandler& operator<<(const T& value) { 66| 49.1k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 49.1k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 49.1k| return *this; 70| 49.1k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA10_cEERS1_RKT_: 65| 55.6k| LoggerHandler& operator<<(const T& value) { 66| 55.6k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 55.6k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 55.6k| return *this; 70| 55.6k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA28_cEERS1_RKT_: 65| 105| LoggerHandler& operator<<(const T& value) { 66| 105| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 105] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 105| return *this; 70| 105| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA30_cEERS1_RKT_: 65| 134| LoggerHandler& operator<<(const T& value) { 66| 134| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 134] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 134| return *this; 70| 134| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA32_cEERS1_RKT_: 65| 47.8k| LoggerHandler& operator<<(const T& value) { 66| 47.8k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 47.8k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 47.8k| return *this; 70| 47.8k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA41_cEERS1_RKT_: 65| 272| LoggerHandler& operator<<(const T& value) { 66| 272| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 272] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 272| return *this; 70| 272| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA26_cEERS1_RKT_: 65| 73| LoggerHandler& operator<<(const T& value) { 66| 73| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 73] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 73| return *this; 70| 73| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA17_cEERS1_RKT_: 65| 96| LoggerHandler& operator<<(const T& value) { 66| 96| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 96] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 96| return *this; 70| 96| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA59_cEERS1_RKT_: 65| 425| LoggerHandler& operator<<(const T& value) { 66| 425| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 425] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 425| return *this; 70| 425| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA11_cEERS1_RKT_: 65| 425| LoggerHandler& operator<<(const T& value) { 66| 425| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 425] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 425| return *this; 70| 425| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA27_cEERS1_RKT_: 65| 557| LoggerHandler& operator<<(const T& value) { 66| 557| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 557] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 557| return *this; 70| 557| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA61_cEERS1_RKT_: 65| 6.46k| LoggerHandler& operator<<(const T& value) { 66| 6.46k| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 6.46k] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 6.46k| return *this; 70| 6.46k| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA49_cEERS1_RKT_: 65| 113| LoggerHandler& operator<<(const T& value) { 66| 113| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 113] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 113| return *this; 70| 113| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA43_cEERS1_RKT_: 65| 873| LoggerHandler& operator<<(const T& value) { 66| 873| if (impl_) { ------------------ | Branch (66:9): [True: 0, False: 873] ------------------ 67| 0| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 0| } 69| 873| return *this; 70| 873| } _ZN4i18n12phonenumbers13LoggerHandlerlsIA37_cEERS1_RKT_: 65| 2.45k| LoggerHandler& operator<<(const T& value) { 66| 2.45k| if (impl_) { ------------------ | Branch (66:9): [True: 2.45k, False: 0] ------------------ 67| 2.45k| impl_->WriteMessage(ConvertToString::DoWork(value)); 68| 2.45k| } 69| 2.45k| return *this; 70| 2.45k| } _ZN4i18n12phonenumbers15ConvertToStringIA37_cE6DoWorkERA37_Kc: 38| 2.45k| static inline string DoWork(const T& s) { 39| 2.45k| return string(s); 40| 2.45k| } _ZN4i18n12phonenumbers13EncodingUtils14DecodeUTF8CharEPKcPi: 30| 42| static inline int DecodeUTF8Char(const char* in, char32* out) { 31| 42| Rune r; 32| 42| int len = chartorune(&r, in); 33| 42| *out = r; 34| 42| return len; 35| 42| } _ZN4i18n12phonenumbers6LoggerC2Ev: 49| 1| Logger() : level_(LOG_ERROR) {} _ZN4i18n12phonenumbers6Logger10WriteLevelEv: 53| 2.45k| virtual void WriteLevel() {} _ZNK4i18n12phonenumbers6Logger5levelEv: 60| 200k| inline int level() const { 61| 200k| return level_; 62| 200k| } _ZN4i18n12phonenumbers6Logger15set_logger_implEPS1_: 77| 2| static inline Logger* set_logger_impl(Logger* logger) { 78| 2| impl_ = logger; 79| 2| return logger; 80| 2| } _ZN4i18n12phonenumbers6Logger19mutable_logger_implEv: 82| 200k| static inline Logger* mutable_logger_impl() { 83| 200k| return impl_; 84| 200k| } _ZN4i18n12phonenumbers10NullLogger12WriteMessageERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 97| 7.36k| virtual void WriteMessage(const string& /* msg */) {} _ZN4i18n12phonenumbers13metadata_sizeEv: 15549| 1|int metadata_size() { 15550| 1| return sizeof(data) / sizeof(data[0]); 15551| 1|} _ZN4i18n12phonenumbers12metadata_getEv: 15553| 1|const void* metadata_get() { 15554| 1| return data; 15555| 1|} _ZN4i18n12phonenumbers13NormalizeUTF822NormalizeDecimalDigitsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 26| 62.2k| static string NormalizeDecimalDigits(const string& number) { 27| 62.2k| string normalized; 28| 62.2k| UnicodeText number_as_unicode; 29| 62.2k| number_as_unicode.PointToUTF8(number.data(), static_cast(number.size())); 30| 62.2k| if (!number_as_unicode.UTF8WasValid()) ------------------ | Branch (30:9): [True: 0, False: 62.2k] ------------------ 31| 0| return normalized; // Return an empty result to indicate an error 32| 62.2k| for (UnicodeText::const_iterator it = number_as_unicode.begin(); 33| 386k| it != number_as_unicode.end(); ------------------ | Branch (33:10): [True: 324k, False: 62.2k] ------------------ 34| 324k| ++it) { 35| 324k| int32_t digitValue = u_charDigitValue(*it); 36| 324k| if (digitValue == -1) { ------------------ | Branch (36:11): [True: 0, False: 324k] ------------------ 37| | // Not a decimal digit. 38| 0| char utf8[4]; 39| 0| int len = it.get_utf8(utf8); 40| 0| normalized.append(utf8, len); 41| 324k| } else { 42| 324k| normalized.push_back('0' + digitValue); 43| 324k| } 44| 324k| } 45| 62.2k| return normalized; 46| 62.2k| } _ZN4i18n12phonenumbers12NumberFormatC2EPN6google8protobuf5ArenaE: 121| 307k| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena), 122| 307k| leading_digits_pattern_(arena) { 123| 307k| SharedCtor(); 124| 307k| RegisterArenaDtor(arena); 125| | // @@protoc_insertion_point(arena_constructor:i18n.phonenumbers.NumberFormat) 126| 307k|} _ZN4i18n12phonenumbers12NumberFormatD2Ev: 165| 306k|NumberFormat::~NumberFormat() { 166| | // @@protoc_insertion_point(destructor:i18n.phonenumbers.NumberFormat) 167| 306k| SharedDtor(); 168| 306k| _internal_metadata_.Delete(); 169| 306k|} _ZN4i18n12phonenumbers12NumberFormat14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE: 221| 933|const char* NumberFormat::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { 222| 933|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure 223| 933| _Internal::HasBits has_bits{}; 224| 4.38k| while (!ctx->Done(&ptr)) { ------------------ | Branch (224:10): [True: 3.45k, False: 933] ------------------ 225| 3.45k| ::PROTOBUF_NAMESPACE_ID::uint32 tag; 226| 3.45k| ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); 227| 3.45k| CHK_(ptr); ------------------ | | 222| 3.45k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 228| 3.45k| switch (tag >> 3) { 229| | // required string pattern = 1; 230| 933| case 1: ------------------ | Branch (230:7): [True: 933, False: 2.51k] ------------------ 231| 933| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { 232| 933| auto str = _internal_mutable_pattern(); 233| 933| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 234| 933| CHK_(ptr); ------------------ | | 222| 933|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 235| 933| } else goto handle_unusual; 236| 933| continue; 237| | // required string format = 2; 238| 933| case 2: ------------------ | Branch (238:7): [True: 933, False: 2.51k] ------------------ 239| 933| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { 240| 933| auto str = _internal_mutable_format(); 241| 933| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 242| 933| CHK_(ptr); ------------------ | | 222| 933|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 243| 933| } else goto handle_unusual; 244| 933| continue; 245| | // repeated string leading_digits_pattern = 3; 246| 933| case 3: ------------------ | Branch (246:7): [True: 932, False: 2.51k] ------------------ 247| 932| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { 248| 932| ptr -= 1; 249| 1.08k| do { 250| 1.08k| ptr += 1; 251| 1.08k| auto str = _internal_add_leading_digits_pattern(); 252| 1.08k| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 253| 1.08k| CHK_(ptr); ------------------ | | 222| 1.08k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 254| 1.08k| if (!ctx->DataAvailable(ptr)) break; ------------------ | Branch (254:17): [True: 371, False: 710] ------------------ 255| 1.08k| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<26>(ptr)); ------------------ | Branch (255:20): [True: 149, False: 561] ------------------ 256| 932| } else goto handle_unusual; 257| 932| continue; 258| | // optional string national_prefix_formatting_rule = 4; 259| 932| case 4: ------------------ | Branch (259:7): [True: 523, False: 2.92k] ------------------ 260| 523| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { 261| 523| auto str = _internal_mutable_national_prefix_formatting_rule(); 262| 523| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 263| 523| CHK_(ptr); ------------------ | | 222| 523|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 264| 523| } else goto handle_unusual; 265| 523| continue; 266| | // optional string domestic_carrier_code_formatting_rule = 5; 267| 523| case 5: ------------------ | Branch (267:7): [True: 55, False: 3.39k] ------------------ 268| 55| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { 269| 55| auto str = _internal_mutable_domestic_carrier_code_formatting_rule(); 270| 55| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 271| 55| CHK_(ptr); ------------------ | | 222| 55|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 272| 55| } else goto handle_unusual; 273| 55| continue; 274| | // optional bool national_prefix_optional_when_formatting = 6 [default = false]; 275| 74| case 6: ------------------ | Branch (275:7): [True: 74, False: 3.37k] ------------------ 276| 74| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 48)) { 277| 74| _Internal::set_has_national_prefix_optional_when_formatting(&has_bits); 278| 74| national_prefix_optional_when_formatting_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); 279| 74| CHK_(ptr); ------------------ | | 222| 74|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 280| 74| } else goto handle_unusual; 281| 74| continue; 282| 74| default: { ------------------ | Branch (282:7): [True: 0, False: 3.45k] ------------------ 283| 0| handle_unusual: 284| 0| if ((tag & 7) == 4 || tag == 0) { ------------------ | Branch (284:13): [True: 0, False: 0] | Branch (284:31): [True: 0, False: 0] ------------------ 285| 0| ctx->SetLastTag(tag); 286| 0| goto success; 287| 0| } 288| 0| ptr = UnknownFieldParse(tag, 289| 0| _internal_metadata_.mutable_unknown_fields(), 290| 0| ptr, ctx); 291| 0| CHK_(ptr != nullptr); ------------------ | | 222| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 292| 0| continue; 293| 0| } 294| 3.45k| } // switch 295| 3.45k| } // while 296| 933|success: 297| 933| _has_bits_.Or(has_bits); 298| 933| return ptr; 299| 0|failure: 300| 0| ptr = nullptr; 301| 0| goto success; 302| 933|#undef CHK_ 303| 933|} _ZN4i18n12phonenumbers12NumberFormat9MergeFromERKS1_: 442| 296k|void NumberFormat::MergeFrom(const NumberFormat& from) { 443| |// @@protoc_insertion_point(class_specific_merge_from_start:i18n.phonenumbers.NumberFormat) 444| 296k| GOOGLE_DCHECK_NE(&from, this); 445| 296k| _internal_metadata_.MergeFrom(from._internal_metadata_); 446| 296k| ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; 447| 296k| (void) cached_has_bits; 448| | 449| 296k| leading_digits_pattern_.MergeFrom(from.leading_digits_pattern_); 450| 296k| cached_has_bits = from._has_bits_[0]; 451| 296k| if (cached_has_bits & 0x0000001fu) { ------------------ | Branch (451:7): [True: 296k, False: 0] ------------------ 452| 296k| if (cached_has_bits & 0x00000001u) { ------------------ | Branch (452:9): [True: 296k, False: 0] ------------------ 453| 296k| _internal_set_pattern(from._internal_pattern()); 454| 296k| } 455| 296k| if (cached_has_bits & 0x00000002u) { ------------------ | Branch (455:9): [True: 296k, False: 0] ------------------ 456| 296k| _internal_set_format(from._internal_format()); 457| 296k| } 458| 296k| if (cached_has_bits & 0x00000004u) { ------------------ | Branch (458:9): [True: 162k, False: 134k] ------------------ 459| 162k| _internal_set_national_prefix_formatting_rule(from._internal_national_prefix_formatting_rule()); 460| 162k| } 461| 296k| if (cached_has_bits & 0x00000008u) { ------------------ | Branch (461:9): [True: 22.9k, False: 273k] ------------------ 462| 22.9k| _internal_set_domestic_carrier_code_formatting_rule(from._internal_domestic_carrier_code_formatting_rule()); 463| 22.9k| } 464| 296k| if (cached_has_bits & 0x00000010u) { ------------------ | Branch (464:9): [True: 13.8k, False: 282k] ------------------ 465| 13.8k| national_prefix_optional_when_formatting_ = from.national_prefix_optional_when_formatting_; 466| 13.8k| } 467| 296k| _has_bits_[0] |= cached_has_bits; 468| 296k| } 469| 296k|} _ZNK4i18n12phonenumbers12NumberFormat13IsInitializedEv: 478| 933|bool NumberFormat::IsInitialized() const { 479| 933| if (_Internal::MissingRequiredFields(_has_bits_)) return false; ------------------ | Branch (479:7): [True: 0, False: 933] ------------------ 480| 933| return true; 481| 933|} _ZN4i18n12phonenumbers15PhoneNumberDescC2EPN6google8protobuf5ArenaE: 514| 3.04k| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena), 515| 3.04k| possible_length_(arena), 516| 3.04k| possible_length_local_only_(arena) { 517| 3.04k| SharedCtor(); 518| 3.04k| RegisterArenaDtor(arena); 519| | // @@protoc_insertion_point(arena_constructor:i18n.phonenumbers.PhoneNumberDesc) 520| 3.04k|} _ZN4i18n12phonenumbers15PhoneNumberDescC2ERKS1_: 522| 3.23k| : ::PROTOBUF_NAMESPACE_ID::MessageLite(), 523| 3.23k| _has_bits_(from._has_bits_), 524| 3.23k| possible_length_(from.possible_length_), 525| 3.23k| possible_length_local_only_(from.possible_length_local_only_) { 526| 3.23k| _internal_metadata_.MergeFrom(from._internal_metadata_); 527| 3.23k| national_number_pattern_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 528| 3.23k| if (from._internal_has_national_number_pattern()) { ------------------ | Branch (528:7): [True: 1.45k, False: 1.78k] ------------------ 529| 1.45k| national_number_pattern_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_national_number_pattern(), 530| 1.45k| GetArena()); 531| 1.45k| } 532| 3.23k| example_number_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 533| 3.23k| if (from._internal_has_example_number()) { ------------------ | Branch (533:7): [True: 1.17k, False: 2.06k] ------------------ 534| 1.17k| example_number_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_example_number(), 535| 1.17k| GetArena()); 536| 1.17k| } 537| | // @@protoc_insertion_point(copy_constructor:i18n.phonenumbers.PhoneNumberDesc) 538| 3.23k|} _ZN4i18n12phonenumbers15PhoneNumberDescD2Ev: 546| 3.23k|PhoneNumberDesc::~PhoneNumberDesc() { 547| | // @@protoc_insertion_point(destructor:i18n.phonenumbers.PhoneNumberDesc) 548| 3.23k| SharedDtor(); 549| 3.23k| _internal_metadata_.Delete(); 550| 3.23k|} _ZN4i18n12phonenumbers15PhoneNumberDesc14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE: 594| 3.04k|const char* PhoneNumberDesc::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { 595| 3.04k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure 596| 3.04k| _Internal::HasBits has_bits{}; 597| 8.37k| while (!ctx->Done(&ptr)) { ------------------ | Branch (597:10): [True: 5.32k, False: 3.04k] ------------------ 598| 5.32k| ::PROTOBUF_NAMESPACE_ID::uint32 tag; 599| 5.32k| ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); 600| 5.32k| CHK_(ptr); ------------------ | | 595| 5.32k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 601| 5.32k| switch (tag >> 3) { 602| | // optional string national_number_pattern = 2; 603| 1.42k| case 2: ------------------ | Branch (603:7): [True: 1.42k, False: 3.89k] ------------------ 604| 1.42k| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { 605| 1.42k| auto str = _internal_mutable_national_number_pattern(); 606| 1.42k| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 607| 1.42k| CHK_(ptr); ------------------ | | 595| 1.42k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 608| 1.42k| } else goto handle_unusual; 609| 1.42k| continue; 610| | // optional string example_number = 6; 611| 1.42k| case 6: ------------------ | Branch (611:7): [True: 1.14k, False: 4.18k] ------------------ 612| 1.14k| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { 613| 1.14k| auto str = _internal_mutable_example_number(); 614| 1.14k| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 615| 1.14k| CHK_(ptr); ------------------ | | 595| 1.14k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 616| 1.14k| } else goto handle_unusual; 617| 1.14k| continue; 618| | // repeated int32 possible_length = 9; 619| 2.51k| case 9: ------------------ | Branch (619:7): [True: 2.51k, False: 2.80k] ------------------ 620| 2.51k| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 72)) { 621| 2.51k| ptr -= 1; 622| 3.24k| do { 623| 3.24k| ptr += 1; 624| 3.24k| _internal_add_possible_length(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); 625| 3.24k| CHK_(ptr); ------------------ | | 595| 3.24k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 626| 3.24k| if (!ctx->DataAvailable(ptr)) break; ------------------ | Branch (626:17): [True: 2.36k, False: 882] ------------------ 627| 3.24k| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<72>(ptr)); ------------------ | Branch (627:20): [True: 732, False: 150] ------------------ 628| 2.51k| } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74) { ------------------ | Branch (628:20): [True: 0, False: 0] ------------------ 629| 0| ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_possible_length(), ptr, ctx); 630| 0| CHK_(ptr); ------------------ | | 595| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 631| 0| } else goto handle_unusual; 632| 2.51k| continue; 633| | // repeated int32 possible_length_local_only = 10; 634| 2.51k| case 10: ------------------ | Branch (634:7): [True: 242, False: 5.08k] ------------------ 635| 242| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) { 636| 242| ptr -= 1; 637| 354| do { 638| 354| ptr += 1; 639| 354| _internal_add_possible_length_local_only(::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr)); 640| 354| CHK_(ptr); ------------------ | | 595| 354|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 641| 354| if (!ctx->DataAvailable(ptr)) break; ------------------ | Branch (641:17): [True: 242, False: 112] ------------------ 642| 354| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<80>(ptr)); ------------------ | Branch (642:20): [True: 112, False: 0] ------------------ 643| 242| } else if (static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 82) { ------------------ | Branch (643:20): [True: 0, False: 0] ------------------ 644| 0| ptr = ::PROTOBUF_NAMESPACE_ID::internal::PackedInt32Parser(_internal_mutable_possible_length_local_only(), ptr, ctx); 645| 0| CHK_(ptr); ------------------ | | 595| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 646| 0| } else goto handle_unusual; 647| 242| continue; 648| 242| default: { ------------------ | Branch (648:7): [True: 0, False: 5.32k] ------------------ 649| 0| handle_unusual: 650| 0| if ((tag & 7) == 4 || tag == 0) { ------------------ | Branch (650:13): [True: 0, False: 0] | Branch (650:31): [True: 0, False: 0] ------------------ 651| 0| ctx->SetLastTag(tag); 652| 0| goto success; 653| 0| } 654| 0| ptr = UnknownFieldParse(tag, 655| 0| _internal_metadata_.mutable_unknown_fields(), 656| 0| ptr, ctx); 657| 0| CHK_(ptr != nullptr); ------------------ | | 595| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 658| 0| continue; 659| 0| } 660| 5.32k| } // switch 661| 5.32k| } // while 662| 3.04k|success: 663| 3.04k| _has_bits_.Or(has_bits); 664| 3.04k| return ptr; 665| 0|failure: 666| 0| ptr = nullptr; 667| 0| goto success; 668| 3.04k|#undef CHK_ 669| 3.04k|} _ZN4i18n12phonenumbers13PhoneMetadataC2EPN6google8protobuf5ArenaE: 996| 509| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena), 997| 509| number_format_(arena), 998| 509| intl_number_format_(arena) { 999| 509| SharedCtor(); 1000| 509| RegisterArenaDtor(arena); 1001| | // @@protoc_insertion_point(arena_constructor:i18n.phonenumbers.PhoneMetadata) 1002| 509|} _ZN4i18n12phonenumbers13PhoneMetadataC2ERKS1_: 1004| 254| : ::PROTOBUF_NAMESPACE_ID::MessageLite(), 1005| 254| _has_bits_(from._has_bits_), 1006| 254| number_format_(from.number_format_), 1007| 254| intl_number_format_(from.intl_number_format_) { 1008| 254| _internal_metadata_.MergeFrom(from._internal_metadata_); 1009| 254| id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1010| 254| if (from._internal_has_id()) { ------------------ | Branch (1010:7): [True: 254, False: 0] ------------------ 1011| 254| id_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_id(), 1012| 254| GetArena()); 1013| 254| } 1014| 254| international_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1015| 254| if (from._internal_has_international_prefix()) { ------------------ | Branch (1015:7): [True: 245, False: 9] ------------------ 1016| 245| international_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_international_prefix(), 1017| 245| GetArena()); 1018| 245| } 1019| 254| national_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1020| 254| if (from._internal_has_national_prefix()) { ------------------ | Branch (1020:7): [True: 144, False: 110] ------------------ 1021| 144| national_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_national_prefix(), 1022| 144| GetArena()); 1023| 144| } 1024| 254| preferred_extn_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1025| 254| if (from._internal_has_preferred_extn_prefix()) { ------------------ | Branch (1025:7): [True: 5, False: 249] ------------------ 1026| 5| preferred_extn_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_preferred_extn_prefix(), 1027| 5| GetArena()); 1028| 5| } 1029| 254| national_prefix_for_parsing_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1030| 254| if (from._internal_has_national_prefix_for_parsing()) { ------------------ | Branch (1030:7): [True: 150, False: 104] ------------------ 1031| 150| national_prefix_for_parsing_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_national_prefix_for_parsing(), 1032| 150| GetArena()); 1033| 150| } 1034| 254| national_prefix_transform_rule_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1035| 254| if (from._internal_has_national_prefix_transform_rule()) { ------------------ | Branch (1035:7): [True: 32, False: 222] ------------------ 1036| 32| national_prefix_transform_rule_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_national_prefix_transform_rule(), 1037| 32| GetArena()); 1038| 32| } 1039| 254| preferred_international_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1040| 254| if (from._internal_has_preferred_international_prefix()) { ------------------ | Branch (1040:7): [True: 25, False: 229] ------------------ 1041| 25| preferred_international_prefix_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_preferred_international_prefix(), 1042| 25| GetArena()); 1043| 25| } 1044| 254| leading_digits_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1045| 254| if (from._internal_has_leading_digits()) { ------------------ | Branch (1045:7): [True: 36, False: 218] ------------------ 1046| 36| leading_digits_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_leading_digits(), 1047| 36| GetArena()); 1048| 36| } 1049| 254| if (from._internal_has_general_desc()) { ------------------ | Branch (1049:7): [True: 254, False: 0] ------------------ 1050| 254| general_desc_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.general_desc_); 1051| 254| } else { 1052| 0| general_desc_ = nullptr; 1053| 0| } 1054| 254| if (from._internal_has_fixed_line()) { ------------------ | Branch (1054:7): [True: 254, False: 0] ------------------ 1055| 254| fixed_line_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.fixed_line_); 1056| 254| } else { 1057| 0| fixed_line_ = nullptr; 1058| 0| } 1059| 254| if (from._internal_has_mobile()) { ------------------ | Branch (1059:7): [True: 254, False: 0] ------------------ 1060| 254| mobile_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.mobile_); 1061| 254| } else { 1062| 0| mobile_ = nullptr; 1063| 0| } 1064| 254| if (from._internal_has_toll_free()) { ------------------ | Branch (1064:7): [True: 254, False: 0] ------------------ 1065| 254| toll_free_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.toll_free_); 1066| 254| } else { 1067| 0| toll_free_ = nullptr; 1068| 0| } 1069| 254| if (from._internal_has_premium_rate()) { ------------------ | Branch (1069:7): [True: 254, False: 0] ------------------ 1070| 254| premium_rate_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.premium_rate_); 1071| 254| } else { 1072| 0| premium_rate_ = nullptr; 1073| 0| } 1074| 254| if (from._internal_has_shared_cost()) { ------------------ | Branch (1074:7): [True: 254, False: 0] ------------------ 1075| 254| shared_cost_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.shared_cost_); 1076| 254| } else { 1077| 0| shared_cost_ = nullptr; 1078| 0| } 1079| 254| if (from._internal_has_personal_number()) { ------------------ | Branch (1079:7): [True: 254, False: 0] ------------------ 1080| 254| personal_number_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.personal_number_); 1081| 254| } else { 1082| 0| personal_number_ = nullptr; 1083| 0| } 1084| 254| if (from._internal_has_voip()) { ------------------ | Branch (1084:7): [True: 254, False: 0] ------------------ 1085| 254| voip_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.voip_); 1086| 254| } else { 1087| 0| voip_ = nullptr; 1088| 0| } 1089| 254| if (from._internal_has_pager()) { ------------------ | Branch (1089:7): [True: 254, False: 0] ------------------ 1090| 254| pager_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.pager_); 1091| 254| } else { 1092| 0| pager_ = nullptr; 1093| 0| } 1094| 254| if (from._internal_has_no_international_dialling()) { ------------------ | Branch (1094:7): [True: 254, False: 0] ------------------ 1095| 254| no_international_dialling_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.no_international_dialling_); 1096| 254| } else { 1097| 0| no_international_dialling_ = nullptr; 1098| 0| } 1099| 254| if (from._internal_has_uan()) { ------------------ | Branch (1099:7): [True: 254, False: 0] ------------------ 1100| 254| uan_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.uan_); 1101| 254| } else { 1102| 0| uan_ = nullptr; 1103| 0| } 1104| 254| if (from._internal_has_emergency()) { ------------------ | Branch (1104:7): [True: 0, False: 254] ------------------ 1105| 0| emergency_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.emergency_); 1106| 254| } else { 1107| 254| emergency_ = nullptr; 1108| 254| } 1109| 254| if (from._internal_has_voicemail()) { ------------------ | Branch (1109:7): [True: 254, False: 0] ------------------ 1110| 254| voicemail_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.voicemail_); 1111| 254| } else { 1112| 0| voicemail_ = nullptr; 1113| 0| } 1114| 254| if (from._internal_has_short_code()) { ------------------ | Branch (1114:7): [True: 0, False: 254] ------------------ 1115| 0| short_code_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.short_code_); 1116| 254| } else { 1117| 254| short_code_ = nullptr; 1118| 254| } 1119| 254| if (from._internal_has_standard_rate()) { ------------------ | Branch (1119:7): [True: 0, False: 254] ------------------ 1120| 0| standard_rate_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.standard_rate_); 1121| 254| } else { 1122| 254| standard_rate_ = nullptr; 1123| 254| } 1124| 254| if (from._internal_has_carrier_specific()) { ------------------ | Branch (1124:7): [True: 0, False: 254] ------------------ 1125| 0| carrier_specific_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.carrier_specific_); 1126| 254| } else { 1127| 254| carrier_specific_ = nullptr; 1128| 254| } 1129| 254| if (from._internal_has_sms_services()) { ------------------ | Branch (1129:7): [True: 0, False: 254] ------------------ 1130| 0| sms_services_ = new ::i18n::phonenumbers::PhoneNumberDesc(*from.sms_services_); 1131| 254| } else { 1132| 254| sms_services_ = nullptr; 1133| 254| } 1134| 254| ::memcpy(&country_code_, &from.country_code_, 1135| 254| static_cast(reinterpret_cast(&mobile_number_portable_region_) - 1136| 254| reinterpret_cast(&country_code_)) + sizeof(mobile_number_portable_region_)); 1137| | // @@protoc_insertion_point(copy_constructor:i18n.phonenumbers.PhoneMetadata) 1138| 254|} _ZN4i18n12phonenumbers13PhoneMetadataD2Ev: 1156| 508|PhoneMetadata::~PhoneMetadata() { 1157| | // @@protoc_insertion_point(destructor:i18n.phonenumbers.PhoneMetadata) 1158| 508| SharedDtor(); 1159| 508| _internal_metadata_.Delete(); 1160| 508|} _ZN4i18n12phonenumbers13PhoneMetadata14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE: 1322| 254|const char* PhoneMetadata::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure 1324| 254| _Internal::HasBits has_bits{}; 1325| 4.82k| while (!ctx->Done(&ptr)) { ------------------ | Branch (1325:10): [True: 4.57k, False: 254] ------------------ 1326| 4.57k| ::PROTOBUF_NAMESPACE_ID::uint32 tag; 1327| 4.57k| ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); 1328| 4.57k| CHK_(ptr); ------------------ | | 1323| 4.57k|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1329| 4.57k| switch (tag >> 3) { 1330| | // optional .i18n.phonenumbers.PhoneNumberDesc general_desc = 1; 1331| 254| case 1: ------------------ | Branch (1331:7): [True: 254, False: 4.31k] ------------------ 1332| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { 1333| 254| ptr = ctx->ParseMessage(_internal_mutable_general_desc(), ptr); 1334| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1335| 254| } else goto handle_unusual; 1336| 254| continue; 1337| | // optional .i18n.phonenumbers.PhoneNumberDesc fixed_line = 2; 1338| 254| case 2: ------------------ | Branch (1338:7): [True: 254, False: 4.31k] ------------------ 1339| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 18)) { 1340| 254| ptr = ctx->ParseMessage(_internal_mutable_fixed_line(), ptr); 1341| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1342| 254| } else goto handle_unusual; 1343| 254| continue; 1344| | // optional .i18n.phonenumbers.PhoneNumberDesc mobile = 3; 1345| 254| case 3: ------------------ | Branch (1345:7): [True: 254, False: 4.31k] ------------------ 1346| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 26)) { 1347| 254| ptr = ctx->ParseMessage(_internal_mutable_mobile(), ptr); 1348| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1349| 254| } else goto handle_unusual; 1350| 254| continue; 1351| | // optional .i18n.phonenumbers.PhoneNumberDesc toll_free = 4; 1352| 254| case 4: ------------------ | Branch (1352:7): [True: 254, False: 4.31k] ------------------ 1353| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 34)) { 1354| 254| ptr = ctx->ParseMessage(_internal_mutable_toll_free(), ptr); 1355| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1356| 254| } else goto handle_unusual; 1357| 254| continue; 1358| | // optional .i18n.phonenumbers.PhoneNumberDesc premium_rate = 5; 1359| 254| case 5: ------------------ | Branch (1359:7): [True: 254, False: 4.31k] ------------------ 1360| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 42)) { 1361| 254| ptr = ctx->ParseMessage(_internal_mutable_premium_rate(), ptr); 1362| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1363| 254| } else goto handle_unusual; 1364| 254| continue; 1365| | // optional .i18n.phonenumbers.PhoneNumberDesc shared_cost = 6; 1366| 254| case 6: ------------------ | Branch (1366:7): [True: 254, False: 4.31k] ------------------ 1367| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 50)) { 1368| 254| ptr = ctx->ParseMessage(_internal_mutable_shared_cost(), ptr); 1369| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1370| 254| } else goto handle_unusual; 1371| 254| continue; 1372| | // optional .i18n.phonenumbers.PhoneNumberDesc personal_number = 7; 1373| 254| case 7: ------------------ | Branch (1373:7): [True: 254, False: 4.31k] ------------------ 1374| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 58)) { 1375| 254| ptr = ctx->ParseMessage(_internal_mutable_personal_number(), ptr); 1376| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1377| 254| } else goto handle_unusual; 1378| 254| continue; 1379| | // optional .i18n.phonenumbers.PhoneNumberDesc voip = 8; 1380| 254| case 8: ------------------ | Branch (1380:7): [True: 254, False: 4.31k] ------------------ 1381| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 66)) { 1382| 254| ptr = ctx->ParseMessage(_internal_mutable_voip(), ptr); 1383| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1384| 254| } else goto handle_unusual; 1385| 254| continue; 1386| | // required string id = 9; 1387| 254| case 9: ------------------ | Branch (1387:7): [True: 254, False: 4.31k] ------------------ 1388| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 74)) { 1389| 254| auto str = _internal_mutable_id(); 1390| 254| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 1391| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1392| 254| } else goto handle_unusual; 1393| 254| continue; 1394| | // optional int32 country_code = 10; 1395| 254| case 10: ------------------ | Branch (1395:7): [True: 254, False: 4.31k] ------------------ 1396| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 80)) { 1397| 254| _Internal::set_has_country_code(&has_bits); 1398| 254| country_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); 1399| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1400| 254| } else goto handle_unusual; 1401| 254| continue; 1402| | // optional string international_prefix = 11; 1403| 254| case 11: ------------------ | Branch (1403:7): [True: 245, False: 4.32k] ------------------ 1404| 245| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 90)) { 1405| 245| auto str = _internal_mutable_international_prefix(); 1406| 245| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 1407| 245| CHK_(ptr); ------------------ | | 1323| 245|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1408| 245| } else goto handle_unusual; 1409| 245| continue; 1410| | // optional string national_prefix = 12; 1411| 245| case 12: ------------------ | Branch (1411:7): [True: 144, False: 4.42k] ------------------ 1412| 144| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 98)) { 1413| 144| auto str = _internal_mutable_national_prefix(); 1414| 144| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 1415| 144| CHK_(ptr); ------------------ | | 1323| 144|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1416| 144| } else goto handle_unusual; 1417| 144| continue; 1418| | // optional string preferred_extn_prefix = 13; 1419| 144| case 13: ------------------ | Branch (1419:7): [True: 5, False: 4.56k] ------------------ 1420| 5| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 106)) { 1421| 5| auto str = _internal_mutable_preferred_extn_prefix(); 1422| 5| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 1423| 5| CHK_(ptr); ------------------ | | 1323| 5|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1424| 5| } else goto handle_unusual; 1425| 5| continue; 1426| | // optional string national_prefix_for_parsing = 15; 1427| 150| case 15: ------------------ | Branch (1427:7): [True: 150, False: 4.42k] ------------------ 1428| 150| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 122)) { 1429| 150| auto str = _internal_mutable_national_prefix_for_parsing(); 1430| 150| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 1431| 150| CHK_(ptr); ------------------ | | 1323| 150|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1432| 150| } else goto handle_unusual; 1433| 150| continue; 1434| | // optional string national_prefix_transform_rule = 16; 1435| 150| case 16: ------------------ | Branch (1435:7): [True: 32, False: 4.54k] ------------------ 1436| 32| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 130)) { 1437| 32| auto str = _internal_mutable_national_prefix_transform_rule(); 1438| 32| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 1439| 32| CHK_(ptr); ------------------ | | 1323| 32|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1440| 32| } else goto handle_unusual; 1441| 32| continue; 1442| | // optional string preferred_international_prefix = 17; 1443| 32| case 17: ------------------ | Branch (1443:7): [True: 25, False: 4.54k] ------------------ 1444| 25| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 138)) { 1445| 25| auto str = _internal_mutable_preferred_international_prefix(); 1446| 25| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 1447| 25| CHK_(ptr); ------------------ | | 1323| 25|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1448| 25| } else goto handle_unusual; 1449| 25| continue; 1450| | // optional bool same_mobile_and_fixed_line_pattern = 18 [default = false]; 1451| 25| case 18: ------------------ | Branch (1451:7): [True: 13, False: 4.56k] ------------------ 1452| 13| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 144)) { 1453| 13| _Internal::set_has_same_mobile_and_fixed_line_pattern(&has_bits); 1454| 13| same_mobile_and_fixed_line_pattern_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); 1455| 13| CHK_(ptr); ------------------ | | 1323| 13|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1456| 13| } else goto handle_unusual; 1457| 13| continue; 1458| | // repeated .i18n.phonenumbers.NumberFormat number_format = 19; 1459| 210| case 19: ------------------ | Branch (1459:7): [True: 210, False: 4.36k] ------------------ 1460| 210| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 154)) { 1461| 210| ptr -= 2; 1462| 754| do { 1463| 754| ptr += 2; 1464| 754| ptr = ctx->ParseMessage(_internal_add_number_format(), ptr); 1465| 754| CHK_(ptr); ------------------ | | 1323| 754|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1466| 754| if (!ctx->DataAvailable(ptr)) break; ------------------ | Branch (1466:17): [True: 0, False: 754] ------------------ 1467| 754| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<154>(ptr)); ------------------ | Branch (1467:20): [True: 544, False: 210] ------------------ 1468| 210| } else goto handle_unusual; 1469| 210| continue; 1470| | // repeated .i18n.phonenumbers.NumberFormat intl_number_format = 20; 1471| 210| case 20: ------------------ | Branch (1471:7): [True: 38, False: 4.53k] ------------------ 1472| 38| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 162)) { 1473| 38| ptr -= 2; 1474| 179| do { 1475| 179| ptr += 2; 1476| 179| ptr = ctx->ParseMessage(_internal_add_intl_number_format(), ptr); 1477| 179| CHK_(ptr); ------------------ | | 1323| 179|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1478| 179| if (!ctx->DataAvailable(ptr)) break; ------------------ | Branch (1478:17): [True: 0, False: 179] ------------------ 1479| 179| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<162>(ptr)); ------------------ | Branch (1479:20): [True: 141, False: 38] ------------------ 1480| 38| } else goto handle_unusual; 1481| 38| continue; 1482| | // optional .i18n.phonenumbers.PhoneNumberDesc pager = 21; 1483| 254| case 21: ------------------ | Branch (1483:7): [True: 254, False: 4.31k] ------------------ 1484| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 170)) { 1485| 254| ptr = ctx->ParseMessage(_internal_mutable_pager(), ptr); 1486| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1487| 254| } else goto handle_unusual; 1488| 254| continue; 1489| | // optional bool main_country_for_code = 22 [default = false]; 1490| 254| case 22: ------------------ | Branch (1490:7): [True: 12, False: 4.56k] ------------------ 1491| 12| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 176)) { 1492| 12| _Internal::set_has_main_country_for_code(&has_bits); 1493| 12| main_country_for_code_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); 1494| 12| CHK_(ptr); ------------------ | | 1323| 12|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1495| 12| } else goto handle_unusual; 1496| 12| continue; 1497| | // optional string leading_digits = 23; 1498| 36| case 23: ------------------ | Branch (1498:7): [True: 36, False: 4.53k] ------------------ 1499| 36| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 186)) { 1500| 36| auto str = _internal_mutable_leading_digits(); 1501| 36| ptr = ::PROTOBUF_NAMESPACE_ID::internal::InlineGreedyStringParser(str, ptr, ctx); 1502| 36| CHK_(ptr); ------------------ | | 1323| 36|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1503| 36| } else goto handle_unusual; 1504| 36| continue; 1505| | // optional .i18n.phonenumbers.PhoneNumberDesc no_international_dialling = 24; 1506| 254| case 24: ------------------ | Branch (1506:7): [True: 254, False: 4.31k] ------------------ 1507| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 194)) { 1508| 254| ptr = ctx->ParseMessage(_internal_mutable_no_international_dialling(), ptr); 1509| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1510| 254| } else goto handle_unusual; 1511| 254| continue; 1512| | // optional .i18n.phonenumbers.PhoneNumberDesc uan = 25; 1513| 254| case 25: ------------------ | Branch (1513:7): [True: 254, False: 4.31k] ------------------ 1514| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 202)) { 1515| 254| ptr = ctx->ParseMessage(_internal_mutable_uan(), ptr); 1516| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1517| 254| } else goto handle_unusual; 1518| 254| continue; 1519| | // optional .i18n.phonenumbers.PhoneNumberDesc emergency = 27; 1520| 254| case 27: ------------------ | Branch (1520:7): [True: 0, False: 4.57k] ------------------ 1521| 0| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 218)) { 1522| 0| ptr = ctx->ParseMessage(_internal_mutable_emergency(), ptr); 1523| 0| CHK_(ptr); ------------------ | | 1323| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1524| 0| } else goto handle_unusual; 1525| 0| continue; 1526| | // optional .i18n.phonenumbers.PhoneNumberDesc voicemail = 28; 1527| 254| case 28: ------------------ | Branch (1527:7): [True: 254, False: 4.31k] ------------------ 1528| 254| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 226)) { 1529| 254| ptr = ctx->ParseMessage(_internal_mutable_voicemail(), ptr); 1530| 254| CHK_(ptr); ------------------ | | 1323| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1531| 254| } else goto handle_unusual; 1532| 254| continue; 1533| | // optional .i18n.phonenumbers.PhoneNumberDesc short_code = 29; 1534| 254| case 29: ------------------ | Branch (1534:7): [True: 0, False: 4.57k] ------------------ 1535| 0| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 234)) { 1536| 0| ptr = ctx->ParseMessage(_internal_mutable_short_code(), ptr); 1537| 0| CHK_(ptr); ------------------ | | 1323| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1538| 0| } else goto handle_unusual; 1539| 0| continue; 1540| | // optional .i18n.phonenumbers.PhoneNumberDesc standard_rate = 30; 1541| 0| case 30: ------------------ | Branch (1541:7): [True: 0, False: 4.57k] ------------------ 1542| 0| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 242)) { 1543| 0| ptr = ctx->ParseMessage(_internal_mutable_standard_rate(), ptr); 1544| 0| CHK_(ptr); ------------------ | | 1323| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1545| 0| } else goto handle_unusual; 1546| 0| continue; 1547| | // optional .i18n.phonenumbers.PhoneNumberDesc carrier_specific = 31; 1548| 0| case 31: ------------------ | Branch (1548:7): [True: 0, False: 4.57k] ------------------ 1549| 0| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 250)) { 1550| 0| ptr = ctx->ParseMessage(_internal_mutable_carrier_specific(), ptr); 1551| 0| CHK_(ptr); ------------------ | | 1323| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1552| 0| } else goto handle_unusual; 1553| 0| continue; 1554| | // optional bool mobile_number_portable_region = 32 [default = false]; 1555| 107| case 32: ------------------ | Branch (1555:7): [True: 107, False: 4.46k] ------------------ 1556| 107| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 0)) { 1557| 107| _Internal::set_has_mobile_number_portable_region(&has_bits); 1558| 107| mobile_number_portable_region_ = ::PROTOBUF_NAMESPACE_ID::internal::ReadVarint64(&ptr); 1559| 107| CHK_(ptr); ------------------ | | 1323| 107|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1560| 107| } else goto handle_unusual; 1561| 107| continue; 1562| | // optional .i18n.phonenumbers.PhoneNumberDesc sms_services = 33; 1563| 107| case 33: ------------------ | Branch (1563:7): [True: 0, False: 4.57k] ------------------ 1564| 0| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { 1565| 0| ptr = ctx->ParseMessage(_internal_mutable_sms_services(), ptr); 1566| 0| CHK_(ptr); ------------------ | | 1323| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1567| 0| } else goto handle_unusual; 1568| 0| continue; 1569| 0| default: { ------------------ | Branch (1569:7): [True: 0, False: 4.57k] ------------------ 1570| 0| handle_unusual: 1571| 0| if ((tag & 7) == 4 || tag == 0) { ------------------ | Branch (1571:13): [True: 0, False: 0] | Branch (1571:31): [True: 0, False: 0] ------------------ 1572| 0| ctx->SetLastTag(tag); 1573| 0| goto success; 1574| 0| } 1575| 0| ptr = UnknownFieldParse(tag, 1576| 0| _internal_metadata_.mutable_unknown_fields(), 1577| 0| ptr, ctx); 1578| 0| CHK_(ptr != nullptr); ------------------ | | 1323| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 1579| 0| continue; 1580| 0| } 1581| 4.57k| } // switch 1582| 4.57k| } // while 1583| 254|success: 1584| 254| _has_bits_.Or(has_bits); 1585| 254| return ptr; 1586| 0|failure: 1587| 0| ptr = nullptr; 1588| 0| goto success; 1589| 254|#undef CHK_ 1590| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata13IsInitializedEv: 2187| 254|bool PhoneMetadata::IsInitialized() const { 2188| 254| if (_Internal::MissingRequiredFields(_has_bits_)) return false; ------------------ | Branch (2188:7): [True: 0, False: 254] ------------------ 2189| 254| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(number_format_)) return false; ------------------ | Branch (2189:7): [True: 0, False: 254] ------------------ 2190| 254| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(intl_number_format_)) return false; ------------------ | Branch (2190:7): [True: 0, False: 254] ------------------ 2191| 254| return true; 2192| 254|} _ZN4i18n12phonenumbers13PhoneMetadata12InternalSwapEPS1_: 2194| 254|void PhoneMetadata::InternalSwap(PhoneMetadata* other) { 2195| 254| using std::swap; 2196| 254| _internal_metadata_.Swap(&other->_internal_metadata_); 2197| 254| swap(_has_bits_[0], other->_has_bits_[0]); 2198| 254| number_format_.InternalSwap(&other->number_format_); 2199| 254| intl_number_format_.InternalSwap(&other->intl_number_format_); 2200| 254| id_.Swap(&other->id_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 2201| 254| international_prefix_.Swap(&other->international_prefix_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 2202| 254| national_prefix_.Swap(&other->national_prefix_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 2203| 254| preferred_extn_prefix_.Swap(&other->preferred_extn_prefix_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 2204| 254| national_prefix_for_parsing_.Swap(&other->national_prefix_for_parsing_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 2205| 254| national_prefix_transform_rule_.Swap(&other->national_prefix_transform_rule_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 2206| 254| preferred_international_prefix_.Swap(&other->preferred_international_prefix_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 2207| 254| leading_digits_.Swap(&other->leading_digits_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 2208| 254| ::PROTOBUF_NAMESPACE_ID::internal::memswap< 2209| 254| PROTOBUF_FIELD_OFFSET(PhoneMetadata, mobile_number_portable_region_) 2210| 254| + sizeof(PhoneMetadata::mobile_number_portable_region_) 2211| 254| - PROTOBUF_FIELD_OFFSET(PhoneMetadata, general_desc_)>( 2212| 254| reinterpret_cast(&general_desc_), 2213| 254| reinterpret_cast(&other->general_desc_)); 2214| 254|} _ZN4i18n12phonenumbers23PhoneMetadataCollectionC2EPN6google8protobuf5ArenaE: 2228| 2| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena), 2229| 2| metadata_(arena) { 2230| 2| SharedCtor(); 2231| 2| RegisterArenaDtor(arena); 2232| | // @@protoc_insertion_point(arena_constructor:i18n.phonenumbers.PhoneMetadataCollection) 2233| 2|} _ZN4i18n12phonenumbers23PhoneMetadataCollectionD2Ev: 2245| 1|PhoneMetadataCollection::~PhoneMetadataCollection() { 2246| | // @@protoc_insertion_point(destructor:i18n.phonenumbers.PhoneMetadataCollection) 2247| 1| SharedDtor(); 2248| 1| _internal_metadata_.Delete(); 2249| 1|} _ZN4i18n12phonenumbers23PhoneMetadataCollection5ClearEv: 2270| 1|void PhoneMetadataCollection::Clear() { 2271| |// @@protoc_insertion_point(message_clear_start:i18n.phonenumbers.PhoneMetadataCollection) 2272| 1| ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; 2273| | // Prevent compiler warnings about cached_has_bits being unused 2274| 1| (void) cached_has_bits; 2275| | 2276| 1| metadata_.Clear(); 2277| 1| _internal_metadata_.Clear(); 2278| 1|} _ZN4i18n12phonenumbers23PhoneMetadataCollection14_InternalParseEPKcPN6google8protobuf8internal12ParseContextE: 2280| 1|const char* PhoneMetadataCollection::_InternalParse(const char* ptr, ::PROTOBUF_NAMESPACE_ID::internal::ParseContext* ctx) { 2281| 1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure 2282| 2| while (!ctx->Done(&ptr)) { ------------------ | Branch (2282:10): [True: 1, False: 1] ------------------ 2283| 1| ::PROTOBUF_NAMESPACE_ID::uint32 tag; 2284| 1| ptr = ::PROTOBUF_NAMESPACE_ID::internal::ReadTag(ptr, &tag); 2285| 1| CHK_(ptr); ------------------ | | 2281| 1|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 2286| 1| switch (tag >> 3) { 2287| | // repeated .i18n.phonenumbers.PhoneMetadata metadata = 1; 2288| 1| case 1: ------------------ | Branch (2288:7): [True: 1, False: 0] ------------------ 2289| 1| if (PROTOBUF_PREDICT_TRUE(static_cast<::PROTOBUF_NAMESPACE_ID::uint8>(tag) == 10)) { 2290| 1| ptr -= 1; 2291| 254| do { 2292| 254| ptr += 1; 2293| 254| ptr = ctx->ParseMessage(_internal_add_metadata(), ptr); 2294| 254| CHK_(ptr); ------------------ | | 2281| 254|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 2295| 254| if (!ctx->DataAvailable(ptr)) break; ------------------ | Branch (2295:17): [True: 1, False: 253] ------------------ 2296| 254| } while (::PROTOBUF_NAMESPACE_ID::internal::ExpectTag<10>(ptr)); ------------------ | Branch (2296:20): [True: 253, False: 0] ------------------ 2297| 1| } else goto handle_unusual; 2298| 1| continue; 2299| 1| default: { ------------------ | Branch (2299:7): [True: 0, False: 1] ------------------ 2300| 0| handle_unusual: 2301| 0| if ((tag & 7) == 4 || tag == 0) { ------------------ | Branch (2301:13): [True: 0, False: 0] | Branch (2301:31): [True: 0, False: 0] ------------------ 2302| 0| ctx->SetLastTag(tag); 2303| 0| goto success; 2304| 0| } 2305| 0| ptr = UnknownFieldParse(tag, 2306| 0| _internal_metadata_.mutable_unknown_fields(), 2307| 0| ptr, ctx); 2308| 0| CHK_(ptr != nullptr); ------------------ | | 2281| 0|#define CHK_(x) if (PROTOBUF_PREDICT_FALSE(!(x))) goto failure ------------------ 2309| 0| continue; 2310| 0| } 2311| 1| } // switch 2312| 1| } // while 2313| 1|success: 2314| 1| return ptr; 2315| 0|failure: 2316| 0| ptr = nullptr; 2317| 0| goto success; 2318| 1|#undef CHK_ 2319| 1|} _ZNK4i18n12phonenumbers23PhoneMetadataCollection13IsInitializedEv: 2389| 1|bool PhoneMetadataCollection::IsInitialized() const { 2390| 1| if (!::PROTOBUF_NAMESPACE_ID::internal::AllAreInitialized(metadata_)) return false; ------------------ | Branch (2390:7): [True: 0, False: 1] ------------------ 2391| 1| return true; 2392| 1|} _ZN6google8protobuf5Arena18CreateMaybeMessageIN4i18n12phonenumbers12NumberFormatEJEEEPT_PS1_DpOT0_: 2409| 306k|template<> PROTOBUF_NOINLINE ::i18n::phonenumbers::NumberFormat* Arena::CreateMaybeMessage< ::i18n::phonenumbers::NumberFormat >(Arena* arena) { 2410| 306k| return Arena::CreateMessageInternal< ::i18n::phonenumbers::NumberFormat >(arena); 2411| 306k|} _ZN6google8protobuf5Arena18CreateMaybeMessageIN4i18n12phonenumbers15PhoneNumberDescEJEEEPT_PS1_DpOT0_: 2412| 3.04k|template<> PROTOBUF_NOINLINE ::i18n::phonenumbers::PhoneNumberDesc* Arena::CreateMaybeMessage< ::i18n::phonenumbers::PhoneNumberDesc >(Arena* arena) { 2413| 3.04k| return Arena::CreateMessageInternal< ::i18n::phonenumbers::PhoneNumberDesc >(arena); 2414| 3.04k|} _ZN6google8protobuf5Arena18CreateMaybeMessageIN4i18n12phonenumbers13PhoneMetadataEJEEEPT_PS1_DpOT0_: 2415| 254|template<> PROTOBUF_NOINLINE ::i18n::phonenumbers::PhoneMetadata* Arena::CreateMaybeMessage< ::i18n::phonenumbers::PhoneMetadata >(Arena* arena) { 2416| 254| return Arena::CreateMessageInternal< ::i18n::phonenumbers::PhoneMetadata >(arena); 2417| 254|} phonemetadata.pb.cc:_ZL55InitDefaultsscc_info_NumberFormat_phonemetadata_2eprotov: 37| 1|static void InitDefaultsscc_info_NumberFormat_phonemetadata_2eproto() { 38| 1| GOOGLE_PROTOBUF_VERIFY_VERSION; 39| | 40| 1| { 41| 1| void* ptr = &::i18n::phonenumbers::_NumberFormat_default_instance_; 42| 1| new (ptr) ::i18n::phonenumbers::NumberFormat(); 43| 1| ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); 44| 1| } 45| 1|} phonemetadata.pb.cc:_ZL56InitDefaultsscc_info_PhoneMetadata_phonemetadata_2eprotov: 50| 1|static void InitDefaultsscc_info_PhoneMetadata_phonemetadata_2eproto() { 51| 1| GOOGLE_PROTOBUF_VERIFY_VERSION; 52| | 53| 1| { 54| 1| void* ptr = &::i18n::phonenumbers::_PhoneMetadata_default_instance_; 55| 1| new (ptr) ::i18n::phonenumbers::PhoneMetadata(); 56| 1| ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); 57| 1| } 58| 1|} phonemetadata.pb.cc:_ZL66InitDefaultsscc_info_PhoneMetadataCollection_phonemetadata_2eprotov: 65| 1|static void InitDefaultsscc_info_PhoneMetadataCollection_phonemetadata_2eproto() { 66| 1| GOOGLE_PROTOBUF_VERIFY_VERSION; 67| | 68| 1| { 69| 1| void* ptr = &::i18n::phonenumbers::_PhoneMetadataCollection_default_instance_; 70| 1| new (ptr) ::i18n::phonenumbers::PhoneMetadataCollection(); 71| 1| ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); 72| 1| } 73| 1|} phonemetadata.pb.cc:_ZL58InitDefaultsscc_info_PhoneNumberDesc_phonemetadata_2eprotov: 79| 1|static void InitDefaultsscc_info_PhoneNumberDesc_phonemetadata_2eproto() { 80| 1| GOOGLE_PROTOBUF_VERIFY_VERSION; 81| | 82| 1| { 83| 1| void* ptr = &::i18n::phonenumbers::_PhoneNumberDesc_default_instance_; 84| 1| new (ptr) ::i18n::phonenumbers::PhoneNumberDesc(); 85| 1| ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); 86| 1| } 87| 1|} _ZN4i18n12phonenumbers12NumberFormat10SharedCtorEv: 156| 307k|void NumberFormat::SharedCtor() { 157| 307k| ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_NumberFormat_phonemetadata_2eproto.base); 158| 307k| pattern_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 159| 307k| format_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 160| 307k| national_prefix_formatting_rule_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 161| 307k| domestic_carrier_code_formatting_rule_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 162| 307k| national_prefix_optional_when_formatting_ = false; 163| 307k|} _ZN4i18n12phonenumbers12NumberFormat10SharedDtorEv: 171| 306k|void NumberFormat::SharedDtor() { 172| 306k| GOOGLE_DCHECK(GetArena() == nullptr); 173| 306k| pattern_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 174| 306k| format_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 175| 306k| national_prefix_formatting_rule_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 176| 306k| domestic_carrier_code_formatting_rule_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 177| 306k|} _ZN4i18n12phonenumbers12NumberFormat17RegisterArenaDtorEPN6google8protobuf5ArenaE: 183| 307k|void NumberFormat::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { 184| 307k|} _ZN4i18n12phonenumbers12NumberFormat9_Internal48set_has_national_prefix_optional_when_formattingEPN6google8protobuf8internal7HasBitsILm1EEE: 109| 74| static void set_has_national_prefix_optional_when_formatting(HasBits* has_bits) { 110| 74| (*has_bits)[0] |= 16u; 111| 74| } _ZN4i18n12phonenumbers12NumberFormat9_Internal21MissingRequiredFieldsERKN6google8protobuf8internal7HasBitsILm1EEE: 115| 933| static bool MissingRequiredFields(const HasBits& has_bits) { 116| 933| return ((has_bits[0] & 0x00000003) ^ 0x00000003) != 0; 117| 933| } _ZN4i18n12phonenumbers15PhoneNumberDesc10SharedCtorEv: 540| 3.04k|void PhoneNumberDesc::SharedCtor() { 541| 3.04k| ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PhoneNumberDesc_phonemetadata_2eproto.base); 542| 3.04k| national_number_pattern_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 543| 3.04k| example_number_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 544| 3.04k|} _ZN4i18n12phonenumbers15PhoneNumberDesc10SharedDtorEv: 552| 3.23k|void PhoneNumberDesc::SharedDtor() { 553| 3.23k| GOOGLE_DCHECK(GetArena() == nullptr); 554| 3.23k| national_number_pattern_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 555| 3.23k| example_number_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 556| 3.23k|} _ZN4i18n12phonenumbers15PhoneNumberDesc17RegisterArenaDtorEPN6google8protobuf5ArenaE: 562| 3.04k|void PhoneNumberDesc::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { 563| 3.04k|} _ZN4i18n12phonenumbers13PhoneMetadata10SharedCtorEv: 1140| 509|void PhoneMetadata::SharedCtor() { 1141| 509| ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PhoneMetadata_phonemetadata_2eproto.base); 1142| 509| id_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1143| 509| international_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1144| 509| national_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1145| 509| preferred_extn_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1146| 509| national_prefix_for_parsing_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1147| 509| national_prefix_transform_rule_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1148| 509| preferred_international_prefix_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1149| 509| leading_digits_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1150| 509| ::memset(reinterpret_cast(this) + static_cast( 1151| 509| reinterpret_cast(&general_desc_) - reinterpret_cast(this)), 1152| 509| 0, static_cast(reinterpret_cast(&mobile_number_portable_region_) - 1153| 509| reinterpret_cast(&general_desc_)) + sizeof(mobile_number_portable_region_)); 1154| 509|} _ZN4i18n12phonenumbers13PhoneMetadata10SharedDtorEv: 1162| 508|void PhoneMetadata::SharedDtor() { 1163| 508| GOOGLE_DCHECK(GetArena() == nullptr); 1164| 508| id_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1165| 508| international_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1166| 508| national_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1167| 508| preferred_extn_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1168| 508| national_prefix_for_parsing_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1169| 508| national_prefix_transform_rule_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1170| 508| preferred_international_prefix_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1171| 508| leading_digits_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 1172| 508| if (this != internal_default_instance()) delete general_desc_; ------------------ | Branch (1172:7): [True: 508, False: 0] ------------------ 1173| 508| if (this != internal_default_instance()) delete fixed_line_; ------------------ | Branch (1173:7): [True: 508, False: 0] ------------------ 1174| 508| if (this != internal_default_instance()) delete mobile_; ------------------ | Branch (1174:7): [True: 508, False: 0] ------------------ 1175| 508| if (this != internal_default_instance()) delete toll_free_; ------------------ | Branch (1175:7): [True: 508, False: 0] ------------------ 1176| 508| if (this != internal_default_instance()) delete premium_rate_; ------------------ | Branch (1176:7): [True: 508, False: 0] ------------------ 1177| 508| if (this != internal_default_instance()) delete shared_cost_; ------------------ | Branch (1177:7): [True: 508, False: 0] ------------------ 1178| 508| if (this != internal_default_instance()) delete personal_number_; ------------------ | Branch (1178:7): [True: 508, False: 0] ------------------ 1179| 508| if (this != internal_default_instance()) delete voip_; ------------------ | Branch (1179:7): [True: 508, False: 0] ------------------ 1180| 508| if (this != internal_default_instance()) delete pager_; ------------------ | Branch (1180:7): [True: 508, False: 0] ------------------ 1181| 508| if (this != internal_default_instance()) delete no_international_dialling_; ------------------ | Branch (1181:7): [True: 508, False: 0] ------------------ 1182| 508| if (this != internal_default_instance()) delete uan_; ------------------ | Branch (1182:7): [True: 508, False: 0] ------------------ 1183| 508| if (this != internal_default_instance()) delete emergency_; ------------------ | Branch (1183:7): [True: 508, False: 0] ------------------ 1184| 508| if (this != internal_default_instance()) delete voicemail_; ------------------ | Branch (1184:7): [True: 508, False: 0] ------------------ 1185| 508| if (this != internal_default_instance()) delete short_code_; ------------------ | Branch (1185:7): [True: 508, False: 0] ------------------ 1186| 508| if (this != internal_default_instance()) delete standard_rate_; ------------------ | Branch (1186:7): [True: 508, False: 0] ------------------ 1187| 508| if (this != internal_default_instance()) delete carrier_specific_; ------------------ | Branch (1187:7): [True: 508, False: 0] ------------------ 1188| 508| if (this != internal_default_instance()) delete sms_services_; ------------------ | Branch (1188:7): [True: 508, False: 0] ------------------ 1189| 508|} _ZN4i18n12phonenumbers13PhoneMetadata17RegisterArenaDtorEPN6google8protobuf5ArenaE: 1195| 509|void PhoneMetadata::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { 1196| 509|} _ZN4i18n12phonenumbers13PhoneMetadata9_Internal20set_has_country_codeEPN6google8protobuf8internal7HasBitsILm1EEE: 889| 254| static void set_has_country_code(HasBits* has_bits) { 890| 254| (*has_bits)[0] |= 33554432u; 891| 254| } _ZN4i18n12phonenumbers13PhoneMetadata9_Internal42set_has_same_mobile_and_fixed_line_patternEPN6google8protobuf8internal7HasBitsILm1EEE: 910| 13| static void set_has_same_mobile_and_fixed_line_pattern(HasBits* has_bits) { 911| 13| (*has_bits)[0] |= 67108864u; 912| 13| } _ZN4i18n12phonenumbers13PhoneMetadata9_Internal29set_has_main_country_for_codeEPN6google8protobuf8internal7HasBitsILm1EEE: 913| 12| static void set_has_main_country_for_code(HasBits* has_bits) { 914| 12| (*has_bits)[0] |= 134217728u; 915| 12| } _ZN4i18n12phonenumbers13PhoneMetadata9_Internal37set_has_mobile_number_portable_regionEPN6google8protobuf8internal7HasBitsILm1EEE: 919| 107| static void set_has_mobile_number_portable_region(HasBits* has_bits) { 920| 107| (*has_bits)[0] |= 268435456u; 921| 107| } _ZN4i18n12phonenumbers13PhoneMetadata9_Internal21MissingRequiredFieldsERKN6google8protobuf8internal7HasBitsILm1EEE: 922| 254| static bool MissingRequiredFields(const HasBits& has_bits) { 923| 254| return ((has_bits[0] & 0x00000001) ^ 0x00000001) != 0; 924| 254| } _ZN4i18n12phonenumbers23PhoneMetadataCollection10SharedCtorEv: 2241| 2|void PhoneMetadataCollection::SharedCtor() { 2242| 2| ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PhoneMetadataCollection_phonemetadata_2eproto.base); 2243| 2|} _ZN4i18n12phonenumbers23PhoneMetadataCollection10SharedDtorEv: 2251| 1|void PhoneMetadataCollection::SharedDtor() { 2252| 1| GOOGLE_DCHECK(GetArena() == nullptr); 2253| 1|} _ZN4i18n12phonenumbers23PhoneMetadataCollection17RegisterArenaDtorEPN6google8protobuf5ArenaE: 2259| 2|void PhoneMetadataCollection::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { 2260| 2|} _ZN4i18n12phonenumbers12NumberFormat11set_patternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1436| 9.65k|inline void NumberFormat::set_pattern(const std::string& value) { 1437| 9.65k| _internal_set_pattern(value); 1438| | // @@protoc_insertion_point(field_set:i18n.phonenumbers.NumberFormat.pattern) 1439| 9.65k|} _ZN4i18n12phonenumbers12NumberFormat21_internal_set_patternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1447| 306k|inline void NumberFormat::_internal_set_pattern(const std::string& value) { 1448| 306k| _has_bits_[0] |= 0x00000001u; 1449| 306k| pattern_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); 1450| 306k|} _ZN4i18n12phonenumbers12NumberFormat10set_formatERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1509| 9.65k|inline void NumberFormat::set_format(const std::string& value) { 1510| 9.65k| _internal_set_format(value); 1511| | // @@protoc_insertion_point(field_set:i18n.phonenumbers.NumberFormat.format) 1512| 9.65k|} _ZN4i18n12phonenumbers12NumberFormat20_internal_set_formatERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1520| 306k|inline void NumberFormat::_internal_set_format(const std::string& value) { 1521| 306k| _has_bits_[0] |= 0x00000002u; 1522| 306k| format_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); 1523| 306k|} _ZN4i18n12phonenumbers12NumberFormatC2Ev: 83| 307k| inline NumberFormat() : NumberFormat(nullptr) {} _ZN4i18n12phonenumbers15PhoneNumberDescC2Ev: 333| 3.04k| inline PhoneNumberDesc() : PhoneNumberDesc(nullptr) {} _ZN4i18n12phonenumbers13PhoneMetadataC2Ev: 543| 509| inline PhoneMetadata() : PhoneMetadata(nullptr) {} _ZN4i18n12phonenumbers13PhoneMetadataC2EOS1_: 548| 254| : PhoneMetadata() { 549| 254| *this = ::std::move(from); 550| 254| } _ZN4i18n12phonenumbers13PhoneMetadataaSEOS1_: 556| 254| inline PhoneMetadata& operator=(PhoneMetadata&& from) noexcept { 557| 254| if (GetArena() == from.GetArena()) { ------------------ | Branch (557:9): [True: 254, False: 0] ------------------ 558| 254| if (this != &from) InternalSwap(&from); ------------------ | Branch (558:11): [True: 254, False: 0] ------------------ 559| 254| } else { 560| 0| CopyFrom(from); 561| 0| } 562| 254| return *this; 563| 254| } _ZN4i18n12phonenumbers13PhoneMetadata25internal_default_instanceEv: 574| 8.63k| static inline const PhoneMetadata* internal_default_instance() { 575| 8.63k| return reinterpret_cast( 576| 8.63k| &_PhoneMetadata_default_instance_); 577| 8.63k| } _ZN4i18n12phonenumbers23PhoneMetadataCollectionC2Ev: 1277| 2| inline PhoneMetadataCollection() : PhoneMetadataCollection(nullptr) {} _ZNK4i18n12phonenumbers12NumberFormat7patternEv: 1432| 67.1k|inline const std::string& NumberFormat::pattern() const { 1433| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.NumberFormat.pattern) 1434| 67.1k| return _internal_pattern(); 1435| 67.1k|} _ZNK4i18n12phonenumbers12NumberFormat17_internal_patternEv: 1444| 363k|inline const std::string& NumberFormat::_internal_pattern() const { 1445| 363k| return pattern_.Get(); 1446| 363k|} _ZN4i18n12phonenumbers12NumberFormat11set_patternEPKc: 1457| 219|inline void NumberFormat::set_pattern(const char* value) { 1458| 219| GOOGLE_DCHECK(value != nullptr); 1459| 219| _has_bits_[0] |= 0x00000001u; 1460| 219| pattern_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); 1461| | // @@protoc_insertion_point(field_set_char:i18n.phonenumbers.NumberFormat.pattern) 1462| 219|} _ZN4i18n12phonenumbers12NumberFormat25_internal_mutable_patternEv: 1470| 933|inline std::string* NumberFormat::_internal_mutable_pattern() { 1471| 933| _has_bits_[0] |= 0x00000001u; 1472| 933| return pattern_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 1473| 933|} _ZNK4i18n12phonenumbers12NumberFormat6formatEv: 1505| 6.30k|inline const std::string& NumberFormat::format() const { 1506| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.NumberFormat.format) 1507| 6.30k| return _internal_format(); 1508| 6.30k|} _ZNK4i18n12phonenumbers12NumberFormat16_internal_formatEv: 1517| 302k|inline const std::string& NumberFormat::_internal_format() const { 1518| 302k| return format_.Get(); 1519| 302k|} _ZN4i18n12phonenumbers12NumberFormat10set_formatEPKc: 1530| 219|inline void NumberFormat::set_format(const char* value) { 1531| 219| GOOGLE_DCHECK(value != nullptr); 1532| 219| _has_bits_[0] |= 0x00000002u; 1533| 219| format_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, ::std::string(value), GetArena()); 1534| | // @@protoc_insertion_point(field_set_char:i18n.phonenumbers.NumberFormat.format) 1535| 219|} _ZN4i18n12phonenumbers12NumberFormat24_internal_mutable_formatEv: 1543| 933|inline std::string* NumberFormat::_internal_mutable_format() { 1544| 933| _has_bits_[0] |= 0x00000002u; 1545| 933| return format_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 1546| 933|} _ZNK4i18n12phonenumbers12NumberFormat37_internal_leading_digits_pattern_sizeEv: 1567| 333k|inline int NumberFormat::_internal_leading_digits_pattern_size() const { 1568| 333k| return leading_digits_pattern_.size(); 1569| 333k|} _ZNK4i18n12phonenumbers12NumberFormat27leading_digits_pattern_sizeEv: 1570| 333k|inline int NumberFormat::leading_digits_pattern_size() const { 1571| 333k| return _internal_leading_digits_pattern_size(); 1572| 333k|} _ZNK4i18n12phonenumbers12NumberFormat32_internal_leading_digits_patternEi: 1580| 325k|inline const std::string& NumberFormat::_internal_leading_digits_pattern(int index) const { 1581| 325k| return leading_digits_pattern_.Get(index); 1582| 325k|} _ZNK4i18n12phonenumbers12NumberFormat22leading_digits_patternEi: 1583| 325k|inline const std::string& NumberFormat::leading_digits_pattern(int index) const { 1584| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.NumberFormat.leading_digits_pattern) 1585| 325k| return _internal_leading_digits_pattern(index); 1586| 325k|} _ZN4i18n12phonenumbers12NumberFormat36_internal_add_leading_digits_patternEv: 1609| 1.08k|inline std::string* NumberFormat::_internal_add_leading_digits_pattern() { 1610| 1.08k| return leading_digits_pattern_.Add(); 1611| 1.08k|} _ZN4i18n12phonenumbers12NumberFormat37clear_national_prefix_formatting_ruleEv: 1648| 130|inline void NumberFormat::clear_national_prefix_formatting_rule() { 1649| 130| national_prefix_formatting_rule_.ClearToEmpty(); 1650| 130| _has_bits_[0] &= ~0x00000004u; 1651| 130|} _ZNK4i18n12phonenumbers12NumberFormat31national_prefix_formatting_ruleEv: 1652| 6.86k|inline const std::string& NumberFormat::national_prefix_formatting_rule() const { 1653| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.NumberFormat.national_prefix_formatting_rule) 1654| 6.86k| return _internal_national_prefix_formatting_rule(); 1655| 6.86k|} _ZNK4i18n12phonenumbers12NumberFormat41_internal_national_prefix_formatting_ruleEv: 1664| 169k|inline const std::string& NumberFormat::_internal_national_prefix_formatting_rule() const { 1665| 169k| return national_prefix_formatting_rule_.Get(); 1666| 169k|} _ZN4i18n12phonenumbers12NumberFormat45_internal_set_national_prefix_formatting_ruleERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1667| 162k|inline void NumberFormat::_internal_set_national_prefix_formatting_rule(const std::string& value) { 1668| 162k| _has_bits_[0] |= 0x00000004u; 1669| 162k| national_prefix_formatting_rule_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); 1670| 162k|} _ZN4i18n12phonenumbers12NumberFormat49_internal_mutable_national_prefix_formatting_ruleEv: 1690| 523|inline std::string* NumberFormat::_internal_mutable_national_prefix_formatting_rule() { 1691| 523| _has_bits_[0] |= 0x00000004u; 1692| 523| return national_prefix_formatting_rule_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 1693| 523|} _ZNK4i18n12phonenumbers12NumberFormat37domestic_carrier_code_formatting_ruleEv: 1753| 1.74k|inline const std::string& NumberFormat::domestic_carrier_code_formatting_rule() const { 1754| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.NumberFormat.domestic_carrier_code_formatting_rule) 1755| 1.74k| return _internal_domestic_carrier_code_formatting_rule(); 1756| 1.74k|} _ZNK4i18n12phonenumbers12NumberFormat47_internal_domestic_carrier_code_formatting_ruleEv: 1765| 24.7k|inline const std::string& NumberFormat::_internal_domestic_carrier_code_formatting_rule() const { 1766| 24.7k| return domestic_carrier_code_formatting_rule_.Get(); 1767| 24.7k|} _ZN4i18n12phonenumbers12NumberFormat51_internal_set_domestic_carrier_code_formatting_ruleERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1768| 22.9k|inline void NumberFormat::_internal_set_domestic_carrier_code_formatting_rule(const std::string& value) { 1769| 22.9k| _has_bits_[0] |= 0x00000008u; 1770| 22.9k| domestic_carrier_code_formatting_rule_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); 1771| 22.9k|} _ZN4i18n12phonenumbers12NumberFormat55_internal_mutable_domestic_carrier_code_formatting_ruleEv: 1791| 55|inline std::string* NumberFormat::_internal_mutable_domestic_carrier_code_formatting_rule() { 1792| 55| _has_bits_[0] |= 0x00000008u; 1793| 55| return domestic_carrier_code_formatting_rule_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 1794| 55|} _ZNK4i18n12phonenumbers15PhoneNumberDesc37_internal_has_national_number_patternEv: 1819| 3.23k|inline bool PhoneNumberDesc::_internal_has_national_number_pattern() const { 1820| 3.23k| bool value = (_has_bits_[0] & 0x00000001u) != 0; 1821| 3.23k| return value; 1822| 3.23k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc23national_number_patternEv: 1830| 152k|inline const std::string& PhoneNumberDesc::national_number_pattern() const { 1831| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumberDesc.national_number_pattern) 1832| 152k| return _internal_national_number_pattern(); 1833| 152k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc33_internal_national_number_patternEv: 1842| 153k|inline const std::string& PhoneNumberDesc::_internal_national_number_pattern() const { 1843| 153k| return national_number_pattern_.Get(); 1844| 153k|} _ZN4i18n12phonenumbers15PhoneNumberDesc41_internal_mutable_national_number_patternEv: 1868| 1.42k|inline std::string* PhoneNumberDesc::_internal_mutable_national_number_pattern() { 1869| 1.42k| _has_bits_[0] |= 0x00000001u; 1870| 1.42k| return national_number_pattern_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 1871| 1.42k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc30_internal_possible_length_sizeEv: 1892| 404k|inline int PhoneNumberDesc::_internal_possible_length_size() const { 1893| 404k| return possible_length_.size(); 1894| 404k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc20possible_length_sizeEv: 1895| 404k|inline int PhoneNumberDesc::possible_length_size() const { 1896| 404k| return _internal_possible_length_size(); 1897| 404k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc25_internal_possible_lengthEi: 1901| 225|inline ::PROTOBUF_NAMESPACE_ID::int32 PhoneNumberDesc::_internal_possible_length(int index) const { 1902| 225| return possible_length_.Get(index); 1903| 225|} _ZNK4i18n12phonenumbers15PhoneNumberDesc15possible_lengthEi: 1904| 225|inline ::PROTOBUF_NAMESPACE_ID::int32 PhoneNumberDesc::possible_length(int index) const { 1905| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumberDesc.possible_length) 1906| 225| return _internal_possible_length(index); 1907| 225|} _ZN4i18n12phonenumbers15PhoneNumberDesc29_internal_add_possible_lengthEi: 1912| 3.24k|inline void PhoneNumberDesc::_internal_add_possible_length(::PROTOBUF_NAMESPACE_ID::int32 value) { 1913| 3.24k| possible_length_.Add(value); 1914| 3.24k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc25_internal_possible_lengthEv: 1920| 998k|PhoneNumberDesc::_internal_possible_length() const { 1921| 998k| return possible_length_; 1922| 998k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc15possible_lengthEv: 1924| 998k|PhoneNumberDesc::possible_length() const { 1925| | // @@protoc_insertion_point(field_list:i18n.phonenumbers.PhoneNumberDesc.possible_length) 1926| 998k| return _internal_possible_length(); 1927| 998k|} _ZN4i18n12phonenumbers15PhoneNumberDesc40_internal_add_possible_length_local_onlyEi: 1959| 354|inline void PhoneNumberDesc::_internal_add_possible_length_local_only(::PROTOBUF_NAMESPACE_ID::int32 value) { 1960| 354| possible_length_local_only_.Add(value); 1961| 354|} _ZNK4i18n12phonenumbers15PhoneNumberDesc36_internal_possible_length_local_onlyEv: 1967| 73.8k|PhoneNumberDesc::_internal_possible_length_local_only() const { 1968| 73.8k| return possible_length_local_only_; 1969| 73.8k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc26possible_length_local_onlyEv: 1971| 73.8k|PhoneNumberDesc::possible_length_local_only() const { 1972| | // @@protoc_insertion_point(field_list:i18n.phonenumbers.PhoneNumberDesc.possible_length_local_only) 1973| 73.8k| return _internal_possible_length_local_only(); 1974| 73.8k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc28_internal_has_example_numberEv: 1986| 164k|inline bool PhoneNumberDesc::_internal_has_example_number() const { 1987| 164k| bool value = (_has_bits_[0] & 0x00000002u) != 0; 1988| 164k| return value; 1989| 164k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc18has_example_numberEv: 1990| 160k|inline bool PhoneNumberDesc::has_example_number() const { 1991| 160k| return _internal_has_example_number(); 1992| 160k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc14example_numberEv: 1997| 23.1k|inline const std::string& PhoneNumberDesc::example_number() const { 1998| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumberDesc.example_number) 1999| 23.1k| return _internal_example_number(); 2000| 23.1k|} _ZNK4i18n12phonenumbers15PhoneNumberDesc24_internal_example_numberEv: 2009| 24.3k|inline const std::string& PhoneNumberDesc::_internal_example_number() const { 2010| 24.3k| return example_number_.Get(); 2011| 24.3k|} _ZN4i18n12phonenumbers15PhoneNumberDesc32_internal_mutable_example_numberEv: 2035| 1.14k|inline std::string* PhoneNumberDesc::_internal_mutable_example_number() { 2036| 1.14k| _has_bits_[0] |= 0x00000002u; 2037| 1.14k| return example_number_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 2038| 1.14k|} _ZNK4i18n12phonenumbers13PhoneMetadata26_internal_has_general_descEv: 2063| 254|inline bool PhoneMetadata::_internal_has_general_desc() const { 2064| 254| bool value = (_has_bits_[0] & 0x00000100u) != 0; 2065| 254| PROTOBUF_ASSUME(!value || general_desc_ != nullptr); 2066| 254| return value; 2067| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata22_internal_general_descEv: 2075| 286k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_general_desc() const { 2076| 286k| const ::i18n::phonenumbers::PhoneNumberDesc* p = general_desc_; 2077| 286k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2077:10): [True: 286k, False: 0] ------------------ 2078| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2079| 286k|} _ZNK4i18n12phonenumbers13PhoneMetadata12general_descEv: 2080| 286k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::general_desc() const { 2081| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.general_desc) 2082| 286k| return _internal_general_desc(); 2083| 286k|} _ZN4i18n12phonenumbers13PhoneMetadata30_internal_mutable_general_descEv: 2113| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_general_desc() { 2114| 254| _has_bits_[0] |= 0x00000100u; 2115| 254| if (general_desc_ == nullptr) { ------------------ | Branch (2115:7): [True: 254, False: 0] ------------------ 2116| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 2117| 254| general_desc_ = p; 2118| 254| } 2119| 254| return general_desc_; 2120| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata24_internal_has_fixed_lineEv: 2146| 254|inline bool PhoneMetadata::_internal_has_fixed_line() const { 2147| 254| bool value = (_has_bits_[0] & 0x00000200u) != 0; 2148| 254| PROTOBUF_ASSUME(!value || fixed_line_ != nullptr); 2149| 254| return value; 2150| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata20_internal_fixed_lineEv: 2158| 45.1k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_fixed_line() const { 2159| 45.1k| const ::i18n::phonenumbers::PhoneNumberDesc* p = fixed_line_; 2160| 45.1k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2160:10): [True: 45.1k, False: 0] ------------------ 2161| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2162| 45.1k|} _ZNK4i18n12phonenumbers13PhoneMetadata10fixed_lineEv: 2163| 45.1k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::fixed_line() const { 2164| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.fixed_line) 2165| 45.1k| return _internal_fixed_line(); 2166| 45.1k|} _ZN4i18n12phonenumbers13PhoneMetadata28_internal_mutable_fixed_lineEv: 2196| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_fixed_line() { 2197| 254| _has_bits_[0] |= 0x00000200u; 2198| 254| if (fixed_line_ == nullptr) { ------------------ | Branch (2198:7): [True: 254, False: 0] ------------------ 2199| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 2200| 254| fixed_line_ = p; 2201| 254| } 2202| 254| return fixed_line_; 2203| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata20_internal_has_mobileEv: 2229| 254|inline bool PhoneMetadata::_internal_has_mobile() const { 2230| 254| bool value = (_has_bits_[0] & 0x00000400u) != 0; 2231| 254| PROTOBUF_ASSUME(!value || mobile_ != nullptr); 2232| 254| return value; 2233| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata16_internal_mobileEv: 2241| 23.7k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_mobile() const { 2242| 23.7k| const ::i18n::phonenumbers::PhoneNumberDesc* p = mobile_; 2243| 23.7k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2243:10): [True: 23.7k, False: 0] ------------------ 2244| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2245| 23.7k|} _ZNK4i18n12phonenumbers13PhoneMetadata6mobileEv: 2246| 23.7k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::mobile() const { 2247| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.mobile) 2248| 23.7k| return _internal_mobile(); 2249| 23.7k|} _ZN4i18n12phonenumbers13PhoneMetadata24_internal_mutable_mobileEv: 2279| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_mobile() { 2280| 254| _has_bits_[0] |= 0x00000400u; 2281| 254| if (mobile_ == nullptr) { ------------------ | Branch (2281:7): [True: 254, False: 0] ------------------ 2282| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 2283| 254| mobile_ = p; 2284| 254| } 2285| 254| return mobile_; 2286| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata23_internal_has_toll_freeEv: 2312| 254|inline bool PhoneMetadata::_internal_has_toll_free() const { 2313| 254| bool value = (_has_bits_[0] & 0x00000800u) != 0; 2314| 254| PROTOBUF_ASSUME(!value || toll_free_ != nullptr); 2315| 254| return value; 2316| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata19_internal_toll_freeEv: 2324| 28.9k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_toll_free() const { 2325| 28.9k| const ::i18n::phonenumbers::PhoneNumberDesc* p = toll_free_; 2326| 28.9k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2326:10): [True: 28.9k, False: 0] ------------------ 2327| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2328| 28.9k|} _ZNK4i18n12phonenumbers13PhoneMetadata9toll_freeEv: 2329| 28.9k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::toll_free() const { 2330| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.toll_free) 2331| 28.9k| return _internal_toll_free(); 2332| 28.9k|} _ZN4i18n12phonenumbers13PhoneMetadata27_internal_mutable_toll_freeEv: 2362| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_toll_free() { 2363| 254| _has_bits_[0] |= 0x00000800u; 2364| 254| if (toll_free_ == nullptr) { ------------------ | Branch (2364:7): [True: 254, False: 0] ------------------ 2365| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 2366| 254| toll_free_ = p; 2367| 254| } 2368| 254| return toll_free_; 2369| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata26_internal_has_premium_rateEv: 2395| 254|inline bool PhoneMetadata::_internal_has_premium_rate() const { 2396| 254| bool value = (_has_bits_[0] & 0x00001000u) != 0; 2397| 254| PROTOBUF_ASSUME(!value || premium_rate_ != nullptr); 2398| 254| return value; 2399| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata22_internal_premium_rateEv: 2407| 27.2k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_premium_rate() const { 2408| 27.2k| const ::i18n::phonenumbers::PhoneNumberDesc* p = premium_rate_; 2409| 27.2k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2409:10): [True: 27.2k, False: 0] ------------------ 2410| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2411| 27.2k|} _ZNK4i18n12phonenumbers13PhoneMetadata12premium_rateEv: 2412| 27.2k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::premium_rate() const { 2413| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.premium_rate) 2414| 27.2k| return _internal_premium_rate(); 2415| 27.2k|} _ZN4i18n12phonenumbers13PhoneMetadata30_internal_mutable_premium_rateEv: 2445| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_premium_rate() { 2446| 254| _has_bits_[0] |= 0x00001000u; 2447| 254| if (premium_rate_ == nullptr) { ------------------ | Branch (2447:7): [True: 254, False: 0] ------------------ 2448| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 2449| 254| premium_rate_ = p; 2450| 254| } 2451| 254| return premium_rate_; 2452| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata25_internal_has_shared_costEv: 2478| 254|inline bool PhoneMetadata::_internal_has_shared_cost() const { 2479| 254| bool value = (_has_bits_[0] & 0x00002000u) != 0; 2480| 254| PROTOBUF_ASSUME(!value || shared_cost_ != nullptr); 2481| 254| return value; 2482| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata21_internal_shared_costEv: 2490| 27.5k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_shared_cost() const { 2491| 27.5k| const ::i18n::phonenumbers::PhoneNumberDesc* p = shared_cost_; 2492| 27.5k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2492:10): [True: 27.5k, False: 0] ------------------ 2493| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2494| 27.5k|} _ZNK4i18n12phonenumbers13PhoneMetadata11shared_costEv: 2495| 27.5k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::shared_cost() const { 2496| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.shared_cost) 2497| 27.5k| return _internal_shared_cost(); 2498| 27.5k|} _ZN4i18n12phonenumbers13PhoneMetadata29_internal_mutable_shared_costEv: 2528| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_shared_cost() { 2529| 254| _has_bits_[0] |= 0x00002000u; 2530| 254| if (shared_cost_ == nullptr) { ------------------ | Branch (2530:7): [True: 254, False: 0] ------------------ 2531| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 2532| 254| shared_cost_ = p; 2533| 254| } 2534| 254| return shared_cost_; 2535| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata29_internal_has_personal_numberEv: 2561| 254|inline bool PhoneMetadata::_internal_has_personal_number() const { 2562| 254| bool value = (_has_bits_[0] & 0x00004000u) != 0; 2563| 254| PROTOBUF_ASSUME(!value || personal_number_ != nullptr); 2564| 254| return value; 2565| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata25_internal_personal_numberEv: 2573| 27.4k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_personal_number() const { 2574| 27.4k| const ::i18n::phonenumbers::PhoneNumberDesc* p = personal_number_; 2575| 27.4k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2575:10): [True: 27.4k, False: 0] ------------------ 2576| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2577| 27.4k|} _ZNK4i18n12phonenumbers13PhoneMetadata15personal_numberEv: 2578| 27.4k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::personal_number() const { 2579| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.personal_number) 2580| 27.4k| return _internal_personal_number(); 2581| 27.4k|} _ZN4i18n12phonenumbers13PhoneMetadata33_internal_mutable_personal_numberEv: 2611| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_personal_number() { 2612| 254| _has_bits_[0] |= 0x00004000u; 2613| 254| if (personal_number_ == nullptr) { ------------------ | Branch (2613:7): [True: 254, False: 0] ------------------ 2614| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 2615| 254| personal_number_ = p; 2616| 254| } 2617| 254| return personal_number_; 2618| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata18_internal_has_voipEv: 2644| 254|inline bool PhoneMetadata::_internal_has_voip() const { 2645| 254| bool value = (_has_bits_[0] & 0x00008000u) != 0; 2646| 254| PROTOBUF_ASSUME(!value || voip_ != nullptr); 2647| 254| return value; 2648| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata14_internal_voipEv: 2656| 27.3k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_voip() const { 2657| 27.3k| const ::i18n::phonenumbers::PhoneNumberDesc* p = voip_; 2658| 27.3k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2658:10): [True: 27.3k, False: 0] ------------------ 2659| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2660| 27.3k|} _ZNK4i18n12phonenumbers13PhoneMetadata4voipEv: 2661| 27.3k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::voip() const { 2662| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.voip) 2663| 27.3k| return _internal_voip(); 2664| 27.3k|} _ZN4i18n12phonenumbers13PhoneMetadata22_internal_mutable_voipEv: 2694| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_voip() { 2695| 254| _has_bits_[0] |= 0x00008000u; 2696| 254| if (voip_ == nullptr) { ------------------ | Branch (2696:7): [True: 254, False: 0] ------------------ 2697| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 2698| 254| voip_ = p; 2699| 254| } 2700| 254| return voip_; 2701| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata19_internal_has_pagerEv: 2727| 254|inline bool PhoneMetadata::_internal_has_pager() const { 2728| 254| bool value = (_has_bits_[0] & 0x00010000u) != 0; 2729| 254| PROTOBUF_ASSUME(!value || pager_ != nullptr); 2730| 254| return value; 2731| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata15_internal_pagerEv: 2739| 29.5k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_pager() const { 2740| 29.5k| const ::i18n::phonenumbers::PhoneNumberDesc* p = pager_; 2741| 29.5k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2741:10): [True: 29.5k, False: 0] ------------------ 2742| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2743| 29.5k|} _ZNK4i18n12phonenumbers13PhoneMetadata5pagerEv: 2744| 29.5k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::pager() const { 2745| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.pager) 2746| 29.5k| return _internal_pager(); 2747| 29.5k|} _ZN4i18n12phonenumbers13PhoneMetadata23_internal_mutable_pagerEv: 2777| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_pager() { 2778| 254| _has_bits_[0] |= 0x00010000u; 2779| 254| if (pager_ == nullptr) { ------------------ | Branch (2779:7): [True: 254, False: 0] ------------------ 2780| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 2781| 254| pager_ = p; 2782| 254| } 2783| 254| return pager_; 2784| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata17_internal_has_uanEv: 2810| 254|inline bool PhoneMetadata::_internal_has_uan() const { 2811| 254| bool value = (_has_bits_[0] & 0x00040000u) != 0; 2812| 254| PROTOBUF_ASSUME(!value || uan_ != nullptr); 2813| 254| return value; 2814| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata13_internal_uanEv: 2822| 26.3k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_uan() const { 2823| 26.3k| const ::i18n::phonenumbers::PhoneNumberDesc* p = uan_; 2824| 26.3k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2824:10): [True: 26.3k, False: 0] ------------------ 2825| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2826| 26.3k|} _ZNK4i18n12phonenumbers13PhoneMetadata3uanEv: 2827| 26.3k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::uan() const { 2828| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.uan) 2829| 26.3k| return _internal_uan(); 2830| 26.3k|} _ZN4i18n12phonenumbers13PhoneMetadata21_internal_mutable_uanEv: 2860| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_uan() { 2861| 254| _has_bits_[0] |= 0x00040000u; 2862| 254| if (uan_ == nullptr) { ------------------ | Branch (2862:7): [True: 254, False: 0] ------------------ 2863| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 2864| 254| uan_ = p; 2865| 254| } 2866| 254| return uan_; 2867| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata23_internal_has_emergencyEv: 2893| 254|inline bool PhoneMetadata::_internal_has_emergency() const { 2894| 254| bool value = (_has_bits_[0] & 0x00080000u) != 0; 2895| 254| PROTOBUF_ASSUME(!value || emergency_ != nullptr); 2896| 254| return value; 2897| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata23_internal_has_voicemailEv: 2976| 254|inline bool PhoneMetadata::_internal_has_voicemail() const { 2977| 254| bool value = (_has_bits_[0] & 0x00100000u) != 0; 2978| 254| PROTOBUF_ASSUME(!value || voicemail_ != nullptr); 2979| 254| return value; 2980| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata19_internal_voicemailEv: 2988| 41.6k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_voicemail() const { 2989| 41.6k| const ::i18n::phonenumbers::PhoneNumberDesc* p = voicemail_; 2990| 41.6k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (2990:10): [True: 41.6k, False: 0] ------------------ 2991| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 2992| 41.6k|} _ZNK4i18n12phonenumbers13PhoneMetadata9voicemailEv: 2993| 41.6k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::voicemail() const { 2994| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.voicemail) 2995| 41.6k| return _internal_voicemail(); 2996| 41.6k|} _ZN4i18n12phonenumbers13PhoneMetadata27_internal_mutable_voicemailEv: 3026| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_voicemail() { 3027| 254| _has_bits_[0] |= 0x00100000u; 3028| 254| if (voicemail_ == nullptr) { ------------------ | Branch (3028:7): [True: 254, False: 0] ------------------ 3029| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 3030| 254| voicemail_ = p; 3031| 254| } 3032| 254| return voicemail_; 3033| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata24_internal_has_short_codeEv: 3059| 254|inline bool PhoneMetadata::_internal_has_short_code() const { 3060| 254| bool value = (_has_bits_[0] & 0x00200000u) != 0; 3061| 254| PROTOBUF_ASSUME(!value || short_code_ != nullptr); 3062| 254| return value; 3063| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata27_internal_has_standard_rateEv: 3142| 254|inline bool PhoneMetadata::_internal_has_standard_rate() const { 3143| 254| bool value = (_has_bits_[0] & 0x00400000u) != 0; 3144| 254| PROTOBUF_ASSUME(!value || standard_rate_ != nullptr); 3145| 254| return value; 3146| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata30_internal_has_carrier_specificEv: 3225| 254|inline bool PhoneMetadata::_internal_has_carrier_specific() const { 3226| 254| bool value = (_has_bits_[0] & 0x00800000u) != 0; 3227| 254| PROTOBUF_ASSUME(!value || carrier_specific_ != nullptr); 3228| 254| return value; 3229| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata26_internal_has_sms_servicesEv: 3308| 254|inline bool PhoneMetadata::_internal_has_sms_services() const { 3309| 254| bool value = (_has_bits_[0] & 0x01000000u) != 0; 3310| 254| PROTOBUF_ASSUME(!value || sms_services_ != nullptr); 3311| 254| return value; 3312| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata39_internal_has_no_international_diallingEv: 3391| 254|inline bool PhoneMetadata::_internal_has_no_international_dialling() const { 3392| 254| bool value = (_has_bits_[0] & 0x00020000u) != 0; 3393| 254| PROTOBUF_ASSUME(!value || no_international_dialling_ != nullptr); 3394| 254| return value; 3395| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata35_internal_no_international_diallingEv: 3403| 5.32k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::_internal_no_international_dialling() const { 3404| 5.32k| const ::i18n::phonenumbers::PhoneNumberDesc* p = no_international_dialling_; 3405| 5.32k| return p != nullptr ? *p : reinterpret_cast( ------------------ | Branch (3405:10): [True: 5.32k, False: 0] ------------------ 3406| 0| ::i18n::phonenumbers::_PhoneNumberDesc_default_instance_); 3407| 5.32k|} _ZNK4i18n12phonenumbers13PhoneMetadata25no_international_diallingEv: 3408| 5.32k|inline const ::i18n::phonenumbers::PhoneNumberDesc& PhoneMetadata::no_international_dialling() const { 3409| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.no_international_dialling) 3410| 5.32k| return _internal_no_international_dialling(); 3411| 5.32k|} _ZN4i18n12phonenumbers13PhoneMetadata43_internal_mutable_no_international_diallingEv: 3441| 254|inline ::i18n::phonenumbers::PhoneNumberDesc* PhoneMetadata::_internal_mutable_no_international_dialling() { 3442| 254| _has_bits_[0] |= 0x00020000u; 3443| 254| if (no_international_dialling_ == nullptr) { ------------------ | Branch (3443:7): [True: 254, False: 0] ------------------ 3444| 254| auto* p = CreateMaybeMessage<::i18n::phonenumbers::PhoneNumberDesc>(GetArena()); 3445| 254| no_international_dialling_ = p; 3446| 254| } 3447| 254| return no_international_dialling_; 3448| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata16_internal_has_idEv: 3474| 254|inline bool PhoneMetadata::_internal_has_id() const { 3475| 254| bool value = (_has_bits_[0] & 0x00000001u) != 0; 3476| 254| return value; 3477| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata2idEv: 3485| 254|inline const std::string& PhoneMetadata::id() const { 3486| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.id) 3487| 254| return _internal_id(); 3488| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata12_internal_idEv: 3497| 508|inline const std::string& PhoneMetadata::_internal_id() const { 3498| 508| return id_.Get(); 3499| 508|} _ZN4i18n12phonenumbers13PhoneMetadata20_internal_mutable_idEv: 3523| 254|inline std::string* PhoneMetadata::_internal_mutable_id() { 3524| 254| _has_bits_[0] |= 0x00000001u; 3525| 254| return id_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 3526| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata22_internal_country_codeEv: 3558| 126k|inline ::PROTOBUF_NAMESPACE_ID::int32 PhoneMetadata::_internal_country_code() const { 3559| 126k| return country_code_; 3560| 126k|} _ZNK4i18n12phonenumbers13PhoneMetadata12country_codeEv: 3561| 126k|inline ::PROTOBUF_NAMESPACE_ID::int32 PhoneMetadata::country_code() const { 3562| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.country_code) 3563| 126k| return _internal_country_code(); 3564| 126k|} _ZNK4i18n12phonenumbers13PhoneMetadata34_internal_has_international_prefixEv: 3575| 254|inline bool PhoneMetadata::_internal_has_international_prefix() const { 3576| 254| bool value = (_has_bits_[0] & 0x00000002u) != 0; 3577| 254| return value; 3578| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata20international_prefixEv: 3586| 49.0k|inline const std::string& PhoneMetadata::international_prefix() const { 3587| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.international_prefix) 3588| 49.0k| return _internal_international_prefix(); 3589| 49.0k|} _ZNK4i18n12phonenumbers13PhoneMetadata30_internal_international_prefixEv: 3598| 49.3k|inline const std::string& PhoneMetadata::_internal_international_prefix() const { 3599| 49.3k| return international_prefix_.Get(); 3600| 49.3k|} _ZN4i18n12phonenumbers13PhoneMetadata38_internal_mutable_international_prefixEv: 3624| 245|inline std::string* PhoneMetadata::_internal_mutable_international_prefix() { 3625| 245| _has_bits_[0] |= 0x00000002u; 3626| 245| return international_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 3627| 245|} _ZNK4i18n12phonenumbers13PhoneMetadata44_internal_has_preferred_international_prefixEv: 3648| 357|inline bool PhoneMetadata::_internal_has_preferred_international_prefix() const { 3649| 357| bool value = (_has_bits_[0] & 0x00000040u) != 0; 3650| 357| return value; 3651| 357|} _ZNK4i18n12phonenumbers13PhoneMetadata34has_preferred_international_prefixEv: 3652| 103|inline bool PhoneMetadata::has_preferred_international_prefix() const { 3653| 103| return _internal_has_preferred_international_prefix(); 3654| 103|} _ZNK4i18n12phonenumbers13PhoneMetadata30preferred_international_prefixEv: 3659| 43|inline const std::string& PhoneMetadata::preferred_international_prefix() const { 3660| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.preferred_international_prefix) 3661| 43| return _internal_preferred_international_prefix(); 3662| 43|} _ZNK4i18n12phonenumbers13PhoneMetadata40_internal_preferred_international_prefixEv: 3671| 68|inline const std::string& PhoneMetadata::_internal_preferred_international_prefix() const { 3672| 68| return preferred_international_prefix_.Get(); 3673| 68|} _ZN4i18n12phonenumbers13PhoneMetadata48_internal_mutable_preferred_international_prefixEv: 3697| 25|inline std::string* PhoneMetadata::_internal_mutable_preferred_international_prefix() { 3698| 25| _has_bits_[0] |= 0x00000040u; 3699| 25| return preferred_international_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 3700| 25|} _ZNK4i18n12phonenumbers13PhoneMetadata29_internal_has_national_prefixEv: 3721| 5.31k|inline bool PhoneMetadata::_internal_has_national_prefix() const { 3722| 5.31k| bool value = (_has_bits_[0] & 0x00000004u) != 0; 3723| 5.31k| return value; 3724| 5.31k|} _ZNK4i18n12phonenumbers13PhoneMetadata19has_national_prefixEv: 3725| 5.06k|inline bool PhoneMetadata::has_national_prefix() const { 3726| 5.06k| return _internal_has_national_prefix(); 3727| 5.06k|} _ZNK4i18n12phonenumbers13PhoneMetadata15national_prefixEv: 3732| 8.27k|inline const std::string& PhoneMetadata::national_prefix() const { 3733| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.national_prefix) 3734| 8.27k| return _internal_national_prefix(); 3735| 8.27k|} _ZNK4i18n12phonenumbers13PhoneMetadata25_internal_national_prefixEv: 3744| 8.41k|inline const std::string& PhoneMetadata::_internal_national_prefix() const { 3745| 8.41k| return national_prefix_.Get(); 3746| 8.41k|} _ZN4i18n12phonenumbers13PhoneMetadata33_internal_mutable_national_prefixEv: 3770| 144|inline std::string* PhoneMetadata::_internal_mutable_national_prefix() { 3771| 144| _has_bits_[0] |= 0x00000004u; 3772| 144| return national_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 3773| 144|} _ZNK4i18n12phonenumbers13PhoneMetadata35_internal_has_preferred_extn_prefixEv: 3794| 1.50k|inline bool PhoneMetadata::_internal_has_preferred_extn_prefix() const { 3795| 1.50k| bool value = (_has_bits_[0] & 0x00000008u) != 0; 3796| 1.50k| return value; 3797| 1.50k|} _ZNK4i18n12phonenumbers13PhoneMetadata25has_preferred_extn_prefixEv: 3798| 1.25k|inline bool PhoneMetadata::has_preferred_extn_prefix() const { 3799| 1.25k| return _internal_has_preferred_extn_prefix(); 3800| 1.25k|} _ZNK4i18n12phonenumbers13PhoneMetadata21preferred_extn_prefixEv: 3805| 166|inline const std::string& PhoneMetadata::preferred_extn_prefix() const { 3806| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.preferred_extn_prefix) 3807| 166| return _internal_preferred_extn_prefix(); 3808| 166|} _ZNK4i18n12phonenumbers13PhoneMetadata31_internal_preferred_extn_prefixEv: 3817| 171|inline const std::string& PhoneMetadata::_internal_preferred_extn_prefix() const { 3818| 171| return preferred_extn_prefix_.Get(); 3819| 171|} _ZN4i18n12phonenumbers13PhoneMetadata39_internal_mutable_preferred_extn_prefixEv: 3843| 5|inline std::string* PhoneMetadata::_internal_mutable_preferred_extn_prefix() { 3844| 5| _has_bits_[0] |= 0x00000008u; 3845| 5| return preferred_extn_prefix_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 3846| 5|} _ZNK4i18n12phonenumbers13PhoneMetadata41_internal_has_national_prefix_for_parsingEv: 3867| 254|inline bool PhoneMetadata::_internal_has_national_prefix_for_parsing() const { 3868| 254| bool value = (_has_bits_[0] & 0x00000010u) != 0; 3869| 254| return value; 3870| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata27national_prefix_for_parsingEv: 3878| 49.8k|inline const std::string& PhoneMetadata::national_prefix_for_parsing() const { 3879| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.national_prefix_for_parsing) 3880| 49.8k| return _internal_national_prefix_for_parsing(); 3881| 49.8k|} _ZNK4i18n12phonenumbers13PhoneMetadata37_internal_national_prefix_for_parsingEv: 3890| 50.0k|inline const std::string& PhoneMetadata::_internal_national_prefix_for_parsing() const { 3891| 50.0k| return national_prefix_for_parsing_.Get(); 3892| 50.0k|} _ZN4i18n12phonenumbers13PhoneMetadata45_internal_mutable_national_prefix_for_parsingEv: 3916| 150|inline std::string* PhoneMetadata::_internal_mutable_national_prefix_for_parsing() { 3917| 150| _has_bits_[0] |= 0x00000010u; 3918| 150| return national_prefix_for_parsing_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 3919| 150|} _ZNK4i18n12phonenumbers13PhoneMetadata44_internal_has_national_prefix_transform_ruleEv: 3940| 254|inline bool PhoneMetadata::_internal_has_national_prefix_transform_rule() const { 3941| 254| bool value = (_has_bits_[0] & 0x00000020u) != 0; 3942| 254| return value; 3943| 254|} _ZNK4i18n12phonenumbers13PhoneMetadata30national_prefix_transform_ruleEv: 3951| 29.5k|inline const std::string& PhoneMetadata::national_prefix_transform_rule() const { 3952| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.national_prefix_transform_rule) 3953| 29.5k| return _internal_national_prefix_transform_rule(); 3954| 29.5k|} _ZNK4i18n12phonenumbers13PhoneMetadata40_internal_national_prefix_transform_ruleEv: 3963| 29.5k|inline const std::string& PhoneMetadata::_internal_national_prefix_transform_rule() const { 3964| 29.5k| return national_prefix_transform_rule_.Get(); 3965| 29.5k|} _ZN4i18n12phonenumbers13PhoneMetadata48_internal_mutable_national_prefix_transform_ruleEv: 3989| 32|inline std::string* PhoneMetadata::_internal_mutable_national_prefix_transform_rule() { 3990| 32| _has_bits_[0] |= 0x00000020u; 3991| 32| return national_prefix_transform_rule_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 3992| 32|} _ZNK4i18n12phonenumbers13PhoneMetadata44_internal_same_mobile_and_fixed_line_patternEv: 4024| 24.9k|inline bool PhoneMetadata::_internal_same_mobile_and_fixed_line_pattern() const { 4025| 24.9k| return same_mobile_and_fixed_line_pattern_; 4026| 24.9k|} _ZNK4i18n12phonenumbers13PhoneMetadata34same_mobile_and_fixed_line_patternEv: 4027| 24.9k|inline bool PhoneMetadata::same_mobile_and_fixed_line_pattern() const { 4028| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.same_mobile_and_fixed_line_pattern) 4029| 24.9k| return _internal_same_mobile_and_fixed_line_pattern(); 4030| 24.9k|} _ZN4i18n12phonenumbers13PhoneMetadata27_internal_add_number_formatEv: 4066| 754|inline ::i18n::phonenumbers::NumberFormat* PhoneMetadata::_internal_add_number_format() { 4067| 754| return number_format_.Add(); 4068| 754|} _ZNK4i18n12phonenumbers13PhoneMetadata13number_formatEv: 4074| 41.7k|PhoneMetadata::number_format() const { 4075| | // @@protoc_insertion_point(field_list:i18n.phonenumbers.PhoneMetadata.number_format) 4076| 41.7k| return number_format_; 4077| 41.7k|} _ZNK4i18n12phonenumbers13PhoneMetadata33_internal_intl_number_format_sizeEv: 4080| 40.5k|inline int PhoneMetadata::_internal_intl_number_format_size() const { 4081| 40.5k| return intl_number_format_.size(); 4082| 40.5k|} _ZNK4i18n12phonenumbers13PhoneMetadata23intl_number_format_sizeEv: 4083| 40.5k|inline int PhoneMetadata::intl_number_format_size() const { 4084| 40.5k| return _internal_intl_number_format_size(); 4085| 40.5k|} _ZN4i18n12phonenumbers13PhoneMetadata32_internal_add_intl_number_formatEv: 4105| 179|inline ::i18n::phonenumbers::NumberFormat* PhoneMetadata::_internal_add_intl_number_format() { 4106| 179| return intl_number_format_.Add(); 4107| 179|} _ZNK4i18n12phonenumbers13PhoneMetadata18intl_number_formatEv: 4113| 5.38k|PhoneMetadata::intl_number_format() const { 4114| | // @@protoc_insertion_point(field_list:i18n.phonenumbers.PhoneMetadata.intl_number_format) 4115| 5.38k| return intl_number_format_; 4116| 5.38k|} _ZNK4i18n12phonenumbers13PhoneMetadata31_internal_main_country_for_codeEv: 4130| 39|inline bool PhoneMetadata::_internal_main_country_for_code() const { 4131| 39| return main_country_for_code_; 4132| 39|} _ZNK4i18n12phonenumbers13PhoneMetadata21main_country_for_codeEv: 4133| 39|inline bool PhoneMetadata::main_country_for_code() const { 4134| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.main_country_for_code) 4135| 39| return _internal_main_country_for_code(); 4136| 39|} _ZNK4i18n12phonenumbers13PhoneMetadata28_internal_has_leading_digitsEv: 4147| 164k|inline bool PhoneMetadata::_internal_has_leading_digits() const { 4148| 164k| bool value = (_has_bits_[0] & 0x00000080u) != 0; 4149| 164k| return value; 4150| 164k|} _ZNK4i18n12phonenumbers13PhoneMetadata18has_leading_digitsEv: 4151| 163k|inline bool PhoneMetadata::has_leading_digits() const { 4152| 163k| return _internal_has_leading_digits(); 4153| 163k|} _ZNK4i18n12phonenumbers13PhoneMetadata14leading_digitsEv: 4158| 127k|inline const std::string& PhoneMetadata::leading_digits() const { 4159| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneMetadata.leading_digits) 4160| 127k| return _internal_leading_digits(); 4161| 127k|} _ZNK4i18n12phonenumbers13PhoneMetadata24_internal_leading_digitsEv: 4170| 127k|inline const std::string& PhoneMetadata::_internal_leading_digits() const { 4171| 127k| return leading_digits_.Get(); 4172| 127k|} _ZN4i18n12phonenumbers13PhoneMetadata32_internal_mutable_leading_digitsEv: 4196| 36|inline std::string* PhoneMetadata::_internal_mutable_leading_digits() { 4197| 36| _has_bits_[0] |= 0x00000080u; 4198| 36| return leading_digits_.Mutable(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, GetArena()); 4199| 36|} _ZN4i18n12phonenumbers23PhoneMetadataCollection22_internal_add_metadataEv: 4277| 254|inline ::i18n::phonenumbers::PhoneMetadata* PhoneMetadataCollection::_internal_add_metadata() { 4278| 254| return metadata_.Add(); 4279| 254|} _ZNK4i18n12phonenumbers23PhoneMetadataCollection8metadataEv: 4285| 256|PhoneMetadataCollection::metadata() const { 4286| | // @@protoc_insertion_point(field_list:i18n.phonenumbers.PhoneMetadataCollection.metadata) 4287| 256| return metadata_; 4288| 256|} _ZN4i18n12phonenumbers13ExactlySameAsERKNS0_11PhoneNumberES3_: 24| 10.2k| const PhoneNumber& second_number) { 25| 10.2k| if (first_number.has_country_code() != second_number.has_country_code() || ------------------ | Branch (25:7): [True: 0, False: 10.2k] ------------------ 26| 10.2k| first_number.country_code() != second_number.country_code()) { ------------------ | Branch (26:7): [True: 58, False: 10.2k] ------------------ 27| 58| return false; 28| 58| } 29| 10.2k| if (first_number.has_national_number() != ------------------ | Branch (29:7): [True: 0, False: 10.2k] ------------------ 30| 10.2k| second_number.has_national_number() || 31| 10.2k| first_number.national_number() != second_number.national_number()) { ------------------ | Branch (31:7): [True: 7.88k, False: 2.35k] ------------------ 32| 7.88k| return false; 33| 7.88k| } 34| 2.35k| if (first_number.has_extension() != second_number.has_extension() || ------------------ | Branch (34:7): [True: 24, False: 2.33k] ------------------ 35| 2.35k| first_number.extension() != second_number.extension()) { ------------------ | Branch (35:7): [True: 0, False: 2.33k] ------------------ 36| 24| return false; 37| 24| } 38| 2.33k| if (first_number.has_italian_leading_zero() != ------------------ | Branch (38:7): [True: 156, False: 2.17k] ------------------ 39| 2.33k| second_number.has_italian_leading_zero() || 40| 2.33k| first_number.italian_leading_zero() != ------------------ | Branch (40:7): [True: 0, False: 2.17k] ------------------ 41| 2.17k| second_number.italian_leading_zero()) { 42| 156| return false; 43| 156| } 44| 2.17k| if (first_number.has_number_of_leading_zeros() != ------------------ | Branch (44:7): [True: 0, False: 2.17k] ------------------ 45| 2.17k| second_number.has_number_of_leading_zeros() || 46| 2.17k| first_number.number_of_leading_zeros() != ------------------ | Branch (46:7): [True: 10, False: 2.16k] ------------------ 47| 2.17k| second_number.number_of_leading_zeros()) { 48| 10| return false; 49| 10| } 50| 2.16k| if (first_number.has_raw_input() != second_number.has_raw_input() || ------------------ | Branch (50:7): [True: 0, False: 2.16k] ------------------ 51| 2.16k| first_number.raw_input() != second_number.raw_input()) { ------------------ | Branch (51:7): [True: 0, False: 2.16k] ------------------ 52| 0| return false; 53| 0| } 54| 2.16k| if (first_number.has_country_code_source() != ------------------ | Branch (54:7): [True: 0, False: 2.16k] ------------------ 55| 2.16k| second_number.has_country_code_source() || 56| 2.16k| first_number.country_code_source() != ------------------ | Branch (56:7): [True: 0, False: 2.16k] ------------------ 57| 2.16k| second_number.country_code_source()) { 58| 0| return false; 59| 0| } 60| 2.16k| if (first_number.has_preferred_domestic_carrier_code() != ------------------ | Branch (60:7): [True: 0, False: 2.16k] ------------------ 61| 2.16k| second_number.has_preferred_domestic_carrier_code() || 62| 2.16k| first_number.preferred_domestic_carrier_code() != ------------------ | Branch (62:7): [True: 0, False: 2.16k] ------------------ 63| 2.16k| second_number.preferred_domestic_carrier_code()) { 64| 0| return false; 65| 0| } 66| 2.16k| return true; 67| 2.16k|} _ZN4i18n12phonenumbers37PhoneNumber_CountryCodeSource_IsValidEi: 37| 3.57k|bool PhoneNumber_CountryCodeSource_IsValid(int value) { 38| 3.57k| switch (value) { 39| 0| case 0: ------------------ | Branch (39:5): [True: 0, False: 3.57k] ------------------ 40| 173| case 1: ------------------ | Branch (40:5): [True: 173, False: 3.40k] ------------------ 41| 235| case 5: ------------------ | Branch (41:5): [True: 62, False: 3.51k] ------------------ 42| 262| case 10: ------------------ | Branch (42:5): [True: 27, False: 3.54k] ------------------ 43| 3.57k| case 20: ------------------ | Branch (43:5): [True: 3.31k, False: 262] ------------------ 44| 3.57k| return true; 45| 0| default: ------------------ | Branch (45:5): [True: 0, False: 3.57k] ------------------ 46| 0| return false; 47| 3.57k| } 48| 3.57k|} _ZN4i18n12phonenumbers11PhoneNumberC2EPN6google8protobuf5ArenaE: 146| 184k| : ::PROTOBUF_NAMESPACE_ID::MessageLite(arena) { 147| 184k| SharedCtor(); 148| 184k| RegisterArenaDtor(arena); 149| | // @@protoc_insertion_point(arena_constructor:i18n.phonenumbers.PhoneNumber) 150| 184k|} _ZN4i18n12phonenumbers11PhoneNumberC2ERKS1_: 152| 18.0k| : ::PROTOBUF_NAMESPACE_ID::MessageLite(), 153| 18.0k| _has_bits_(from._has_bits_) { 154| 18.0k| _internal_metadata_.MergeFrom(from._internal_metadata_); 155| 18.0k| extension_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 156| 18.0k| if (from._internal_has_extension()) { ------------------ | Branch (156:7): [True: 613, False: 17.4k] ------------------ 157| 613| extension_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_extension(), 158| 613| GetArena()); 159| 613| } 160| 18.0k| raw_input_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 161| 18.0k| if (from._internal_has_raw_input()) { ------------------ | Branch (161:7): [True: 7.24k, False: 10.7k] ------------------ 162| 7.24k| raw_input_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_raw_input(), 163| 7.24k| GetArena()); 164| 7.24k| } 165| 18.0k| preferred_domestic_carrier_code_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 166| 18.0k| if (from._internal_has_preferred_domestic_carrier_code()) { ------------------ | Branch (166:7): [True: 204, False: 17.8k] ------------------ 167| 204| preferred_domestic_carrier_code_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, from._internal_preferred_domestic_carrier_code(), 168| 204| GetArena()); 169| 204| } 170| 18.0k| ::memcpy(&national_number_, &from.national_number_, 171| 18.0k| static_cast(reinterpret_cast(&number_of_leading_zeros_) - 172| 18.0k| reinterpret_cast(&national_number_)) + sizeof(number_of_leading_zeros_)); 173| | // @@protoc_insertion_point(copy_constructor:i18n.phonenumbers.PhoneNumber) 174| 18.0k|} _ZN4i18n12phonenumbers11PhoneNumberD2Ev: 188| 202k|PhoneNumber::~PhoneNumber() { 189| | // @@protoc_insertion_point(destructor:i18n.phonenumbers.PhoneNumber) 190| 202k| SharedDtor(); 191| 202k| _internal_metadata_.Delete(); 192| 202k|} _ZN4i18n12phonenumbers11PhoneNumber9MergeFromERKS1_: 507| 7.92k|void PhoneNumber::MergeFrom(const PhoneNumber& from) { 508| |// @@protoc_insertion_point(class_specific_merge_from_start:i18n.phonenumbers.PhoneNumber) 509| 7.92k| GOOGLE_DCHECK_NE(&from, this); 510| 7.92k| _internal_metadata_.MergeFrom(from._internal_metadata_); 511| 7.92k| ::PROTOBUF_NAMESPACE_ID::uint32 cached_has_bits = 0; 512| 7.92k| (void) cached_has_bits; 513| | 514| 7.92k| cached_has_bits = from._has_bits_[0]; 515| 7.92k| if (cached_has_bits & 0x000000ffu) { ------------------ | Branch (515:7): [True: 7.92k, False: 0] ------------------ 516| 7.92k| if (cached_has_bits & 0x00000001u) { ------------------ | Branch (516:9): [True: 0, False: 7.92k] ------------------ 517| 0| _internal_set_extension(from._internal_extension()); 518| 0| } 519| 7.92k| if (cached_has_bits & 0x00000002u) { ------------------ | Branch (519:9): [True: 0, False: 7.92k] ------------------ 520| 0| _internal_set_raw_input(from._internal_raw_input()); 521| 0| } 522| 7.92k| if (cached_has_bits & 0x00000004u) { ------------------ | Branch (522:9): [True: 0, False: 7.92k] ------------------ 523| 0| _internal_set_preferred_domestic_carrier_code(from._internal_preferred_domestic_carrier_code()); 524| 0| } 525| 7.92k| if (cached_has_bits & 0x00000008u) { ------------------ | Branch (525:9): [True: 7.92k, False: 0] ------------------ 526| 7.92k| national_number_ = from.national_number_; 527| 7.92k| } 528| 7.92k| if (cached_has_bits & 0x00000010u) { ------------------ | Branch (528:9): [True: 7.92k, False: 0] ------------------ 529| 7.92k| country_code_ = from.country_code_; 530| 7.92k| } 531| 7.92k| if (cached_has_bits & 0x00000020u) { ------------------ | Branch (531:9): [True: 1.35k, False: 6.56k] ------------------ 532| 1.35k| italian_leading_zero_ = from.italian_leading_zero_; 533| 1.35k| } 534| 7.92k| if (cached_has_bits & 0x00000040u) { ------------------ | Branch (534:9): [True: 0, False: 7.92k] ------------------ 535| 0| country_code_source_ = from.country_code_source_; 536| 0| } 537| 7.92k| if (cached_has_bits & 0x00000080u) { ------------------ | Branch (537:9): [True: 0, False: 7.92k] ------------------ 538| 0| number_of_leading_zeros_ = from.number_of_leading_zeros_; 539| 0| } 540| 7.92k| _has_bits_[0] |= cached_has_bits; 541| 7.92k| } 542| 7.92k|} _ZN4i18n12phonenumbers11PhoneNumber12InternalSwapEPS1_: 556| 49.4k|void PhoneNumber::InternalSwap(PhoneNumber* other) { 557| 49.4k| using std::swap; 558| 49.4k| _internal_metadata_.Swap(&other->_internal_metadata_); 559| 49.4k| swap(_has_bits_[0], other->_has_bits_[0]); 560| 49.4k| extension_.Swap(&other->extension_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 561| 49.4k| raw_input_.Swap(&other->raw_input_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 562| 49.4k| preferred_domestic_carrier_code_.Swap(&other->preferred_domestic_carrier_code_, &::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited(), GetArena()); 563| 49.4k| ::PROTOBUF_NAMESPACE_ID::internal::memswap< 564| 49.4k| PROTOBUF_FIELD_OFFSET(PhoneNumber, country_code_source_) 565| 49.4k| + sizeof(PhoneNumber::country_code_source_) 566| 49.4k| - PROTOBUF_FIELD_OFFSET(PhoneNumber, national_number_)>( 567| 49.4k| reinterpret_cast(&national_number_), 568| 49.4k| reinterpret_cast(&other->national_number_)); 569| 49.4k| swap(number_of_leading_zeros_, other->number_of_leading_zeros_); 570| 49.4k|} phonenumber.pb.cc:_ZL52InitDefaultsscc_info_PhoneNumber_phonenumber_2eprotov: 22| 1|static void InitDefaultsscc_info_PhoneNumber_phonenumber_2eproto() { 23| 1| GOOGLE_PROTOBUF_VERIFY_VERSION; 24| | 25| 1| { 26| 1| void* ptr = &::i18n::phonenumbers::_PhoneNumber_default_instance_; 27| 1| new (ptr) ::i18n::phonenumbers::PhoneNumber(); 28| 1| ::PROTOBUF_NAMESPACE_ID::internal::OnShutdownDestroyMessage(ptr); 29| 1| } 30| 1|} _ZN4i18n12phonenumbers11PhoneNumber10SharedCtorEv: 176| 184k|void PhoneNumber::SharedCtor() { 177| 184k| ::PROTOBUF_NAMESPACE_ID::internal::InitSCC(&scc_info_PhoneNumber_phonenumber_2eproto.base); 178| 184k| extension_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 179| 184k| raw_input_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 180| 184k| preferred_domestic_carrier_code_.UnsafeSetDefault(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 181| 184k| ::memset(reinterpret_cast(this) + static_cast( 182| 184k| reinterpret_cast(&national_number_) - reinterpret_cast(this)), 183| 184k| 0, static_cast(reinterpret_cast(&country_code_source_) - 184| 184k| reinterpret_cast(&national_number_)) + sizeof(country_code_source_)); 185| 184k| number_of_leading_zeros_ = 1; 186| 184k|} _ZN4i18n12phonenumbers11PhoneNumber10SharedDtorEv: 194| 202k|void PhoneNumber::SharedDtor() { 195| 202k| GOOGLE_DCHECK(GetArena() == nullptr); 196| 202k| extension_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 197| 202k| raw_input_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 198| 202k| preferred_domestic_carrier_code_.DestroyNoArena(&::PROTOBUF_NAMESPACE_ID::internal::GetEmptyStringAlreadyInited()); 199| 202k|} _ZN4i18n12phonenumbers11PhoneNumber17RegisterArenaDtorEPN6google8protobuf5ArenaE: 205| 184k|void PhoneNumber::RegisterArenaDtor(::PROTOBUF_NAMESPACE_ID::Arena*) { 206| 184k|} _ZN4i18n12phonenumbers11PhoneNumberC2Ev: 94| 184k| inline PhoneNumber() : PhoneNumber(nullptr) {} _ZN4i18n12phonenumbers11PhoneNumber4SwapEPS1_: 135| 49.4k| inline void Swap(PhoneNumber* other) { 136| 49.4k| if (other == this) return; ------------------ | Branch (136:9): [True: 0, False: 49.4k] ------------------ 137| 49.4k| if (GetArena() == other->GetArena()) { ------------------ | Branch (137:9): [True: 49.4k, False: 0] ------------------ 138| 49.4k| InternalSwap(other); 139| 49.4k| } else { 140| 0| ::PROTOBUF_NAMESPACE_ID::internal::GenericSwap(this, other); 141| 0| } 142| 49.4k| } _ZNK4i18n12phonenumbers11PhoneNumber26_internal_has_country_codeEv: 395| 20.5k|inline bool PhoneNumber::_internal_has_country_code() const { 396| 20.5k| bool value = (_has_bits_[0] & 0x00000010u) != 0; 397| 20.5k| return value; 398| 20.5k|} _ZNK4i18n12phonenumbers11PhoneNumber16has_country_codeEv: 399| 20.5k|inline bool PhoneNumber::has_country_code() const { 400| 20.5k| return _internal_has_country_code(); 401| 20.5k|} _ZNK4i18n12phonenumbers11PhoneNumber22_internal_country_codeEv: 406| 377k|inline ::PROTOBUF_NAMESPACE_ID::int32 PhoneNumber::_internal_country_code() const { 407| 377k| return country_code_; 408| 377k|} _ZNK4i18n12phonenumbers11PhoneNumber12country_codeEv: 409| 377k|inline ::PROTOBUF_NAMESPACE_ID::int32 PhoneNumber::country_code() const { 410| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumber.country_code) 411| 377k| return _internal_country_code(); 412| 377k|} _ZN4i18n12phonenumbers11PhoneNumber26_internal_set_country_codeEi: 413| 130k|inline void PhoneNumber::_internal_set_country_code(::PROTOBUF_NAMESPACE_ID::int32 value) { 414| 130k| _has_bits_[0] |= 0x00000010u; 415| 130k| country_code_ = value; 416| 130k|} _ZN4i18n12phonenumbers11PhoneNumber16set_country_codeEi: 417| 130k|inline void PhoneNumber::set_country_code(::PROTOBUF_NAMESPACE_ID::int32 value) { 418| 130k| _internal_set_country_code(value); 419| | // @@protoc_insertion_point(field_set:i18n.phonenumbers.PhoneNumber.country_code) 420| 130k|} _ZNK4i18n12phonenumbers11PhoneNumber29_internal_has_national_numberEv: 423| 20.4k|inline bool PhoneNumber::_internal_has_national_number() const { 424| 20.4k| bool value = (_has_bits_[0] & 0x00000008u) != 0; 425| 20.4k| return value; 426| 20.4k|} _ZNK4i18n12phonenumbers11PhoneNumber19has_national_numberEv: 427| 20.4k|inline bool PhoneNumber::has_national_number() const { 428| 20.4k| return _internal_has_national_number(); 429| 20.4k|} _ZNK4i18n12phonenumbers11PhoneNumber25_internal_national_numberEv: 434| 272k|inline ::PROTOBUF_NAMESPACE_ID::uint64 PhoneNumber::_internal_national_number() const { 435| 272k| return national_number_; 436| 272k|} _ZNK4i18n12phonenumbers11PhoneNumber15national_numberEv: 437| 272k|inline ::PROTOBUF_NAMESPACE_ID::uint64 PhoneNumber::national_number() const { 438| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumber.national_number) 439| 272k| return _internal_national_number(); 440| 272k|} _ZN4i18n12phonenumbers11PhoneNumber29_internal_set_national_numberEm: 441| 71.3k|inline void PhoneNumber::_internal_set_national_number(::PROTOBUF_NAMESPACE_ID::uint64 value) { 442| 71.3k| _has_bits_[0] |= 0x00000008u; 443| 71.3k| national_number_ = value; 444| 71.3k|} _ZN4i18n12phonenumbers11PhoneNumber19set_national_numberEm: 445| 71.3k|inline void PhoneNumber::set_national_number(::PROTOBUF_NAMESPACE_ID::uint64 value) { 446| 71.3k| _internal_set_national_number(value); 447| | // @@protoc_insertion_point(field_set:i18n.phonenumbers.PhoneNumber.national_number) 448| 71.3k|} _ZNK4i18n12phonenumbers11PhoneNumber23_internal_has_extensionEv: 451| 91.8k|inline bool PhoneNumber::_internal_has_extension() const { 452| 91.8k| bool value = (_has_bits_[0] & 0x00000001u) != 0; 453| 91.8k| return value; 454| 91.8k|} _ZNK4i18n12phonenumbers11PhoneNumber13has_extensionEv: 455| 73.8k|inline bool PhoneNumber::has_extension() const { 456| 73.8k| return _internal_has_extension(); 457| 73.8k|} _ZN4i18n12phonenumbers11PhoneNumber15clear_extensionEv: 458| 7.83k|inline void PhoneNumber::clear_extension() { 459| 7.83k| extension_.ClearToEmpty(); 460| 7.83k| _has_bits_[0] &= ~0x00000001u; 461| 7.83k|} _ZNK4i18n12phonenumbers11PhoneNumber9extensionEv: 462| 28.7k|inline const std::string& PhoneNumber::extension() const { 463| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumber.extension) 464| 28.7k| return _internal_extension(); 465| 28.7k|} _ZN4i18n12phonenumbers11PhoneNumber13set_extensionERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 466| 1.59k|inline void PhoneNumber::set_extension(const std::string& value) { 467| 1.59k| _internal_set_extension(value); 468| | // @@protoc_insertion_point(field_set:i18n.phonenumbers.PhoneNumber.extension) 469| 1.59k|} _ZNK4i18n12phonenumbers11PhoneNumber19_internal_extensionEv: 474| 29.3k|inline const std::string& PhoneNumber::_internal_extension() const { 475| 29.3k| return extension_.Get(); 476| 29.3k|} _ZN4i18n12phonenumbers11PhoneNumber23_internal_set_extensionERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 477| 1.59k|inline void PhoneNumber::_internal_set_extension(const std::string& value) { 478| 1.59k| _has_bits_[0] |= 0x00000001u; 479| 1.59k| extension_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); 480| 1.59k|} _ZNK4i18n12phonenumbers11PhoneNumber34_internal_has_italian_leading_zeroEv: 524| 4.66k|inline bool PhoneNumber::_internal_has_italian_leading_zero() const { 525| 4.66k| bool value = (_has_bits_[0] & 0x00000020u) != 0; 526| 4.66k| return value; 527| 4.66k|} _ZNK4i18n12phonenumbers11PhoneNumber24has_italian_leading_zeroEv: 528| 4.66k|inline bool PhoneNumber::has_italian_leading_zero() const { 529| 4.66k| return _internal_has_italian_leading_zero(); 530| 4.66k|} _ZNK4i18n12phonenumbers11PhoneNumber30_internal_italian_leading_zeroEv: 535| 203k|inline bool PhoneNumber::_internal_italian_leading_zero() const { 536| 203k| return italian_leading_zero_; 537| 203k|} _ZNK4i18n12phonenumbers11PhoneNumber20italian_leading_zeroEv: 538| 203k|inline bool PhoneNumber::italian_leading_zero() const { 539| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumber.italian_leading_zero) 540| 203k| return _internal_italian_leading_zero(); 541| 203k|} _ZN4i18n12phonenumbers11PhoneNumber34_internal_set_italian_leading_zeroEb: 542| 11.0k|inline void PhoneNumber::_internal_set_italian_leading_zero(bool value) { 543| 11.0k| _has_bits_[0] |= 0x00000020u; 544| 11.0k| italian_leading_zero_ = value; 545| 11.0k|} _ZN4i18n12phonenumbers11PhoneNumber24set_italian_leading_zeroEb: 546| 11.0k|inline void PhoneNumber::set_italian_leading_zero(bool value) { 547| 11.0k| _internal_set_italian_leading_zero(value); 548| | // @@protoc_insertion_point(field_set:i18n.phonenumbers.PhoneNumber.italian_leading_zero) 549| 11.0k|} _ZNK4i18n12phonenumbers11PhoneNumber37_internal_has_number_of_leading_zerosEv: 552| 4.35k|inline bool PhoneNumber::_internal_has_number_of_leading_zeros() const { 553| 4.35k| bool value = (_has_bits_[0] & 0x00000080u) != 0; 554| 4.35k| return value; 555| 4.35k|} _ZNK4i18n12phonenumbers11PhoneNumber27has_number_of_leading_zerosEv: 556| 4.35k|inline bool PhoneNumber::has_number_of_leading_zeros() const { 557| 4.35k| return _internal_has_number_of_leading_zeros(); 558| 4.35k|} _ZNK4i18n12phonenumbers11PhoneNumber33_internal_number_of_leading_zerosEv: 563| 36.7k|inline ::PROTOBUF_NAMESPACE_ID::int32 PhoneNumber::_internal_number_of_leading_zeros() const { 564| 36.7k| return number_of_leading_zeros_; 565| 36.7k|} _ZNK4i18n12phonenumbers11PhoneNumber23number_of_leading_zerosEv: 566| 36.7k|inline ::PROTOBUF_NAMESPACE_ID::int32 PhoneNumber::number_of_leading_zeros() const { 567| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumber.number_of_leading_zeros) 568| 36.7k| return _internal_number_of_leading_zeros(); 569| 36.7k|} _ZN4i18n12phonenumbers11PhoneNumber37_internal_set_number_of_leading_zerosEi: 570| 1.68k|inline void PhoneNumber::_internal_set_number_of_leading_zeros(::PROTOBUF_NAMESPACE_ID::int32 value) { 571| 1.68k| _has_bits_[0] |= 0x00000080u; 572| 1.68k| number_of_leading_zeros_ = value; 573| 1.68k|} _ZN4i18n12phonenumbers11PhoneNumber27set_number_of_leading_zerosEi: 574| 1.68k|inline void PhoneNumber::set_number_of_leading_zeros(::PROTOBUF_NAMESPACE_ID::int32 value) { 575| 1.68k| _internal_set_number_of_leading_zeros(value); 576| | // @@protoc_insertion_point(field_set:i18n.phonenumbers.PhoneNumber.number_of_leading_zeros) 577| 1.68k|} _ZNK4i18n12phonenumbers11PhoneNumber23_internal_has_raw_inputEv: 580| 34.1k|inline bool PhoneNumber::_internal_has_raw_input() const { 581| 34.1k| bool value = (_has_bits_[0] & 0x00000002u) != 0; 582| 34.1k| return value; 583| 34.1k|} _ZNK4i18n12phonenumbers11PhoneNumber13has_raw_inputEv: 584| 16.1k|inline bool PhoneNumber::has_raw_input() const { 585| 16.1k| return _internal_has_raw_input(); 586| 16.1k|} _ZNK4i18n12phonenumbers11PhoneNumber9raw_inputEv: 591| 30.1k|inline const std::string& PhoneNumber::raw_input() const { 592| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumber.raw_input) 593| 30.1k| return _internal_raw_input(); 594| 30.1k|} _ZN4i18n12phonenumbers11PhoneNumber13set_raw_inputERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 595| 3.50k|inline void PhoneNumber::set_raw_input(const std::string& value) { 596| 3.50k| _internal_set_raw_input(value); 597| | // @@protoc_insertion_point(field_set:i18n.phonenumbers.PhoneNumber.raw_input) 598| 3.50k|} _ZNK4i18n12phonenumbers11PhoneNumber19_internal_raw_inputEv: 603| 37.4k|inline const std::string& PhoneNumber::_internal_raw_input() const { 604| 37.4k| return raw_input_.Get(); 605| 37.4k|} _ZN4i18n12phonenumbers11PhoneNumber23_internal_set_raw_inputERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 606| 3.50k|inline void PhoneNumber::_internal_set_raw_input(const std::string& value) { 607| 3.50k| _has_bits_[0] |= 0x00000002u; 608| 3.50k| raw_input_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); 609| 3.50k|} _ZNK4i18n12phonenumbers11PhoneNumber33_internal_has_country_code_sourceEv: 653| 10.9k|inline bool PhoneNumber::_internal_has_country_code_source() const { 654| 10.9k| bool value = (_has_bits_[0] & 0x00000040u) != 0; 655| 10.9k| return value; 656| 10.9k|} _ZNK4i18n12phonenumbers11PhoneNumber23has_country_code_sourceEv: 657| 10.9k|inline bool PhoneNumber::has_country_code_source() const { 658| 10.9k| return _internal_has_country_code_source(); 659| 10.9k|} _ZNK4i18n12phonenumbers11PhoneNumber29_internal_country_code_sourceEv: 664| 4.74k|inline ::i18n::phonenumbers::PhoneNumber_CountryCodeSource PhoneNumber::_internal_country_code_source() const { 665| 4.74k| return static_cast< ::i18n::phonenumbers::PhoneNumber_CountryCodeSource >(country_code_source_); 666| 4.74k|} _ZNK4i18n12phonenumbers11PhoneNumber19country_code_sourceEv: 667| 4.74k|inline ::i18n::phonenumbers::PhoneNumber_CountryCodeSource PhoneNumber::country_code_source() const { 668| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumber.country_code_source) 669| 4.74k| return _internal_country_code_source(); 670| 4.74k|} _ZN4i18n12phonenumbers11PhoneNumber33_internal_set_country_code_sourceENS0_29PhoneNumber_CountryCodeSourceE: 671| 3.57k|inline void PhoneNumber::_internal_set_country_code_source(::i18n::phonenumbers::PhoneNumber_CountryCodeSource value) { 672| 3.57k| assert(::i18n::phonenumbers::PhoneNumber_CountryCodeSource_IsValid(value)); 673| 3.57k| _has_bits_[0] |= 0x00000040u; 674| 3.57k| country_code_source_ = value; 675| 3.57k|} _ZN4i18n12phonenumbers11PhoneNumber23set_country_code_sourceENS0_29PhoneNumber_CountryCodeSourceE: 676| 3.57k|inline void PhoneNumber::set_country_code_source(::i18n::phonenumbers::PhoneNumber_CountryCodeSource value) { 677| 3.57k| _internal_set_country_code_source(value); 678| | // @@protoc_insertion_point(field_set:i18n.phonenumbers.PhoneNumber.country_code_source) 679| 3.57k|} _ZNK4i18n12phonenumbers11PhoneNumber45_internal_has_preferred_domestic_carrier_codeEv: 682| 22.3k|inline bool PhoneNumber::_internal_has_preferred_domestic_carrier_code() const { 683| 22.3k| bool value = (_has_bits_[0] & 0x00000004u) != 0; 684| 22.3k| return value; 685| 22.3k|} _ZNK4i18n12phonenumbers11PhoneNumber35has_preferred_domestic_carrier_codeEv: 686| 4.33k|inline bool PhoneNumber::has_preferred_domestic_carrier_code() const { 687| 4.33k| return _internal_has_preferred_domestic_carrier_code(); 688| 4.33k|} _ZNK4i18n12phonenumbers11PhoneNumber31preferred_domestic_carrier_codeEv: 693| 14.0k|inline const std::string& PhoneNumber::preferred_domestic_carrier_code() const { 694| | // @@protoc_insertion_point(field_get:i18n.phonenumbers.PhoneNumber.preferred_domestic_carrier_code) 695| 14.0k| return _internal_preferred_domestic_carrier_code(); 696| 14.0k|} _ZN4i18n12phonenumbers11PhoneNumber35set_preferred_domestic_carrier_codeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 697| 95|inline void PhoneNumber::set_preferred_domestic_carrier_code(const std::string& value) { 698| 95| _internal_set_preferred_domestic_carrier_code(value); 699| | // @@protoc_insertion_point(field_set:i18n.phonenumbers.PhoneNumber.preferred_domestic_carrier_code) 700| 95|} _ZNK4i18n12phonenumbers11PhoneNumber41_internal_preferred_domestic_carrier_codeEv: 705| 14.2k|inline const std::string& PhoneNumber::_internal_preferred_domestic_carrier_code() const { 706| 14.2k| return preferred_domestic_carrier_code_.Get(); 707| 14.2k|} _ZN4i18n12phonenumbers11PhoneNumber45_internal_set_preferred_domestic_carrier_codeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 708| 95|inline void PhoneNumber::_internal_set_preferred_domestic_carrier_code(const std::string& value) { 709| 95| _has_bits_[0] |= 0x00000004u; 710| 95| preferred_domestic_carrier_code_.Set(::PROTOBUF_NAMESPACE_ID::internal::ArenaStringPtr::EmptyDefault{}, value, GetArena()); 711| 95|} _ZN4i18n12phonenumbers15PhoneNumberUtilC2Ev: 859| 1| : logger_(Logger::set_logger_impl(new NullLogger())), 860| 1| matcher_api_(new RegexBasedMatcher()), 861| 1| reg_exps_(new PhoneNumberRegExpsAndMappings), 862| 1| country_calling_code_to_region_code_map_( 863| 1| new std::vector()), 864| 1| nanpa_regions_(new absl::node_hash_set()), 865| 1| region_to_metadata_map_(new absl::node_hash_map()), 866| 1| country_code_to_non_geographical_metadata_map_( 867| 1| new absl::node_hash_map) { 868| 1| Logger::set_logger_impl(logger_.get()); 869| | // TODO: Update the java version to put the contents of the init 870| | // method inside the constructor as well to keep both in sync. 871| 1| PhoneMetadataCollection metadata_collection; 872| 1| if (!LoadCompiledInMetadata(&metadata_collection)) { ------------------ | Branch (872:7): [True: 0, False: 1] ------------------ 873| 0| LOG(DFATAL) << "Could not parse compiled-in metadata."; 874| 0| return; 875| 0| } 876| | // Storing data in a temporary map to make it easier to find other regions 877| | // that share a country calling code when inserting data. 878| 1| std::map* > country_calling_code_to_region_map; 879| 1| for (RepeatedPtrField::const_iterator it = 880| 1| metadata_collection.metadata().begin(); 881| 255| it != metadata_collection.metadata().end(); ------------------ | Branch (881:8): [True: 254, False: 1] ------------------ 882| 254| ++it) { 883| 254| const string& region_code = it->id(); 884| 254| if (region_code == RegionCode::GetUnknown()) { ------------------ | Branch (884:9): [True: 0, False: 254] ------------------ 885| 0| continue; 886| 0| } 887| | 888| 254| int country_calling_code = it->country_code(); 889| 254| if (kRegionCodeForNonGeoEntity == region_code) { ------------------ | Branch (889:9): [True: 9, False: 245] ------------------ 890| 9| country_code_to_non_geographical_metadata_map_->insert( 891| 9| std::make_pair(country_calling_code, *it)); 892| 245| } else { 893| 245| region_to_metadata_map_->insert(std::make_pair(region_code, *it)); 894| 245| } 895| 254| std::map* >::iterator calling_code_in_map = 896| 254| country_calling_code_to_region_map.find(country_calling_code); 897| 254| if (calling_code_in_map != country_calling_code_to_region_map.end()) { ------------------ | Branch (897:9): [True: 39, False: 215] ------------------ 898| 39| if (it->main_country_for_code()) { ------------------ | Branch (898:11): [True: 6, False: 33] ------------------ 899| 6| calling_code_in_map->second->push_front(region_code); 900| 33| } else { 901| 33| calling_code_in_map->second->push_back(region_code); 902| 33| } 903| 215| } else { 904| | // For most country calling codes, there will be only one region code. 905| 215| std::list* list_with_region_code = new std::list(); 906| 215| list_with_region_code->push_back(region_code); 907| 215| country_calling_code_to_region_map.insert( 908| 215| std::make_pair(country_calling_code, list_with_region_code)); 909| 215| } 910| 254| if (country_calling_code == kNanpaCountryCode) { ------------------ | Branch (910:9): [True: 25, False: 229] ------------------ 911| 25| nanpa_regions_->insert(region_code); 912| 25| } 913| 254| } 914| | 915| 1| country_calling_code_to_region_code_map_->insert( 916| 1| country_calling_code_to_region_code_map_->begin(), 917| 1| country_calling_code_to_region_map.begin(), 918| 1| country_calling_code_to_region_map.end()); 919| | // Sort all the pairs in ascending order according to country calling code. 920| 1| std::sort(country_calling_code_to_region_code_map_->begin(), 921| 1| country_calling_code_to_region_code_map_->end(), OrderByFirst()); 922| 1|} _ZNK4i18n12phonenumbers15PhoneNumberUtil19GetSupportedRegionsEPNSt3__13setINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS2_4lessIS9_EENS7_IS9_EEEE: 931| 9.65k| const { 932| 9.65k| DCHECK(regions); ------------------ | | 29| 9.65k|#define DCHECK(X) assert(X) ------------------ 933| 9.65k| for (absl::node_hash_map::const_iterator it = 934| 2.37M| region_to_metadata_map_->begin(); it != region_to_metadata_map_->end(); ------------------ | Branch (934:42): [True: 2.36M, False: 9.65k] ------------------ 935| 2.36M| ++it) { 936| 2.36M| regions->insert(it->first); 937| 2.36M| } 938| 9.65k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil37GetSupportedGlobalNetworkCallingCodesEPNSt3__13setIiNS2_4lessIiEENS2_9allocatorIiEEEE: 941| 446| std::set* calling_codes) const { 942| 446| DCHECK(calling_codes); ------------------ | | 29| 446|#define DCHECK(X) assert(X) ------------------ 943| 446| for (absl::node_hash_map::const_iterator it = 944| 446| country_code_to_non_geographical_metadata_map_->begin(); 945| 4.46k| it != country_code_to_non_geographical_metadata_map_->end(); ++it) { ------------------ | Branch (945:8): [True: 4.01k, False: 446] ------------------ 946| 4.01k| calling_codes->insert(it->first); 947| 4.01k| } 948| 446|} _ZN4i18n12phonenumbers15PhoneNumberUtil11GetInstanceEv: 990| 9.65k|PhoneNumberUtil* PhoneNumberUtil::GetInstance() { 991| 9.65k| return Singleton::GetInstance(); 992| 9.65k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil20TrimUnwantedEndCharsEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1009| 61.0k|void PhoneNumberUtil::TrimUnwantedEndChars(string* number) const { 1010| 61.0k| DCHECK(number); ------------------ | | 29| 61.0k|#define DCHECK(X) assert(X) ------------------ 1011| 61.0k| UnicodeText number_as_unicode; 1012| 61.0k| number_as_unicode.PointToUTF8(number->data(), static_cast(number->size())); 1013| 61.0k| if (!number_as_unicode.UTF8WasValid()) { ------------------ | Branch (1013:7): [True: 0, False: 61.0k] ------------------ 1014| | // The input wasn't valid UTF-8. Produce an empty string to indicate an error. 1015| 0| number->clear(); 1016| 0| return; 1017| 0| } 1018| 61.0k| char current_char[5]; 1019| 61.0k| int len; 1020| 61.0k| UnicodeText::const_reverse_iterator reverse_it(number_as_unicode.end()); 1021| 66.0k| for (; reverse_it.base() != number_as_unicode.begin(); ++reverse_it) { ------------------ | Branch (1021:10): [True: 65.5k, False: 450] ------------------ 1022| 65.5k| len = reverse_it.get_utf8(current_char); 1023| 65.5k| current_char[len] = '\0'; 1024| 65.5k| if (!reg_exps_->unwanted_end_char_pattern_->FullMatch(current_char)) { ------------------ | Branch (1024:9): [True: 60.5k, False: 4.96k] ------------------ 1025| 60.5k| break; 1026| 60.5k| } 1027| 65.5k| } 1028| | 1029| 61.0k| number->assign(UnicodeText::UTF8Substring(number_as_unicode.begin(), 1030| 61.0k| reverse_it.base())); 1031| 61.0k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil21GetNddPrefixForRegionERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbPS8_: 1064| 9.99k| string* national_prefix) const { 1065| 9.99k| DCHECK(national_prefix); ------------------ | | 29| 9.99k|#define DCHECK(X) assert(X) ------------------ 1066| 9.99k| const PhoneMetadata* metadata = GetMetadataForRegion(region_code); 1067| 9.99k| if (!metadata) { ------------------ | Branch (1067:7): [True: 1.72k, False: 8.27k] ------------------ 1068| 1.72k| LOG(WARNING) << "Invalid or unknown region code (" << region_code 1069| 1.72k| << ") provided."; 1070| 1.72k| return; 1071| 1.72k| } 1072| 8.27k| national_prefix->assign(metadata->national_prefix()); 1073| 8.27k| if (strip_non_digits) { ------------------ | Branch (1073:7): [True: 3.01k, False: 5.25k] ------------------ 1074| | // Note: if any other non-numeric symbols are ever used in national 1075| | // prefixes, these would have to be removed here as well. 1076| 3.01k| strrmm(national_prefix, "~"); 1077| 3.01k| } 1078| 8.27k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil17IsValidRegionCodeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1080| 234k|bool PhoneNumberUtil::IsValidRegionCode(const string& region_code) const { 1081| 234k| return (region_to_metadata_map_->find(region_code) != 1082| 234k| region_to_metadata_map_->end()); 1083| 234k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil26HasValidCountryCallingCodeEi: 1086| 106k| int country_calling_code) const { 1087| | // Create an IntRegionsPair with the country_code passed in, and use it to 1088| | // locate the pair with the same country_code in the sorted vector. 1089| 106k| IntRegionsPair target_pair; 1090| 106k| target_pair.first = country_calling_code; 1091| 106k| return (std::binary_search(country_calling_code_to_region_code_map_->begin(), 1092| 106k| country_calling_code_to_region_code_map_->end(), 1093| 106k| target_pair, OrderByFirst())); 1094| 106k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil20GetMetadataForRegionERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1099| 564k| const string& region_code) const { 1100| 564k| absl::node_hash_map::const_iterator it = 1101| 564k| region_to_metadata_map_->find(region_code); 1102| 564k| if (it != region_to_metadata_map_->end()) { ------------------ | Branch (1102:7): [True: 536k, False: 27.0k] ------------------ 1103| 536k| return &it->second; 1104| 536k| } 1105| 27.0k| return NULL; 1106| 564k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil35GetMetadataForNonGeographicalRegionEi: 1109| 14.6k| int country_calling_code) const { 1110| 14.6k| absl::node_hash_map::const_iterator it = 1111| 14.6k| country_code_to_non_geographical_metadata_map_->find( 1112| 14.6k| country_calling_code); 1113| 14.6k| if (it != country_code_to_non_geographical_metadata_map_->end()) { ------------------ | Branch (1113:7): [True: 5.01k, False: 9.62k] ------------------ 1114| 5.01k| return &it->second; 1115| 5.01k| } 1116| 9.62k| return NULL; 1117| 14.6k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil6FormatERKNS0_11PhoneNumberENS1_17PhoneNumberFormatEPNSt3__112basic_stringIcNS6_11char_traitsIcEENS6_9allocatorIcEEEE: 1121| 37.6k| string* formatted_number) const { 1122| 37.6k| DCHECK(formatted_number); ------------------ | | 29| 37.6k|#define DCHECK(X) assert(X) ------------------ 1123| 37.6k| if (number.national_number() == 0) { ------------------ | Branch (1123:7): [True: 8.36k, False: 29.3k] ------------------ 1124| 8.36k| const string& raw_input = number.raw_input(); 1125| 8.36k| if (!raw_input.empty()) { ------------------ | Branch (1125:9): [True: 271, False: 8.09k] ------------------ 1126| | // Unparseable numbers that kept their raw input just use that. 1127| | // This is the only case where a number can be formatted as E164 without a 1128| | // leading '+' symbol (but the original number wasn't parseable anyway). 1129| | // TODO: Consider removing the 'if' above so that unparseable 1130| | // strings without raw input format to the empty string instead of "+00". 1131| 271| formatted_number->assign(raw_input); 1132| 271| return; 1133| 271| } 1134| 8.36k| } 1135| 37.4k| int country_calling_code = number.country_code(); 1136| 37.4k| string national_significant_number; 1137| 37.4k| GetNationalSignificantNumber(number, &national_significant_number); 1138| 37.4k| if (number_format == E164) { ------------------ | Branch (1138:7): [True: 6.08k, False: 31.3k] ------------------ 1139| | // Early exit for E164 case (even if the country calling code is invalid) 1140| | // since no formatting of the national number needs to be applied. 1141| | // Extensions are not formatted. 1142| 6.08k| formatted_number->assign(national_significant_number); 1143| 6.08k| PrefixNumberWithCountryCallingCode(country_calling_code, E164, 1144| 6.08k| formatted_number); 1145| 6.08k| return; 1146| 6.08k| } 1147| 31.3k| if (!HasValidCountryCallingCode(country_calling_code)) { ------------------ | Branch (1147:7): [True: 5.85k, False: 25.4k] ------------------ 1148| 5.85k| formatted_number->assign(national_significant_number); 1149| 5.85k| return; 1150| 5.85k| } 1151| | // Note here that all NANPA formatting rules are contained by US, so we use 1152| | // that to format NANPA numbers. The same applies to Russian Fed regions - 1153| | // rules are contained by Russia. French Indian Ocean country rules are 1154| | // contained by Réunion. 1155| 25.4k| string region_code; 1156| 25.4k| GetRegionCodeForCountryCode(country_calling_code, ®ion_code); 1157| | // Metadata cannot be NULL because the country calling code is valid (which 1158| | // means that the region code cannot be ZZ and must be one of our supported 1159| | // region codes). 1160| 25.4k| const PhoneMetadata* metadata = 1161| 25.4k| GetMetadataForRegionOrCallingCode(country_calling_code, region_code); 1162| 25.4k| FormatNsn(national_significant_number, *metadata, number_format, 1163| 25.4k| formatted_number); 1164| 25.4k| MaybeAppendFormattedExtension(number, *metadata, number_format, 1165| 25.4k| formatted_number); 1166| 25.4k| PrefixNumberWithCountryCallingCode(country_calling_code, number_format, 1167| 25.4k| formatted_number); 1168| 25.4k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil15FormatByPatternERKNS0_11PhoneNumberENS1_17PhoneNumberFormatERKN6google8protobuf16RepeatedPtrFieldINS0_12NumberFormatEEEPNSt3__112basic_stringIcNSD_11char_traitsIcEENSD_9allocatorIcEEEE: 1174| 9.78k| string* formatted_number) const { 1175| 9.78k| DCHECK(formatted_number); ------------------ | | 29| 9.78k|#define DCHECK(X) assert(X) ------------------ 1176| 9.78k| int country_calling_code = number.country_code(); 1177| | // Note GetRegionCodeForCountryCode() is used because formatting information 1178| | // for regions which share a country calling code is contained by only one 1179| | // region for performance reasons. For example, for NANPA regions it will be 1180| | // contained in the metadata for US. 1181| 9.78k| string national_significant_number; 1182| 9.78k| GetNationalSignificantNumber(number, &national_significant_number); 1183| 9.78k| if (!HasValidCountryCallingCode(country_calling_code)) { ------------------ | Branch (1183:7): [True: 2.14k, False: 7.63k] ------------------ 1184| 2.14k| formatted_number->assign(national_significant_number); 1185| 2.14k| return; 1186| 2.14k| } 1187| 7.63k| string region_code; 1188| 7.63k| GetRegionCodeForCountryCode(country_calling_code, ®ion_code); 1189| | // Metadata cannot be NULL because the country calling code is valid. 1190| 7.63k| const PhoneMetadata* metadata = 1191| 7.63k| GetMetadataForRegionOrCallingCode(country_calling_code, region_code); 1192| 7.63k| const NumberFormat* formatting_pattern = 1193| 7.63k| ChooseFormattingPatternForNumber(user_defined_formats, 1194| 7.63k| national_significant_number); 1195| 7.63k| if (!formatting_pattern) { ------------------ | Branch (1195:7): [True: 6.78k, False: 855] ------------------ 1196| | // If no pattern above is matched, we format the number as a whole. 1197| 6.78k| formatted_number->assign(national_significant_number); 1198| 6.78k| } else { 1199| 855| NumberFormat num_format_copy; 1200| | // Before we do a replacement of the national prefix pattern $NP with the 1201| | // national prefix, we need to copy the rule so that subsequent replacements 1202| | // for different numbers have the appropriate national prefix. 1203| 855| num_format_copy.MergeFrom(*formatting_pattern); 1204| 855| string national_prefix_formatting_rule( 1205| 855| formatting_pattern->national_prefix_formatting_rule()); 1206| 855| if (!national_prefix_formatting_rule.empty()) { ------------------ | Branch (1206:9): [True: 0, False: 855] ------------------ 1207| 0| const string& national_prefix = metadata->national_prefix(); 1208| 0| if (!national_prefix.empty()) { ------------------ | Branch (1208:11): [True: 0, False: 0] ------------------ 1209| | // Replace $NP with national prefix and $FG with the first group ($1). 1210| 0| GlobalReplaceSubstring("$NP", national_prefix, 1211| 0| &national_prefix_formatting_rule); 1212| 0| GlobalReplaceSubstring("$FG", "$1", &national_prefix_formatting_rule); 1213| 0| num_format_copy.set_national_prefix_formatting_rule( 1214| 0| national_prefix_formatting_rule); 1215| 0| } else { 1216| | // We don't want to have a rule for how to format the national prefix if 1217| | // there isn't one. 1218| 0| num_format_copy.clear_national_prefix_formatting_rule(); 1219| 0| } 1220| 0| } 1221| 855| FormatNsnUsingPattern(national_significant_number, num_format_copy, 1222| 855| number_format, formatted_number); 1223| 855| } 1224| 7.63k| MaybeAppendFormattedExtension(number, *metadata, NATIONAL, formatted_number); 1225| 7.63k| PrefixNumberWithCountryCallingCode(country_calling_code, number_format, 1226| 7.63k| formatted_number); 1227| 7.63k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil35FormatNationalNumberWithCarrierCodeERKNS0_11PhoneNumberERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPSB_: 1232| 19.3k| string* formatted_number) const { 1233| 19.3k| int country_calling_code = number.country_code(); 1234| 19.3k| string national_significant_number; 1235| 19.3k| GetNationalSignificantNumber(number, &national_significant_number); 1236| 19.3k| if (!HasValidCountryCallingCode(country_calling_code)) { ------------------ | Branch (1236:7): [True: 4.28k, False: 15.0k] ------------------ 1237| 4.28k| formatted_number->assign(national_significant_number); 1238| 4.28k| return; 1239| 4.28k| } 1240| | 1241| | // Note GetRegionCodeForCountryCode() is used because formatting information 1242| | // for regions which share a country calling code is contained by only one 1243| | // region for performance reasons. For example, for NANPA regions it will be 1244| | // contained in the metadata for US. 1245| 15.0k| string region_code; 1246| 15.0k| GetRegionCodeForCountryCode(country_calling_code, ®ion_code); 1247| | // Metadata cannot be NULL because the country calling code is valid. 1248| 15.0k| const PhoneMetadata* metadata = 1249| 15.0k| GetMetadataForRegionOrCallingCode(country_calling_code, region_code); 1250| 15.0k| FormatNsnWithCarrier(national_significant_number, *metadata, NATIONAL, 1251| 15.0k| carrier_code, formatted_number); 1252| 15.0k| MaybeAppendFormattedExtension(number, *metadata, NATIONAL, formatted_number); 1253| 15.0k| PrefixNumberWithCountryCallingCode(country_calling_code, NATIONAL, 1254| 15.0k| formatted_number); 1255| 15.0k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil33GetMetadataForRegionOrCallingCodeEiRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1258| 129k| int country_calling_code, const string& region_code) const { 1259| 129k| return kRegionCodeForNonGeoEntity == region_code ------------------ | Branch (1259:10): [True: 973, False: 128k] ------------------ 1260| 129k| ? GetMetadataForNonGeographicalRegion(country_calling_code) 1261| 129k| : GetMetadataForRegion(region_code); 1262| 129k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil44FormatNationalNumberWithPreferredCarrierCodeERKNS0_11PhoneNumberERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPSB_: 1267| 9.65k| string* formatted_number) const { 1268| 9.65k| FormatNationalNumberWithCarrierCode( 1269| 9.65k| number, 1270| | // Historically, we set this to an empty string when parsing with raw 1271| | // input if none was found in the input string. However, this doesn't 1272| | // result in a number we can dial. For this reason, we treat the empty 1273| | // string the same as if it isn't set at all. 1274| 9.65k| !number.preferred_domestic_carrier_code().empty() ------------------ | Branch (1274:7): [True: 92, False: 9.56k] ------------------ 1275| 9.65k| ? number.preferred_domestic_carrier_code() 1276| 9.65k| : fallback_carrier_code, 1277| 9.65k| formatted_number); 1278| 9.65k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil28FormatNumberForMobileDialingERKNS0_11PhoneNumberERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEbPSB_: 1284| 9.65k| string* formatted_number) const { 1285| 9.65k| int country_calling_code = number.country_code(); 1286| 9.65k| if (!HasValidCountryCallingCode(country_calling_code)) { ------------------ | Branch (1286:7): [True: 2.14k, False: 7.50k] ------------------ 1287| 2.14k| formatted_number->assign(number.has_raw_input() ? number.raw_input() : ""); ------------------ | Branch (1287:30): [True: 0, False: 2.14k] ------------------ 1288| 2.14k| return; 1289| 2.14k| } 1290| | 1291| 7.50k| formatted_number->assign(""); 1292| | // Clear the extension, as that part cannot normally be dialed together with 1293| | // the main number. 1294| 7.50k| PhoneNumber number_no_extension(number); 1295| 7.50k| number_no_extension.clear_extension(); 1296| 7.50k| string region_code; 1297| 7.50k| GetRegionCodeForCountryCode(country_calling_code, ®ion_code); 1298| 7.50k| PhoneNumberType number_type = GetNumberType(number_no_extension); 1299| 7.50k| bool is_valid_number = (number_type != UNKNOWN); 1300| 7.50k| if (calling_from == region_code) { ------------------ | Branch (1300:7): [True: 5.83k, False: 1.67k] ------------------ 1301| 5.83k| bool is_fixed_line_or_mobile = 1302| 5.83k| (number_type == FIXED_LINE) || (number_type == MOBILE) || ------------------ | Branch (1302:9): [True: 159, False: 5.67k] | Branch (1302:40): [True: 55, False: 5.61k] ------------------ 1303| 5.83k| (number_type == FIXED_LINE_OR_MOBILE); ------------------ | Branch (1303:9): [True: 8, False: 5.61k] ------------------ 1304| | // Carrier codes may be needed in some countries. We handle this here. 1305| 5.83k| if ((region_code == "BR") && (is_fixed_line_or_mobile)) { ------------------ | Branch (1305:9): [True: 79, False: 5.75k] | Branch (1305:34): [True: 13, False: 66] ------------------ 1306| | // Historically, we set this to an empty string when parsing with raw 1307| | // input if none was found in the input string. However, this doesn't 1308| | // result in a number we can dial. For this reason, we treat the empty 1309| | // string the same as if it isn't set at all. 1310| 13| if (!number_no_extension.preferred_domestic_carrier_code().empty()) { ------------------ | Branch (1310:11): [True: 5, False: 8] ------------------ 1311| 5| FormatNationalNumberWithPreferredCarrierCode(number_no_extension, "", 1312| 5| formatted_number); 1313| 8| } else { 1314| | // Brazilian fixed line and mobile numbers need to be dialed with a 1315| | // carrier code when called within Brazil. Without that, most of the 1316| | // carriers won't connect the call. Because of that, we return an empty 1317| | // string here. 1318| 8| formatted_number->assign(""); 1319| 8| } 1320| 5.82k| } else if (country_calling_code == kNanpaCountryCode) { ------------------ | Branch (1320:16): [True: 16, False: 5.80k] ------------------ 1321| | // For NANPA countries, we output international format for numbers that 1322| | // can be dialed internationally, since that always works, except for 1323| | // numbers which might potentially be short numbers, which are always 1324| | // dialled in national format. 1325| 16| const PhoneMetadata* region_metadata = GetMetadataForRegion(calling_from); 1326| 16| string national_number; 1327| 16| GetNationalSignificantNumber(number_no_extension, &national_number); 1328| 16| if (CanBeInternationallyDialled(number_no_extension) && ------------------ | Branch (1328:11): [True: 16, False: 0] ------------------ 1329| 16| TestNumberLength(national_number, *region_metadata) != TOO_SHORT) { ------------------ | Branch (1329:11): [True: 5, False: 11] ------------------ 1330| 5| Format(number_no_extension, INTERNATIONAL, formatted_number); 1331| 11| } else { 1332| 11| Format(number_no_extension, NATIONAL, formatted_number); 1333| 11| } 1334| 5.80k| } else { 1335| | // For non-geographical countries, and Mexican, Chilean and Uzbek fixed 1336| | // line and mobile numbers, we output international format for numbers 1337| | // that can be dialed internationally as that always works. 1338| 5.80k| if ((region_code == kRegionCodeForNonGeoEntity || ------------------ | Branch (1338:12): [True: 1, False: 5.80k] ------------------ 1339| | // MX fixed line and mobile numbers should always be formatted in 1340| | // international format, even when dialed within MX. For national 1341| | // format to work, a carrier code needs to be used, and the correct 1342| | // carrier code depends on if the caller and callee are from the same 1343| | // local area. It is trickier to get that to work correctly than 1344| | // using international format, which is tested to work fine on all 1345| | // carriers. 1346| | // CL fixed line numbers need the national prefix when dialing in the 1347| | // national format, but don't have it when used for display. The 1348| | // reverse is true for mobile numbers. As a result, we output them in 1349| | // the international format to make it work. 1350| | // UZ mobile and fixed-line numbers have to be formatted in 1351| | // international format or prefixed with special codes like 03, 04 1352| | // (for fixed-line) and 05 (for mobile) for dialling successfully 1353| | // from mobile devices. As we do not have complete information on 1354| | // special codes and to be consistent with formatting across all 1355| | // phone types we return the number in international format here. 1356| 5.80k| ((region_code == "MX" || ------------------ | Branch (1356:14): [True: 23, False: 5.78k] ------------------ 1357| 5.80k| region_code == "CL" || ------------------ | Branch (1357:14): [True: 29, False: 5.75k] ------------------ 1358| 5.80k| region_code == "UZ") && ------------------ | Branch (1358:14): [True: 42, False: 5.70k] ------------------ 1359| 5.80k| is_fixed_line_or_mobile)) && ------------------ | Branch (1359:13): [True: 4, False: 90] ------------------ 1360| 5.80k| CanBeInternationallyDialled(number_no_extension)) { ------------------ | Branch (1360:11): [True: 5, False: 0] ------------------ 1361| 5| Format(number_no_extension, INTERNATIONAL, formatted_number); 1362| 5.79k| } else { 1363| 5.79k| Format(number_no_extension, NATIONAL, formatted_number); 1364| 5.79k| } 1365| 5.80k| } 1366| 5.83k| } else if (is_valid_number && ------------------ | Branch (1366:14): [True: 260, False: 1.41k] ------------------ 1367| 1.67k| CanBeInternationallyDialled(number_no_extension)) { ------------------ | Branch (1367:7): [True: 256, False: 4] ------------------ 1368| | // We assume that short numbers are not diallable from outside their 1369| | // region, so if a number is not a valid regular length phone number, we 1370| | // treat it as if it cannot be internationally dialled. 1371| 256| with_formatting ------------------ | Branch (1371:5): [True: 35, False: 221] ------------------ 1372| 256| ? Format(number_no_extension, INTERNATIONAL, formatted_number) 1373| 256| : Format(number_no_extension, E164, formatted_number); 1374| 256| return; 1375| 256| } 1376| 7.25k| if (!with_formatting) { ------------------ | Branch (1376:7): [True: 4.63k, False: 2.61k] ------------------ 1377| 4.63k| NormalizeDiallableCharsOnly(formatted_number); 1378| 4.63k| } 1379| 7.25k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil31FormatOutOfCountryCallingNumberERKNS0_11PhoneNumberERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPSB_: 1384| 6.23k| string* formatted_number) const { 1385| 6.23k| DCHECK(formatted_number); ------------------ | | 29| 6.23k|#define DCHECK(X) assert(X) ------------------ 1386| 6.23k| if (!IsValidRegionCode(calling_from)) { ------------------ | Branch (1386:7): [True: 1.67k, False: 4.56k] ------------------ 1387| 1.67k| VLOG(1) << "Trying to format number from invalid region " << calling_from 1388| 1.67k| << ". International formatting applied."; 1389| 1.67k| Format(number, INTERNATIONAL, formatted_number); 1390| 1.67k| return; 1391| 1.67k| } 1392| 4.56k| int country_code = number.country_code(); 1393| 4.56k| string national_significant_number; 1394| 4.56k| GetNationalSignificantNumber(number, &national_significant_number); 1395| 4.56k| if (!HasValidCountryCallingCode(country_code)) { ------------------ | Branch (1395:7): [True: 614, False: 3.95k] ------------------ 1396| 614| formatted_number->assign(national_significant_number); 1397| 614| return; 1398| 614| } 1399| 3.95k| if (country_code == kNanpaCountryCode) { ------------------ | Branch (1399:7): [True: 372, False: 3.58k] ------------------ 1400| 372| if (IsNANPACountry(calling_from)) { ------------------ | Branch (1400:9): [True: 347, False: 25] ------------------ 1401| | // For NANPA regions, return the national format for these regions but 1402| | // prefix it with the country calling code. 1403| 347| Format(number, NATIONAL, formatted_number); 1404| 347| formatted_number->insert(0, StrCat(country_code, " ")); 1405| 347| return; 1406| 347| } 1407| 3.58k| } else if (country_code == GetCountryCodeForValidRegion(calling_from)) { ------------------ | Branch (1407:14): [True: 3.50k, False: 78] ------------------ 1408| | // If neither region is a NANPA region, then we check to see if the 1409| | // country calling code of the number and the country calling code of the 1410| | // region we are calling from are the same. 1411| | // For regions that share a country calling code, the country calling code 1412| | // need not be dialled. This also applies when dialling within a region, so 1413| | // this if clause covers both these cases. 1414| | // Technically this is the case for dialling from la Réunion to other 1415| | // overseas departments of France (French Guiana, Martinique, Guadeloupe), 1416| | // but not vice versa - so we don't cover this edge case for now and for 1417| | // those cases return the version including country calling code. 1418| | // Details here: 1419| | // http://www.petitfute.com/voyage/225-info-pratiques-reunion 1420| 3.50k| Format(number, NATIONAL, formatted_number); 1421| 3.50k| return; 1422| 3.50k| } 1423| | // Metadata cannot be NULL because we checked 'IsValidRegionCode()' above. 1424| 103| const PhoneMetadata* metadata_calling_from = 1425| 103| GetMetadataForRegion(calling_from); 1426| 103| const string& international_prefix = 1427| 103| metadata_calling_from->international_prefix(); 1428| | 1429| | // In general, if there is a preferred international prefix, use that. 1430| | // Otherwise, for regions that have multiple international prefixes, the 1431| | // international format of the number is returned since we would not know 1432| | // which one to use. 1433| 103| std::string international_prefix_for_formatting; 1434| 103| if (metadata_calling_from->has_preferred_international_prefix()) { ------------------ | Branch (1434:7): [True: 18, False: 85] ------------------ 1435| 18| international_prefix_for_formatting = 1436| 18| metadata_calling_from->preferred_international_prefix(); 1437| 85| } else if (reg_exps_->single_international_prefix_->FullMatch( ------------------ | Branch (1437:14): [True: 81, False: 4] ------------------ 1438| 85| international_prefix)) { 1439| 81| international_prefix_for_formatting = international_prefix; 1440| 81| } 1441| | 1442| 103| string region_code; 1443| 103| GetRegionCodeForCountryCode(country_code, ®ion_code); 1444| | // Metadata cannot be NULL because the country_code is valid. 1445| 103| const PhoneMetadata* metadata_for_region = 1446| 103| GetMetadataForRegionOrCallingCode(country_code, region_code); 1447| 103| FormatNsn(national_significant_number, *metadata_for_region, INTERNATIONAL, 1448| 103| formatted_number); 1449| 103| MaybeAppendFormattedExtension(number, *metadata_for_region, INTERNATIONAL, 1450| 103| formatted_number); 1451| 103| if (!international_prefix_for_formatting.empty()) { ------------------ | Branch (1451:7): [True: 99, False: 4] ------------------ 1452| 99| formatted_number->insert( 1453| 99| 0, StrCat(international_prefix_for_formatting, " ", country_code, " ")); 1454| 99| } else { 1455| 4| PrefixNumberWithCountryCallingCode(country_code, INTERNATIONAL, 1456| 4| formatted_number); 1457| 4| } 1458| 103|} _ZNK4i18n12phonenumbers15PhoneNumberUtil22FormatInOriginalFormatERKNS0_11PhoneNumberERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPSB_: 1462| 9.65k| string* formatted_number) const { 1463| 9.65k| DCHECK(formatted_number); ------------------ | | 29| 9.65k|#define DCHECK(X) assert(X) ------------------ 1464| | 1465| 9.65k| if (number.has_raw_input() && !HasFormattingPatternForNumber(number)) { ------------------ | Branch (1465:7): [True: 3.42k, False: 6.22k] | Branch (1465:33): [True: 3.02k, False: 408] ------------------ 1466| | // We check if we have the formatting pattern because without that, we might 1467| | // format the number as a group without national prefix. 1468| 3.02k| formatted_number->assign(number.raw_input()); 1469| 3.02k| return; 1470| 3.02k| } 1471| 6.63k| if (!number.has_country_code_source()) { ------------------ | Branch (1471:7): [True: 6.22k, False: 408] ------------------ 1472| 6.22k| Format(number, NATIONAL, formatted_number); 1473| 6.22k| return; 1474| 6.22k| } 1475| 408| switch (number.country_code_source()) { 1476| 30| case PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN: ------------------ | Branch (1476:5): [True: 30, False: 378] ------------------ 1477| 30| Format(number, INTERNATIONAL, formatted_number); 1478| 30| break; 1479| 17| case PhoneNumber::FROM_NUMBER_WITH_IDD: ------------------ | Branch (1479:5): [True: 17, False: 391] ------------------ 1480| 17| FormatOutOfCountryCallingNumber(number, region_calling_from, 1481| 17| formatted_number); 1482| 17| break; 1483| 12| case PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN: ------------------ | Branch (1483:5): [True: 12, False: 396] ------------------ 1484| 12| Format(number, INTERNATIONAL, formatted_number); 1485| 12| formatted_number->erase(formatted_number->begin()); 1486| 12| break; 1487| 349| case PhoneNumber::FROM_DEFAULT_COUNTRY: ------------------ | Branch (1487:5): [True: 349, False: 59] ------------------ 1488| | // Fall-through to default case. 1489| 349| default: ------------------ | Branch (1489:5): [True: 0, False: 408] ------------------ 1490| 349| string region_code; 1491| 349| GetRegionCodeForCountryCode(number.country_code(), ®ion_code); 1492| | // We strip non-digits from the NDD here, and from the raw input later, so 1493| | // that we can compare them easily. 1494| 349| string national_prefix; 1495| 349| GetNddPrefixForRegion(region_code, true /* strip non-digits */, 1496| 349| &national_prefix); 1497| 349| if (national_prefix.empty()) { ------------------ | Branch (1497:11): [True: 79, False: 270] ------------------ 1498| | // If the region doesn't have a national prefix at all, we can safely 1499| | // return the national format without worrying about a national prefix 1500| | // being added. 1501| 79| Format(number, NATIONAL, formatted_number); 1502| 79| break; 1503| 79| } 1504| | // Otherwise, we check if the original number was entered with a national 1505| | // prefix. 1506| 270| if (RawInputContainsNationalPrefix(number.raw_input(), national_prefix, ------------------ | Branch (1506:11): [True: 37, False: 233] ------------------ 1507| 270| region_code)) { 1508| | // If so, we can safely return the national format. 1509| 37| Format(number, NATIONAL, formatted_number); 1510| 37| break; 1511| 37| } 1512| | // Metadata cannot be NULL here because GetNddPrefixForRegion() (above) 1513| | // leaves the prefix empty if there is no metadata for the region. 1514| 233| const PhoneMetadata* metadata = GetMetadataForRegion(region_code); 1515| 233| string national_number; 1516| 233| GetNationalSignificantNumber(number, &national_number); 1517| | // This shouldn't be NULL, because we have checked that above with 1518| | // HasFormattingPatternForNumber. 1519| 233| const NumberFormat* format_rule = 1520| 233| ChooseFormattingPatternForNumber(metadata->number_format(), 1521| 233| national_number); 1522| | // The format rule could still be NULL here if the national number was 0 1523| | // and there was no raw input (this should not be possible for numbers 1524| | // generated by the phonenumber library as they would also not have a 1525| | // country calling code and we would have exited earlier). 1526| 233| if (!format_rule) { ------------------ | Branch (1526:11): [True: 0, False: 233] ------------------ 1527| 0| Format(number, NATIONAL, formatted_number); 1528| 0| break; 1529| 0| } 1530| | // When the format we apply to this number doesn't contain national 1531| | // prefix, we can just return the national format. 1532| | // TODO: Refactor the code below with the code in 1533| | // IsNationalPrefixPresentIfRequired. 1534| 233| string candidate_national_prefix_rule( 1535| 233| format_rule->national_prefix_formatting_rule()); 1536| | // We assume that the first-group symbol will never be _before_ the 1537| | // national prefix. 1538| 233| if (!candidate_national_prefix_rule.empty()) { ------------------ | Branch (1538:11): [True: 137, False: 96] ------------------ 1539| 137| size_t index_of_first_group = candidate_national_prefix_rule.find("$1"); 1540| 137| if (index_of_first_group == string::npos) { ------------------ | Branch (1540:13): [True: 0, False: 137] ------------------ 1541| 0| LOG(ERROR) << "First group missing in national prefix rule: " 1542| 0| << candidate_national_prefix_rule; 1543| 0| Format(number, NATIONAL, formatted_number); 1544| 0| break; 1545| 0| } 1546| 137| candidate_national_prefix_rule.erase(index_of_first_group); 1547| 137| NormalizeDigitsOnly(&candidate_national_prefix_rule); 1548| 137| } 1549| 233| if (candidate_national_prefix_rule.empty()) { ------------------ | Branch (1549:11): [True: 103, False: 130] ------------------ 1550| | // National prefix not used when formatting this number. 1551| 103| Format(number, NATIONAL, formatted_number); 1552| 103| break; 1553| 103| } 1554| | // Otherwise, we need to remove the national prefix from our output. 1555| 130| RepeatedPtrField number_formats; 1556| 130| NumberFormat* number_format = number_formats.Add(); 1557| 130| number_format->MergeFrom(*format_rule); 1558| 130| number_format->clear_national_prefix_formatting_rule(); 1559| 130| FormatByPattern(number, NATIONAL, number_formats, formatted_number); 1560| 130| break; 1561| 408| } 1562| | // If no digit is inserted/removed/modified as a result of our formatting, we 1563| | // return the formatted phone number; otherwise we return the raw input the 1564| | // user entered. 1565| 408| if (!formatted_number->empty() && !number.raw_input().empty()) { ------------------ | Branch (1565:7): [True: 408, False: 0] | Branch (1565:37): [True: 408, False: 0] ------------------ 1566| 408| string normalized_formatted_number(*formatted_number); 1567| 408| NormalizeDiallableCharsOnly(&normalized_formatted_number); 1568| 408| string normalized_raw_input(number.raw_input()); 1569| 408| NormalizeDiallableCharsOnly(&normalized_raw_input); 1570| 408| if (normalized_formatted_number != normalized_raw_input) { ------------------ | Branch (1570:9): [True: 285, False: 123] ------------------ 1571| 285| formatted_number->assign(number.raw_input()); 1572| 285| } 1573| 408| } 1574| 408|} _ZNK4i18n12phonenumbers15PhoneNumberUtil30RawInputContainsNationalPrefixERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_SA_: 1581| 270| const string& region_code) const { 1582| 270| string normalized_national_number(raw_input); 1583| 270| NormalizeDigitsOnly(&normalized_national_number); 1584| 270| if (HasPrefixString(normalized_national_number, national_prefix)) { ------------------ | Branch (1584:7): [True: 83, False: 187] ------------------ 1585| | // Some Japanese numbers (e.g. 00777123) might be mistaken to contain 1586| | // the national prefix when written without it (e.g. 0777123) if we just 1587| | // do prefix matching. To tackle that, we check the validity of the 1588| | // number if the assumed national prefix is removed (777123 won't be 1589| | // valid in Japan). 1590| 83| PhoneNumber number_without_national_prefix; 1591| 83| if (Parse(normalized_national_number.substr(national_prefix.length()), ------------------ | Branch (1591:9): [True: 72, False: 11] ------------------ 1592| 83| region_code, &number_without_national_prefix) 1593| 83| == NO_PARSING_ERROR) { 1594| 72| return IsValidNumber(number_without_national_prefix); 1595| 72| } 1596| 83| } 1597| 198| return false; 1598| 270|} _ZNK4i18n12phonenumbers15PhoneNumberUtil29HasFormattingPatternForNumberERKNS0_11PhoneNumberE: 1601| 3.42k| const PhoneNumber& number) const { 1602| 3.42k| int country_calling_code = number.country_code(); 1603| 3.42k| string region_code; 1604| 3.42k| GetRegionCodeForCountryCode(country_calling_code, ®ion_code); 1605| 3.42k| const PhoneMetadata* metadata = 1606| 3.42k| GetMetadataForRegionOrCallingCode(country_calling_code, region_code); 1607| 3.42k| if (!metadata) { ------------------ | Branch (1607:7): [True: 0, False: 3.42k] ------------------ 1608| 0| return false; 1609| 0| } 1610| 3.42k| string national_number; 1611| 3.42k| GetNationalSignificantNumber(number, &national_number); 1612| 3.42k| const NumberFormat* format_rule = 1613| 3.42k| ChooseFormattingPatternForNumber(metadata->number_format(), 1614| 3.42k| national_number); 1615| 3.42k| return format_rule; 1616| 3.42k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil35FormatOutOfCountryKeepingAlphaCharsERKNS0_11PhoneNumberERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPSB_: 1621| 9.65k| string* formatted_number) const { 1622| | // If there is no raw input, then we can't keep alpha characters because there 1623| | // aren't any. In this case, we return FormatOutOfCountryCallingNumber. 1624| 9.65k| if (number.raw_input().empty()) { ------------------ | Branch (1624:7): [True: 6.22k, False: 3.42k] ------------------ 1625| 6.22k| FormatOutOfCountryCallingNumber(number, calling_from, formatted_number); 1626| 6.22k| return; 1627| 6.22k| } 1628| 3.42k| int country_code = number.country_code(); 1629| 3.42k| if (!HasValidCountryCallingCode(country_code)) { ------------------ | Branch (1629:7): [True: 0, False: 3.42k] ------------------ 1630| 0| formatted_number->assign(number.raw_input()); 1631| 0| return; 1632| 0| } 1633| | // Strip any prefix such as country calling code, IDD, that was present. We do 1634| | // this by comparing the number in raw_input with the parsed number. 1635| 3.42k| string raw_input_copy(number.raw_input()); 1636| | // Normalize punctuation. We retain number grouping symbols such as " " only. 1637| 3.42k| NormalizeHelper(reg_exps_->all_plus_number_grouping_symbols_, true, 1638| 3.42k| &raw_input_copy); 1639| | // Now we trim everything before the first three digits in the parsed number. 1640| | // We choose three because all valid alpha numbers have 3 digits at the start 1641| | // - if it does not, then we don't trim anything at all. Similarly, if the 1642| | // national number was less than three digits, we don't trim anything at all. 1643| 3.42k| string national_number; 1644| 3.42k| GetNationalSignificantNumber(number, &national_number); 1645| 3.42k| if (national_number.length() > 3) { ------------------ | Branch (1645:7): [True: 729, False: 2.69k] ------------------ 1646| 729| size_t first_national_number_digit = 1647| 729| raw_input_copy.find(national_number.substr(0, 3)); 1648| 729| if (first_national_number_digit != string::npos) { ------------------ | Branch (1648:9): [True: 524, False: 205] ------------------ 1649| 524| raw_input_copy = raw_input_copy.substr(first_national_number_digit); 1650| 524| } 1651| 729| } 1652| 3.42k| const PhoneMetadata* metadata = GetMetadataForRegion(calling_from); 1653| 3.42k| if (country_code == kNanpaCountryCode) { ------------------ | Branch (1653:7): [True: 420, False: 3.00k] ------------------ 1654| 420| if (IsNANPACountry(calling_from)) { ------------------ | Branch (1654:9): [True: 381, False: 39] ------------------ 1655| 381| StrAppend(formatted_number, country_code, " ", raw_input_copy); 1656| 381| return; 1657| 381| } 1658| 3.00k| } else if (metadata && ------------------ | Branch (1658:14): [True: 2.97k, False: 38] ------------------ 1659| 3.00k| country_code == GetCountryCodeForValidRegion(calling_from)) { ------------------ | Branch (1659:14): [True: 2.87k, False: 98] ------------------ 1660| 2.87k| const NumberFormat* formatting_pattern = 1661| 2.87k| ChooseFormattingPatternForNumber(metadata->number_format(), 1662| 2.87k| national_number); 1663| 2.87k| if (!formatting_pattern) { ------------------ | Branch (1663:9): [True: 2.65k, False: 219] ------------------ 1664| | // If no pattern above is matched, we format the original input. 1665| 2.65k| formatted_number->assign(raw_input_copy); 1666| 2.65k| return; 1667| 2.65k| } 1668| 219| NumberFormat new_format; 1669| 219| new_format.MergeFrom(*formatting_pattern); 1670| | // The first group is the first group of digits that the user wrote 1671| | // together. 1672| 219| new_format.set_pattern("(\\d+)(.*)"); 1673| | // Here we just concatenate them back together after the national prefix 1674| | // has been fixed. 1675| 219| new_format.set_format("$1$2"); 1676| | // Now we format using this pattern instead of the default pattern, but 1677| | // with the national prefix prefixed if necessary. 1678| | // This will not work in the cases where the pattern (and not the 1679| | // leading digits) decide whether a national prefix needs to be used, since 1680| | // we have overridden the pattern to match anything, but that is not the 1681| | // case in the metadata to date. 1682| 219| FormatNsnUsingPattern(raw_input_copy, new_format, NATIONAL, 1683| 219| formatted_number); 1684| 219| return; 1685| 2.87k| } 1686| | 1687| 175| string international_prefix_for_formatting; 1688| | // If an unsupported region-calling-from is entered, or a country with 1689| | // multiple international prefixes, the international format of the number is 1690| | // returned, unless there is a preferred international prefix. 1691| 175| if (metadata) { ------------------ | Branch (1691:7): [True: 123, False: 52] ------------------ 1692| 123| const string& international_prefix = metadata->international_prefix(); 1693| 123| international_prefix_for_formatting = 1694| 123| reg_exps_->single_international_prefix_->FullMatch(international_prefix) ------------------ | Branch (1694:9): [True: 98, False: 25] ------------------ 1695| 123| ? international_prefix 1696| 123| : metadata->preferred_international_prefix(); 1697| 123| } 1698| 175| if (!international_prefix_for_formatting.empty()) { ------------------ | Branch (1698:7): [True: 118, False: 57] ------------------ 1699| 118| StrAppend(formatted_number, international_prefix_for_formatting, " ", 1700| 118| country_code, " ", raw_input_copy); 1701| 118| } else { 1702| | // Invalid region entered as country-calling-from (so no metadata was found 1703| | // for it) or the region chosen has multiple international dialling 1704| | // prefixes. 1705| 57| if (!IsValidRegionCode(calling_from)) { ------------------ | Branch (1705:9): [True: 52, False: 5] ------------------ 1706| 52| VLOG(1) << "Trying to format number from invalid region " << calling_from 1707| 52| << ". International formatting applied."; 1708| 52| } 1709| 57| formatted_number->assign(raw_input_copy); 1710| 57| PrefixNumberWithCountryCallingCode(country_code, INTERNATIONAL, 1711| 57| formatted_number); 1712| 57| } 1713| 175| std::string region_code; 1714| 175| GetRegionCodeForCountryCode(country_code, ®ion_code); 1715| | // Metadata cannot be null because the country code is valid. 1716| 175| const PhoneMetadata* metadata_for_region = 1717| 175| GetMetadataForRegionOrCallingCode(country_code, region_code); 1718| | // Strip any extension 1719| 175| std::string extension; 1720| 175| MaybeStripExtension(formatted_number, &extension); 1721| | // Append the formatted extension 1722| 175| MaybeAppendFormattedExtension(number, *metadata_for_region, INTERNATIONAL, 1723| 175| formatted_number); 1724| 175|} _ZNK4i18n12phonenumbers15PhoneNumberUtil32ChooseFormattingPatternForNumberERKN6google8protobuf16RepeatedPtrFieldINS0_12NumberFormatEEERKNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEE: 1728| 54.7k| const string& national_number) const { 1729| 54.7k| for (RepeatedPtrField::const_iterator 1730| 381k| it = available_formats.begin(); it != available_formats.end(); ++it) { ------------------ | Branch (1730:40): [True: 333k, False: 47.8k] ------------------ 1731| 333k| int size = it->leading_digits_pattern_size(); 1732| 333k| if (size > 0) { ------------------ | Branch (1732:9): [True: 325k, False: 7.58k] ------------------ 1733| 325k| const scoped_ptr number_copy( 1734| 325k| reg_exps_->regexp_factory_->CreateInput(national_number)); 1735| | // We always use the last leading_digits_pattern, as it is the most 1736| | // detailed. 1737| 325k| if (!reg_exps_->regexp_cache_->GetRegExp( ------------------ | Branch (1737:11): [True: 272k, False: 53.2k] ------------------ 1738| 325k| it->leading_digits_pattern(size - 1)).Consume( 1739| 325k| number_copy.get())) { 1740| 272k| continue; 1741| 272k| } 1742| 325k| } 1743| 60.8k| const RegExp& pattern_to_match( 1744| 60.8k| reg_exps_->regexp_cache_->GetRegExp(it->pattern())); 1745| 60.8k| if (pattern_to_match.FullMatch(national_number)) { ------------------ | Branch (1745:9): [True: 6.94k, False: 53.8k] ------------------ 1746| 6.94k| return &(*it); 1747| 6.94k| } 1748| 60.8k| } 1749| 47.8k| return NULL; 1750| 54.7k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil32FormatNsnUsingPatternWithCarrierERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_12NumberFormatENS1_17PhoneNumberFormatESA_PS8_: 1759| 6.30k| string* formatted_number) const { 1760| 6.30k| DCHECK(formatted_number); ------------------ | | 29| 6.30k|#define DCHECK(X) assert(X) ------------------ 1761| 6.30k| string number_format_rule(formatting_pattern.format()); 1762| 6.30k| if (number_format == PhoneNumberUtil::NATIONAL && ------------------ | Branch (1762:7): [True: 4.23k, False: 2.07k] ------------------ 1763| 6.30k| carrier_code.length() > 0 && ------------------ | Branch (1763:7): [True: 1.21k, False: 3.01k] ------------------ 1764| 6.30k| formatting_pattern.domestic_carrier_code_formatting_rule().length() > 0) { ------------------ | Branch (1764:7): [True: 527, False: 688] ------------------ 1765| | // Replace the $CC in the formatting rule with the desired carrier code. 1766| 527| string carrier_code_formatting_rule = 1767| 527| formatting_pattern.domestic_carrier_code_formatting_rule(); 1768| 527| reg_exps_->carrier_code_pattern_->Replace(&carrier_code_formatting_rule, 1769| 527| carrier_code); 1770| 527| reg_exps_->first_group_capturing_pattern_-> 1771| 527| Replace(&number_format_rule, carrier_code_formatting_rule); 1772| 5.78k| } else { 1773| | // Use the national prefix formatting rule instead. 1774| 5.78k| string national_prefix_formatting_rule = 1775| 5.78k| formatting_pattern.national_prefix_formatting_rule(); 1776| 5.78k| if (number_format == PhoneNumberUtil::NATIONAL && ------------------ | Branch (1776:9): [True: 3.70k, False: 2.07k] ------------------ 1777| 5.78k| national_prefix_formatting_rule.length() > 0) { ------------------ | Branch (1777:9): [True: 1.51k, False: 2.19k] ------------------ 1778| | // Apply the national_prefix_formatting_rule as the formatting_pattern 1779| | // contains only information on how the national significant number 1780| | // should be formatted at this point. 1781| 1.51k| reg_exps_->first_group_capturing_pattern_->Replace( 1782| 1.51k| &number_format_rule, national_prefix_formatting_rule); 1783| 1.51k| } 1784| 5.78k| } 1785| 6.30k| formatted_number->assign(national_number); 1786| | 1787| 6.30k| const RegExp& pattern_to_match( 1788| 6.30k| reg_exps_->regexp_cache_->GetRegExp(formatting_pattern.pattern())); 1789| 6.30k| pattern_to_match.GlobalReplace(formatted_number, number_format_rule); 1790| | 1791| 6.30k| if (number_format == RFC3966) { ------------------ | Branch (1791:7): [True: 302, False: 6.00k] ------------------ 1792| | // First consume any leading punctuation, if any was present. 1793| 302| const scoped_ptr number( 1794| 302| reg_exps_->regexp_factory_->CreateInput(*formatted_number)); 1795| 302| if (reg_exps_->separator_pattern_->Consume(number.get())) { ------------------ | Branch (1795:9): [True: 40, False: 262] ------------------ 1796| 40| formatted_number->assign(number->ToString()); 1797| 40| } 1798| | // Then replace all separators with a "-". 1799| 302| reg_exps_->separator_pattern_->GlobalReplace(formatted_number, "-"); 1800| 302| } 1801| 6.30k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil21FormatNsnUsingPatternERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_12NumberFormatENS1_17PhoneNumberFormatEPS8_: 1809| 1.07k| string* formatted_number) const { 1810| 1.07k| DCHECK(formatted_number); ------------------ | | 29| 1.07k|#define DCHECK(X) assert(X) ------------------ 1811| 1.07k| FormatNsnUsingPatternWithCarrier(national_number, formatting_pattern, 1812| 1.07k| number_format, "", formatted_number); 1813| 1.07k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil9FormatNsnERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_13PhoneMetadataENS1_17PhoneNumberFormatEPS8_: 1818| 25.5k| string* formatted_number) const { 1819| 25.5k| DCHECK(formatted_number); ------------------ | | 29| 25.5k|#define DCHECK(X) assert(X) ------------------ 1820| 25.5k| FormatNsnWithCarrier(number, metadata, number_format, "", formatted_number); 1821| 25.5k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil20FormatNsnWithCarrierERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_13PhoneMetadataENS1_17PhoneNumberFormatESA_PS8_: 1832| 40.5k| string* formatted_number) const { 1833| 40.5k| DCHECK(formatted_number); ------------------ | | 29| 40.5k|#define DCHECK(X) assert(X) ------------------ 1834| | // When the intl_number_formats exists, we use that to format national number 1835| | // for the INTERNATIONAL format instead of using the number_formats. 1836| 40.5k| const RepeatedPtrField available_formats = 1837| 40.5k| (metadata.intl_number_format_size() == 0 || number_format == NATIONAL) ------------------ | Branch (1837:8): [True: 20.5k, False: 20.0k] | Branch (1837:51): [True: 14.6k, False: 5.38k] ------------------ 1838| 40.5k| ? metadata.number_format() 1839| 40.5k| : metadata.intl_number_format(); 1840| 40.5k| const NumberFormat* formatting_pattern = 1841| 40.5k| ChooseFormattingPatternForNumber(available_formats, number); 1842| 40.5k| if (!formatting_pattern) { ------------------ | Branch (1842:7): [True: 35.3k, False: 5.23k] ------------------ 1843| 35.3k| formatted_number->assign(number); 1844| 35.3k| } else { 1845| 5.23k| FormatNsnUsingPatternWithCarrier(number, *formatting_pattern, number_format, 1846| 5.23k| carrier_code, formatted_number); 1847| 5.23k| } 1848| 40.5k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil29MaybeAppendFormattedExtensionERKNS0_11PhoneNumberERKNS0_13PhoneMetadataENS1_17PhoneNumberFormatEPNSt3__112basic_stringIcNS9_11char_traitsIcEENS9_9allocatorIcEEEE: 1856| 48.4k| string* formatted_number) const { 1857| 48.4k| DCHECK(formatted_number); ------------------ | | 29| 48.4k|#define DCHECK(X) assert(X) ------------------ 1858| 48.4k| if (number.has_extension() && number.extension().length() > 0) { ------------------ | Branch (1858:7): [True: 1.26k, False: 47.1k] | Branch (1858:33): [True: 1.26k, False: 0] ------------------ 1859| 1.26k| if (number_format == RFC3966) { ------------------ | Branch (1859:9): [True: 10, False: 1.25k] ------------------ 1860| 10| StrAppend(formatted_number, kRfc3966ExtnPrefix, number.extension()); 1861| 1.25k| } else { 1862| 1.25k| if (metadata.has_preferred_extn_prefix()) { ------------------ | Branch (1862:11): [True: 166, False: 1.08k] ------------------ 1863| 166| StrAppend(formatted_number, metadata.preferred_extn_prefix(), 1864| 166| number.extension()); 1865| 1.08k| } else { 1866| 1.08k| StrAppend(formatted_number, kDefaultExtnPrefix, number.extension()); 1867| 1.08k| } 1868| 1.25k| } 1869| 1.26k| } 1870| 48.4k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil14IsNANPACountryERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1872| 10.4k|bool PhoneNumberUtil::IsNANPACountry(const string& region_code) const { 1873| 10.4k| return nanpa_regions_->find(region_code) != nanpa_regions_->end(); 1874| 10.4k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil35GetRegionCodesForCountryCallingCodeEiPNSt3__14listINS2_12basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS7_IS9_EEEE: 1880| 171k| std::list* region_codes) const { 1881| 171k| DCHECK(region_codes); ------------------ | | 29| 171k|#define DCHECK(X) assert(X) ------------------ 1882| | // Create a IntRegionsPair with the country_code passed in, and use it to 1883| | // locate the pair with the same country_code in the sorted vector. 1884| 171k| IntRegionsPair target_pair; 1885| 171k| target_pair.first = country_calling_code; 1886| 171k| typedef std::vector::const_iterator ConstIterator; 1887| 171k| std::pair range = 1888| 171k| std::equal_range(country_calling_code_to_region_code_map_->begin(), 1889| 171k| country_calling_code_to_region_code_map_->end(), 1890| 171k| target_pair, OrderByFirst()); 1891| 171k| if (range.first != range.second) { ------------------ | Branch (1891:7): [True: 157k, False: 13.6k] ------------------ 1892| 157k| region_codes->insert(region_codes->begin(), 1893| 157k| range.first->second->begin(), 1894| 157k| range.first->second->end()); 1895| 157k| } 1896| 171k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil27GetRegionCodeForCountryCodeEiPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1903| 90.0k| string* region_code) const { 1904| 90.0k| DCHECK(region_code); ------------------ | | 29| 90.0k|#define DCHECK(X) assert(X) ------------------ 1905| 90.0k| std::list region_codes; 1906| | 1907| 90.0k| GetRegionCodesForCountryCallingCode(country_calling_code, ®ion_codes); 1908| 90.0k| *region_code = (region_codes.size() > 0) ? ------------------ | Branch (1908:18): [True: 87.1k, False: 2.91k] ------------------ 1909| 87.1k| region_codes.front() : RegionCode::GetUnknown(); 1910| 90.0k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil22GetRegionCodeForNumberERKNS0_11PhoneNumberEPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 1913| 81.2k| string* region_code) const { 1914| 81.2k| DCHECK(region_code); ------------------ | | 29| 81.2k|#define DCHECK(X) assert(X) ------------------ 1915| 81.2k| int country_calling_code = number.country_code(); 1916| 81.2k| std::list region_codes; 1917| 81.2k| GetRegionCodesForCountryCallingCode(country_calling_code, ®ion_codes); 1918| 81.2k| if (region_codes.size() == 0) { ------------------ | Branch (1918:7): [True: 10.7k, False: 70.5k] ------------------ 1919| 10.7k| VLOG(1) << "Missing/invalid country calling code (" 1920| 10.7k| << country_calling_code << ")"; 1921| 10.7k| *region_code = RegionCode::GetUnknown(); 1922| 10.7k| return; 1923| 10.7k| } 1924| 70.5k| if (region_codes.size() == 1) { ------------------ | Branch (1924:7): [True: 43.3k, False: 27.1k] ------------------ 1925| 43.3k| *region_code = region_codes.front(); 1926| 43.3k| } else { 1927| 27.1k| GetRegionCodeForNumberFromRegionList(number, region_codes, region_code); 1928| 27.1k| } 1929| 70.5k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil36GetRegionCodeForNumberFromRegionListERKNS0_11PhoneNumberERKNSt3__14listINS5_12basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEENSA_ISC_EEEEPSC_: 1933| 27.1k| string* region_code) const { 1934| 27.1k| DCHECK(region_code); ------------------ | | 29| 27.1k|#define DCHECK(X) assert(X) ------------------ 1935| 27.1k| string national_number; 1936| 27.1k| GetNationalSignificantNumber(number, &national_number); 1937| 27.1k| for (std::list::const_iterator it = region_codes.begin(); 1938| 180k| it != region_codes.end(); ++it) { ------------------ | Branch (1938:8): [True: 163k, False: 16.6k] ------------------ 1939| | // Metadata cannot be NULL because the region codes come from the country 1940| | // calling code map. 1941| 163k| const PhoneMetadata* metadata = GetMetadataForRegion(*it); 1942| 163k| if (metadata->has_leading_digits()) { ------------------ | Branch (1942:9): [True: 127k, False: 36.6k] ------------------ 1943| 127k| const scoped_ptr number( 1944| 127k| reg_exps_->regexp_factory_->CreateInput(national_number)); 1945| 127k| if (reg_exps_->regexp_cache_-> ------------------ | Branch (1945:11): [True: 3.96k, False: 123k] ------------------ 1946| 127k| GetRegExp(metadata->leading_digits()).Consume(number.get())) { 1947| 3.96k| *region_code = *it; 1948| 3.96k| return; 1949| 3.96k| } 1950| 127k| } else if (GetNumberTypeHelper(national_number, *metadata) != UNKNOWN) { ------------------ | Branch (1950:16): [True: 6.53k, False: 30.1k] ------------------ 1951| 6.53k| *region_code = *it; 1952| 6.53k| return; 1953| 6.53k| } 1954| 163k| } 1955| 16.6k| *region_code = RegionCode::GetUnknown(); 1956| 16.6k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil23GetCountryCodeForRegionERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1958| 9.65k|int PhoneNumberUtil::GetCountryCodeForRegion(const string& region_code) const { 1959| 9.65k| if (!IsValidRegionCode(region_code)) { ------------------ | Branch (1959:7): [True: 1.72k, False: 7.92k] ------------------ 1960| 1.72k| LOG(WARNING) << "Invalid or unknown region code (" << region_code 1961| 1.72k| << ") provided."; 1962| 1.72k| return 0; 1963| 1.72k| } 1964| 7.92k| return GetCountryCodeForValidRegion(region_code); 1965| 9.65k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil28GetCountryCodeForValidRegionERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 1968| 31.1k| const string& region_code) const { 1969| 31.1k| const PhoneMetadata* metadata = GetMetadataForRegion(region_code); 1970| 31.1k| return metadata->country_code(); 1971| 31.1k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil23GetInvalidExampleNumberERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS0_11PhoneNumberE: 1983| 9.65k| PhoneNumber* number) const { 1984| 9.65k| DCHECK(number); ------------------ | | 29| 9.65k|#define DCHECK(X) assert(X) ------------------ 1985| 9.65k| if (!IsValidRegionCode(region_code)) { ------------------ | Branch (1985:7): [True: 1.72k, False: 7.92k] ------------------ 1986| 1.72k| LOG(WARNING) << "Invalid or unknown region code (" << region_code 1987| 1.72k| << ") provided."; 1988| 1.72k| return false; 1989| 1.72k| } 1990| | // We start off with a valid fixed-line number since every country supports 1991| | // this. Alternatively we could start with a different number type, since 1992| | // fixed-line numbers typically have a wide breadth of valid number lengths 1993| | // and we may have to make it very short before we get an invalid number. 1994| 7.92k| const PhoneMetadata* region_metadata = GetMetadataForRegion(region_code); 1995| 7.92k| const PhoneNumberDesc* desc = 1996| 7.92k| GetNumberDescByType(*region_metadata, FIXED_LINE); 1997| 7.92k| if (!desc->has_example_number()) { ------------------ | Branch (1997:7): [True: 0, False: 7.92k] ------------------ 1998| | // This shouldn't happen - we have a test for this. 1999| 0| return false; 2000| 0| } 2001| 7.92k| const string& example_number = desc->example_number(); 2002| | // Try and make the number invalid. We do this by changing the length. We try 2003| | // reducing the length of the number, since currently no region has a number 2004| | // that is the same length as kMinLengthForNsn. This is probably quicker than 2005| | // making the number longer, which is another alternative. We could also use 2006| | // the possible number pattern to extract the possible lengths of the number 2007| | // to make this faster, but this method is only for unit-testing so simplicity 2008| | // is preferred to performance. 2009| | // We don't want to return a number that can't be parsed, so we check the 2010| | // number is long enough. We try all possible lengths because phone number 2011| | // plans often have overlapping prefixes so the number 123456 might be valid 2012| | // as a fixed-line number, and 12345 as a mobile number. It would be faster to 2013| | // loop in a different order, but we prefer numbers that look closer to real 2014| | // numbers (and it gives us a variety of different lengths for the resulting 2015| | // phone numbers - otherwise they would all be kMinLengthForNsn digits long.) 2016| 7.92k| for (size_t phone_number_length = example_number.length() - 1; 2017| 17.6k| phone_number_length >= kMinLengthForNsn; ------------------ | Branch (2017:8): [True: 17.6k, False: 0] ------------------ 2018| 17.6k| phone_number_length--) { 2019| 17.6k| string number_to_try = example_number.substr(0, phone_number_length); 2020| 17.6k| PhoneNumber possibly_valid_number; 2021| 17.6k| Parse(number_to_try, region_code, &possibly_valid_number); 2022| | // We don't check the return value since we have already checked the 2023| | // length, we know example numbers have only valid digits, and we know the 2024| | // region code is fine. 2025| 17.6k| if (!IsValidNumber(possibly_valid_number)) { ------------------ | Branch (2025:9): [True: 7.92k, False: 9.72k] ------------------ 2026| 7.92k| number->MergeFrom(possibly_valid_number); 2027| 7.92k| return true; 2028| 7.92k| } 2029| 17.6k| } 2030| | // We have a test to check that this doesn't happen for any of our supported 2031| | // regions. 2032| 0| return false; 2033| 7.92k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil23GetExampleNumberForTypeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEENS1_15PhoneNumberTypeEPNS0_11PhoneNumberE: 2041| 150k| PhoneNumber* number) const { 2042| 150k| DCHECK(number); ------------------ | | 29| 150k|#define DCHECK(X) assert(X) ------------------ 2043| 150k| if (!IsValidRegionCode(region_code)) { ------------------ | Branch (2043:7): [True: 1.72k, False: 148k] ------------------ 2044| 1.72k| LOG(WARNING) << "Invalid or unknown region code (" << region_code 2045| 1.72k| << ") provided."; 2046| 1.72k| return false; 2047| 1.72k| } 2048| 148k| const PhoneMetadata* region_metadata = GetMetadataForRegion(region_code); 2049| 148k| const PhoneNumberDesc* desc = GetNumberDescByType(*region_metadata, type); 2050| 148k| if (desc && desc->has_example_number()) { ------------------ | Branch (2050:7): [True: 148k, False: 0] | Branch (2050:15): [True: 15.1k, False: 133k] ------------------ 2051| 15.1k| ErrorType success = Parse(desc->example_number(), region_code, number); 2052| 15.1k| if (success == NO_PARSING_ERROR) { ------------------ | Branch (2052:9): [True: 15.1k, False: 0] ------------------ 2053| 15.1k| return true; 2054| 15.1k| } else { 2055| 0| LOG(ERROR) << "Error parsing example number (" 2056| 0| << static_cast(success) << ")"; 2057| 0| } 2058| 15.1k| } 2059| 133k| return false; 2060| 148k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil23GetExampleNumberForTypeENS1_15PhoneNumberTypeEPNS0_11PhoneNumberE: 2064| 9.65k| PhoneNumber* number) const { 2065| 9.65k| DCHECK(number); ------------------ | | 29| 9.65k|#define DCHECK(X) assert(X) ------------------ 2066| 9.65k| std::set regions; 2067| 9.65k| GetSupportedRegions(®ions); 2068| 140k| for (const string& region_code : regions) { ------------------ | Branch (2068:34): [True: 140k, False: 446] ------------------ 2069| 140k| if (GetExampleNumberForType(region_code, type, number)) { ------------------ | Branch (2069:9): [True: 9.20k, False: 131k] ------------------ 2070| 9.20k| return true; 2071| 9.20k| } 2072| 140k| } 2073| | // If there wasn't an example number for a region, try the non-geographical 2074| | // entities. 2075| 446| std::set global_network_calling_codes; 2076| 446| GetSupportedGlobalNetworkCallingCodes(&global_network_calling_codes); 2077| 446| for (std::set::const_iterator it = global_network_calling_codes.begin(); 2078| 4.46k| it != global_network_calling_codes.end(); ++it) { ------------------ | Branch (2078:8): [True: 4.01k, False: 446] ------------------ 2079| 4.01k| int country_calling_code = *it; 2080| 4.01k| const PhoneMetadata* metadata = 2081| 4.01k| GetMetadataForNonGeographicalRegion(country_calling_code); 2082| 4.01k| const PhoneNumberDesc* desc = GetNumberDescByType(*metadata, type); 2083| 4.01k| if (desc->has_example_number()) { ------------------ | Branch (2083:9): [True: 0, False: 4.01k] ------------------ 2084| 0| ErrorType success = Parse(StrCat(kPlusSign, 2085| 0| country_calling_code, 2086| 0| desc->example_number()), 2087| 0| RegionCode::GetUnknown(), number); 2088| 0| if (success == NO_PARSING_ERROR) { ------------------ | Branch (2088:11): [True: 0, False: 0] ------------------ 2089| 0| return true; 2090| 0| } else { 2091| 0| LOG(ERROR) << "Error parsing example number (" 2092| 0| << static_cast(success) << ")"; 2093| 0| } 2094| 0| } 2095| 4.01k| } 2096| | // There are no example numbers of this type for any country in the library. 2097| 446| return false; 2098| 446|} _ZNK4i18n12phonenumbers15PhoneNumberUtil31GetExampleNumberForNonGeoEntityEiPNS0_11PhoneNumberE: 2101| 9.65k| int country_calling_code, PhoneNumber* number) const { 2102| 9.65k| DCHECK(number); ------------------ | | 29| 9.65k|#define DCHECK(X) assert(X) ------------------ 2103| 9.65k| const PhoneMetadata* metadata = 2104| 9.65k| GetMetadataForNonGeographicalRegion(country_calling_code); 2105| 9.65k| if (metadata) { ------------------ | Branch (2105:7): [True: 27, False: 9.62k] ------------------ 2106| | // For geographical entities, fixed-line data is always present. However, 2107| | // for non-geographical entities, this is not the case, so we have to go 2108| | // through different types to find the example number. We don't check 2109| | // fixed-line or personal number since they aren't used by non-geographical 2110| | // entities (if this changes, a unit-test will catch this.) 2111| 27| const int kNumberTypes = 7; 2112| 27| PhoneNumberDesc types[kNumberTypes] = { 2113| 27| metadata->mobile(), metadata->toll_free(), metadata->shared_cost(), 2114| 27| metadata->voip(), metadata->voicemail(), metadata->uan(), 2115| 27| metadata->premium_rate()}; 2116| 82| for (int i = 0; i < kNumberTypes; ++i) { ------------------ | Branch (2116:21): [True: 82, False: 0] ------------------ 2117| 82| if (types[i].has_example_number()) { ------------------ | Branch (2117:11): [True: 27, False: 55] ------------------ 2118| 27| ErrorType success = Parse(StrCat(kPlusSign, 2119| 27| SimpleItoa(country_calling_code), 2120| 27| types[i].example_number()), 2121| 27| RegionCode::GetUnknown(), number); 2122| 27| if (success == NO_PARSING_ERROR) { ------------------ | Branch (2122:13): [True: 27, False: 0] ------------------ 2123| 27| return true; 2124| 27| } else { 2125| 0| LOG(ERROR) << "Error parsing example number (" 2126| 0| << static_cast(success) << ")"; 2127| 0| } 2128| 27| } 2129| 82| } 2130| 9.62k| } else { 2131| 9.62k| LOG(WARNING) << "Invalid or unknown country calling code provided: " 2132| 9.62k| << country_calling_code; 2133| 9.62k| } 2134| 9.62k| return false; 2135| 9.65k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil5ParseERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_PNS0_11PhoneNumberE: 2139| 82.8k| PhoneNumber* number) const { 2140| 82.8k| DCHECK(number); ------------------ | | 29| 82.8k|#define DCHECK(X) assert(X) ------------------ 2141| 82.8k| return ParseHelper(number_to_parse, default_region, false, true, number); 2142| 82.8k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil20ParseAndKeepRawInputERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_PNS0_11PhoneNumberE: 2147| 6.63k| PhoneNumber* number) const { 2148| 6.63k| DCHECK(number); ------------------ | | 29| 6.63k|#define DCHECK(X) assert(X) ------------------ 2149| 6.63k| return ParseHelper(number_to_parse, default_region, true, true, number); 2150| 6.63k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil21CheckRegionForParsingERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_: 2158| 58.6k| const string& default_region) const { 2159| 58.6k| if (!IsValidRegionCode(default_region) && !number_to_parse.empty()) { ------------------ | Branch (2159:7): [True: 10.0k, False: 48.5k] | Branch (2159:45): [True: 10.0k, False: 0] ------------------ 2160| 10.0k| const scoped_ptr number( 2161| 10.0k| reg_exps_->regexp_factory_->CreateInput(number_to_parse)); 2162| 10.0k| if (!reg_exps_->plus_chars_pattern_->Consume(number.get())) { ------------------ | Branch (2162:9): [True: 8.53k, False: 1.54k] ------------------ 2163| 8.53k| return false; 2164| 8.53k| } 2165| 10.0k| } 2166| 50.0k| return true; 2167| 58.6k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil19ExtractPhoneContextERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEm: 2176| 90.2k| const size_t index_of_phone_context) const { 2177| | // If no phone-context parameter is present 2178| 90.2k| if (index_of_phone_context == std::string::npos) { ------------------ | Branch (2178:7): [True: 89.5k, False: 680] ------------------ 2179| 89.5k| return absl::nullopt; 2180| 89.5k| } 2181| | 2182| 680| size_t phone_context_start = 2183| 680| index_of_phone_context + strlen(kRfc3966PhoneContext); 2184| | // If phone-context parameter is empty 2185| 680| if (phone_context_start >= number_to_extract_from.length()) { ------------------ | Branch (2185:7): [True: 27, False: 653] ------------------ 2186| 27| return ""; 2187| 27| } 2188| | 2189| 653| size_t phone_context_end = 2190| 653| number_to_extract_from.find(';', phone_context_start); 2191| | // If phone-context is not the last parameter 2192| 653| if (phone_context_end != std::string::npos) { ------------------ | Branch (2192:7): [True: 152, False: 501] ------------------ 2193| 152| return number_to_extract_from.substr( 2194| 152| phone_context_start, phone_context_end - phone_context_start); 2195| 501| } else { 2196| 501| return number_to_extract_from.substr(phone_context_start); 2197| 501| } 2198| 653|} _ZNK4i18n12phonenumbers15PhoneNumberUtil19IsPhoneContextValidEN4absl12lts_202206238optionalINSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEEE: 2203| 90.2k| const absl::optional phone_context) const { 2204| 90.2k| if (!phone_context.has_value()) { ------------------ | Branch (2204:7): [True: 89.5k, False: 680] ------------------ 2205| 89.5k| return true; 2206| 89.5k| } 2207| 680| if (phone_context.value().empty()) { ------------------ | Branch (2207:7): [True: 43, False: 637] ------------------ 2208| 43| return false; 2209| 43| } 2210| | 2211| | // Does phone-context value match pattern of global-number-digits or 2212| | // domainname 2213| 637| return reg_exps_->rfc3966_global_number_digits_pattern_->FullMatch( ------------------ | Branch (2213:10): [True: 173, False: 464] ------------------ 2214| 637| std::string{phone_context.value()}) || 2215| 637| reg_exps_->rfc3966_domainname_pattern_->FullMatch( ------------------ | Branch (2215:7): [True: 116, False: 348] ------------------ 2216| 464| std::string{phone_context.value()}); 2217| 680|} _ZNK4i18n12phonenumbers15PhoneNumberUtil29BuildNationalNumberForParsingERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPS8_: 2223| 90.2k| const string& number_to_parse, string* national_number) const { 2224| 90.2k| size_t index_of_phone_context = number_to_parse.find(kRfc3966PhoneContext); 2225| | 2226| 90.2k| absl::optional phone_context = 2227| 90.2k| ExtractPhoneContext(number_to_parse, index_of_phone_context); 2228| 90.2k| if (!IsPhoneContextValid(phone_context)) { ------------------ | Branch (2228:7): [True: 391, False: 89.8k] ------------------ 2229| 391| VLOG(2) << "The phone-context value is invalid."; 2230| 391| return NOT_A_NUMBER; 2231| 391| } 2232| | 2233| 89.8k| if (phone_context.has_value()) { ------------------ | Branch (2233:7): [True: 289, False: 89.5k] ------------------ 2234| | // If the phone context contains a phone number prefix, we need to capture 2235| | // it, whereas domains will be ignored. 2236| 289| if (phone_context.value().at(0) == kPlusSign[0]) { ------------------ | Branch (2236:9): [True: 173, False: 116] ------------------ 2237| | // Additional parameters might follow the phone context. If so, we will 2238| | // remove them here because the parameters after phone context are not 2239| | // important for parsing the phone number. 2240| 173| StrAppend(national_number, phone_context.value()); 2241| 173| } 2242| | 2243| | // Now append everything between the "tel:" prefix and the phone-context. 2244| | // This should include the national number, an optional extension or 2245| | // isdn-subaddress component. Note we also handle the case when "tel:" is 2246| | // missing, as we have seen in some of the phone number inputs. In that 2247| | // case, we append everything from the beginning. 2248| 289| size_t index_of_rfc_prefix = number_to_parse.find(kRfc3966Prefix); 2249| 289| int index_of_national_number = (index_of_rfc_prefix != string::npos) ? ------------------ | Branch (2249:36): [True: 60, False: 229] ------------------ 2250| 229| static_cast(index_of_rfc_prefix + strlen(kRfc3966Prefix)) : 0; 2251| 289| StrAppend( 2252| 289| national_number, 2253| 289| number_to_parse.substr( 2254| 289| index_of_national_number, 2255| 289| index_of_phone_context - index_of_national_number)); 2256| 89.5k| } else { 2257| | // Extract a possible number from the string passed in (this strips leading 2258| | // characters that could not be the start of a phone number.) 2259| 89.5k| ExtractPossibleNumber(number_to_parse, national_number); 2260| 89.5k| } 2261| | 2262| | // Delete the isdn-subaddress and everything after it if it is present. Note 2263| | // extension won't appear at the same time with isdn-subaddress according to 2264| | // paragraph 5.3 of the RFC3966 spec. 2265| 89.8k| size_t index_of_isdn = national_number->find(kRfc3966IsdnSubaddress); 2266| 89.8k| if (index_of_isdn != string::npos) { ------------------ | Branch (2266:7): [True: 66, False: 89.7k] ------------------ 2267| 66| national_number->erase(index_of_isdn); 2268| 66| } 2269| | // If both phone context and isdn-subaddress are absent but other parameters 2270| | // are present, the parameters are left in nationalNumber. This is because 2271| | // we are concerned about deleting content from a potential number string 2272| | // when there is no strong evidence that the number is actually written in 2273| | // RFC3966. 2274| 89.8k| return NO_PARSING_ERROR; 2275| 90.2k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil11ParseHelperERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_bbPNS0_11PhoneNumberE: 2285| 90.2k| PhoneNumber* phone_number) const { 2286| 90.2k| DCHECK(phone_number); ------------------ | | 29| 90.2k|#define DCHECK(X) assert(X) ------------------ 2287| | 2288| 90.2k| string national_number; 2289| 90.2k| PhoneNumberUtil::ErrorType build_national_number_for_parsing_return = 2290| 90.2k| BuildNationalNumberForParsing(number_to_parse, &national_number); 2291| 90.2k| if (build_national_number_for_parsing_return != NO_PARSING_ERROR) { ------------------ | Branch (2291:7): [True: 391, False: 89.8k] ------------------ 2292| 391| return build_national_number_for_parsing_return; 2293| 391| } 2294| | 2295| 89.8k| if (!IsViablePhoneNumber(national_number)) { ------------------ | Branch (2295:7): [True: 30.4k, False: 59.3k] ------------------ 2296| 30.4k| VLOG(2) << "The string supplied did not seem to be a phone number."; 2297| 30.4k| return NOT_A_NUMBER; 2298| 30.4k| } 2299| | 2300| 59.3k| if (check_region && ------------------ | Branch (2300:7): [True: 58.6k, False: 717] ------------------ 2301| 59.3k| !CheckRegionForParsing(national_number, default_region)) { ------------------ | Branch (2301:7): [True: 8.53k, False: 50.0k] ------------------ 2302| 8.53k| VLOG(1) << "Missing or invalid default country."; 2303| 8.53k| return INVALID_COUNTRY_CODE_ERROR; 2304| 8.53k| } 2305| 50.7k| PhoneNumber temp_number; 2306| 50.7k| if (keep_raw_input) { ------------------ | Branch (2306:7): [True: 3.50k, False: 47.2k] ------------------ 2307| 3.50k| temp_number.set_raw_input(number_to_parse); 2308| 3.50k| } 2309| | // Attempt to parse extension first, since it doesn't require country-specific 2310| | // data and we want to have the non-normalised number here. 2311| 50.7k| string extension; 2312| 50.7k| MaybeStripExtension(&national_number, &extension); 2313| 50.7k| if (!extension.empty()) { ------------------ | Branch (2313:7): [True: 1.02k, False: 49.7k] ------------------ 2314| 1.02k| temp_number.set_extension(extension); 2315| 1.02k| } 2316| 50.7k| const PhoneMetadata* country_metadata = GetMetadataForRegion(default_region); 2317| | // Check to see if the number is given in international format so we know 2318| | // whether this number is from the default country or not. 2319| 50.7k| string normalized_national_number(national_number); 2320| 50.7k| ErrorType country_code_error = 2321| 50.7k| MaybeExtractCountryCode(country_metadata, keep_raw_input, 2322| 50.7k| &normalized_national_number, &temp_number); 2323| 50.7k| if (country_code_error != NO_PARSING_ERROR) { ------------------ | Branch (2323:7): [True: 1.08k, False: 49.6k] ------------------ 2324| 1.08k| const scoped_ptr number_string_piece( 2325| 1.08k| reg_exps_->regexp_factory_->CreateInput(national_number)); 2326| 1.08k| if ((country_code_error == INVALID_COUNTRY_CODE_ERROR) && ------------------ | Branch (2326:9): [True: 1.01k, False: 79] ------------------ 2327| 1.08k| (reg_exps_->plus_chars_pattern_->Consume(number_string_piece.get()))) { ------------------ | Branch (2327:9): [True: 1.00k, False: 6] ------------------ 2328| 1.00k| normalized_national_number.assign(number_string_piece->ToString()); 2329| | // Strip the plus-char, and try again. 2330| 1.00k| MaybeExtractCountryCode(country_metadata, 2331| 1.00k| keep_raw_input, 2332| 1.00k| &normalized_national_number, 2333| 1.00k| &temp_number); 2334| 1.00k| if (temp_number.country_code() == 0) { ------------------ | Branch (2334:11): [True: 912, False: 92] ------------------ 2335| 912| return INVALID_COUNTRY_CODE_ERROR; 2336| 912| } 2337| 1.00k| } else { 2338| 85| return country_code_error; 2339| 85| } 2340| 1.08k| } 2341| 49.7k| int country_code = temp_number.country_code(); 2342| 49.7k| if (country_code != 0) { ------------------ | Branch (2342:7): [True: 1.77k, False: 48.0k] ------------------ 2343| 1.77k| string phone_number_region; 2344| 1.77k| GetRegionCodeForCountryCode(country_code, &phone_number_region); 2345| 1.77k| if (phone_number_region != default_region) { ------------------ | Branch (2345:9): [True: 1.60k, False: 173] ------------------ 2346| 1.60k| country_metadata = 2347| 1.60k| GetMetadataForRegionOrCallingCode(country_code, phone_number_region); 2348| 1.60k| } 2349| 48.0k| } else if (country_metadata) { ------------------ | Branch (2349:14): [True: 47.4k, False: 598] ------------------ 2350| | // If no extracted country calling code, use the region supplied instead. 2351| | // Note that the national number was already normalized by 2352| | // MaybeExtractCountryCode. 2353| 47.4k| country_code = country_metadata->country_code(); 2354| 47.4k| } 2355| 49.7k| if (normalized_national_number.length() < kMinLengthForNsn) { ------------------ | Branch (2355:7): [True: 171, False: 49.6k] ------------------ 2356| 171| VLOG(2) << "The string supplied is too short to be a phone number."; 2357| 171| return TOO_SHORT_NSN; 2358| 171| } 2359| 49.6k| if (country_metadata) { ------------------ | Branch (2359:7): [True: 49.0k, False: 604] ------------------ 2360| 49.0k| string carrier_code; 2361| 49.0k| string potential_national_number(normalized_national_number); 2362| 49.0k| MaybeStripNationalPrefixAndCarrierCode(*country_metadata, 2363| 49.0k| &potential_national_number, 2364| 49.0k| &carrier_code); 2365| | // We require that the NSN remaining after stripping the national prefix 2366| | // and carrier code be long enough to be a possible length for the region. 2367| | // Otherwise, we don't do the stripping, since the original number could be 2368| | // a valid short number. 2369| 49.0k| ValidationResult validation_result = 2370| 49.0k| TestNumberLength(potential_national_number, *country_metadata); 2371| 49.0k| if (validation_result != TOO_SHORT && ------------------ | Branch (2371:9): [True: 33.0k, False: 16.0k] ------------------ 2372| 49.0k| validation_result != IS_POSSIBLE_LOCAL_ONLY && ------------------ | Branch (2372:9): [True: 31.4k, False: 1.56k] ------------------ 2373| 49.0k| validation_result != INVALID_LENGTH) { ------------------ | Branch (2373:9): [True: 31.2k, False: 182] ------------------ 2374| 31.2k| normalized_national_number.assign(potential_national_number); 2375| 31.2k| if (keep_raw_input && !carrier_code.empty()) { ------------------ | Branch (2375:11): [True: 560, False: 30.7k] | Branch (2375:29): [True: 95, False: 465] ------------------ 2376| 95| temp_number.set_preferred_domestic_carrier_code(carrier_code); 2377| 95| } 2378| 31.2k| } 2379| 49.0k| } 2380| 49.6k| size_t normalized_national_number_length = 2381| 49.6k| normalized_national_number.length(); 2382| 49.6k| if (normalized_national_number_length < kMinLengthForNsn) { ------------------ | Branch (2382:7): [True: 0, False: 49.6k] ------------------ 2383| 0| VLOG(2) << "The string supplied is too short to be a phone number."; 2384| 0| return TOO_SHORT_NSN; 2385| 0| } 2386| 49.6k| if (normalized_national_number_length > kMaxLengthForNsn) { ------------------ | Branch (2386:7): [True: 213, False: 49.4k] ------------------ 2387| 213| VLOG(2) << "The string supplied is too long to be a phone number."; 2388| 213| return TOO_LONG_NSN; 2389| 213| } 2390| 49.4k| temp_number.set_country_code(country_code); 2391| 49.4k| SetItalianLeadingZerosForPhoneNumber(normalized_national_number, 2392| 49.4k| &temp_number); 2393| 49.4k| uint64 number_as_int; 2394| 49.4k| safe_strtou64(normalized_national_number, &number_as_int); 2395| 49.4k| temp_number.set_national_number(number_as_int); 2396| 49.4k| phone_number->Swap(&temp_number); 2397| 49.4k| return NO_PARSING_ERROR; 2398| 49.6k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil21ExtractPossibleNumberERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPS8_: 2411| 89.5k| string* extracted_number) const { 2412| 89.5k| DCHECK(extracted_number); ------------------ | | 29| 89.5k|#define DCHECK(X) assert(X) ------------------ 2413| | 2414| 89.5k| UnicodeText number_as_unicode; 2415| 89.5k| number_as_unicode.PointToUTF8(number.data(), static_cast(number.size())); 2416| 89.5k| if (!number_as_unicode.UTF8WasValid()) { ------------------ | Branch (2416:7): [True: 2.73k, False: 86.8k] ------------------ 2417| | // The input wasn't valid UTF-8. Produce an empty string to indicate an error. 2418| 2.73k| extracted_number->clear(); 2419| 2.73k| return; 2420| 2.73k| } 2421| 86.8k| char current_char[5]; 2422| 86.8k| int len; 2423| 86.8k| UnicodeText::const_iterator it; 2424| 97.9k| for (it = number_as_unicode.begin(); it != number_as_unicode.end(); ++it) { ------------------ | Branch (2424:40): [True: 72.2k, False: 25.7k] ------------------ 2425| 72.2k| len = it.get_utf8(current_char); 2426| 72.2k| current_char[len] = '\0'; 2427| 72.2k| if (reg_exps_->valid_start_char_pattern_->FullMatch(current_char)) { ------------------ | Branch (2427:9): [True: 61.0k, False: 11.1k] ------------------ 2428| 61.0k| break; 2429| 61.0k| } 2430| 72.2k| } 2431| | 2432| 86.8k| if (it == number_as_unicode.end()) { ------------------ | Branch (2432:7): [True: 25.7k, False: 61.0k] ------------------ 2433| | // No valid start character was found. extracted_number should be set to 2434| | // empty string. 2435| 25.7k| extracted_number->clear(); 2436| 25.7k| return; 2437| 25.7k| } 2438| | 2439| 61.0k| extracted_number->assign( 2440| 61.0k| UnicodeText::UTF8Substring(it, number_as_unicode.end())); 2441| 61.0k| TrimUnwantedEndChars(extracted_number); 2442| 61.0k| if (extracted_number->length() == 0) { ------------------ | Branch (2442:7): [True: 450, False: 60.5k] ------------------ 2443| 450| return; 2444| 450| } 2445| | 2446| | // Now remove any extra numbers at the end. 2447| 60.5k| reg_exps_->capture_up_to_second_number_start_pattern_-> 2448| 60.5k| PartialMatch(*extracted_number, extracted_number); 2449| 60.5k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil16IsPossibleNumberERKNS0_11PhoneNumberE: 2451| 17.1k|bool PhoneNumberUtil::IsPossibleNumber(const PhoneNumber& number) const { 2452| 17.1k| ValidationResult result = IsPossibleNumberWithReason(number); 2453| 17.1k| return result == IS_POSSIBLE || result == IS_POSSIBLE_LOCAL_ONLY; ------------------ | Branch (2453:10): [True: 2.19k, False: 14.9k] | Branch (2453:35): [True: 1.18k, False: 13.7k] ------------------ 2454| 17.1k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil23IsPossibleNumberForTypeERKNS0_11PhoneNumberENS1_15PhoneNumberTypeE: 2457| 9.65k| const PhoneNumber& number, const PhoneNumberType type) const { 2458| 9.65k| ValidationResult result = IsPossibleNumberForTypeWithReason(number, type); 2459| 9.65k| return result == IS_POSSIBLE || result == IS_POSSIBLE_LOCAL_ONLY; ------------------ | Branch (2459:10): [True: 768, False: 8.88k] | Branch (2459:35): [True: 261, False: 8.62k] ------------------ 2460| 9.65k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil25IsPossibleNumberForStringERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_: 2464| 9.65k| const string& region_dialing_from) const { 2465| 9.65k| PhoneNumber number_proto; 2466| 9.65k| if (Parse(number, region_dialing_from, &number_proto) == NO_PARSING_ERROR) { ------------------ | Branch (2466:7): [True: 7.50k, False: 2.14k] ------------------ 2467| 7.50k| return IsPossibleNumber(number_proto); 2468| 7.50k| } else { 2469| 2.14k| return false; 2470| 2.14k| } 2471| 9.65k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil26IsPossibleNumberWithReasonERKNS0_11PhoneNumberE: 2474| 18.3k| const PhoneNumber& number) const { 2475| 18.3k| return IsPossibleNumberForTypeWithReason(number, PhoneNumberUtil::UNKNOWN); 2476| 18.3k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil33IsPossibleNumberForTypeWithReasonERKNS0_11PhoneNumberENS1_15PhoneNumberTypeE: 2480| 28.0k| PhoneNumberType type) const { 2481| 28.0k| string national_number; 2482| 28.0k| GetNationalSignificantNumber(number, &national_number); 2483| 28.0k| int country_code = number.country_code(); 2484| | // Note: For regions that share a country calling code, like NANPA numbers, we 2485| | // just use the rules from the default region (US in this case) since the 2486| | // GetRegionCodeForNumber will not work if the number is possible but not 2487| | // valid. There is in fact one country calling code (290) where the possible 2488| | // number pattern differs between various regions (Saint Helena and Tristan da 2489| | // Cuñha), but this is handled by putting all possible lengths for any country 2490| | // with this country calling code in the metadata for the default region in 2491| | // this case. 2492| 28.0k| if (!HasValidCountryCallingCode(country_code)) { ------------------ | Branch (2492:7): [True: 4.31k, False: 23.7k] ------------------ 2493| 4.31k| return INVALID_COUNTRY_CODE; 2494| 4.31k| } 2495| 23.7k| string region_code; 2496| 23.7k| GetRegionCodeForCountryCode(country_code, ®ion_code); 2497| | // Metadata cannot be NULL because the country calling code is valid. 2498| 23.7k| const PhoneMetadata* metadata = 2499| 23.7k| GetMetadataForRegionOrCallingCode(country_code, region_code); 2500| 23.7k| return TestNumberLength(national_number, *metadata, type); 2501| 28.0k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil21TruncateTooLongNumberEPNS0_11PhoneNumberE: 2503| 583|bool PhoneNumberUtil::TruncateTooLongNumber(PhoneNumber* number) const { 2504| 583| if (IsValidNumber(*number)) { ------------------ | Branch (2504:7): [True: 17, False: 566] ------------------ 2505| 17| return true; 2506| 17| } 2507| 566| PhoneNumber number_copy(*number); 2508| 566| uint64 national_number = number->national_number(); 2509| 1.21k| do { 2510| 1.21k| national_number /= 10; 2511| 1.21k| number_copy.set_national_number(national_number); 2512| 1.21k| if (IsPossibleNumberWithReason(number_copy) == TOO_SHORT || ------------------ | Branch (2512:9): [True: 503, False: 712] ------------------ 2513| 1.21k| national_number == 0) { ------------------ | Branch (2513:9): [True: 28, False: 684] ------------------ 2514| 531| return false; 2515| 531| } 2516| 1.21k| } while (!IsValidNumber(number_copy)); ------------------ | Branch (2516:12): [True: 649, False: 35] ------------------ 2517| 35| number->set_national_number(national_number); 2518| 35| return true; 2519| 566|} _ZNK4i18n12phonenumbers15PhoneNumberUtil13GetNumberTypeERKNS0_11PhoneNumberE: 2522| 33.0k| const PhoneNumber& number) const { 2523| 33.0k| string region_code; 2524| 33.0k| GetRegionCodeForNumber(number, ®ion_code); 2525| 33.0k| const PhoneMetadata* metadata = 2526| 33.0k| GetMetadataForRegionOrCallingCode(number.country_code(), region_code); 2527| 33.0k| if (!metadata) { ------------------ | Branch (2527:7): [True: 11.5k, False: 21.5k] ------------------ 2528| 11.5k| return UNKNOWN; 2529| 11.5k| } 2530| 21.5k| string national_significant_number; 2531| 21.5k| GetNationalSignificantNumber(number, &national_significant_number); 2532| 21.5k| return GetNumberTypeHelper(national_significant_number, *metadata); 2533| 33.0k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil13IsValidNumberERKNS0_11PhoneNumberE: 2535| 18.9k|bool PhoneNumberUtil::IsValidNumber(const PhoneNumber& number) const { 2536| 18.9k| string region_code; 2537| 18.9k| GetRegionCodeForNumber(number, ®ion_code); 2538| 18.9k| return IsValidNumberForRegion(number, region_code); 2539| 18.9k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil22IsValidNumberForRegionERKNS0_11PhoneNumberERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 2542| 18.9k| const string& region_code) const { 2543| 18.9k| int country_code = number.country_code(); 2544| 18.9k| const PhoneMetadata* metadata = 2545| 18.9k| GetMetadataForRegionOrCallingCode(country_code, region_code); 2546| 18.9k| if (!metadata || ------------------ | Branch (2546:7): [True: 2.30k, False: 16.6k] ------------------ 2547| 18.9k| ((kRegionCodeForNonGeoEntity != region_code) && ------------------ | Branch (2547:8): [True: 16.6k, False: 38] ------------------ 2548| 16.6k| country_code != GetCountryCodeForValidRegion(region_code))) { ------------------ | Branch (2548:8): [True: 0, False: 16.6k] ------------------ 2549| | // Either the region code was invalid, or the country calling code for this 2550| | // number does not match that of the region code. 2551| 2.30k| return false; 2552| 2.30k| } 2553| 16.6k| string national_number; 2554| 16.6k| GetNationalSignificantNumber(number, &national_number); 2555| | 2556| 16.6k| return GetNumberTypeHelper(national_number, *metadata) != UNKNOWN; 2557| 18.9k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil20IsNumberGeographicalERKNS0_11PhoneNumberE: 2560| 9.65k| const PhoneNumber& phone_number) const { 2561| 9.65k| return IsNumberGeographical(GetNumberType(phone_number), 2562| 9.65k| phone_number.country_code()); 2563| 9.65k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil20IsNumberGeographicalENS1_15PhoneNumberTypeEi: 2566| 23.4k| PhoneNumberType phone_number_type, int country_calling_code) const { 2567| 23.4k| return phone_number_type == PhoneNumberUtil::FIXED_LINE || ------------------ | Branch (2567:10): [True: 5.42k, False: 17.9k] ------------------ 2568| 23.4k| phone_number_type == PhoneNumberUtil::FIXED_LINE_OR_MOBILE || ------------------ | Branch (2568:7): [True: 381, False: 17.6k] ------------------ 2569| 23.4k| (reg_exps_->geo_mobile_countries_.find(country_calling_code) ------------------ | Branch (2569:8): [True: 796, False: 16.8k] ------------------ 2570| 17.6k| != reg_exps_->geo_mobile_countries_.end() && 2571| 17.6k| phone_number_type == PhoneNumberUtil::MOBILE); ------------------ | Branch (2571:8): [True: 26, False: 770] ------------------ 2572| 23.4k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil36SetItalianLeadingZerosForPhoneNumberERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPNS0_11PhoneNumberE: 2577| 49.4k| const string& national_number, PhoneNumber* phone_number) const { 2578| 49.4k| if (national_number.length() > 1 && national_number[0] == '0') { ------------------ | Branch (2578:7): [True: 49.4k, False: 0] | Branch (2578:39): [True: 9.64k, False: 39.7k] ------------------ 2579| 9.64k| phone_number->set_italian_leading_zero(true); 2580| 9.64k| size_t number_of_leading_zeros = 1; 2581| | // Note that if the national number is all "0"s, the last "0" is not 2582| | // counted as a leading zero. 2583| 10.3k| while (number_of_leading_zeros < national_number.length() - 1 && ------------------ | Branch (2583:12): [True: 8.21k, False: 2.11k] ------------------ 2584| 10.3k| national_number[number_of_leading_zeros] == '0') { ------------------ | Branch (2584:9): [True: 687, False: 7.52k] ------------------ 2585| 687| number_of_leading_zeros++; 2586| 687| } 2587| 9.64k| if (number_of_leading_zeros != 1) { ------------------ | Branch (2587:9): [True: 276, False: 9.36k] ------------------ 2588| 276| phone_number->set_number_of_leading_zeros(static_cast(number_of_leading_zeros)); 2589| 276| } 2590| 9.64k| } 2591| 49.4k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil20IsNumberMatchingDescERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_15PhoneNumberDescE: 2594| 330k| const string& national_number, const PhoneNumberDesc& number_desc) const { 2595| | // Check if any possible number lengths are present; if so, we use them to 2596| | // avoid checking the validation pattern if they don't match. If they are 2597| | // absent, this means they match the general description, which we have 2598| | // already checked before checking a specific number type. 2599| 330k| int actual_length = static_cast(national_number.length()); 2600| 330k| if (number_desc.possible_length_size() > 0 && ------------------ | Branch (2600:7): [True: 308k, False: 21.9k] ------------------ 2601| 330k| std::find(number_desc.possible_length().begin(), ------------------ | Branch (2601:7): [True: 209k, False: 99.0k] ------------------ 2602| 308k| number_desc.possible_length().end(), 2603| 308k| actual_length) == number_desc.possible_length().end()) { 2604| 209k| return false; 2605| 209k| } 2606| 121k| return IsMatch(*matcher_api_, national_number, number_desc); 2607| 330k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil19GetNumberTypeHelperERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_13PhoneMetadataE: 2610| 74.8k| const string& national_number, const PhoneMetadata& metadata) const { 2611| 74.8k| if (!IsNumberMatchingDesc(national_number, metadata.general_desc())) { ------------------ | Branch (2611:7): [True: 49.1k, False: 25.6k] ------------------ 2612| 49.1k| VLOG(4) << "Number type unknown - doesn't match general national number" 2613| 49.1k| << " pattern."; 2614| 49.1k| return PhoneNumberUtil::UNKNOWN; 2615| 49.1k| } 2616| 25.6k| if (IsNumberMatchingDesc(national_number, metadata.premium_rate())) { ------------------ | Branch (2616:7): [True: 105, False: 25.5k] ------------------ 2617| 105| VLOG(4) << "Number is a premium number."; 2618| 105| return PhoneNumberUtil::PREMIUM_RATE; 2619| 105| } 2620| 25.5k| if (IsNumberMatchingDesc(national_number, metadata.toll_free())) { ------------------ | Branch (2620:7): [True: 86, False: 25.4k] ------------------ 2621| 86| VLOG(4) << "Number is a toll-free number."; 2622| 86| return PhoneNumberUtil::TOLL_FREE; 2623| 86| } 2624| 25.4k| if (IsNumberMatchingDesc(national_number, metadata.shared_cost())) { ------------------ | Branch (2624:7): [True: 82, False: 25.4k] ------------------ 2625| 82| VLOG(4) << "Number is a shared cost number."; 2626| 82| return PhoneNumberUtil::SHARED_COST; 2627| 82| } 2628| 25.4k| if (IsNumberMatchingDesc(national_number, metadata.voip())) { ------------------ | Branch (2628:7): [True: 159, False: 25.2k] ------------------ 2629| 159| VLOG(4) << "Number is a VOIP (Voice over IP) number."; 2630| 159| return PhoneNumberUtil::VOIP; 2631| 159| } 2632| 25.2k| if (IsNumberMatchingDesc(national_number, metadata.personal_number())) { ------------------ | Branch (2632:7): [True: 43, False: 25.2k] ------------------ 2633| 43| VLOG(4) << "Number is a personal number."; 2634| 43| return PhoneNumberUtil::PERSONAL_NUMBER; 2635| 43| } 2636| 25.2k| if (IsNumberMatchingDesc(national_number, metadata.pager())) { ------------------ | Branch (2636:7): [True: 73, False: 25.1k] ------------------ 2637| 73| VLOG(4) << "Number is a pager number."; 2638| 73| return PhoneNumberUtil::PAGER; 2639| 73| } 2640| 25.1k| if (IsNumberMatchingDesc(national_number, metadata.uan())) { ------------------ | Branch (2640:7): [True: 96, False: 25.0k] ------------------ 2641| 96| VLOG(4) << "Number is a UAN."; 2642| 96| return PhoneNumberUtil::UAN; 2643| 96| } 2644| 25.0k| if (IsNumberMatchingDesc(national_number, metadata.voicemail())) { ------------------ | Branch (2644:7): [True: 48, False: 24.9k] ------------------ 2645| 48| VLOG(4) << "Number is a voicemail number."; 2646| 48| return PhoneNumberUtil::VOICEMAIL; 2647| 48| } 2648| | 2649| 24.9k| bool is_fixed_line = 2650| 24.9k| IsNumberMatchingDesc(national_number, metadata.fixed_line()); 2651| 24.9k| if (is_fixed_line) { ------------------ | Branch (2651:7): [True: 18.0k, False: 6.95k] ------------------ 2652| 18.0k| if (metadata.same_mobile_and_fixed_line_pattern()) { ------------------ | Branch (2652:9): [True: 425, False: 17.6k] ------------------ 2653| 425| VLOG(4) << "Fixed-line and mobile patterns equal, number is fixed-line" 2654| 425| << " or mobile"; 2655| 425| return PhoneNumberUtil::FIXED_LINE_OR_MOBILE; 2656| 17.6k| } else if (IsNumberMatchingDesc(national_number, metadata.mobile())) { ------------------ | Branch (2656:16): [True: 66, False: 17.5k] ------------------ 2657| 66| VLOG(4) << "Fixed-line and mobile patterns differ, but number is " 2658| 66| << "still fixed-line or mobile"; 2659| 66| return PhoneNumberUtil::FIXED_LINE_OR_MOBILE; 2660| 66| } 2661| 17.5k| VLOG(4) << "Number is a fixed line number."; 2662| 17.5k| return PhoneNumberUtil::FIXED_LINE; 2663| 18.0k| } 2664| | // Otherwise, test to see if the number is mobile. Only do this if certain 2665| | // that the patterns for mobile and fixed line aren't the same. 2666| 6.95k| if (!metadata.same_mobile_and_fixed_line_pattern() && ------------------ | Branch (2666:7): [True: 4.71k, False: 2.24k] ------------------ 2667| 6.95k| IsNumberMatchingDesc(national_number, metadata.mobile())) { ------------------ | Branch (2667:7): [True: 491, False: 4.22k] ------------------ 2668| 491| VLOG(4) << "Number is a mobile number."; 2669| 491| return PhoneNumberUtil::MOBILE; 2670| 491| } 2671| 6.46k| VLOG(4) << "Number type unknown - doesn\'t match any specific number type" 2672| 6.46k| << " pattern."; 2673| 6.46k| return PhoneNumberUtil::UNKNOWN; 2674| 6.95k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil28GetNationalSignificantNumberERKNS0_11PhoneNumberEPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 2678| 176k| string* national_number) const { 2679| 176k| DCHECK(national_number); ------------------ | | 29| 176k|#define DCHECK(X) assert(X) ------------------ 2680| | // If leading zero(s) have been set, we prefix this now. Note this is not a 2681| | // national prefix. Ensure the number of leading zeros is at least 0 so we 2682| | // don't crash in the case of malicious input. 2683| 176k| StrAppend(national_number, number.italian_leading_zero() ? ------------------ | Branch (2683:30): [True: 30.9k, False: 145k] ------------------ 2684| 145k| string(std::max(number.number_of_leading_zeros(), 0), '0') : ""); 2685| 176k| StrAppend(national_number, number.national_number()); 2686| 176k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil31GetLengthOfGeographicalAreaCodeERKNS0_11PhoneNumberE: 2689| 9.65k| const PhoneNumber& number) const { 2690| 9.65k| string region_code; 2691| 9.65k| GetRegionCodeForNumber(number, ®ion_code); 2692| 9.65k| const PhoneMetadata* metadata = GetMetadataForRegion(region_code); 2693| 9.65k| if (!metadata) { ------------------ | Branch (2693:7): [True: 4.58k, False: 5.06k] ------------------ 2694| 4.58k| return 0; 2695| 4.58k| } 2696| | 2697| 5.06k| PhoneNumberType type = GetNumberType(number); 2698| 5.06k| int country_calling_code = number.country_code(); 2699| | 2700| | // If a country doesn't use a national prefix, and this number doesn't have an 2701| | // Italian leading zero, we assume it is a closed dialling plan with no area 2702| | // codes. 2703| | // Note:this is our general assumption, but there are exceptions which are 2704| | // tracked in COUNTRIES_WITHOUT_NATIONAL_PREFIX_WITH_AREA_CODES. 2705| 5.06k| if (!metadata->has_national_prefix() && !number.italian_leading_zero() && ------------------ | Branch (2705:7): [True: 1.05k, False: 4.00k] | Branch (2705:7): [True: 946, False: 4.11k] | Branch (2705:43): [True: 968, False: 88] ------------------ 2706| 5.06k| reg_exps_->countries_without_national_prefix_with_area_codes_.find( ------------------ | Branch (2706:7): [True: 946, False: 22] ------------------ 2707| 968| country_calling_code) == 2708| 968| reg_exps_->countries_without_national_prefix_with_area_codes_.end()) { 2709| 946| return 0; 2710| 946| } 2711| | 2712| 4.11k| if (type == PhoneNumberUtil::MOBILE && ------------------ | Branch (2712:7): [True: 54, False: 4.06k] | Branch (2712:7): [True: 1, False: 4.11k] ------------------ 2713| 4.11k| reg_exps_->geo_mobile_countries_without_mobile_area_codes_.find( ------------------ | Branch (2713:7): [True: 1, False: 53] ------------------ 2714| 54| country_calling_code) != 2715| 54| reg_exps_->geo_mobile_countries_without_mobile_area_codes_.end()) { 2716| 1| return 0; 2717| 1| } 2718| | 2719| 4.11k| if (!IsNumberGeographical(type, country_calling_code)) { ------------------ | Branch (2719:7): [True: 3.81k, False: 304] ------------------ 2720| 3.81k| return 0; 2721| 3.81k| } 2722| | 2723| 304| return GetLengthOfNationalDestinationCode(number); 2724| 4.11k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil34GetLengthOfNationalDestinationCodeERKNS0_11PhoneNumberE: 2727| 9.95k| const PhoneNumber& number) const { 2728| 9.95k| PhoneNumber copied_proto(number); 2729| 9.95k| if (number.has_extension()) { ------------------ | Branch (2729:7): [True: 325, False: 9.62k] ------------------ 2730| | // Clear the extension so it's not included when formatting. 2731| 325| copied_proto.clear_extension(); 2732| 325| } 2733| | 2734| 9.95k| string formatted_number; 2735| 9.95k| Format(copied_proto, INTERNATIONAL, &formatted_number); 2736| 9.95k| const scoped_ptr i18n_number( 2737| 9.95k| reg_exps_->regexp_factory_->CreateInput(formatted_number)); 2738| 9.95k| string digit_group; 2739| 9.95k| string ndc; 2740| 9.95k| string third_group; 2741| 28.8k| for (int i = 0; i < 3; ++i) { ------------------ | Branch (2741:19): [True: 27.6k, False: 1.16k] ------------------ 2742| 27.6k| if (!reg_exps_->capturing_ascii_digits_pattern_->FindAndConsume( ------------------ | Branch (2742:9): [True: 8.79k, False: 18.8k] ------------------ 2743| 27.6k| i18n_number.get(), &digit_group)) { 2744| | // We should find at least three groups. 2745| 8.79k| return 0; 2746| 8.79k| } 2747| 18.8k| if (i == 1) { ------------------ | Branch (2747:9): [True: 7.74k, False: 11.1k] ------------------ 2748| 7.74k| ndc = digit_group; 2749| 11.1k| } else if (i == 2) { ------------------ | Branch (2749:16): [True: 1.16k, False: 9.95k] ------------------ 2750| 1.16k| third_group = digit_group; 2751| 1.16k| } 2752| 18.8k| } 2753| | 2754| 1.16k| if (GetNumberType(number) == MOBILE) { ------------------ | Branch (2754:7): [True: 89, False: 1.07k] ------------------ 2755| | // For example Argentinian mobile numbers, when formatted in the 2756| | // international format, are in the form of +54 9 NDC XXXX.... As a result, 2757| | // we take the length of the third group (NDC) and add the length of the 2758| | // mobile token, which also forms part of the national significant number. 2759| | // This assumes that the mobile token is always formatted separately from 2760| | // the rest of the phone number. 2761| 89| string mobile_token; 2762| 89| GetCountryMobileToken(number.country_code(), &mobile_token); 2763| 89| if (!mobile_token.empty()) { ------------------ | Branch (2763:9): [True: 12, False: 77] ------------------ 2764| 12| return static_cast(third_group.size() + mobile_token.size()); 2765| 12| } 2766| 89| } 2767| 1.14k| return static_cast(ndc.size()); 2768| 1.16k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil21GetCountryMobileTokenEiPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 2771| 9.73k| string* mobile_token) const { 2772| 9.73k| DCHECK(mobile_token); ------------------ | | 29| 9.73k|#define DCHECK(X) assert(X) ------------------ 2773| 9.73k| std::map::iterator it = reg_exps_->mobile_token_mappings_.find( 2774| 9.73k| country_calling_code); 2775| 9.73k| if (it != reg_exps_->mobile_token_mappings_.end()) { ------------------ | Branch (2775:7): [True: 14, False: 9.72k] ------------------ 2776| 14| *mobile_token = it->second; 2777| 9.72k| } else { 2778| 9.72k| mobile_token->assign(""); 2779| 9.72k| } 2780| 9.73k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil19NormalizeDigitsOnlyEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 2782| 62.2k|void PhoneNumberUtil::NormalizeDigitsOnly(string* number) const { 2783| 62.2k| DCHECK(number); ------------------ | | 29| 62.2k|#define DCHECK(X) assert(X) ------------------ 2784| 62.2k| const RegExp& non_digits_pattern = reg_exps_->regexp_cache_->GetRegExp( 2785| 62.2k| StrCat("[^", kDigits, "]")); 2786| | // Delete everything that isn't valid digits. 2787| 62.2k| non_digits_pattern.GlobalReplace(number, ""); 2788| | // Normalize all decimal digits to ASCII digits. 2789| 62.2k| number->assign(NormalizeUTF8::NormalizeDecimalDigits(*number)); 2790| 62.2k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil27NormalizeDiallableCharsOnlyEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 2792| 15.0k|void PhoneNumberUtil::NormalizeDiallableCharsOnly(string* number) const { 2793| 15.0k| DCHECK(number); ------------------ | | 29| 15.0k|#define DCHECK(X) assert(X) ------------------ 2794| 15.0k| NormalizeHelper(reg_exps_->diallable_char_mappings_, 2795| 15.0k| true /* remove non matches */, number); 2796| 15.0k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil13IsAlphaNumberERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 2798| 9.65k|bool PhoneNumberUtil::IsAlphaNumber(const string& number) const { 2799| 9.65k| if (!IsViablePhoneNumber(number)) { ------------------ | Branch (2799:7): [True: 3.20k, False: 6.44k] ------------------ 2800| | // Number is too short, or doesn't match the basic phone number pattern. 2801| 3.20k| return false; 2802| 3.20k| } 2803| | // Copy the number, since we are going to try and strip the extension from it. 2804| 6.44k| string number_copy(number); 2805| 6.44k| string extension; 2806| 6.44k| MaybeStripExtension(&number_copy, &extension); 2807| 6.44k| return reg_exps_->valid_alpha_phone_pattern_->FullMatch(number_copy); 2808| 9.65k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil30ConvertAlphaCharactersInNumberEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 2810| 9.65k|void PhoneNumberUtil::ConvertAlphaCharactersInNumber(string* number) const { 2811| 9.65k| DCHECK(number); ------------------ | | 29| 9.65k|#define DCHECK(X) assert(X) ------------------ 2812| 9.65k| NormalizeHelper(reg_exps_->alpha_phone_mappings_, false, number); 2813| 9.65k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil9NormalizeEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 2827| 51.7k|void PhoneNumberUtil::Normalize(string* number) const { 2828| 51.7k| DCHECK(number); ------------------ | | 29| 51.7k|#define DCHECK(X) assert(X) ------------------ 2829| 51.7k| if (reg_exps_->valid_alpha_phone_pattern_->PartialMatch(*number)) { ------------------ | Branch (2829:7): [True: 2.11k, False: 49.6k] ------------------ 2830| 2.11k| NormalizeHelper(reg_exps_->alpha_phone_mappings_, true, number); 2831| 2.11k| } 2832| 51.7k| NormalizeDigitsOnly(number); 2833| 51.7k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil19IsViablePhoneNumberERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 2841| 101k|bool PhoneNumberUtil::IsViablePhoneNumber(const string& number) const { 2842| 101k| if (number.length() < kMinLengthForNsn) { ------------------ | Branch (2842:7): [True: 29.9k, False: 71.1k] ------------------ 2843| 29.9k| return false; 2844| 29.9k| } 2845| 71.1k| return reg_exps_->valid_phone_number_pattern_->FullMatch(number); 2846| 101k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil16ParsePrefixAsIddERKNS0_6RegExpEPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 2851| 49.4k| string* number) const { 2852| 49.4k| DCHECK(number); ------------------ | | 29| 49.4k|#define DCHECK(X) assert(X) ------------------ 2853| 49.4k| const scoped_ptr number_copy( 2854| 49.4k| reg_exps_->regexp_factory_->CreateInput(*number)); 2855| | // First attempt to strip the idd_pattern at the start, if present. We make a 2856| | // copy so that we can revert to the original string if necessary. 2857| 49.4k| if (idd_pattern.Consume(number_copy.get())) { ------------------ | Branch (2857:7): [True: 495, False: 48.9k] ------------------ 2858| | // Only strip this if the first digit after the match is not a 0, since 2859| | // country calling codes cannot begin with 0. 2860| 495| string extracted_digit; 2861| 495| if (reg_exps_->capturing_digit_pattern_->PartialMatch( ------------------ | Branch (2861:9): [True: 442, False: 53] ------------------ 2862| 495| number_copy->ToString(), &extracted_digit)) { 2863| 442| NormalizeDigitsOnly(&extracted_digit); 2864| 442| if (extracted_digit == "0") { ------------------ | Branch (2864:11): [True: 111, False: 331] ------------------ 2865| 111| return false; 2866| 111| } 2867| 442| } 2868| 384| number->assign(number_copy->ToString()); 2869| 384| return true; 2870| 495| } 2871| 48.9k| return false; 2872| 49.4k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil41MaybeStripInternationalPrefixAndNormalizeERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPS8_: 2886| 51.7k| string* number) const { 2887| 51.7k| DCHECK(number); ------------------ | | 29| 51.7k|#define DCHECK(X) assert(X) ------------------ 2888| 51.7k| if (number->empty()) { ------------------ | Branch (2888:7): [True: 0, False: 51.7k] ------------------ 2889| 0| return PhoneNumber::FROM_DEFAULT_COUNTRY; 2890| 0| } 2891| 51.7k| const scoped_ptr number_string_piece( 2892| 51.7k| reg_exps_->regexp_factory_->CreateInput(*number)); 2893| 51.7k| if (reg_exps_->plus_chars_pattern_->Consume(number_string_piece.get())) { ------------------ | Branch (2893:7): [True: 2.33k, False: 49.4k] ------------------ 2894| 2.33k| number->assign(number_string_piece->ToString()); 2895| | // Can now normalize the rest of the number since we've consumed the "+" 2896| | // sign at the start. 2897| 2.33k| Normalize(number); 2898| 2.33k| return PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN; 2899| 2.33k| } 2900| | // Attempt to parse the first digits as an international prefix. 2901| 49.4k| const RegExp& idd_pattern = 2902| 49.4k| reg_exps_->regexp_cache_->GetRegExp(possible_idd_prefix); 2903| 49.4k| Normalize(number); 2904| 49.4k| return ParsePrefixAsIdd(idd_pattern, number) ------------------ | Branch (2904:10): [True: 384, False: 49.0k] ------------------ 2905| 49.4k| ? PhoneNumber::FROM_NUMBER_WITH_IDD 2906| 49.4k| : PhoneNumber::FROM_DEFAULT_COUNTRY; 2907| 51.7k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil38MaybeStripNationalPrefixAndCarrierCodeERKNS0_13PhoneMetadataEPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEESC_: 2917| 49.8k| string* carrier_code) const { 2918| 49.8k| DCHECK(number); ------------------ | | 29| 49.8k|#define DCHECK(X) assert(X) ------------------ 2919| 49.8k| string carrier_code_temp; 2920| 49.8k| const string& possible_national_prefix = 2921| 49.8k| metadata.national_prefix_for_parsing(); 2922| 49.8k| if (number->empty() || possible_national_prefix.empty()) { ------------------ | Branch (2922:7): [True: 82, False: 49.8k] | Branch (2922:26): [True: 20.3k, False: 29.5k] ------------------ 2923| | // Early return for numbers of zero length or with no national prefix 2924| | // possible. 2925| 20.3k| return false; 2926| 20.3k| } 2927| | // We use two copies here since Consume modifies the phone number, and if the 2928| | // first if-clause fails the number will already be changed. 2929| 29.5k| const scoped_ptr number_copy( 2930| 29.5k| reg_exps_->regexp_factory_->CreateInput(*number)); 2931| 29.5k| const scoped_ptr number_copy_without_transform( 2932| 29.5k| reg_exps_->regexp_factory_->CreateInput(*number)); 2933| 29.5k| string number_string_copy(*number); 2934| 29.5k| string captured_part_of_prefix; 2935| 29.5k| const PhoneNumberDesc& general_desc = metadata.general_desc(); 2936| | // Check if the original number is viable. 2937| 29.5k| bool is_viable_original_number = 2938| 29.5k| IsMatch(*matcher_api_, *number, general_desc); 2939| | // Attempt to parse the first digits as a national prefix. We make a 2940| | // copy so that we can revert to the original string if necessary. 2941| 29.5k| const string& transform_rule = metadata.national_prefix_transform_rule(); 2942| 29.5k| const RegExp& possible_national_prefix_pattern = 2943| 29.5k| reg_exps_->regexp_cache_->GetRegExp(possible_national_prefix); 2944| 29.5k| if (!transform_rule.empty() && ------------------ | Branch (2944:7): [True: 6.95k, False: 22.5k] ------------------ 2945| 29.5k| (possible_national_prefix_pattern.Consume( ------------------ | Branch (2945:8): [True: 149, False: 6.80k] ------------------ 2946| 6.95k| number_copy.get(), &carrier_code_temp, &captured_part_of_prefix) || 2947| 6.95k| possible_national_prefix_pattern.Consume( ------------------ | Branch (2947:8): [True: 1.80k, False: 5.00k] ------------------ 2948| 6.80k| number_copy.get(), &captured_part_of_prefix)) && 2949| 29.5k| !captured_part_of_prefix.empty()) { ------------------ | Branch (2949:7): [True: 575, False: 1.38k] ------------------ 2950| | // If this succeeded, then we must have had a transform rule and there must 2951| | // have been some part of the prefix that we captured. 2952| | // We make the transformation and check that the resultant number is still 2953| | // viable. If so, replace the number and return. 2954| 575| possible_national_prefix_pattern.Replace(&number_string_copy, 2955| 575| transform_rule); 2956| 575| if (is_viable_original_number && ------------------ | Branch (2956:9): [True: 22, False: 553] ------------------ 2957| 575| !IsMatch(*matcher_api_, number_string_copy, general_desc)) { ------------------ | Branch (2957:9): [True: 22, False: 0] ------------------ 2958| 22| return false; 2959| 22| } 2960| 553| number->assign(number_string_copy); 2961| 553| if (carrier_code) { ------------------ | Branch (2961:9): [True: 501, False: 52] ------------------ 2962| 501| carrier_code->assign(carrier_code_temp); 2963| 501| } 2964| 28.9k| } else if (possible_national_prefix_pattern.Consume( ------------------ | Branch (2964:14): [True: 1.49k, False: 27.4k] ------------------ 2965| 28.9k| number_copy_without_transform.get(), &carrier_code_temp) || 2966| 28.9k| possible_national_prefix_pattern.Consume( ------------------ | Branch (2966:14): [True: 761, False: 26.6k] ------------------ 2967| 27.4k| number_copy_without_transform.get())) { 2968| 2.25k| VLOG(4) << "Parsed the first digits as a national prefix."; 2969| | // If captured_part_of_prefix is empty, this implies nothing was captured by 2970| | // the capturing groups in possible_national_prefix; therefore, no 2971| | // transformation is necessary, and we just remove the national prefix. 2972| 2.25k| const string number_copy_as_string = 2973| 2.25k| number_copy_without_transform->ToString(); 2974| 2.25k| if (is_viable_original_number && ------------------ | Branch (2974:9): [True: 239, False: 2.01k] ------------------ 2975| 2.25k| !IsMatch(*matcher_api_, number_copy_as_string, general_desc)) { ------------------ | Branch (2975:9): [True: 59, False: 180] ------------------ 2976| 59| return false; 2977| 59| } 2978| 2.19k| number->assign(number_copy_as_string); 2979| 2.19k| if (carrier_code) { ------------------ | Branch (2979:9): [True: 2.07k, False: 124] ------------------ 2980| 2.07k| carrier_code->assign(carrier_code_temp); 2981| 2.07k| } 2982| 26.6k| } else { 2983| 26.6k| return false; 2984| 0| VLOG(4) << "The first digits did not match the national prefix."; 2985| 0| } 2986| 2.74k| return true; 2987| 29.5k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil19MaybeStripExtensionEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEES9_: 2993| 57.4k| const { 2994| 57.4k| DCHECK(number); ------------------ | | 29| 57.4k|#define DCHECK(X) assert(X) ------------------ 2995| 57.4k| DCHECK(extension); ------------------ | | 29| 57.4k|#define DCHECK(X) assert(X) ------------------ 2996| | // There are six extension capturing groups in the regular expression. 2997| 57.4k| string possible_extension_one; 2998| 57.4k| string possible_extension_two; 2999| 57.4k| string possible_extension_three; 3000| 57.4k| string possible_extension_four; 3001| 57.4k| string possible_extension_five; 3002| 57.4k| string possible_extension_six; 3003| 57.4k| string number_copy(*number); 3004| 57.4k| const scoped_ptr number_copy_as_regexp_input( 3005| 57.4k| reg_exps_->regexp_factory_->CreateInput(number_copy)); 3006| 57.4k| if (reg_exps_->extn_pattern_->Consume( ------------------ | Branch (3006:7): [True: 1.64k, False: 55.7k] ------------------ 3007| 57.4k| number_copy_as_regexp_input.get(), false, &possible_extension_one, 3008| 57.4k| &possible_extension_two, &possible_extension_three, 3009| 57.4k| &possible_extension_four, &possible_extension_five, 3010| 57.4k| &possible_extension_six)) { 3011| | // Replace the extensions in the original string here. 3012| 1.64k| reg_exps_->extn_pattern_->Replace(&number_copy, ""); 3013| | // If we find a potential extension, and the number preceding this is a 3014| | // viable number, we assume it is an extension. 3015| 1.64k| if ((!possible_extension_one.empty() || !possible_extension_two.empty() || ------------------ | Branch (3015:10): [True: 28, False: 1.61k] | Branch (3015:45): [True: 54, False: 1.55k] ------------------ 3016| 1.64k| !possible_extension_three.empty() || ------------------ | Branch (3016:10): [True: 1.08k, False: 469] ------------------ 3017| 1.64k| !possible_extension_four.empty() || !possible_extension_five.empty() || ------------------ | Branch (3017:10): [True: 31, False: 438] | Branch (3017:46): [True: 270, False: 168] ------------------ 3018| 1.64k| !possible_extension_six.empty()) && ------------------ | Branch (3018:10): [True: 168, False: 0] ------------------ 3019| 1.64k| IsViablePhoneNumber(number_copy)) { ------------------ | Branch (3019:9): [True: 1.28k, False: 353] ------------------ 3020| 1.28k| number->assign(number_copy); 3021| 1.28k| if (!possible_extension_one.empty()) { ------------------ | Branch (3021:11): [True: 28, False: 1.25k] ------------------ 3022| 28| extension->assign(possible_extension_one); 3023| 1.25k| } else if (!possible_extension_two.empty()) { ------------------ | Branch (3023:18): [True: 54, False: 1.20k] ------------------ 3024| 54| extension->assign(possible_extension_two); 3025| 1.20k| } else if (!possible_extension_three.empty()) { ------------------ | Branch (3025:18): [True: 736, False: 469] ------------------ 3026| 736| extension->assign(possible_extension_three); 3027| 736| } else if (!possible_extension_four.empty()) { ------------------ | Branch (3027:18): [True: 31, False: 438] ------------------ 3028| 31| extension->assign(possible_extension_four); 3029| 438| } else if (!possible_extension_five.empty()) { ------------------ | Branch (3029:18): [True: 270, False: 168] ------------------ 3030| 270| extension->assign(possible_extension_five); 3031| 270| } else if (!possible_extension_six.empty()) { ------------------ | Branch (3031:18): [True: 168, False: 0] ------------------ 3032| 168| extension->assign(possible_extension_six); 3033| 168| } 3034| 1.28k| return true; 3035| 1.28k| } 3036| 1.64k| } 3037| 56.1k| return false; 3038| 57.4k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil18ExtractCountryCodeEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 3045| 2.61k|int PhoneNumberUtil::ExtractCountryCode(string* national_number) const { 3046| 2.61k| int potential_country_code; 3047| 2.61k| if (national_number->empty() || (national_number->at(0) == '0')) { ------------------ | Branch (3047:7): [True: 0, False: 2.61k] | Branch (3047:35): [True: 608, False: 2.00k] ------------------ 3048| | // Country codes do not begin with a '0'. 3049| 608| return 0; 3050| 608| } 3051| 4.73k| for (size_t i = 1; i <= kMaxLengthCountryCode; ++i) { ------------------ | Branch (3051:22): [True: 4.32k, False: 419] ------------------ 3052| 4.32k| safe_strto32(national_number->substr(0, i), &potential_country_code); 3053| 4.32k| string region_code; 3054| 4.32k| GetRegionCodeForCountryCode(potential_country_code, ®ion_code); 3055| 4.32k| if (region_code != RegionCode::GetUnknown()) { ------------------ | Branch (3055:9): [True: 1.58k, False: 2.73k] ------------------ 3056| 1.58k| national_number->erase(0, i); 3057| 1.58k| return potential_country_code; 3058| 1.58k| } 3059| 4.32k| } 3060| 419| return 0; 3061| 2.00k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil23MaybeExtractCountryCodeEPKNS0_13PhoneMetadataEbPNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEEPNS0_11PhoneNumberE: 3087| 51.7k| PhoneNumber* phone_number) const { 3088| 51.7k| DCHECK(national_number); ------------------ | | 29| 51.7k|#define DCHECK(X) assert(X) ------------------ 3089| 51.7k| DCHECK(phone_number); ------------------ | | 29| 51.7k|#define DCHECK(X) assert(X) ------------------ 3090| | // Set the default prefix to be something that will never match if there is no 3091| | // default region. 3092| 51.7k| string possible_country_idd_prefix = default_region_metadata ------------------ | Branch (3092:40): [True: 48.8k, False: 2.95k] ------------------ 3093| 51.7k| ? default_region_metadata->international_prefix() 3094| 51.7k| : "NonMatch"; 3095| 51.7k| PhoneNumber::CountryCodeSource country_code_source = 3096| 51.7k| MaybeStripInternationalPrefixAndNormalize(possible_country_idd_prefix, 3097| 51.7k| national_number); 3098| 51.7k| if (keep_raw_input) { ------------------ | Branch (3098:7): [True: 3.54k, False: 48.2k] ------------------ 3099| 3.54k| phone_number->set_country_code_source(country_code_source); 3100| 3.54k| } 3101| 51.7k| if (country_code_source != PhoneNumber::FROM_DEFAULT_COUNTRY) { ------------------ | Branch (3101:7): [True: 2.72k, False: 49.0k] ------------------ 3102| 2.72k| if (national_number->length() <= kMinLengthForNsn) { ------------------ | Branch (3102:9): [True: 113, False: 2.61k] ------------------ 3103| 113| VLOG(2) << "Phone number had an IDD, but after this was not " 3104| 113| << "long enough to be a viable phone number."; 3105| 113| return TOO_SHORT_AFTER_IDD; 3106| 113| } 3107| 2.61k| int potential_country_code = ExtractCountryCode(national_number); 3108| 2.61k| if (potential_country_code != 0) { ------------------ | Branch (3108:9): [True: 1.58k, False: 1.02k] ------------------ 3109| 1.58k| phone_number->set_country_code(potential_country_code); 3110| 1.58k| return NO_PARSING_ERROR; 3111| 1.58k| } 3112| | // If this fails, they must be using a strange country calling code that we 3113| | // don't recognize, or that doesn't exist. 3114| 1.02k| return INVALID_COUNTRY_CODE_ERROR; 3115| 49.0k| } else if (default_region_metadata) { ------------------ | Branch (3115:14): [True: 47.7k, False: 1.29k] ------------------ 3116| | // Check to see if the number starts with the country calling code for the 3117| | // default region. If so, we remove the country calling code, and do some 3118| | // checks on the validity of the number before and after. 3119| 47.7k| int default_country_code = default_region_metadata->country_code(); 3120| 47.7k| string default_country_code_string(SimpleItoa(default_country_code)); 3121| 47.7k| VLOG(4) << "Possible country calling code: " << default_country_code_string; 3122| 47.7k| string potential_national_number; 3123| 47.7k| if (TryStripPrefixString(*national_number, ------------------ | Branch (3123:9): [True: 873, False: 46.9k] ------------------ 3124| 47.7k| default_country_code_string, 3125| 47.7k| &potential_national_number)) { 3126| 873| const PhoneNumberDesc& general_num_desc = 3127| 873| default_region_metadata->general_desc(); 3128| 873| MaybeStripNationalPrefixAndCarrierCode(*default_region_metadata, 3129| 873| &potential_national_number, 3130| 873| NULL); 3131| 873| VLOG(4) << "Number without country calling code prefix"; 3132| | // If the number was not valid before but is valid now, or if it was too 3133| | // long before, we consider the number with the country code stripped to 3134| | // be a better result and keep that instead. 3135| 873| if ((!IsMatch(*matcher_api_, *national_number, general_num_desc) && ------------------ | Branch (3135:12): [True: 814, False: 59] ------------------ 3136| 873| IsMatch( ------------------ | Branch (3136:11): [True: 71, False: 743] ------------------ 3137| 814| *matcher_api_, potential_national_number, general_num_desc)) || 3138| 873| TestNumberLength(*national_number, *default_region_metadata) == ------------------ | Branch (3138:11): [True: 122, False: 680] ------------------ 3139| 802| TOO_LONG) { 3140| 193| national_number->assign(potential_national_number); 3141| 193| if (keep_raw_input) { ------------------ | Branch (3141:13): [True: 27, False: 166] ------------------ 3142| 27| phone_number->set_country_code_source( 3143| 27| PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN); 3144| 27| } 3145| 193| phone_number->set_country_code(default_country_code); 3146| 193| return NO_PARSING_ERROR; 3147| 193| } 3148| 873| } 3149| 47.7k| } 3150| | // No country calling code present. Set the country_code to 0. 3151| 48.8k| phone_number->set_country_code(0); 3152| 48.8k| return NO_PARSING_ERROR; 3153| 51.7k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil13IsNumberMatchERKNS0_11PhoneNumberES4_: 3157| 10.3k| const PhoneNumber& second_number_in) const { 3158| | // We only are about the fields that uniquely define a number, so we copy 3159| | // these across explicitly. 3160| 10.3k| PhoneNumber first_number; 3161| 10.3k| CopyCoreFieldsOnly(first_number_in, &first_number); 3162| 10.3k| PhoneNumber second_number; 3163| 10.3k| CopyCoreFieldsOnly(second_number_in, &second_number); 3164| | // Early exit if both had extensions and these are different. 3165| 10.3k| if (first_number.has_extension() && second_number.has_extension() && ------------------ | Branch (3165:7): [True: 426, False: 9.93k] | Branch (3165:39): [True: 118, False: 308] ------------------ 3166| 10.3k| first_number.extension() != second_number.extension()) { ------------------ | Branch (3166:7): [True: 67, False: 51] ------------------ 3167| 67| return NO_MATCH; 3168| 67| } 3169| 10.2k| int first_number_country_code = first_number.country_code(); 3170| 10.2k| int second_number_country_code = second_number.country_code(); 3171| | // Both had country calling code specified. 3172| 10.2k| if (first_number_country_code != 0 && second_number_country_code != 0) { ------------------ | Branch (3172:7): [True: 7.83k, False: 2.46k] | Branch (3172:41): [True: 398, False: 7.43k] ------------------ 3173| 398| if (ExactlySameAs(first_number, second_number)) { ------------------ | Branch (3173:9): [True: 51, False: 347] ------------------ 3174| 51| return EXACT_MATCH; 3175| 347| } else if (first_number_country_code == second_number_country_code && ------------------ | Branch (3175:16): [True: 289, False: 58] ------------------ 3176| 347| IsNationalNumberSuffixOfTheOther(first_number, second_number)) { ------------------ | Branch (3176:16): [True: 38, False: 251] ------------------ 3177| | // A SHORT_NSN_MATCH occurs if there is a difference because of the 3178| | // presence or absence of an 'Italian leading zero', the presence or 3179| | // absence of an extension, or one NSN being a shorter variant of the 3180| | // other. 3181| 38| return SHORT_NSN_MATCH; 3182| 38| } 3183| | // This is not a match. 3184| 309| return NO_MATCH; 3185| 398| } 3186| | // Checks cases where one or both country calling codes were not specified. To 3187| | // make equality checks easier, we first set the country_code fields to be 3188| | // equal. 3189| 9.89k| first_number.set_country_code(second_number_country_code); 3190| | // If all else was the same, then this is an NSN_MATCH. 3191| 9.89k| if (ExactlySameAs(first_number, second_number)) { ------------------ | Branch (3191:7): [True: 2.11k, False: 7.78k] ------------------ 3192| 2.11k| return NSN_MATCH; 3193| 2.11k| } 3194| 7.78k| if (IsNationalNumberSuffixOfTheOther(first_number, second_number)) { ------------------ | Branch (3194:7): [True: 823, False: 6.95k] ------------------ 3195| 823| return SHORT_NSN_MATCH; 3196| 823| } 3197| 6.95k| return NO_MATCH; 3198| 7.78k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil27IsNumberMatchWithTwoStringsERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_: 3202| 9.65k| const string& second_number) const { 3203| 9.65k| PhoneNumber first_number_as_proto; 3204| 9.65k| ErrorType error_type = 3205| 9.65k| Parse(first_number, RegionCode::GetUnknown(), &first_number_as_proto); 3206| 9.65k| if (error_type == NO_PARSING_ERROR) { ------------------ | Branch (3206:7): [True: 341, False: 9.30k] ------------------ 3207| 341| return IsNumberMatchWithOneString(first_number_as_proto, second_number); 3208| 341| } 3209| 9.30k| if (error_type == INVALID_COUNTRY_CODE_ERROR) { ------------------ | Branch (3209:7): [True: 7.57k, False: 1.73k] ------------------ 3210| 7.57k| PhoneNumber second_number_as_proto; 3211| 7.57k| ErrorType error_type = Parse(second_number, RegionCode::GetUnknown(), 3212| 7.57k| &second_number_as_proto); 3213| 7.57k| if (error_type == NO_PARSING_ERROR) { ------------------ | Branch (3213:9): [True: 27, False: 7.55k] ------------------ 3214| 27| return IsNumberMatchWithOneString(second_number_as_proto, first_number); 3215| 27| } 3216| 7.55k| if (error_type == INVALID_COUNTRY_CODE_ERROR) { ------------------ | Branch (3216:9): [True: 302, False: 7.25k] ------------------ 3217| 302| error_type = ParseHelper(first_number, RegionCode::GetUnknown(), false, 3218| 302| false, &first_number_as_proto); 3219| 302| if (error_type == NO_PARSING_ERROR) { ------------------ | Branch (3219:11): [True: 240, False: 62] ------------------ 3220| 240| error_type = ParseHelper(second_number, RegionCode::GetUnknown(), false, 3221| 240| false, &second_number_as_proto); 3222| 240| if (error_type == NO_PARSING_ERROR) { ------------------ | Branch (3222:13): [True: 197, False: 43] ------------------ 3223| 197| return IsNumberMatch(first_number_as_proto, second_number_as_proto); 3224| 197| } 3225| 240| } 3226| 302| } 3227| 7.55k| } 3228| | // One or more of the phone numbers we are trying to match is not a viable 3229| | // phone number. 3230| 9.08k| return INVALID_NUMBER; 3231| 9.30k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil26IsNumberMatchWithOneStringERKNS0_11PhoneNumberERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEE: 3235| 10.0k| const string& second_number) const { 3236| | // First see if the second number has an implicit country calling code, by 3237| | // attempting to parse it. 3238| 10.0k| PhoneNumber second_number_as_proto; 3239| 10.0k| ErrorType error_type = 3240| 10.0k| Parse(second_number, RegionCode::GetUnknown(), &second_number_as_proto); 3241| 10.0k| if (error_type == NO_PARSING_ERROR) { ------------------ | Branch (3241:7): [True: 40, False: 9.97k] ------------------ 3242| 40| return IsNumberMatch(first_number, second_number_as_proto); 3243| 40| } 3244| 9.97k| if (error_type == INVALID_COUNTRY_CODE_ERROR) { ------------------ | Branch (3244:7): [True: 524, False: 9.45k] ------------------ 3245| | // The second number has no country calling code. EXACT_MATCH is no longer 3246| | // possible. We parse it as if the region was the same as that for the 3247| | // first number, and if EXACT_MATCH is returned, we replace this with 3248| | // NSN_MATCH. 3249| 524| string first_number_region; 3250| 524| GetRegionCodeForCountryCode(first_number.country_code(), 3251| 524| &first_number_region); 3252| 524| if (first_number_region != RegionCode::GetUnknown()) { ------------------ | Branch (3252:9): [True: 349, False: 175] ------------------ 3253| 349| PhoneNumber second_number_with_first_number_region; 3254| 349| Parse(second_number, first_number_region, 3255| 349| &second_number_with_first_number_region); 3256| 349| MatchType match = IsNumberMatch(first_number, 3257| 349| second_number_with_first_number_region); 3258| 349| if (match == EXACT_MATCH) { ------------------ | Branch (3258:11): [True: 28, False: 321] ------------------ 3259| 28| return NSN_MATCH; 3260| 28| } 3261| 321| return match; 3262| 349| } else { 3263| | // If the first number didn't have a valid country calling code, then we 3264| | // parse the second number without one as well. 3265| 175| error_type = ParseHelper(second_number, RegionCode::GetUnknown(), false, 3266| 175| false, &second_number_as_proto); 3267| 175| if (error_type == NO_PARSING_ERROR) { ------------------ | Branch (3267:11): [True: 126, False: 49] ------------------ 3268| 126| return IsNumberMatch(first_number, second_number_as_proto); 3269| 126| } 3270| 175| } 3271| 524| } 3272| | // One or more of the phone numbers we are trying to match is not a viable 3273| | // phone number. 3274| 9.50k| return INVALID_NUMBER; 3275| 9.97k|} _ZNK4i18n12phonenumbers15PhoneNumberUtil27CanBeInternationallyDialledERKNS0_11PhoneNumberE: 3283| 9.93k| const PhoneNumber& number) const { 3284| 9.93k| string region_code; 3285| 9.93k| GetRegionCodeForNumber(number, ®ion_code); 3286| 9.93k| const PhoneMetadata* metadata = GetMetadataForRegion(region_code); 3287| 9.93k| if (!metadata) { ------------------ | Branch (3287:7): [True: 4.61k, False: 5.32k] ------------------ 3288| | // Note numbers belonging to non-geographical entities (e.g. +800 numbers) 3289| | // are always internationally diallable, and will be caught here. 3290| 4.61k| return true; 3291| 4.61k| } 3292| 5.32k| string national_significant_number; 3293| 5.32k| GetNationalSignificantNumber(number, &national_significant_number); 3294| 5.32k| return !IsNumberMatchingDesc( 3295| 5.32k| national_significant_number, metadata->no_international_dialling()); 3296| 9.93k|} _ZN4i18n12phonenumbers29PhoneNumberRegExpsAndMappingsC2Ev: 782| 1| : valid_phone_number_( 783| 1| StrCat(kDigits, "{", PhoneNumberUtil::kMinLengthForNsn, "}|[", 784| 1| PhoneNumberUtil::kPlusChars, "]*(?:[", 785| 1| PhoneNumberUtil::kValidPunctuation, kStarSign, "]*", 786| 1| kDigits, "){3,}[", PhoneNumberUtil::kValidPunctuation, 787| 1| kStarSign, kValidAlpha, kDigits, "]*")), 788| 1| extn_patterns_for_parsing_(CreateExtnPattern(/* for_parsing= */ true)), 789| 1| rfc3966_phone_digit_( 790| 1| StrCat("(", kDigits, "|", kRfc3966VisualSeparator, ")")), 791| 1| alphanum_(StrCat(kValidAlphaInclUppercase, kDigits)), 792| 1| rfc3966_domainlabel_( 793| 1| StrCat("[", alphanum_, "]+((\\-)*[", alphanum_, "])*")), 794| 1| rfc3966_toplabel_(StrCat("[", kValidAlphaInclUppercase, 795| 1| "]+((\\-)*[", alphanum_, "])*")), 796| 1| regexp_factory_(new RegExpFactory()), 797| 1| regexp_cache_(new RegExpCache(*regexp_factory_.get(), 128)), 798| 1| diallable_char_mappings_(), 799| 1| alpha_mappings_(), 800| 1| alpha_phone_mappings_(), 801| 1| all_plus_number_grouping_symbols_(), 802| 1| mobile_token_mappings_(), 803| 1| countries_without_national_prefix_with_area_codes_(), 804| 1| geo_mobile_countries_without_mobile_area_codes_(), 805| 1| geo_mobile_countries_(), 806| 1| single_international_prefix_(regexp_factory_->CreateRegExp( 807| | /* "[\\d]+(?:[~⁓∼～][\\d]+)?" */ 808| 1| "[\\d]+(?:[~\xE2\x81\x93\xE2\x88\xBC\xEF\xBD\x9E][\\d]+)?")), 809| 1| digits_pattern_( 810| 1| regexp_factory_->CreateRegExp(StrCat("[", kDigits, "]*"))), 811| 1| capturing_digit_pattern_( 812| 1| regexp_factory_->CreateRegExp(StrCat("([", kDigits, "])"))), 813| 1| capturing_ascii_digits_pattern_( 814| 1| regexp_factory_->CreateRegExp("(\\d+)")), 815| 1| valid_start_char_pattern_(regexp_factory_->CreateRegExp( 816| 1| StrCat("[", PhoneNumberUtil::kPlusChars, kDigits, "]"))), 817| 1| capture_up_to_second_number_start_pattern_( 818| 1| regexp_factory_->CreateRegExp( 819| 1| PhoneNumberUtil::kCaptureUpToSecondNumberStart)), 820| 1| unwanted_end_char_pattern_( 821| 1| regexp_factory_->CreateRegExp("[^\\p{N}\\p{L}#]")), 822| 1| separator_pattern_(regexp_factory_->CreateRegExp( 823| 1| StrCat("[", PhoneNumberUtil::kValidPunctuation, "]+"))), 824| 1| extn_patterns_for_matching_( 825| 1| CreateExtnPattern(/* for_parsing= */ false)), 826| 1| extn_pattern_(regexp_factory_->CreateRegExp( 827| 1| StrCat("(?i)(?:", extn_patterns_for_parsing_, ")$"))), 828| 1| valid_phone_number_pattern_(regexp_factory_->CreateRegExp( 829| 1| StrCat("(?i)", valid_phone_number_, 830| 1| "(?:", extn_patterns_for_parsing_, ")?"))), 831| 1| valid_alpha_phone_pattern_(regexp_factory_->CreateRegExp( 832| 1| StrCat("(?i)(?:.*?[", kValidAlpha, "]){3}"))), 833| | // The first_group_capturing_pattern was originally set to $1 but there 834| | // are some countries for which the first group is not used in the 835| | // national pattern (e.g. Argentina) so the $1 group does not match 836| | // correctly. Therefore, we use \d, so that the first group actually 837| | // used in the pattern will be matched. 838| 1| first_group_capturing_pattern_( 839| 1| regexp_factory_->CreateRegExp("(\\$\\d)")), 840| 1| carrier_code_pattern_(regexp_factory_->CreateRegExp("\\$CC")), 841| 1| plus_chars_pattern_(regexp_factory_->CreateRegExp( 842| 1| StrCat("[", PhoneNumberUtil::kPlusChars, "]+"))), 843| 1| rfc3966_global_number_digits_pattern_(regexp_factory_->CreateRegExp( 844| 1| StrCat("^\\", kPlusSign, rfc3966_phone_digit_, "*", kDigits, 845| 1| rfc3966_phone_digit_, "*$"))), 846| 1| rfc3966_domainname_pattern_(regexp_factory_->CreateRegExp(StrCat( 847| 1| "^(", rfc3966_domainlabel_, "\\.)*", rfc3966_toplabel_, "\\.?$"))) { 848| 1| InitializeMapsAndSets(); 849| 1| } phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_117CreateExtnPatternEb: 220| 2|std::string CreateExtnPattern(bool for_parsing) { 221| | // We cap the maximum length of an extension based on the ambiguity of the 222| | // way the extension is prefixed. As per ITU, the officially allowed 223| | // length for extensions is actually 40, but we don't support this since we 224| | // haven't seen real examples and this introduces many false interpretations 225| | // as the extension labels are not standardized. 226| 2| int ext_limit_after_explicit_label = 20; 227| 2| int ext_limit_after_likely_label = 15; 228| 2| int ext_limit_after_ambiguous_char = 9; 229| 2| int ext_limit_when_not_sure = 6; 230| | 231| | // Canonical-equivalence doesn't seem to be an option with RE2, so we allow 232| | // two options for representing any non-ASCII character like ó - the character 233| | // itself, and one in the unicode decomposed form with the combining acute 234| | // accent. 235| | 236| | // Here the extension is called out in a more explicit way, i.e mentioning it 237| | // obvious patterns like "ext.". 238| 2| string explicit_ext_labels = 239| 2| "(?:e?xt(?:ensi(?:o\xCC\x81?|\xC3\xB3))?n?|(?:\xEF\xBD\x85)?" 240| 2| "\xEF\xBD\x98\xEF\xBD\x94(?:\xEF\xBD\x8E)?|\xD0\xB4\xD0\xBE\xD0\xB1|" 241| 2| "anexo)"; 242| | // One-character symbols that can be used to indicate an extension, and less 243| | // commonly used or more ambiguous extension labels. 244| 2| string ambiguous_ext_labels = 245| 2| "(?:[x\xEF\xBD\x98#\xEF\xBC\x83~\xEF\xBD\x9E]|int|" 246| 2| "\xEF\xBD\x89\xEF\xBD\x8E\xEF\xBD\x94)"; 247| | // When extension is not separated clearly. 248| 2| string ambiguous_separator = "[- ]+"; 249| | 250| 2| string rfc_extn = StrCat(kRfc3966ExtnPrefix, 251| 2| ExtnDigits(ext_limit_after_explicit_label)); 252| 2| string explicit_extn = StrCat( 253| 2| kPossibleSeparatorsBetweenNumberAndExtLabel, 254| 2| explicit_ext_labels, kPossibleCharsAfterExtLabel, 255| 2| ExtnDigits(ext_limit_after_explicit_label), 256| 2| kOptionalExtSuffix); 257| 2| string ambiguous_extn = StrCat( 258| 2| kPossibleSeparatorsBetweenNumberAndExtLabel, 259| 2| ambiguous_ext_labels, kPossibleCharsAfterExtLabel, 260| 2| ExtnDigits(ext_limit_after_ambiguous_char), 261| 2| kOptionalExtSuffix); 262| 2| string american_style_extn_with_suffix = StrCat( 263| 2| ambiguous_separator, ExtnDigits(ext_limit_when_not_sure), "#"); 264| | 265| | // The first regular expression covers RFC 3966 format, where the extension is 266| | // added using ";ext=". The second more generic where extension is mentioned 267| | // with explicit labels like "ext:". In both the above cases we allow more 268| | // numbers in extension than any other extension labels. The third one 269| | // captures when single character extension labels or less commonly used 270| | // labels are present. In such cases we capture fewer extension digits in 271| | // order to reduce the chance of falsely interpreting two numbers beside each 272| | // other as a number + extension. The fourth one covers the special case of 273| | // American numbers where the extension is written with a hash at the end, 274| | // such as "- 503#". 275| 2| string extension_pattern = StrCat( 276| 2| rfc_extn, "|", 277| 2| explicit_extn, "|", 278| 2| ambiguous_extn, "|", 279| 2| american_style_extn_with_suffix); 280| | // Additional pattern that is supported when parsing extensions, not when 281| | // matching. 282| 2| if (for_parsing) { ------------------ | Branch (282:7): [True: 1, False: 1] ------------------ 283| | // ",," is commonly used for auto dialling the extension when connected. 284| | // Semi-colon works in Iphone and also in Android to pop up a button with 285| | // the extension number following. 286| 1| string auto_dialling_and_ext_labels_found = "(?:,{2}|;)"; 287| | // This is same as kPossibleSeparatorsBetweenNumberAndExtLabel, but not 288| | // matching comma as extension label may have it. 289| 1| string possible_separators_number_extLabel_no_comma = "[ \xC2\xA0\\t]*"; 290| | 291| 1| string auto_dialling_extn = StrCat( 292| 1| possible_separators_number_extLabel_no_comma, 293| 1| auto_dialling_and_ext_labels_found, kPossibleCharsAfterExtLabel, 294| 1| ExtnDigits(ext_limit_after_likely_label), 295| 1| kOptionalExtSuffix); 296| 1| string only_commas_extn = StrCat( 297| 1| possible_separators_number_extLabel_no_comma, 298| 1| "(?:,)+", kPossibleCharsAfterExtLabel, 299| 1| ExtnDigits(ext_limit_after_ambiguous_char), 300| 1| kOptionalExtSuffix); 301| | // Here the first pattern is exclusive for extension autodialling formats 302| | // which are used when dialling and in this case we accept longer 303| | // extensions. However, the second pattern is more liberal on number of 304| | // commas that acts as extension labels, so we have strict cap on number of 305| | // digits in such extensions. 306| 1| return StrCat(extension_pattern, "|", 307| 1| auto_dialling_extn, "|", 308| 1| only_commas_extn); 309| 1| } 310| 1| return extension_pattern; 311| 2|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_110ExtnDigitsEi: 210| 10|std::string ExtnDigits(int max_length) { 211| 10| return StrCat("([", kDigits, "]{1,", max_length, "})"); 212| 10|} _ZN4i18n12phonenumbers29PhoneNumberRegExpsAndMappings21InitializeMapsAndSetsEv: 521| 1| void InitializeMapsAndSets() { 522| 1| diallable_char_mappings_.insert(std::make_pair('+', '+')); 523| 1| diallable_char_mappings_.insert(std::make_pair('*', '*')); 524| 1| diallable_char_mappings_.insert(std::make_pair('#', '#')); 525| | // Here we insert all punctuation symbols that we wish to respect when 526| | // formatting alpha numbers, as they show the intended number groupings. 527| 1| all_plus_number_grouping_symbols_.insert( 528| 1| std::make_pair(ToUnicodeCodepoint("-"), '-')); 529| 1| all_plus_number_grouping_symbols_.insert( 530| 1| std::make_pair(ToUnicodeCodepoint("\xEF\xBC\x8D" /* "－" */), '-')); 531| 1| all_plus_number_grouping_symbols_.insert( 532| 1| std::make_pair(ToUnicodeCodepoint("\xE2\x80\x90" /* "‐" */), '-')); 533| 1| all_plus_number_grouping_symbols_.insert( 534| 1| std::make_pair(ToUnicodeCodepoint("\xE2\x80\x91" /* "‑" */), '-')); 535| 1| all_plus_number_grouping_symbols_.insert( 536| 1| std::make_pair(ToUnicodeCodepoint("\xE2\x80\x92" /* "‒" */), '-')); 537| 1| all_plus_number_grouping_symbols_.insert( 538| 1| std::make_pair(ToUnicodeCodepoint("\xE2\x80\x93" /* "–" */), '-')); 539| 1| all_plus_number_grouping_symbols_.insert( 540| 1| std::make_pair(ToUnicodeCodepoint("\xE2\x80\x94" /* "—" */), '-')); 541| 1| all_plus_number_grouping_symbols_.insert( 542| 1| std::make_pair(ToUnicodeCodepoint("\xE2\x80\x95" /* "―" */), '-')); 543| 1| all_plus_number_grouping_symbols_.insert( 544| 1| std::make_pair(ToUnicodeCodepoint("\xE2\x88\x92" /* "−" */), '-')); 545| 1| all_plus_number_grouping_symbols_.insert( 546| 1| std::make_pair(ToUnicodeCodepoint("/"), '/')); 547| 1| all_plus_number_grouping_symbols_.insert( 548| 1| std::make_pair(ToUnicodeCodepoint("\xEF\xBC\x8F" /* "／" */), '/')); 549| 1| all_plus_number_grouping_symbols_.insert( 550| 1| std::make_pair(ToUnicodeCodepoint(" "), ' ')); 551| 1| all_plus_number_grouping_symbols_.insert( 552| 1| std::make_pair(ToUnicodeCodepoint("\xE3\x80\x80" /* "　" */), ' ')); 553| 1| all_plus_number_grouping_symbols_.insert( 554| 1| std::make_pair(ToUnicodeCodepoint("\xE2\x81\xA0"), ' ')); 555| 1| all_plus_number_grouping_symbols_.insert( 556| 1| std::make_pair(ToUnicodeCodepoint("."), '.')); 557| 1| all_plus_number_grouping_symbols_.insert( 558| 1| std::make_pair(ToUnicodeCodepoint("\xEF\xBC\x8E" /* "．" */), '.')); 559| | // Only the upper-case letters are added here - the lower-case versions are 560| | // added programmatically. 561| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("A"), '2')); 562| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("B"), '2')); 563| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("C"), '2')); 564| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("D"), '3')); 565| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("E"), '3')); 566| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("F"), '3')); 567| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("G"), '4')); 568| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("H"), '4')); 569| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("I"), '4')); 570| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("J"), '5')); 571| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("K"), '5')); 572| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("L"), '5')); 573| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("M"), '6')); 574| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("N"), '6')); 575| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("O"), '6')); 576| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("P"), '7')); 577| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("Q"), '7')); 578| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("R"), '7')); 579| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("S"), '7')); 580| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("T"), '8')); 581| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("U"), '8')); 582| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("V"), '8')); 583| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("W"), '9')); 584| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("X"), '9')); 585| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("Y"), '9')); 586| 1| alpha_mappings_.insert(std::make_pair(ToUnicodeCodepoint("Z"), '9')); 587| 1| std::map lower_case_mappings; 588| 1| std::map alpha_letters; 589| 1| for (std::map::const_iterator it = alpha_mappings_.begin(); 590| 27| it != alpha_mappings_.end(); ------------------ | Branch (590:10): [True: 26, False: 1] ------------------ 591| 26| ++it) { 592| | // Convert all the upper-case ASCII letters to lower-case. 593| 26| if (it->first < 128) { ------------------ | Branch (593:11): [True: 26, False: 0] ------------------ 594| 26| char letter_as_upper = static_cast(it->first); 595| 26| char32 letter_as_lower = static_cast(tolower(letter_as_upper)); 596| 26| lower_case_mappings.insert(std::make_pair(letter_as_lower, it->second)); 597| | // Add the letters in both variants to the alpha_letters map. This just 598| | // pairs each letter with its upper-case representation so that it can 599| | // be retained when normalising alpha numbers. 600| 26| alpha_letters.insert(std::make_pair(letter_as_lower, letter_as_upper)); 601| 26| alpha_letters.insert(std::make_pair(it->first, letter_as_upper)); 602| 26| } 603| 26| } 604| | // In the Java version we don't insert the lower-case mappings in the map, 605| | // because we convert to upper case on the fly. Doing this here would 606| | // involve pulling in all of ICU, which we don't want to do if we don't have 607| | // to. 608| 1| alpha_mappings_.insert(lower_case_mappings.begin(), 609| 1| lower_case_mappings.end()); 610| 1| alpha_phone_mappings_.insert(alpha_mappings_.begin(), 611| 1| alpha_mappings_.end()); 612| 1| all_plus_number_grouping_symbols_.insert(alpha_letters.begin(), 613| 1| alpha_letters.end()); 614| | // Add the ASCII digits so that they don't get deleted by NormalizeHelper(). 615| 11| for (char c = '0'; c <= '9'; ++c) { ------------------ | Branch (615:24): [True: 10, False: 1] ------------------ 616| 10| diallable_char_mappings_.insert(std::make_pair(c, c)); 617| 10| alpha_phone_mappings_.insert(std::make_pair(c, c)); 618| 10| all_plus_number_grouping_symbols_.insert(std::make_pair(c, c)); 619| 10| } 620| | 621| 1| mobile_token_mappings_.insert(std::make_pair(54, '9')); 622| 1| countries_without_national_prefix_with_area_codes_.insert(52); // Mexico 623| 1| geo_mobile_countries_without_mobile_area_codes_.insert(86); // China 624| 1| geo_mobile_countries_.insert(52); // Mexico 625| 1| geo_mobile_countries_.insert(54); // Argentina 626| 1| geo_mobile_countries_.insert(55); // Brazil 627| | // Indonesia: some prefixes only (fixed CMDA wireless) 628| 1| geo_mobile_countries_.insert(62); 629| 1| geo_mobile_countries_.insert( 630| 1| geo_mobile_countries_without_mobile_area_codes_.begin(), 631| 1| geo_mobile_countries_without_mobile_area_codes_.end()); 632| 1| } phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_118ToUnicodeCodepointEPKc: 202| 42|char32 ToUnicodeCodepoint(const char* unicode_char) { 203| 42| char32 codepoint; 204| 42| EncodingUtils::DecodeUTF8Char(unicode_char, &codepoint); 205| 42| return codepoint; 206| 42|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_122LoadCompiledInMetadataEPNS0_23PhoneMetadataCollectionE: 124| 1|bool LoadCompiledInMetadata(PhoneMetadataCollection* metadata) { 125| 1| if (!metadata->ParseFromArray(metadata_get(), metadata_size())) { ------------------ | Branch (125:7): [True: 0, False: 1] ------------------ 126| 0| LOG(ERROR) << "Could not parse binary data."; 127| 0| return false; 128| 0| } 129| 1| return true; 130| 1|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_125DescHasPossibleNumberDataERKNS0_15PhoneNumberDescE: 356| 575|bool DescHasPossibleNumberData(const PhoneNumberDesc& desc) { 357| | // If this is empty, it means numbers of this type inherit from the "general 358| | // desc" -> the value "-1" means that no numbers exist for this type. 359| 575| return desc.possible_length_size() != 1 || desc.possible_length(0) != -1; ------------------ | Branch (359:10): [True: 350, False: 225] | Branch (359:46): [True: 224, False: 1] ------------------ 360| 575|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_134PrefixNumberWithCountryCallingCodeEiNS0_15PhoneNumberUtil17PhoneNumberFormatEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 168| 54.2k| string* formatted_number) { 169| 54.2k| switch (number_format) { 170| 10.0k| case PhoneNumberUtil::E164: ------------------ | Branch (170:5): [True: 10.0k, False: 44.2k] ------------------ 171| 10.0k| formatted_number->insert(0, StrCat(kPlusSign, country_calling_code)); 172| 10.0k| return; 173| 10.2k| case PhoneNumberUtil::INTERNATIONAL: ------------------ | Branch (173:5): [True: 10.2k, False: 44.0k] ------------------ 174| 10.2k| formatted_number->insert(0, StrCat(kPlusSign, country_calling_code, " ")); 175| 10.2k| return; 176| 2.88k| case PhoneNumberUtil::RFC3966: ------------------ | Branch (176:5): [True: 2.88k, False: 51.3k] ------------------ 177| 2.88k| formatted_number->insert(0, StrCat(kRfc3966Prefix, kPlusSign, 178| 2.88k| country_calling_code, "-")); 179| 2.88k| return; 180| 31.1k| case PhoneNumberUtil::NATIONAL: ------------------ | Branch (180:5): [True: 31.1k, False: 23.1k] ------------------ 181| 31.1k| default: ------------------ | Branch (181:5): [True: 0, False: 54.2k] ------------------ 182| | // Do nothing. 183| 31.1k| return; 184| 54.2k| } 185| 54.2k|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_116TestNumberLengthERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_13PhoneMetadataE: 482| 49.8k| const string& number, const PhoneMetadata& metadata) { 483| 49.8k| return TestNumberLength(number, metadata, PhoneNumberUtil::UNKNOWN); 484| 49.8k|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_115NormalizeHelperERKNSt3__13mapIicNS2_4lessIiEENS2_9allocatorINS2_4pairIKicEEEEEEbPNS2_12basic_stringIcNS2_11char_traitsIcEENS6_IcEEEE: 326| 30.2k| string* number) { 327| 30.2k| DCHECK(number); ------------------ | | 29| 30.2k|#define DCHECK(X) assert(X) ------------------ 328| 30.2k| UnicodeText number_as_unicode; 329| 30.2k| number_as_unicode.PointToUTF8(number->data(), static_cast(number->size())); 330| 30.2k| if (!number_as_unicode.UTF8WasValid()) { ------------------ | Branch (330:7): [True: 978, False: 29.3k] ------------------ 331| | // The input wasn't valid UTF-8. Produce an empty string to indicate an error. 332| 978| number->clear(); 333| 978| return; 334| 978| } 335| 29.3k| string normalized_number; 336| 29.3k| char unicode_char[5]; 337| 29.3k| for (UnicodeText::const_iterator it = number_as_unicode.begin(); 338| 96.8k| it != number_as_unicode.end(); ------------------ | Branch (338:8): [True: 67.5k, False: 29.3k] ------------------ 339| 67.5k| ++it) { 340| 67.5k| std::map::const_iterator found_glyph_pair = 341| 67.5k| normalization_replacements.find(*it); 342| 67.5k| if (found_glyph_pair != normalization_replacements.end()) { ------------------ | Branch (342:9): [True: 60.1k, False: 7.40k] ------------------ 343| 60.1k| normalized_number.push_back(found_glyph_pair->second); 344| 60.1k| } else if (!remove_non_matches) { ------------------ | Branch (344:16): [True: 646, False: 6.76k] ------------------ 345| | // Find out how long this unicode char is so we can append it all. 346| 646| int char_len = it.get_utf8(unicode_char); 347| 646| normalized_number.append(unicode_char, char_len); 348| 646| } 349| | // If neither of the above are true, we remove this character. 350| 67.5k| } 351| 29.3k| number->assign(normalized_number); 352| 29.3k|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_119GetNumberDescByTypeERKNS0_13PhoneMetadataENS0_15PhoneNumberUtil15PhoneNumberTypeE: 136| 234k| PhoneNumberUtil::PhoneNumberType type) { 137| 234k| switch (type) { 138| 1.55k| case PhoneNumberUtil::PREMIUM_RATE: ------------------ | Branch (138:5): [True: 1.55k, False: 233k] ------------------ 139| 1.55k| return &metadata.premium_rate(); 140| 3.31k| case PhoneNumberUtil::TOLL_FREE: ------------------ | Branch (140:5): [True: 3.31k, False: 231k] ------------------ 141| 3.31k| return &metadata.toll_free(); 142| 1.44k| case PhoneNumberUtil::MOBILE: ------------------ | Branch (142:5): [True: 1.44k, False: 233k] ------------------ 143| 1.44k| return &metadata.mobile(); 144| 19.2k| case PhoneNumberUtil::FIXED_LINE: ------------------ | Branch (144:5): [True: 19.2k, False: 215k] ------------------ 145| 20.1k| case PhoneNumberUtil::FIXED_LINE_OR_MOBILE: ------------------ | Branch (145:5): [True: 865, False: 234k] ------------------ 146| 20.1k| return &metadata.fixed_line(); 147| 2.03k| case PhoneNumberUtil::SHARED_COST: ------------------ | Branch (147:5): [True: 2.03k, False: 232k] ------------------ 148| 2.03k| return &metadata.shared_cost(); 149| 1.96k| case PhoneNumberUtil::VOIP: ------------------ | Branch (149:5): [True: 1.96k, False: 232k] ------------------ 150| 1.96k| return &metadata.voip(); 151| 2.24k| case PhoneNumberUtil::PERSONAL_NUMBER: ------------------ | Branch (151:5): [True: 2.24k, False: 232k] ------------------ 152| 2.24k| return &metadata.personal_number(); 153| 4.32k| case PhoneNumberUtil::PAGER: ------------------ | Branch (153:5): [True: 4.32k, False: 230k] ------------------ 154| 4.32k| return &metadata.pager(); 155| 1.18k| case PhoneNumberUtil::UAN: ------------------ | Branch (155:5): [True: 1.18k, False: 233k] ------------------ 156| 1.18k| return &metadata.uan(); 157| 16.5k| case PhoneNumberUtil::VOICEMAIL: ------------------ | Branch (157:5): [True: 16.5k, False: 218k] ------------------ 158| 16.5k| return &metadata.voicemail(); 159| 180k| default: ------------------ | Branch (159:5): [True: 180k, False: 54.7k] ------------------ 160| 180k| return &metadata.general_desc(); 161| 234k| } 162| 234k|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_116TestNumberLengthERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_13PhoneMetadataENS0_15PhoneNumberUtil15PhoneNumberTypeE: 404| 73.5k| PhoneNumberUtil::PhoneNumberType type) { 405| 73.5k| const PhoneNumberDesc* desc_for_type = GetNumberDescByType(metadata, type); 406| | // There should always be "possibleLengths" set for every element. This is 407| | // declared in the XML schema which is verified by 408| | // PhoneNumberMetadataSchemaTest. For size efficiency, where a 409| | // sub-description (e.g. fixed-line) has the same possibleLengths as the 410| | // parent, this is missing, so we fall back to the general desc (where no 411| | // numbers of the type exist at all, there is one possible length (-1) which 412| | // is guaranteed not to match the length of any real phone number). 413| 73.5k| RepeatedField possible_lengths = 414| 73.5k| desc_for_type->possible_length_size() == 0 ------------------ | Branch (414:7): [True: 1.45k, False: 72.0k] ------------------ 415| 73.5k| ? metadata.general_desc().possible_length() 416| 73.5k| : desc_for_type->possible_length(); 417| 73.5k| RepeatedField local_lengths = 418| 73.5k| desc_for_type->possible_length_local_only(); 419| 73.5k| if (type == PhoneNumberUtil::FIXED_LINE_OR_MOBILE) { ------------------ | Branch (419:7): [True: 288, False: 73.2k] ------------------ 420| 288| const PhoneNumberDesc* fixed_line_desc = 421| 288| GetNumberDescByType(metadata, PhoneNumberUtil::FIXED_LINE); 422| 288| if (!DescHasPossibleNumberData(*fixed_line_desc)) { ------------------ | Branch (422:9): [True: 1, False: 287] ------------------ 423| | // The rare case has been encountered where no fixedLine data is available 424| | // (true for some non-geographical entities), so we just check mobile. 425| 1| return TestNumberLength(number, metadata, PhoneNumberUtil::MOBILE); 426| 287| } else { 427| 287| const PhoneNumberDesc* mobile_desc = 428| 287| GetNumberDescByType(metadata, PhoneNumberUtil::MOBILE); 429| 287| if (DescHasPossibleNumberData(*mobile_desc)) { ------------------ | Branch (429:11): [True: 287, False: 0] ------------------ 430| | // Merge the mobile data in if there was any. Note that when adding the 431| | // possible lengths from mobile, we have to again check they aren't 432| | // empty since if they are this indicates they are the same as the 433| | // general desc and should be obtained from there. 434| 287| possible_lengths.MergeFrom( 435| 287| mobile_desc->possible_length_size() == 0 ------------------ | Branch (435:13): [True: 51, False: 236] ------------------ 436| 287| ? metadata.general_desc().possible_length() 437| 287| : mobile_desc->possible_length()); 438| 287| std::sort(possible_lengths.begin(), possible_lengths.end()); 439| | 440| 287| if (local_lengths.size() == 0) { ------------------ | Branch (440:13): [True: 114, False: 173] ------------------ 441| 114| local_lengths = mobile_desc->possible_length_local_only(); 442| 173| } else { 443| 173| local_lengths.MergeFrom(mobile_desc->possible_length_local_only()); 444| 173| std::sort(local_lengths.begin(), local_lengths.end()); 445| 173| } 446| 287| } 447| 287| } 448| 288| } 449| | 450| | // If the type is not suported at all (indicated by the possible lengths 451| | // containing -1 at this point) we return invalid length. 452| 73.5k| if (possible_lengths.Get(0) == -1) { ------------------ | Branch (452:7): [True: 1.56k, False: 71.9k] ------------------ 453| 1.56k| return PhoneNumberUtil::INVALID_LENGTH; 454| 1.56k| } 455| | 456| 71.9k| int actual_length = static_cast(number.length()); 457| | // This is safe because there is never an overlap beween the possible lengths 458| | // and the local-only lengths; this is checked at build time. 459| 71.9k| if (std::find(local_lengths.begin(), local_lengths.end(), actual_length) != ------------------ | Branch (459:7): [True: 3.12k, False: 68.8k] ------------------ 460| 71.9k| local_lengths.end()) { 461| 3.12k| return PhoneNumberUtil::IS_POSSIBLE_LOCAL_ONLY; 462| 3.12k| } 463| 68.8k| int minimum_length = possible_lengths.Get(0); 464| 68.8k| if (minimum_length == actual_length) { ------------------ | Branch (464:7): [True: 15.0k, False: 53.7k] ------------------ 465| 15.0k| return PhoneNumberUtil::IS_POSSIBLE; 466| 53.7k| } else if (minimum_length > actual_length) { ------------------ | Branch (466:14): [True: 32.6k, False: 21.1k] ------------------ 467| 32.6k| return PhoneNumberUtil::TOO_SHORT; 468| 32.6k| } else if (*(possible_lengths.end() - 1) < actual_length) { ------------------ | Branch (468:14): [True: 2.07k, False: 19.0k] ------------------ 469| 2.07k| return PhoneNumberUtil::TOO_LONG; 470| 2.07k| } 471| | // We skip the first element; we've already checked it. 472| 19.0k| return std::find(possible_lengths.begin() + 1, possible_lengths.end(), ------------------ | Branch (472:10): [True: 18.7k, False: 242] ------------------ 473| 19.0k| actual_length) != possible_lengths.end() 474| 19.0k| ? PhoneNumberUtil::IS_POSSIBLE 475| 19.0k| : PhoneNumberUtil::INVALID_LENGTH; 476| 68.8k|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_17IsMatchERKNS0_10MatcherApiERKNSt3__112basic_stringIcNS5_11char_traitsIcEENS5_9allocatorIcEEEERKNS0_15PhoneNumberDescE: 508| 152k| const string& number, const PhoneNumberDesc& desc) { 509| 152k| return matcher_api.MatchNationalNumber(number, desc, false); 510| 152k|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_118CopyCoreFieldsOnlyERKNS0_11PhoneNumberEPS2_: 491| 20.7k|void CopyCoreFieldsOnly(const PhoneNumber& number, PhoneNumber* pruned_number) { 492| 20.7k| pruned_number->set_country_code(number.country_code()); 493| 20.7k| pruned_number->set_national_number(number.national_number()); 494| 20.7k| if (!number.extension().empty()) { ------------------ | Branch (494:7): [True: 578, False: 20.1k] ------------------ 495| 578| pruned_number->set_extension(number.extension()); 496| 578| } 497| 20.7k| if (number.italian_leading_zero()) { ------------------ | Branch (497:7): [True: 1.41k, False: 19.3k] ------------------ 498| 1.41k| pruned_number->set_italian_leading_zero(true); 499| | // This field is only relevant if there are leading zeros at all. 500| 1.41k| pruned_number->set_number_of_leading_zeros( 501| 1.41k| number.number_of_leading_zeros()); 502| 1.41k| } 503| 20.7k|} phonenumberutil.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_132IsNationalNumberSuffixOfTheOtherERKNS0_11PhoneNumberES4_: 190| 8.07k| const PhoneNumber& second_number) { 191| 8.07k| const string& first_number_national_number = 192| 8.07k| SimpleItoa(static_cast(first_number.national_number())); 193| 8.07k| const string& second_number_national_number = 194| 8.07k| SimpleItoa(static_cast(second_number.national_number())); 195| | // Note that HasSuffixString returns true if the numbers are equal. 196| 8.07k| return HasSuffixString(first_number_national_number, ------------------ | Branch (196:10): [True: 822, False: 7.24k] ------------------ 197| 8.07k| second_number_national_number) || 198| 8.07k| HasSuffixString(second_number_national_number, ------------------ | Branch (198:10): [True: 39, False: 7.20k] ------------------ 199| 7.24k| first_number_national_number); 200| 8.07k|} _ZN4i18n12phonenumbers17RegexBasedMatcherC2Ev: 33| 1| : regexp_factory_(new RegExpFactory()), 34| 1| regexp_cache_(new RegExpCache(*regexp_factory_, 128)) {} _ZNK4i18n12phonenumbers17RegexBasedMatcher19MatchNationalNumberERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKNS0_15PhoneNumberDescEb: 41| 152k| bool allow_prefix_match) const { 42| 152k| const string& national_number_pattern = number_desc.national_number_pattern(); 43| | // We don't want to consider it a prefix match when matching non-empty input 44| | // against an empty pattern. 45| 152k| if (national_number_pattern.empty()) { ------------------ | Branch (45:7): [True: 0, False: 152k] ------------------ 46| 0| return false; 47| 0| } 48| 152k| return Match(number, national_number_pattern, allow_prefix_match); 49| 152k|} _ZNK4i18n12phonenumbers17RegexBasedMatcher5MatchERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEESA_b: 54| 152k| bool allow_prefix_match) const { 55| 152k| const RegExp& regexp(regexp_cache_->GetRegExp(number_pattern)); 56| | 57| 152k| if (regexp.FullMatch(number)) { ------------------ | Branch (57:7): [True: 57.8k, False: 94.6k] ------------------ 58| 57.8k| return true; 59| 57.8k| } 60| 94.6k| const scoped_ptr normalized_number_input( 61| 94.6k| regexp_factory_->CreateInput(number)); 62| 94.6k| return regexp.Consume(normalized_number_input.get()) ------------------ | Branch (62:10): [True: 1.04k, False: 93.6k] ------------------ 63| 94.6k| ? allow_prefix_match 64| 94.6k| : false; 65| 152k|} _ZN4i18n12phonenumbers11RegExpInputD2Ev: 41| 1.40M| virtual ~RegExpInput() {} _ZNK4i18n12phonenumbers6RegExp7ConsumeEPNS0_11RegExpInputEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEESB_: 113| 6.95k| string* matched_string2) const { 114| 6.95k| return Consume(input_string, true, matched_string1, matched_string2, NULL, 115| 6.95k| NULL, NULL, NULL); 116| 6.95k| } _ZNK4i18n12phonenumbers6RegExp7ConsumeEPNS0_11RegExpInputEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 118| 35.7k| inline bool Consume(RegExpInput* input_string, string* matched_string) const { 119| 35.7k| return Consume(input_string, true, matched_string, NULL, NULL, NULL, NULL, 120| 35.7k| NULL); 121| 35.7k| } _ZNK4i18n12phonenumbers6RegExp7ConsumeEPNS0_11RegExpInputE: 123| 687k| inline bool Consume(RegExpInput* input_string) const { 124| 687k| return Consume(input_string, true, NULL, NULL, NULL, NULL, NULL, NULL); 125| 687k| } _ZNK4i18n12phonenumbers6RegExp14FindAndConsumeEPNS0_11RegExpInputEPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEE: 130| 27.6k| string* matched_string) const { 131| 27.6k| return Consume(input_string, false, matched_string, NULL, NULL, NULL, NULL, 132| 27.6k| NULL); 133| 27.6k| } _ZNK4i18n12phonenumbers6RegExp12PartialMatchERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPS8_: 147| 61.0k| string* matched_string) const { 148| 61.0k| return Match(input_string, false, matched_string); 149| 61.0k| } _ZNK4i18n12phonenumbers6RegExp12PartialMatchERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 151| 51.7k| inline bool PartialMatch(const string& input_string) const { 152| 51.7k| return Match(input_string, false, NULL); 153| 51.7k| } _ZNK4i18n12phonenumbers6RegExp9FullMatchERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 160| 429k| inline bool FullMatch(const string& input_string) const { 161| 429k| return Match(input_string, true, NULL); 162| 429k| } _ZNK4i18n12phonenumbers6RegExp7ReplaceEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKS8_: 176| 4.78k| const string& replacement_string) const { 177| 4.78k| return Replace(string_to_process, false, replacement_string); 178| 4.78k| } _ZNK4i18n12phonenumbers6RegExp13GlobalReplaceEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEERKS8_: 181| 68.9k| const string& replacement_string) const { 182| 68.9k| return Replace(string_to_process, true, replacement_string); 183| 68.9k| } _ZNK4i18n12phonenumbers16ICURegExpFactory11CreateInputERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 236| 786k|RegExpInput* ICURegExpFactory::CreateInput(const string& utf8_input) const { 237| 786k| return new IcuRegExpInput(utf8_input); 238| 786k|} _ZNK4i18n12phonenumbers16ICURegExpFactory12CreateRegExpERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 240| 6.31k|RegExp* ICURegExpFactory::CreateRegExp(const string& utf8_regexp) const { 241| 6.31k| return new IcuRegExp(utf8_regexp); 242| 6.31k|} _ZN4i18n12phonenumbers14IcuRegExpInputC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 69| 1.40M| : utf8_input_(Utf8StringToUnicodeString(utf8_input)), 70| 1.40M| position_(0) {} regexp_adapter_icu.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_125Utf8StringToUnicodeStringERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 54| 1.43M|UnicodeString Utf8StringToUnicodeString(const string& source) { 55| | // Note that we don't use icu::StringPiece(const string&). 56| 1.43M| return UnicodeString::fromUTF8( 57| 1.43M| icu::StringPiece(source.c_str(), static_cast(source.size()))); 58| 1.43M|} _ZN4i18n12phonenumbers14IcuRegExpInputD2Ev: 77| 1.40M| virtual ~IcuRegExpInput() {} _ZNK4i18n12phonenumbers14IcuRegExpInput8ToStringEv: 79| 6.51k| virtual string ToString() const { 80| 6.51k| return UnicodeStringToUtf8String(utf8_input_.tempSubString(position_)); 81| 6.51k| } regexp_adapter_icu.cc:_ZN4i18n12phonenumbers12_GLOBAL__N_125UnicodeStringToUtf8StringERKN6icu_6613UnicodeStringE: 47| 55.5k|string UnicodeStringToUtf8String(const UnicodeString& source) { 48| 55.5k| string data; 49| 55.5k| source.toUTF8String(data); 50| 55.5k| return data; 51| 55.5k|} _ZN4i18n12phonenumbers9IcuRegExpC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 108| 6.31k| explicit IcuRegExp(const string& utf8_regexp) { 109| 6.31k| UParseError parse_error; 110| 6.31k| UErrorCode status = U_ZERO_ERROR; 111| 6.31k| utf8_regexp_.reset(RegexPattern::compile( 112| 6.31k| Utf8StringToUnicodeString(utf8_regexp), 0, parse_error, status)); 113| 6.31k| if (U_FAILURE(status)) { ------------------ | Branch (113:9): [True: 2.45k, False: 3.86k] ------------------ 114| | // The provided regular expressions should compile correctly. 115| 2.45k| LOG(ERROR) << "Error compiling regular expression: " << utf8_regexp; 116| 2.45k| utf8_regexp_.reset(NULL); 117| 2.45k| } 118| 6.31k| } _ZNK4i18n12phonenumbers9IcuRegExp7ConsumeEPNS0_11RegExpInputEbPNSt3__112basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEESB_SB_SB_SB_SB_: 133| 815k| string* matched_string6) const { 134| 815k| DCHECK(input_string); ------------------ | | 29| 815k|#define DCHECK(X) assert(X) ------------------ 135| 815k| if (!utf8_regexp_.get()) { ------------------ | Branch (135:9): [True: 0, False: 815k] ------------------ 136| 0| return false; 137| 0| } 138| 815k| IcuRegExpInput* const input = static_cast(input_string); 139| 815k| UErrorCode status = U_ZERO_ERROR; 140| 815k| const scoped_ptr matcher( 141| 815k| utf8_regexp_->matcher(*input->Data(), status)); 142| 815k| bool match_succeeded = anchor_at_start ------------------ | Branch (142:28): [True: 730k, False: 85.0k] ------------------ 143| 815k| ? matcher->lookingAt(input->position(), status) 144| 815k| : matcher->find(input->position(), status); 145| 815k| if (!match_succeeded || U_FAILURE(status)) { ------------------ | Branch (145:9): [True: 724k, False: 90.9k] | Branch (145:29): [True: 0, False: 90.9k] ------------------ 146| 724k| return false; 147| 724k| } 148| 90.9k| string* const matched_strings[] = {matched_string1, matched_string2, 149| 90.9k| matched_string3, matched_string4, 150| 90.9k| matched_string5, matched_string6}; 151| | // If less matches than expected - fail. 152| 623k| for (size_t i = 0; i < arraysize(matched_strings); ++i) { ------------------ | | 131| 623k|#define arraysize(array) (sizeof(ArraySizeHelper(array))) ------------------ | Branch (152:24): [True: 534k, False: 88.3k] ------------------ 153| 534k| if (matched_strings[i]) { ------------------ | Branch (153:11): [True: 36.6k, False: 497k] ------------------ 154| | // Groups are counted from 1 rather than 0. 155| 36.6k| const int group_index = static_cast(i + 1); 156| 36.6k| if (group_index > matcher->groupCount()) { ------------------ | Branch (156:13): [True: 2.56k, False: 34.1k] ------------------ 157| 2.56k| return false; 158| 2.56k| } 159| 34.1k| *matched_strings[i] = 160| 34.1k| UnicodeStringToUtf8String(matcher->group(group_index, status)); 161| 34.1k| } 162| 534k| } 163| 88.3k| input->set_position(matcher->end(status)); 164| 88.3k| return !U_FAILURE(status); 165| 90.9k| } _ZN4i18n12phonenumbers14IcuRegExpInput4DataEv: 83| 1.42M| UnicodeString* Data() { 84| 1.42M| return &utf8_input_; 85| 1.42M| } _ZNK4i18n12phonenumbers14IcuRegExpInput8positionEv: 90| 1.35M| int position() const { 91| 1.35M| return position_; 92| 1.35M| } _ZN4i18n12phonenumbers14IcuRegExpInput12set_positionEi: 94| 88.3k| void set_position(int position) { 95| 88.3k| DCHECK(position >= 0 && position <= utf8_input_.length()); ------------------ | | 29| 88.3k|#define DCHECK(X) assert(X) ------------------ 96| 88.3k| position_ = position; 97| 88.3k| } _ZNK4i18n12phonenumbers9IcuRegExp5MatchERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbPS8_: 169| 542k| string* matched_string) const { 170| 542k| if (!utf8_regexp_.get()) { ------------------ | Branch (170:9): [True: 2.45k, False: 540k] ------------------ 171| 2.45k| return false; 172| 2.45k| } 173| 540k| IcuRegExpInput input(input_string); 174| 540k| UErrorCode status = U_ZERO_ERROR; 175| 540k| const scoped_ptr matcher( 176| 540k| utf8_regexp_->matcher(*input.Data(), status)); 177| 540k| bool match_succeeded = full_match ------------------ | Branch (177:28): [True: 427k, False: 112k] ------------------ 178| 540k| ? matcher->matches(input.position(), status) 179| 540k| : matcher->find(input.position(), status); 180| 540k| if (!match_succeeded || U_FAILURE(status)) { ------------------ | Branch (180:9): [True: 338k, False: 201k] | Branch (180:29): [True: 0, False: 201k] ------------------ 181| 338k| return false; 182| 338k| } 183| 201k| if (matcher->groupCount() > 0 && matched_string) { ------------------ | Branch (183:9): [True: 74.4k, False: 127k] | Branch (183:38): [True: 830, False: 73.6k] ------------------ 184| 830| *matched_string = UnicodeStringToUtf8String(matcher->group(1, status)); 185| 830| } 186| 201k| return !U_FAILURE(status); 187| 540k| } _ZNK4i18n12phonenumbers9IcuRegExp7ReplaceEPNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEbRKS8_: 191| 73.6k| const string& replacement_string) const { 192| 73.6k| DCHECK(string_to_process); ------------------ | | 29| 73.6k|#define DCHECK(X) assert(X) ------------------ 193| 73.6k| if (!utf8_regexp_.get()) { ------------------ | Branch (193:9): [True: 0, False: 73.6k] ------------------ 194| 0| return false; 195| 0| } 196| 73.6k| IcuRegExpInput input(*string_to_process); 197| 73.6k| UErrorCode status = U_ZERO_ERROR; 198| 73.6k| const scoped_ptr matcher( 199| 73.6k| utf8_regexp_->matcher(*input.Data(), status)); 200| 73.6k| if (U_FAILURE(status)) { ------------------ | Branch (200:9): [True: 0, False: 73.6k] ------------------ 201| 0| return false; 202| 0| } 203| | 204| 73.6k| UnicodeString output; 205| | // We reimplement ReplaceFirst and ReplaceAll such that their behaviour is 206| | // consistent with the RE2 reg-ex matcher. 207| 73.6k| if (!matcher->find()) { ------------------ | Branch (207:9): [True: 59.4k, False: 14.2k] ------------------ 208| 59.4k| return false; 209| 59.4k| } 210| 14.2k| matcher->appendReplacement(output, 211| 14.2k| Utf8StringToUnicodeString(replacement_string), 212| 14.2k| status); 213| 14.2k| if (global) { ------------------ | Branch (213:9): [True: 9.48k, False: 4.78k] ------------------ 214| | // Continue and look for more matches. 215| 20.2k| while (matcher->find()) { ------------------ | Branch (215:14): [True: 10.7k, False: 9.48k] ------------------ 216| 10.7k| matcher->appendReplacement( 217| 10.7k| output, 218| 10.7k| Utf8StringToUnicodeString(replacement_string), 219| 10.7k| status); 220| 10.7k| } 221| 9.48k| } 222| | 223| 14.2k| matcher->appendTail(output); 224| 14.2k| if (U_FAILURE(status)) { ------------------ | Branch (224:9): [True: 218, False: 14.0k] ------------------ 225| 218| return false; 226| 218| } 227| 14.0k| const string replaced_string = UnicodeStringToUtf8String(output); 228| 14.0k| *string_to_process = replaced_string; 229| 14.0k| return true; 230| 14.2k| } _ZN4i18n12phonenumbers11RegExpCacheC2ERKNS0_21AbstractRegExpFactoryEm: 33| 2| : regexp_factory_(regexp_factory), 34| |#ifdef I18N_PHONENUMBERS_USE_TR1_UNORDERED_MAP 35| | cache_impl_(new CacheImpl(min_items)) 36| |#else 37| 2| cache_impl_(new CacheImpl()) 38| |#endif 39| 2|{} _ZN4i18n12phonenumbers11RegExpCache9GetRegExpERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 49| 813k|const RegExp& RegExpCache::GetRegExp(const string& pattern) { 50| 813k| AutoLock l(lock_); 51| 813k| CacheImpl::const_iterator it = cache_impl_->find(pattern); 52| 813k| if (it != cache_impl_->end()) return *it->second; ------------------ | Branch (52:7): [True: 807k, False: 6.30k] ------------------ 53| | 54| 6.30k| const RegExp* regexp = regexp_factory_.CreateRegExp(pattern); 55| 6.30k| cache_impl_->insert(std::make_pair(pattern, regexp)); 56| 6.30k| return *regexp; 57| 813k|} _ZN4i18n12phonenumbers10RegionCode10GetUnknownEv: 28| 63.4k| static const char* GetUnknown() { 29| 63.4k| return ZZ(); 30| 63.4k| } _ZN4i18n12phonenumbers10RegionCode2ZZEv: 32| 63.4k| static const char* ZZ() { 33| 63.4k| return "ZZ"; 34| 63.4k| } _ZNK4i18n12phonenumbers3gtl12OrderByFirstclINSt3__14pairIiPNS4_4listINS4_12basic_stringIcNS4_11char_traitsIcEENS4_9allocatorIcEEEENSA_ISC_EEEEEEEEbRKT_SJ_: 25| 3.36M| bool operator()(const T& p1, const T& p2) const { 26| 3.36M| return p1.first < p2.first; 27| 3.36M| } _ZN4i18n12phonenumbers10SimpleItoaEi: 40| 47.8k|string SimpleItoa(int n) { 41| 47.8k| return absl::StrCat(n); 42| 47.8k|} _ZN4i18n12phonenumbers10SimpleItoaEm: 44| 16.1k|string SimpleItoa(uint64 n) { 45| 16.1k| return absl::StrCat(n); 46| 16.1k|} _ZN4i18n12phonenumbers15HasPrefixStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 52| 270|bool HasPrefixString(const string& s, const string& prefix) { 53| 270| return absl::StartsWith(s, prefix); 54| 270|} _ZN4i18n12phonenumbers20TryStripPrefixStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_PS7_: 77| 47.7k|bool TryStripPrefixString(const string& in, const string& prefix, string* out) { 78| 47.7k| assert(out); 79| 47.7k| const bool has_prefix = in.compare(0, prefix.length(), prefix) == 0; 80| 47.7k| out->assign(has_prefix ? in.substr(prefix.length()) : in); ------------------ | Branch (80:15): [True: 873, False: 46.9k] ------------------ 81| | 82| 47.7k| return has_prefix; 83| 47.7k|} _ZN4i18n12phonenumbers15HasSuffixStringERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEES9_: 85| 15.3k|bool HasSuffixString(const string& s, const string& suffix) { 86| 15.3k| return absl::EndsWith(s, suffix); 87| 15.3k|} _ZN4i18n12phonenumbers12safe_strto32ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPi: 95| 4.32k|void safe_strto32(const string& s, int32 *n) { 96| 4.32k| GenericAtoi(s, n); 97| 4.32k|} _ZN4i18n12phonenumbers13safe_strtou64ERKNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEEPm: 99| 49.4k|void safe_strtou64(const string& s, uint64 *n) { 100| 49.4k| GenericAtoi(s, n); 101| 49.4k|} _ZN4i18n12phonenumbers6strrmmEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKS7_: 107| 3.01k|void strrmm(string* s, const string& chars) { 108| 5.02k| for (string::iterator it = s->begin(); it != s->end(); ) { ------------------ | Branch (108:42): [True: 2.00k, False: 3.01k] ------------------ 109| 2.00k| const char current_char = *it; 110| 2.00k| if (chars.find(current_char) != string::npos) { ------------------ | Branch (110:9): [True: 0, False: 2.00k] ------------------ 111| 0| it = s->erase(it); 112| 2.00k| } else { 113| 2.00k| ++it; 114| 2.00k| } 115| 2.00k| } 116| 3.01k|} _ZN4i18n12phonenumbers12StringHolderC2ERKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEE: 126| 179k| : absl::AlphaNum(s) 127| 179k|{} _ZN4i18n12phonenumbers12StringHolderC2EPKc: 130| 228k| : absl::AlphaNum(cp) 131| 228k|{} _ZN4i18n12phonenumbers12StringHolderC2Em: 134| 200k| : absl::AlphaNum(n) 135| 200k|{} _ZN4i18n12phonenumbers12StringHolderD2Ev: 137| 609k|StringHolder::~StringHolder() {} _ZN4i18n12phonenumbers6StrCatERKNS0_12StringHolderES3_: 154| 10.3k|string StrCat(const StringHolder& s1, const StringHolder& s2) { 155| 10.3k| return absl::StrCat(s1, s2); 156| 10.3k|} _ZN4i18n12phonenumbers6StrCatERKNS0_12StringHolderES3_S3_: 159| 72.5k| const StringHolder& s3) { 160| 72.5k| return absl::StrCat(s1, s2, s3); 161| 72.5k|} _ZN4i18n12phonenumbers6StrCatERKNS0_12StringHolderES3_S3_S3_: 164| 2.98k| const StringHolder& s3, const StringHolder& s4) { 165| 2.98k| return absl::StrCat(s1, s2, s3, s4); 166| 2.98k|} _ZN4i18n12phonenumbers6StrCatERKNS0_12StringHolderES3_S3_S3_S3_: 170| 22| const StringHolder& s5) { 171| 22| return absl::StrCat(s1, s2, s3, s4, s5); 172| 22|} _ZN4i18n12phonenumbers6StrCatERKNS0_12StringHolderES3_S3_S3_S3_S3_S3_: 183| 3| const StringHolder& s7) { 184| 3| return absl::StrCat(s1, s2, s3, s4, s5, s6, s7); 185| 3|} _ZN4i18n12phonenumbers6StrCatERKNS0_12StringHolderES3_S3_S3_S3_S3_S3_S3_S3_S3_S3_S3_S3_S3_S3_S3_: 264| 1| const StringHolder& s15, const StringHolder& s16) { 265| 1| return absl::StrCat(s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12, 266| 1| s13, s14, s15, s16); 267| 1|} _ZN4i18n12phonenumbers9StrAppendEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS0_12StringHolderE: 271| 354k|void StrAppend(string* dest, const StringHolder& s1) { 272| 354k| absl::StrAppend(dest, s1); 273| 354k|} _ZN4i18n12phonenumbers9StrAppendEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS0_12StringHolderESB_: 275| 1.26k|void StrAppend(string* dest, const StringHolder& s1, const StringHolder& s2) { 276| 1.26k| absl::StrAppend(dest, s1, s2); 277| 1.26k|} _ZN4i18n12phonenumbers9StrAppendEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS0_12StringHolderESB_SB_: 280| 381| const StringHolder& s3) { 281| 381| absl::StrAppend(dest, s1, s2, s3); 282| 381|} _ZN4i18n12phonenumbers9StrAppendEPNSt3__112basic_stringIcNS1_11char_traitsIcEENS1_9allocatorIcEEEERKNS0_12StringHolderESB_SB_SB_SB_: 291| 118| const StringHolder& s5) { 292| 118| absl::StrAppend(dest, s1, s2, s3, s4, s5); 293| 118|} _ZN4i18n12phonenumbers11GenericAtoiIiEEvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPT_: 90| 4.32k|void GenericAtoi(const string& s, T* out) { 91| 4.32k| if (!absl::SimpleAtoi(s, out)) ------------------ | Branch (91:7): [True: 0, False: 4.32k] ------------------ 92| 0| *out = 0; 93| 4.32k|} _ZN4i18n12phonenumbers11GenericAtoiImEEvRKNSt3__112basic_stringIcNS2_11char_traitsIcEENS2_9allocatorIcEEEEPT_: 90| 49.4k|void GenericAtoi(const string& s, T* out) { 91| 49.4k| if (!absl::SimpleAtoi(s, out)) ------------------ | Branch (91:7): [True: 0, False: 49.4k] ------------------ 92| 0| *out = 0; 93| 49.4k|} charntorune: 68| 1.20M|{ 69| 1.20M| int c, c1, c2, c3; 70| 1.20M| long l; 71| | 72| | /* When we're not allowed to read anything */ 73| 1.20M| if(length <= 0) { ------------------ | Branch (73:5): [True: 0, False: 1.20M] ------------------ 74| 0| goto badlen; 75| 0| } 76| | 77| | /* 78| | * one character sequence (7-bit value) 79| | * 00000-0007F => T1 80| | */ 81| 1.20M| c = *(uchar*)str; 82| 1.20M| if(c < Tx) { ------------------ | Branch (82:5): [True: 1.17M, False: 32.7k] ------------------ 83| 1.17M| *rune = (Rune)c; 84| 1.17M| return 1; 85| 1.17M| } 86| | 87| | // If we can't read more than one character we must stop 88| 32.7k| if(length <= 1) { ------------------ | Branch (88:5): [True: 3.48k, False: 29.3k] ------------------ 89| 3.48k| goto badlen; 90| 3.48k| } 91| | 92| | /* 93| | * two character sequence (11-bit value) 94| | * 0080-07FF => T2 Tx 95| | */ 96| 29.3k| c1 = *(uchar*)(str+1) ^ Tx; 97| 29.3k| if(c1 & Testx) ------------------ | Branch (97:5): [True: 11.7k, False: 17.6k] ------------------ 98| 11.7k| goto bad; 99| 17.6k| if(c < T3) { ------------------ | Branch (99:5): [True: 6.65k, False: 10.9k] ------------------ 100| 6.65k| if(c < T2) ------------------ | Branch (100:6): [True: 3.59k, False: 3.06k] ------------------ 101| 3.59k| goto bad; 102| 3.06k| l = ((c << Bitx) | c1) & Rune2; 103| 3.06k| if(l <= Rune1) ------------------ | Branch (103:6): [True: 371, False: 2.68k] ------------------ 104| 371| goto bad; 105| 2.68k| *rune = (Rune)l; 106| 2.68k| return 2; 107| 3.06k| } 108| | 109| | // If we can't read more than two characters we must stop 110| 10.9k| if(length <= 2) { ------------------ | Branch (110:5): [True: 208, False: 10.7k] ------------------ 111| 208| goto badlen; 112| 208| } 113| | 114| | /* 115| | * three character sequence (16-bit value) 116| | * 0800-FFFF => T3 Tx Tx 117| | */ 118| 10.7k| c2 = *(uchar*)(str+2) ^ Tx; 119| 10.7k| if(c2 & Testx) ------------------ | Branch (119:5): [True: 1.04k, False: 9.70k] ------------------ 120| 1.04k| goto bad; 121| 9.70k| if(c < T4) { ------------------ | Branch (121:5): [True: 3.92k, False: 5.78k] ------------------ 122| 3.92k| l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3; 123| 3.92k| if(l <= Rune2) ------------------ | Branch (123:6): [True: 254, False: 3.66k] ------------------ 124| 254| goto bad; 125| 3.66k| if (SurrogateMin <= l && l <= SurrogateMax) ------------------ | Branch (125:7): [True: 1.98k, False: 1.68k] | Branch (125:28): [True: 259, False: 1.72k] ------------------ 126| 259| goto bad; 127| 3.40k| *rune = (Rune)l; 128| 3.40k| return 3; 129| 3.66k| } 130| | 131| 5.78k| if (length <= 3) ------------------ | Branch (131:6): [True: 117, False: 5.66k] ------------------ 132| 117| goto badlen; 133| | 134| | /* 135| | * four character sequence (21-bit value) 136| | * 10000-1FFFFF => T4 Tx Tx Tx 137| | */ 138| 5.66k| c3 = *(uchar*)(str+3) ^ Tx; 139| 5.66k| if (c3 & Testx) ------------------ | Branch (139:6): [True: 330, False: 5.33k] ------------------ 140| 330| goto bad; 141| 5.33k| if (c < T5) { ------------------ | Branch (141:6): [True: 5.22k, False: 113] ------------------ 142| 5.22k| l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4; 143| 5.22k| if (l <= Rune3 || l > Runemax) ------------------ | Branch (143:7): [True: 143, False: 5.07k] | Branch (143:21): [True: 110, False: 4.96k] ------------------ 144| 253| goto bad; 145| 4.96k| *rune = (Rune)l; 146| 4.96k| return 4; 147| 5.22k| } 148| | 149| | // Support for 5-byte or longer UTF-8 would go here, but 150| | // since we don't have that, we'll just fall through to bad. 151| | 152| | /* 153| | * bad decoding 154| | */ 155| 17.9k|bad: 156| 17.9k| *rune = Bad; 157| 17.9k| return 1; 158| 3.80k|badlen: 159| 3.80k| *rune = Bad; 160| 3.80k| return 0; 161| | 162| 5.33k|} chartorune: 171| 42|{ 172| 42| int c, c1, c2, c3; 173| 42| long l; 174| | 175| | /* 176| | * one character sequence 177| | * 00000-0007F => T1 178| | */ 179| 42| c = *(uchar*)str; 180| 42| if(c < Tx) { ------------------ | Branch (180:5): [True: 30, False: 12] ------------------ 181| 30| *rune = (Rune)c; 182| 30| return 1; 183| 30| } 184| | 185| | /* 186| | * two character sequence 187| | * 0080-07FF => T2 Tx 188| | */ 189| 12| c1 = *(uchar*)(str+1) ^ Tx; 190| 12| if(c1 & Testx) ------------------ | Branch (190:5): [True: 0, False: 12] ------------------ 191| 0| goto bad; 192| 12| if(c < T3) { ------------------ | Branch (192:5): [True: 0, False: 12] ------------------ 193| 0| if(c < T2) ------------------ | Branch (193:6): [True: 0, False: 0] ------------------ 194| 0| goto bad; 195| 0| l = ((c << Bitx) | c1) & Rune2; 196| 0| if(l <= Rune1) ------------------ | Branch (196:6): [True: 0, False: 0] ------------------ 197| 0| goto bad; 198| 0| *rune = (Rune)l; 199| 0| return 2; 200| 0| } 201| | 202| | /* 203| | * three character sequence 204| | * 0800-FFFF => T3 Tx Tx 205| | */ 206| 12| c2 = *(uchar*)(str+2) ^ Tx; 207| 12| if(c2 & Testx) ------------------ | Branch (207:5): [True: 0, False: 12] ------------------ 208| 0| goto bad; 209| 12| if(c < T4) { ------------------ | Branch (209:5): [True: 12, False: 0] ------------------ 210| 12| l = ((((c << Bitx) | c1) << Bitx) | c2) & Rune3; 211| 12| if(l <= Rune2) ------------------ | Branch (211:6): [True: 0, False: 12] ------------------ 212| 0| goto bad; 213| 12| if (SurrogateMin <= l && l <= SurrogateMax) ------------------ | Branch (213:7): [True: 3, False: 9] | Branch (213:28): [True: 0, False: 3] ------------------ 214| 0| goto bad; 215| 12| *rune = (Rune)l; 216| 12| return 3; 217| 12| } 218| | 219| | /* 220| | * four character sequence (21-bit value) 221| | * 10000-1FFFFF => T4 Tx Tx Tx 222| | */ 223| 0| c3 = *(uchar*)(str+3) ^ Tx; 224| 0| if (c3 & Testx) ------------------ | Branch (224:6): [True: 0, False: 0] ------------------ 225| 0| goto bad; 226| 0| if (c < T5) { ------------------ | Branch (226:6): [True: 0, False: 0] ------------------ 227| 0| l = ((((((c << Bitx) | c1) << Bitx) | c2) << Bitx) | c3) & Rune4; 228| 0| if (l <= Rune3 || l > Runemax) ------------------ | Branch (228:7): [True: 0, False: 0] | Branch (228:21): [True: 0, False: 0] ------------------ 229| 0| goto bad; 230| 0| *rune = (Rune)l; 231| 0| return 4; 232| 0| } 233| | 234| | /* 235| | * Support for 5-byte or longer UTF-8 would go here, but 236| | * since we don't have that, we'll just fall through to bad. 237| | */ 238| | 239| | /* 240| | * bad decoding 241| | */ 242| 0|bad: 243| 0| *rune = Bad; 244| 0| return 1; 245| 0|} isvalidcharntorune: 249| 16.0k|{ 250| 16.0k| *consumed = charntorune(rune, str, length); 251| 16.0k| return *rune != Runeerror || *consumed == 3; ------------------ | Branch (251:9): [True: 6.27k, False: 9.79k] | Branch (251:31): [True: 0, False: 9.79k] ------------------ 252| 16.0k|} _ZN4i18n12phonenumbers11UnicodeText4Repr7reserveEi: 109| 3.71k|void UnicodeText::Repr::reserve(int new_capacity) { 110| | // If there's already enough capacity, and we're an owner, do nothing. 111| 3.71k| if (capacity_ >= new_capacity && ours_) return; ------------------ | Branch (111:7): [True: 0, False: 3.71k] | Branch (111:36): [True: 0, False: 0] ------------------ 112| | 113| | // Otherwise, allocate a new buffer. 114| 3.71k| capacity_ = max(new_capacity, (3 * capacity_) / 2 + 20); 115| 3.71k| char* new_data = new char[capacity_]; 116| | 117| | // If there is an old buffer, copy it into the new buffer. 118| 3.71k| if (data_) { ------------------ | Branch (118:7): [True: 0, False: 3.71k] ------------------ 119| 0| memcpy(new_data, data_, size_); 120| 0| if (ours_) delete[] data_; // If we owned the old buffer, free it. ------------------ | Branch (120:9): [True: 0, False: 0] ------------------ 121| 0| } 122| 3.71k| data_ = new_data; 123| 3.71k| ours_ = true; // We own the new buffer. 124| | // size_ is unchanged. 125| 3.71k|} _ZN4i18n12phonenumbers11UnicodeText4Repr6resizeEi: 127| 3.71k|void UnicodeText::Repr::resize(int new_size) { 128| 3.71k| if (new_size == 0) { ------------------ | Branch (128:7): [True: 0, False: 3.71k] ------------------ 129| 0| clear(); 130| 3.71k| } else { 131| 3.71k| if (!ours_ || new_size > capacity_) reserve(new_size); ------------------ | Branch (131:9): [True: 0, False: 3.71k] | Branch (131:19): [True: 3.71k, False: 0] ------------------ 132| | // Clear the memory in the expanded part. 133| 3.71k| if (size_ < new_size) memset(data_ + size_, 0, new_size - size_); ------------------ | Branch (133:9): [True: 3.71k, False: 0] ------------------ 134| 3.71k| size_ = new_size; 135| 3.71k| ours_ = true; 136| 3.71k| } 137| 3.71k|} _ZN4i18n12phonenumbers11UnicodeText4Repr4CopyEPKci: 148| 3.71k|void UnicodeText::Repr::Copy(const char* data, int size) { 149| 3.71k| resize(size); 150| 3.71k| memcpy(data_, data, size); 151| 3.71k|} _ZN4i18n12phonenumbers11UnicodeText4Repr7PointToEPKci: 162| 239k|void UnicodeText::Repr::PointTo(const char* data, int size) { 163| 239k| if (ours_ && data_) delete[] data_; // If we owned the old buffer, free it. ------------------ | Branch (163:7): [True: 239k, False: 0] | Branch (163:16): [True: 0, False: 239k] ------------------ 164| 239k| data_ = const_cast(data); 165| 239k| size_ = size; 166| 239k| capacity_ = size; 167| 239k| ours_ = false; 168| 239k|} _ZN4i18n12phonenumbers11UnicodeTextC2Ev: 196| 243k|UnicodeText::UnicodeText() { 197| 243k|} _ZN4i18n12phonenumbers11UnicodeText13UTF8SubstringERKNS1_14const_iteratorES4_: 212| 122k| const const_iterator& last) { 213| 122k| assert(first <= last && "Incompatible iterators"); 214| 122k| return string(first.it_, last.it_ - first.it_); 215| 122k|} _ZN4i18n12phonenumbers11UnicodeText11PointToUTF8EPKci: 271| 243k|UnicodeText& UnicodeText::PointToUTF8(const char* buffer, int byte_length) { 272| 243k| repr_.utf8_was_valid_ = UniLib:: IsInterchangeValid(buffer, byte_length); 273| 243k| if (repr_.utf8_was_valid_) { ------------------ | Branch (273:7): [True: 239k, False: 3.71k] ------------------ 274| 239k| repr_.PointTo(buffer, byte_length); 275| 239k| } else { 276| 3.71k| LOG(WARNING) << "UTF-8 buffer is not interchange-valid."; 277| 3.71k| repr_.Copy(buffer, byte_length); 278| 3.71k| repr_.size_ = ConvertToInterchangeValid(repr_.data_, byte_length); 279| 3.71k| } 280| 243k| return *this; 281| 243k|} _ZN4i18n12phonenumbers11UnicodeTextD2Ev: 363| 243k|UnicodeText::~UnicodeText() {} _ZN4i18n12phonenumbers11UnicodeText14const_iteratorC2Ev: 417| 86.8k|UnicodeText::const_iterator::const_iterator() : it_(0) {} _ZN4i18n12phonenumbers11UnicodeText14const_iteratorC2ERKS2_: 420| 375k| : it_(other.it_) { 421| 375k|} _ZN4i18n12phonenumbers11UnicodeText14const_iteratoraSERKS2_: 424| 86.8k|UnicodeText::const_iterator::operator=(const const_iterator& other) { 425| 86.8k| if (&other != this) ------------------ | Branch (425:7): [True: 86.8k, False: 0] ------------------ 426| 86.8k| it_ = other.it_; 427| 86.8k| return *this; 428| 86.8k|} _ZNK4i18n12phonenumbers11UnicodeText5beginEv: 430| 305k|UnicodeText::const_iterator UnicodeText::begin() const { 431| 305k| return const_iterator(repr_.data_); 432| 305k|} _ZNK4i18n12phonenumbers11UnicodeText3endEv: 434| 790k|UnicodeText::const_iterator UnicodeText::end() const { 435| 790k| return const_iterator(repr_.data_ + repr_.size_); 436| 790k|} _ZN4i18n12phonenumbersltERKNS0_11UnicodeText14const_iteratorES4_: 439| 122k| const UnicodeText::const_iterator& rhs) { 440| 122k| return lhs.it_ < rhs.it_; 441| 122k|} _ZNK4i18n12phonenumbers11UnicodeText14const_iteratordeEv: 443| 391k|char32 UnicodeText::const_iterator::operator*() const { 444| | // (We could call chartorune here, but that does some 445| | // error-checking, and we're guaranteed that our data is valid 446| | // UTF-8. Also, we expect this routine to be called very often. So 447| | // for speed, we do the calculation ourselves.) 448| | 449| | // Convert from UTF-8 450| 391k| uint8 byte1 = static_cast(it_[0]); 451| 391k| if (byte1 < 0x80) ------------------ | Branch (451:7): [True: 389k, False: 2.15k] ------------------ 452| 389k| return byte1; 453| | 454| 2.15k| uint8 byte2 = static_cast(it_[1]); 455| 2.15k| if (byte1 < 0xE0) ------------------ | Branch (455:7): [True: 631, False: 1.52k] ------------------ 456| 631| return ((byte1 & 0x1F) << 6) 457| 631| | (byte2 & 0x3F); 458| | 459| 1.52k| uint8 byte3 = static_cast(it_[2]); 460| 1.52k| if (byte1 < 0xF0) ------------------ | Branch (460:7): [True: 748, False: 775] ------------------ 461| 748| return ((byte1 & 0x0F) << 12) 462| 748| | ((byte2 & 0x3F) << 6) 463| 748| | (byte3 & 0x3F); 464| | 465| 775| uint8 byte4 = static_cast(it_[3]); 466| 775| return ((byte1 & 0x07) << 18) 467| 775| | ((byte2 & 0x3F) << 12) 468| 775| | ((byte3 & 0x3F) << 6) 469| 775| | (byte4 & 0x3F); 470| 1.52k|} _ZN4i18n12phonenumbers11UnicodeText14const_iteratorppEv: 472| 402k|UnicodeText::const_iterator& UnicodeText::const_iterator::operator++() { 473| 402k| it_ += UniLib::OneCharLen(it_); 474| 402k| return *this; 475| 402k|} _ZN4i18n12phonenumbers11UnicodeText14const_iteratormmEv: 477| 70.5k|UnicodeText::const_iterator& UnicodeText::const_iterator::operator--() { 478| 74.6k| while (UniLib::IsTrailByte(*--it_)) { } ------------------ | Branch (478:10): [True: 4.08k, False: 70.5k] ------------------ 479| 70.5k| return *this; 480| 70.5k|} _ZNK4i18n12phonenumbers11UnicodeText14const_iterator8get_utf8EPc: 482| 138k|int UnicodeText::const_iterator::get_utf8(char* utf8_output) const { 483| 138k| utf8_output[0] = it_[0]; 484| 138k| if (static_cast(it_[0]) < 0x80) ------------------ | Branch (484:7): [True: 136k, False: 2.19k] ------------------ 485| 136k| return 1; 486| | 487| 2.19k| utf8_output[1] = it_[1]; 488| 2.19k| if (static_cast(it_[0]) < 0xE0) ------------------ | Branch (488:7): [True: 537, False: 1.65k] ------------------ 489| 537| return 2; 490| | 491| 1.65k| utf8_output[2] = it_[2]; 492| 1.65k| if (static_cast(it_[0]) < 0xF0) ------------------ | Branch (492:7): [True: 692, False: 967] ------------------ 493| 692| return 3; 494| | 495| 967| utf8_output[3] = it_[3]; 496| 967| return 4; 497| 1.65k|} unicodetext.cc:_ZN4i18n12phonenumbersL25ConvertToInterchangeValidEPci: 58| 3.71k|static int ConvertToInterchangeValid(char* start, int len) { 59| | // This routine is called only when we've discovered that a UTF-8 buffer 60| | // that was passed to CopyUTF8, TakeOwnershipOfUTF8, or PointToUTF8 61| | // was not interchange valid. This indicates a bug in the caller, and 62| | // a LOG(WARNING) is done in that case. 63| | // This is similar to CoerceToInterchangeValid, but it replaces each 64| | // structurally valid byte with a space, and each non-interchange 65| | // character with a space, even when that character requires more 66| | // than one byte in UTF8. E.g., "\xEF\xB7\x90" (U+FDD0) is 67| | // structurally valid UTF8, but U+FDD0 is not an interchange-valid 68| | // code point. The result should contain one space, not three. 69| | // 70| | // Since the conversion never needs to write more data than it 71| | // reads, it is safe to change the buffer in place. It returns the 72| | // number of bytes written. 73| 3.71k| char* const in = start; 74| 3.71k| char* out = start; 75| 3.71k| char* const end = start + len; 76| 19.7k| while (start < end) { ------------------ | Branch (76:10): [True: 17.1k, False: 2.67k] ------------------ 77| 17.1k| int good = UniLib::SpanInterchangeValid(start, static_cast(end - start)); 78| 17.1k| if (good > 0) { ------------------ | Branch (78:9): [True: 3.09k, False: 14.0k] ------------------ 79| 3.09k| if (out != start) { ------------------ | Branch (79:11): [True: 142, False: 2.95k] ------------------ 80| 142| memmove(out, start, good); 81| 142| } 82| 3.09k| out += good; 83| 3.09k| start += good; 84| 3.09k| if (start == end) { ------------------ | Branch (84:11): [True: 1.03k, False: 2.06k] ------------------ 85| 1.03k| break; 86| 1.03k| } 87| 3.09k| } 88| | // Is the current string invalid UTF8 or just non-interchange UTF8? 89| 16.0k| Rune rune; 90| 16.0k| int n; 91| 16.0k| if (isvalidcharntorune(start, static_cast(end - start), &rune, &n)) { ------------------ | Branch (91:9): [True: 6.27k, False: 9.79k] ------------------ 92| | // structurally valid UTF8, but not interchange valid 93| 6.27k| start += n; // Skip over the whole character. 94| 9.79k| } else { // bad UTF8 95| 9.79k| start += 1; // Skip over just one byte 96| 9.79k| } 97| 16.0k| *out++ = ' '; 98| 16.0k| } 99| 3.71k| return static_cast(out - in); 100| 3.71k|} _ZN4i18n12phonenumberseqERKNS0_11UnicodeText14const_iteratorES4_: 214| 733k| friend bool operator==(const CI& lhs, const CI& rhs) { 215| 733k| return lhs.it_ == rhs.it_; } _ZN4i18n12phonenumbersneERKNS0_11UnicodeText14const_iteratorES4_: 216| 647k| friend bool operator!=(const CI& lhs, const CI& rhs) { 217| 647k| return !(lhs == rhs); } _ZN4i18n12phonenumbersleERKNS0_11UnicodeText14const_iteratorES4_: 221| 122k| friend bool operator<=(const CI& lhs, const CI& rhs) { 222| 122k| return !(rhs < lhs); } _ZN4i18n12phonenumbers11UnicodeText14const_iteratorC2EPKc: 242| 1.09M| explicit const_iterator(const char* it) : it_(it) {} _ZN4i18n12phonenumbers11UnicodeText22const_reverse_iteratorC2ENS1_14const_iteratorE: 253| 61.0k| std::reverse_iterator(it) {} _ZNK4i18n12phonenumbers11UnicodeText22const_reverse_iterator8get_utf8EPc: 258| 65.5k| int get_utf8(char* buf) const { 259| 65.5k| const_iterator tmp_it = base(); 260| 65.5k| return (--tmp_it).get_utf8(buf); 261| 65.5k| } _ZNK4i18n12phonenumbers11UnicodeText12UTF8WasValidEv: 317| 243k| bool UTF8WasValid() const { return repr_.utf8_was_valid_; } _ZN4i18n12phonenumbers11UnicodeText4ReprC2Ev: 340| 243k| Repr() : data_(NULL), size_(0), capacity_(0), ours_(true), utf8_was_valid_(true) {} _ZN4i18n12phonenumbers11UnicodeText4ReprD2Ev: 341| 243k| ~Repr() { if (ours_) delete[] data_; } ------------------ | Branch (341:19): [True: 3.71k, False: 239k] ------------------ _ZN4i18n12phonenumbers6UniLib20SpanInterchangeValidEPKci: 48| 260k|int SpanInterchangeValid(const char* begin, int byte_length) { 49| 260k| Rune rune; 50| 260k| const char* p = begin; 51| 260k| const char* end = begin + byte_length; 52| 1.43M| while (p < end) { ------------------ | Branch (52:10): [True: 1.19M, False: 240k] ------------------ 53| 1.19M| int bytes_consumed = charntorune(&rune, p, static_cast(end - p)); 54| | // We want to accept Runeerror == U+FFFD as a valid char, but it is used 55| | // by chartorune to indicate error. Luckily, the real codepoint is size 3 56| | // while errors return bytes_consumed <= 1. 57| 1.19M| if ((rune == Runeerror && bytes_consumed <= 1) || ------------------ | Branch (57:10): [True: 12.0k, False: 1.18M] | Branch (57:31): [True: 11.9k, False: 78] ------------------ 58| 1.19M| !IsInterchangeValidCodepoint(rune)) { ------------------ | Branch (58:9): [True: 7.84k, False: 1.17M] ------------------ 59| 19.7k| break; // Found 60| 19.7k| } 61| 1.17M| p += bytes_consumed; 62| 1.17M| } 63| 260k| return static_cast(p - begin); 64| 260k|} unilib.cc:_ZN4i18n12phonenumbers6UniLib12_GLOBAL__N_127IsInterchangeValidCodepointEi: 39| 1.18M|inline bool IsInterchangeValidCodepoint(char32 c) { 40| 1.18M| return !((c >= 0x00 && c <= 0x08) || c == 0x0B || (c >= 0x0E && c <= 0x1F) || ------------------ | Branch (40:13): [True: 1.18M, False: 0] | Branch (40:26): [True: 5.45k, False: 1.17M] | Branch (40:40): [True: 269, False: 1.17M] | Branch (40:54): [True: 1.17M, False: 2.07k] | Branch (40:67): [True: 1.52k, False: 1.17M] ------------------ 41| 1.18M| (c >= 0x7F && c <= 0x9F) || ------------------ | Branch (41:13): [True: 11.1k, False: 1.16M] | Branch (41:26): [True: 392, False: 10.7k] ------------------ 42| 1.18M| (c >= 0xD800 && c <= 0xDFFF) || ------------------ | Branch (42:13): [True: 6.57k, False: 1.16M] | Branch (42:28): [True: 0, False: 6.57k] ------------------ 43| 1.18M| (c >= 0xFDD0 && c <= 0xFDEF) || (c&0xFFFE) == 0xFFFE); ------------------ | Branch (43:13): [True: 6.35k, False: 1.16M] | Branch (43:28): [True: 108, False: 6.24k] | Branch (43:44): [True: 96, False: 1.17M] ------------------ 44| 1.18M|} _ZN4i18n12phonenumbers6UniLib10OneCharLenEPKc: 62| 402k|inline int OneCharLen(const char* src) { 63| 402k| return kUTF8LenTbl[*reinterpret_cast(src)]; 64| 402k|} _ZN4i18n12phonenumbers6UniLib11IsTrailByteEc: 72| 74.6k|inline bool IsTrailByte(char x) { 73| | // return (x & 0xC0) == 0x80; 74| | // Since trail bytes are always in [0x80, 0xBF], we can optimize: 75| 74.6k| return static_cast(x) < -0x40; 76| 74.6k|} _ZN4i18n12phonenumbers6UniLib18IsInterchangeValidEPKci: 88| 243k|inline bool IsInterchangeValid(const char* src, int byte_length) { 89| 243k| return (byte_length == SpanInterchangeValid(src, byte_length)); 90| 243k|} _Z22ConsumePhoneNumberTypeR18FuzzedDataProvider: 37| 9.65k| FuzzedDataProvider& fuzzed_data) { 38| 9.65k| switch (fuzzed_data.ConsumeIntegralInRange(0, 11)) { 39| 4.85k| case 0: ------------------ | Branch (39:5): [True: 4.85k, False: 4.79k] ------------------ 40| 4.85k| return i18n::phonenumbers::PhoneNumberUtil::FIXED_LINE; 41| 395| case 1: ------------------ | Branch (41:5): [True: 395, False: 9.25k] ------------------ 42| 395| return i18n::phonenumbers::PhoneNumberUtil::MOBILE; 43| 293| case 2: ------------------ | Branch (43:5): [True: 293, False: 9.35k] ------------------ 44| 293| return i18n::phonenumbers::PhoneNumberUtil::FIXED_LINE_OR_MOBILE; 45| 843| case 3: ------------------ | Branch (45:5): [True: 843, False: 8.80k] ------------------ 46| 843| return i18n::phonenumbers::PhoneNumberUtil::TOLL_FREE; 47| 394| case 4: ------------------ | Branch (47:5): [True: 394, False: 9.25k] ------------------ 48| 394| return i18n::phonenumbers::PhoneNumberUtil::PREMIUM_RATE; 49| 413| case 5: ------------------ | Branch (49:5): [True: 413, False: 9.23k] ------------------ 50| 413| return i18n::phonenumbers::PhoneNumberUtil::SHARED_COST; 51| 282| case 6: ------------------ | Branch (51:5): [True: 282, False: 9.36k] ------------------ 52| 282| return i18n::phonenumbers::PhoneNumberUtil::VOIP; 53| 323| case 7: ------------------ | Branch (53:5): [True: 323, False: 9.32k] ------------------ 54| 323| return i18n::phonenumbers::PhoneNumberUtil::PERSONAL_NUMBER; 55| 624| case 8: ------------------ | Branch (55:5): [True: 624, False: 9.02k] ------------------ 56| 624| return i18n::phonenumbers::PhoneNumberUtil::PAGER; 57| 401| case 9: ------------------ | Branch (57:5): [True: 401, False: 9.24k] ------------------ 58| 401| return i18n::phonenumbers::PhoneNumberUtil::UAN; 59| 377| case 10: ------------------ | Branch (59:5): [True: 377, False: 9.27k] ------------------ 60| 377| return i18n::phonenumbers::PhoneNumberUtil::VOICEMAIL; 61| 446| default: ------------------ | Branch (61:5): [True: 446, False: 9.20k] ------------------ 62| 446| return i18n::phonenumbers::PhoneNumberUtil::UNKNOWN; 63| 9.65k| } 64| 9.65k|} _Z24ConsumePhoneNumberFormatR18FuzzedDataProvider: 68| 19.3k| FuzzedDataProvider& fuzzed_data) { 69| 19.3k| switch (fuzzed_data.ConsumeIntegralInRange(0, 3)) { 70| 11.9k| case 0: ------------------ | Branch (70:5): [True: 11.9k, False: 7.31k] ------------------ 71| 11.9k| return i18n::phonenumbers::PhoneNumberUtil::E164; 72| 2.33k| case 1: ------------------ | Branch (72:5): [True: 2.33k, False: 16.9k] ------------------ 73| 2.33k| return i18n::phonenumbers::PhoneNumberUtil::INTERNATIONAL; 74| 2.07k| case 2: ------------------ | Branch (74:5): [True: 2.07k, False: 17.2k] ------------------ 75| 2.07k| return i18n::phonenumbers::PhoneNumberUtil::NATIONAL; 76| 2.91k| default: ------------------ | Branch (76:5): [True: 2.91k, False: 16.3k] ------------------ 77| 2.91k| return i18n::phonenumbers::PhoneNumberUtil::RFC3966; 78| 19.3k| } 79| 19.3k|} LLVMFuzzerTestOneInput: 81| 9.65k|extern "C" int LLVMFuzzerTestOneInput(const uint8_t* data, size_t size) { 82| | // initialize the phone util 83| 9.65k| i18n::phonenumbers::PhoneNumberUtil* phone_util = 84| 9.65k| i18n::phonenumbers::PhoneNumberUtil::GetInstance(); 85| 9.65k| FuzzedDataProvider fuzzed_data(data, size); 86| | 87| | // initialize the first phone number, region and country calling code 88| 9.65k| i18n::phonenumbers::PhoneNumber phone_number; 89| 9.65k| bool region_is_2_bytes = fuzzed_data.ConsumeBool(); 90| 9.65k| std::string region = fuzzed_data.ConsumeBytesAsString(region_is_2_bytes ? 2 : 3); ------------------ | Branch (90:57): [True: 9.47k, False: 180] ------------------ 91| 9.65k| std::string number = fuzzed_data.ConsumeRandomLengthString(32); 92| 9.65k| int country_calling_code = fuzzed_data.ConsumeIntegral(); 93| | 94| | // trigger either one of the public parse methods 95| 9.65k| if (fuzzed_data.ConsumeBool()) { ------------------ | Branch (95:7): [True: 3.68k, False: 5.96k] ------------------ 96| 3.68k| phone_util->ParseAndKeepRawInput(number, region, &phone_number); 97| 5.96k| } else { 98| 5.96k| phone_util->Parse(number, region, &phone_number); 99| 5.96k| } 100| | 101| | // initialize the second phone number, this is used only for the 102| | // isNumberMatch* methods 103| 9.65k| i18n::phonenumbers::PhoneNumber phone_number2; 104| 9.65k| std::string number2 = fuzzed_data.ConsumeRandomLengthString(32); 105| 9.65k| if (fuzzed_data.ConsumeBool()) { ------------------ | Branch (105:7): [True: 2.95k, False: 6.69k] ------------------ 106| 2.95k| phone_util->ParseAndKeepRawInput(number2, region, &phone_number2); 107| 6.69k| } else { 108| 6.69k| phone_util->Parse(number2, region, &phone_number2); 109| 6.69k| } 110| | 111| | // randomly trigger the truncate method, this may affect state of the input 112| | // for the method calls that follow it 113| 9.65k| if (fuzzed_data.ConsumeIntegralInRange(0, 10) == 5) { ------------------ | Branch (113:7): [True: 583, False: 9.06k] ------------------ 114| 583| phone_util->TruncateTooLongNumber(&phone_number); 115| 583| } 116| | 117| | // fuzz public methods 118| 9.65k| phone_util->IsAlphaNumber(number); 119| 9.65k| phone_util->IsPossibleNumber(phone_number); 120| 9.65k| phone_util->IsNumberMatch(phone_number, phone_number2); 121| 9.65k| phone_util->IsNumberMatchWithOneString(phone_number, number2); 122| 9.65k| phone_util->IsNumberMatchWithTwoStrings(number, number2); 123| 9.65k| phone_util->CanBeInternationallyDialled(phone_number); 124| 9.65k| phone_util->GetNumberType(phone_number); 125| 9.65k| phone_util->GetLengthOfGeographicalAreaCode(phone_number); 126| 9.65k| phone_util->GetLengthOfNationalDestinationCode(phone_number); 127| 9.65k| phone_util->IsNANPACountry(region); 128| 9.65k| phone_util->GetCountryCodeForRegion(region); 129| 9.65k| phone_util->IsPossibleNumberForString(number, region); 130| 9.65k| phone_util->IsNumberGeographical(phone_number); 131| 9.65k| i18n::phonenumbers::PhoneNumberUtil::PhoneNumberType number_type = 132| 9.65k| ConsumePhoneNumberType(fuzzed_data); 133| 9.65k| phone_util->IsNumberGeographical(number_type, country_calling_code); 134| 9.65k| phone_util->IsPossibleNumberForType(phone_number, number_type); 135| | 136| 9.65k| i18n::phonenumbers::PhoneNumber example_number; 137| 9.65k| phone_util->GetExampleNumberForType(region, number_type, &example_number); 138| | 139| 9.65k| i18n::phonenumbers::PhoneNumber example_number_2; 140| 9.65k| phone_util->GetExampleNumberForType(number_type, &example_number_2); 141| | 142| 9.65k| i18n::phonenumbers::PhoneNumber invalid_number; 143| 9.65k| phone_util->GetInvalidExampleNumber(region, &invalid_number); 144| | 145| 9.65k| i18n::phonenumbers::PhoneNumber non_geo_number; 146| 9.65k| phone_util->GetExampleNumberForNonGeoEntity(country_calling_code, &non_geo_number); 147| | 148| 9.65k| std::string output; 149| 9.65k| phone_util->GetCountryMobileToken(country_calling_code, &output); 150| 9.65k| output.clear(); 151| | 152| 9.65k| phone_util->GetRegionCodeForNumber(phone_number, &output); 153| 9.65k| output.clear(); 154| | 155| 9.65k| phone_util->GetNddPrefixForRegion(region, fuzzed_data.ConsumeBool(), &output); 156| 9.65k| output.clear(); 157| | 158| | // Fuzz the methods which affect the input string, but not the PhoneNumber object 159| 9.65k| std::string input = fuzzed_data.ConsumeRandomLengthString(32); 160| 9.65k| phone_util->ConvertAlphaCharactersInNumber(&input); 161| 9.65k| input.clear(); 162| | 163| 9.65k| input = fuzzed_data.ConsumeRandomLengthString(32); 164| 9.65k| phone_util->NormalizeDigitsOnly(&input); 165| 9.65k| input.clear(); 166| | 167| 9.65k| input = fuzzed_data.ConsumeRandomLengthString(32); 168| 9.65k| phone_util->NormalizeDiallableCharsOnly(&input); 169| 9.65k| input.clear(); 170| | 171| | // Fuzz the formatting methods 172| 9.65k| i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat format = ConsumePhoneNumberFormat(fuzzed_data); 173| | 174| 9.65k| std::string formatted; 175| 9.65k| phone_util->Format(phone_number, format, &formatted); 176| 9.65k| formatted.clear(); 177| | 178| 9.65k| phone_util->FormatInOriginalFormat(phone_number, region, &formatted); 179| 9.65k| formatted.clear(); 180| | 181| 9.65k| phone_util->FormatNumberForMobileDialing(phone_number, region, 182| 9.65k| fuzzed_data.ConsumeBool(), &formatted); 183| 9.65k| formatted.clear(); 184| | 185| 9.65k| phone_util->FormatNationalNumberWithPreferredCarrierCode(phone_number, region, &formatted); 186| 9.65k| formatted.clear(); 187| | 188| 9.65k| phone_util->FormatOutOfCountryKeepingAlphaChars(phone_number, region, &formatted); 189| 9.65k| formatted.clear(); 190| | 191| 9.65k| std::string carrier = fuzzed_data.ConsumeRandomLengthString(8); 192| 9.65k| phone_util->FormatNationalNumberWithCarrierCode(phone_number, carrier, &formatted); 193| 9.65k| formatted.clear(); 194| | 195| | // setup the parameters for FormatByPattern 196| 9.65k| i18n::phonenumbers::PhoneNumberUtil::PhoneNumberFormat number_format = ConsumePhoneNumberFormat(fuzzed_data); 197| 9.65k| RepeatedPtrField number_formats; 198| 9.65k| i18n::phonenumbers::NumberFormat* temp_number_format = number_formats.Add(); 199| 9.65k| std::string pattern = fuzzed_data.ConsumeRandomLengthString(16); 200| 9.65k| std::string format_string = fuzzed_data.ConsumeRandomLengthString(16); 201| 9.65k| temp_number_format->set_pattern(pattern); 202| 9.65k| temp_number_format->set_format(format_string); 203| | 204| | // fuzz FormatByPattern 205| 9.65k| phone_util->FormatByPattern(phone_number, number_format, number_formats, &formatted); 206| 9.65k| formatted.clear(); 207| | 208| 9.65k| return 0; 209| 9.65k|}