RubyGems - phonelib - Versions diffs - 0.6.5 → 0.6.6 - Mend

phonelib 0.6.5 → 0.6.6

Files changed (1989) hide show

data/data/libphonenumber/cpp/src/phonenumbers/metadata.h DELETED

@@ -1,29 +0,0 @@
-/*
- * Copyright (C) 2011 The Libphonenumber Authors
- *
- * Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- * http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-#ifndef I18N_PHONENUMBERS_METADATA_H_
-#define I18N_PHONENUMBERS_METADATA_H_
-namespace i18n {
-namespace phonenumbers {
-int metadata_size();
-const void* metadata_get();
-}  // namespace phonenumbers
-}  // namespace i18n
-#endif  // I18N_PHONENUMBERS_METADATA_H_

data/data/libphonenumber/cpp/src/phonenumbers/normalize_utf8.h DELETED

@@ -1,50 +0,0 @@
-// Copyright (C) 2011 The Libphonenumber Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-#include <string>
-#include "phonenumbers/utf/unicodetext.h"
-namespace i18n {
-namespace phonenumbers {
-using std::string;
-struct NormalizeUTF8 {
-  // Put a UTF-8 string in ASCII digits: All decimal digits (Nd) replaced by
-  // their ASCII counterparts; all other characters are copied from input to
-  // output.
-  static string NormalizeDecimalDigits(const string& number) {
-    string normalized;
-    UnicodeText number_as_unicode;
-    number_as_unicode.PointToUTF8(number.data(), number.size());
-    for (UnicodeText::const_iterator it = number_as_unicode.begin();
-         it != number_as_unicode.end();
-         ++it) {
-      int32_t digitValue = u_charDigitValue(*it);
-      if (digitValue == -1) {
-        // Not a decimal digit.
-        char utf8[4];
-        int len = it.get_utf8(utf8);
-        normalized.append(utf8, len);
-      } else {
-        normalized.push_back('0' + digitValue);
-      }
-    }
-    return normalized;
-  }
-};
-}  // namespace phonenumbers
-}  // namespace i18n

data/data/libphonenumber/cpp/src/phonenumbers/phonenumber.cc DELETED

@@ -1,87 +0,0 @@
-// Copyright (C) 2009 The Libphonenumber Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// Author: Philippe Liard
-#include "phonenumbers/phonemetadata.pb.h"
-#include "phonenumbers/phonenumber.pb.h"
-namespace i18n {
-namespace phonenumbers {
-bool ExactlySameAs(const PhoneNumber& first_number,
-                   const PhoneNumber& second_number) {
-  if (first_number.has_country_code() != second_number.has_country_code() ||
-      first_number.country_code() != second_number.country_code()) {
-    return false;
-  }
-  if (first_number.has_national_number() !=
-      second_number.has_national_number() ||
-      first_number.national_number() != second_number.national_number()) {
-    return false;
-  }
-  if (first_number.has_extension() != second_number.has_extension() ||
-      first_number.extension() != second_number.extension()) {
-    return false;
-  }
-  if (first_number.has_italian_leading_zero() !=
-      second_number.has_italian_leading_zero() ||
-      first_number.italian_leading_zero() !=
-      second_number.italian_leading_zero()) {
-    return false;
-  }
-  if (first_number.has_raw_input() != second_number.has_raw_input() ||
-      first_number.raw_input() != second_number.raw_input()) {
-    return false;
-  }
-  if (first_number.has_country_code_source() !=
-      second_number.has_country_code_source() ||
-      first_number.country_code_source() !=
-      second_number.country_code_source()) {
-    return false;
-  }
-  if (first_number.has_preferred_domestic_carrier_code() !=
-      second_number.has_preferred_domestic_carrier_code() ||
-      first_number.preferred_domestic_carrier_code() !=
-      second_number.preferred_domestic_carrier_code()) {
-    return false;
-  }
-  return true;
-}
-bool ExactlySameAs(const PhoneNumberDesc& first_number_desc,
-                   const PhoneNumberDesc& second_number_desc) {
-  if (first_number_desc.has_national_number_pattern() !=
-      second_number_desc.has_national_number_pattern() ||
-      first_number_desc.national_number_pattern() !=
-      second_number_desc.national_number_pattern()) {
-    return false;
-  }
-  if (first_number_desc.has_possible_number_pattern() !=
-      second_number_desc.has_possible_number_pattern() ||
-      first_number_desc.possible_number_pattern() !=
-      second_number_desc.possible_number_pattern()) {
-    return false;
-  }
-  if (first_number_desc.has_example_number() !=
-      second_number_desc.has_example_number() ||
-      first_number_desc.example_number() !=
-      second_number_desc.example_number()) {
-    return false;
-  }
-  return true;
-}
-}  // namespace phonenumbers
-}  // namespace i18n

data/data/libphonenumber/cpp/src/phonenumbers/phonenumber.h DELETED

@@ -1,40 +0,0 @@
-// Copyright (C) 2009 The Libphonenumber Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-// Author: Philippe Liard
-#ifndef I18N_PHONENUMBERS_PHONENUMBER_H_
-#define I18N_PHONENUMBERS_PHONENUMBER_H_
-// Helper functions dealing with PhoneNumber and PhoneNumberDesc comparisons.
-namespace i18n {
-namespace phonenumbers {
-class PhoneNumber;
-class PhoneNumberDesc;
-// Compares two phone numbers.
-bool ExactlySameAs(const PhoneNumber& first_number,
-                   const PhoneNumber& second_number);
-// Compares two phone number descriptions.
-bool ExactlySameAs(const PhoneNumberDesc& first_number_desc,
-                   const PhoneNumberDesc& second_number_desc);
-}  // namespace phonenumbers
-}  // namespace i18n
-#endif  // I18N_PHONENUMBERS_PHONENUMBER_H_

data/data/libphonenumber/cpp/src/phonenumbers/phonenumbermatch.cc DELETED

@@ -1,91 +0,0 @@
-// Copyright (C) 2011 The Libphonenumber Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: Tao Huang
-//
-// Implementation of a mutable match of a phone number within a piece of
-// text. Matches may be found using PhoneNumberUtil::FindNumbers.
-#include "phonenumbers/phonenumbermatch.h"
-#include <string>
-#include "phonenumbers/phonenumber.h"
-#include "phonenumbers/phonenumber.pb.h"
-#include "phonenumbers/stringutil.h"
-namespace i18n {
-namespace phonenumbers {
-PhoneNumberMatch::PhoneNumberMatch(int start,
-                                   const string& raw_string,
-                                   const PhoneNumber& number)
-    : start_(start), raw_string_(raw_string), number_(number) {
-}
-PhoneNumberMatch::PhoneNumberMatch()
-    : start_(-1), raw_string_(""), number_(PhoneNumber::default_instance()) {
-}
-const PhoneNumber& PhoneNumberMatch::number() const {
-  return number_;
-}
-int PhoneNumberMatch::start() const {
-  return start_;
-}
-int PhoneNumberMatch::end() const {
-  return start_ + raw_string_.length();
-}
-int PhoneNumberMatch::length() const {
-  return raw_string_.length();
-}
-const string& PhoneNumberMatch::raw_string() const {
-  return raw_string_;
-}
-void PhoneNumberMatch::set_start(int start) {
-  start_ = start;
-}
-void PhoneNumberMatch::set_raw_string(const string& raw_string) {
-  raw_string_ = raw_string;
-}
-void PhoneNumberMatch::set_number(const PhoneNumber& number) {
-  number_.CopyFrom(number);
-}
-string PhoneNumberMatch::ToString() const {
-  return StrCat("PhoneNumberMatch [", start(), ",", end(), ") ",
-                raw_string_.c_str());
-}
-bool PhoneNumberMatch::Equals(const PhoneNumberMatch& match) const {
-  return ExactlySameAs(match.number_, number_) &&
-      match.raw_string_.compare(raw_string_) == 0 &&
-      match.start_ == start_;
-}
-void PhoneNumberMatch::CopyFrom(const PhoneNumberMatch& match) {
-  raw_string_ = match.raw_string();
-  start_ = match.start();
-  number_ = match.number();
-}
-}  // namespace phonenumbers
-}  // namespace i18n

data/data/libphonenumber/cpp/src/phonenumbers/phonenumbermatch.h DELETED

@@ -1,125 +0,0 @@
-// Copyright (C) 2011 The Libphonenumber Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: Tao Huang
-//
-// A mutable match of a phone number within a piece of text.
-// Matches may be found using PhoneNumberUtil::FindNumbers.
-//
-// A match consists of the phone number as well as the start and end offsets of
-// the corresponding subsequence of the searched text. Use raw_string() to
-// obtain a copy of the matched subsequence.
-//
-// The following annotated example clarifies the relationship between the
-// searched text, the match offsets, and the parsed number:
-//
-// string text = "Call me at +1 425 882-8080 for details.";
-// const string country = "US";
-//
-// // Find the first phone number match:
-// PhoneNumberMatcher matcher(text, country);
-// if (matcher.HasNext()) {
-//   PhoneNumberMatch match;
-//   matcher.Next(&match);
-// }
-//
-// // raw_string() contains the phone number as it appears in the text.
-// "+1 425 882-8080" == match.raw_string();
-//
-// // start() and end() define the range of the matched subsequence.
-// string subsequence = text.substr(match.start(), match.end());
-// "+1 425 882-8080" == subsequence;
-//
-// // number() returns the the same result as PhoneNumberUtil::Parse()
-// // invoked on raw_string().
-// const PhoneNumberUtil& util = *PhoneNumberUtil::GetInstance();
-// util.Parse(match.raw_string(), country).Equals(match.number());
-//
-// This class is a port of PhoneNumberMatch.java
-#ifndef I18N_PHONENUMBERS_PHONENUMBERMATCH_H_
-#define I18N_PHONENUMBERS_PHONENUMBERMATCH_H_
-#include <string>
-#include "phonenumbers/base/basictypes.h"
-#include "phonenumbers/phonenumber.pb.h"
-namespace i18n {
-namespace phonenumbers {
-using std::string;
-class PhoneNumberMatch {
- public:
-  // Creates a new match.
-  // - start is the index into the target text.
-  // - match is the matched string of the target text.
-  // - number is the matched phone number.
-  PhoneNumberMatch(int start,
-                   const string& raw_string,
-                   const PhoneNumber& number);
-  // Default constructor.
-  PhoneNumberMatch();
-  ~PhoneNumberMatch() {}
-  // Returns the phone number matched by the receiver.
-  const PhoneNumber& number() const;
-  // Returns the start index of the matched phone number within the searched
-  // text.
-  int start() const;
-  // Returns the exclusive end index of the matched phone number within the
-  // searched text.
-  int end() const;
-  // Returns the length of the text matched in the searched text.
-  int length() const;
-  // Returns the raw string matched as a phone number in the searched text.
-  const string& raw_string() const;
-  // Returns a string containing debug information.
-  string ToString() const;
-  void set_start(int start);
-  void set_raw_string(const string& raw_string);
-  void set_number(const PhoneNumber& number);
-  bool Equals(const PhoneNumberMatch& number) const;
-  void CopyFrom(const PhoneNumberMatch& number);
- private:
-  // The start index into the text.
-  int start_;
-  // The raw substring matched.
-  string raw_string_;
-  // The matched phone number.
-  PhoneNumber number_;
-  DISALLOW_COPY_AND_ASSIGN(PhoneNumberMatch);
-};
-}  // namespace phonenumbers
-}  // namespace i18n
-#endif  // I18N_PHONENUMBERS_PHONENUMBERMATCH_H_

data/data/libphonenumber/cpp/src/phonenumbers/phonenumbermatcher.cc DELETED

@@ -1,907 +0,0 @@
-// Copyright (C) 2011 The Libphonenumber Authors
-//
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//
-// http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-// Author: Lara Rennie
-// Author: Tao Huang
-//
-// Implementation of a stateful class that finds and extracts telephone numbers
-// from text.
-#include "phonenumbers/phonenumbermatcher.h"
-#ifndef I18N_PHONENUMBERS_USE_ICU_REGEXP
-#error phonenumbermatcher depends on ICU \
-    (i.e. I18N_PHONENUMBERS_USE_ICU_REGEXP must be set)
-#endif  // I18N_PHONENUMBERS_USE_ICU_REGEXP
-#include <ctype.h>
-#include <stddef.h>
-#include <limits>
-#include <map>
-#include <string>
-#include <utility>
-#include <vector>
-#include <unicode/uchar.h>
-#include "phonenumbers/alternate_format.h"
-#include "phonenumbers/base/logging.h"
-#include "phonenumbers/base/memory/scoped_ptr.h"
-#include "phonenumbers/base/memory/singleton.h"
-#include "phonenumbers/callback.h"
-#include "phonenumbers/default_logger.h"
-#include "phonenumbers/encoding_utils.h"
-#include "phonenumbers/normalize_utf8.h"
-#include "phonenumbers/phonemetadata.pb.h"
-#include "phonenumbers/phonenumber.pb.h"
-#include "phonenumbers/phonenumbermatch.h"
-#include "phonenumbers/phonenumberutil.h"
-#include "phonenumbers/regexp_adapter.h"
-#include "phonenumbers/regexp_adapter_icu.h"
-#include "phonenumbers/stringutil.h"
-#ifdef I18N_PHONENUMBERS_USE_RE2
-#include "phonenumbers/regexp_adapter_re2.h"
-#endif  // I18N_PHONENUMBERS_USE_RE2_AND_ICU
-using std::map;
-using std::numeric_limits;
-using std::string;
-using std::vector;
-namespace i18n {
-namespace phonenumbers {
-namespace {
-// Returns a regular expression quantifier with an upper and lower limit.
-string Limit(int lower, int upper) {
-  DCHECK_GE(lower, 0);
-  DCHECK_GT(upper, 0);
-  DCHECK_LT(lower, upper);
-  return StrCat("{", lower, ",", upper, "}");
-}
-bool IsInvalidPunctuationSymbol(char32 character) {
-  return character == '%' || u_charType(character) == U_CURRENCY_SYMBOL;
-}
-bool ContainsOnlyValidXChars(const PhoneNumber& number, const string& candidate,
-                             const PhoneNumberUtil& util) {
-  // The characters 'x' and 'X' can be (1) a carrier code, in which case they
-  // always precede the national significant number or (2) an extension sign,
-  // in which case they always precede the extension number. We assume a
-  // carrier code is more than 1 digit, so the first case has to have more than
-  // 1 consecutive 'x' or 'X', whereas the second case can only have exactly 1
-  // 'x' or 'X'.
-  size_t found;
-  found = candidate.find_first_of("xX");
-  // We ignore the character if 'x' or 'X' appears as the last character of
-  // the string.
-  while (found != string::npos && found < candidate.length() - 1) {
-    // We only look for 'x' or 'X' in ASCII form.
-    char next_char = candidate[found + 1];
-    if (next_char == 'x' || next_char == 'X') {
-      // This is the carrier code case, in which the 'X's always precede the
-      // national significant number.
-      ++found;
-      if (util.IsNumberMatchWithOneString(
-              number, candidate.substr(found, candidate.length() - found))
-          != PhoneNumberUtil::NSN_MATCH) {
-        return false;
-      }
-    } else {
-      string normalized_extension(candidate.substr(found,
-                                                   candidate.length() - found));
-      util.NormalizeDigitsOnly(&normalized_extension);
-      if (normalized_extension != number.extension()) {
-        return false;
-      }
-    }
-    found = candidate.find_first_of("xX", found + 1);
-  }
-  return true;
-}
-bool AllNumberGroupsRemainGrouped(
-    const PhoneNumberUtil& util,
-    const PhoneNumber& number,
-    const string& normalized_candidate,
-    const vector<string>& formatted_number_groups) {
-  size_t from_index = 0;
-  if (number.country_code_source() != PhoneNumber::FROM_DEFAULT_COUNTRY) {
-    // First skip the country code if the normalized candidate contained it.
-    string country_code = SimpleItoa(number.country_code());
-    from_index = normalized_candidate.find(country_code) + country_code.size();
-  }
-  // Check each group of consecutive digits are not broken into separate
-  // groupings in the normalized_candidate string.
-  for (size_t i = 0; i < formatted_number_groups.size(); ++i) {
-    // Fails if the substring of normalized_candidate starting from from_index
-    // doesn't contain the consecutive digits in formatted_number_groups.at(i).
-    from_index = normalized_candidate.find(formatted_number_groups.at(i),
-                                           from_index);
-    if (from_index == string::npos) {
-      return false;
-    }
-    // Moves from_index forward.
-    from_index += formatted_number_groups.at(i).length();
-    if (i == 0 && from_index < normalized_candidate.length()) {
-      // We are at the position right after the NDC. We get the region used for
-      // formatting information based on the country code in the phone number,
-      // rather than the number itself, as we do not need to distinguish between
-      // different countries with the same country calling code and this is
-      // faster.
-      string region;
-      util.GetRegionCodeForCountryCode(number.country_code(), &region);
-      string ndd_prefix;
-      util.GetNddPrefixForRegion(region, true, &ndd_prefix);
-      // Note although normalized_candidate might contain non-ASCII formatting
-      // characters, they won't be treated as ASCII digits when converted to a
-      // char.
-      if (!ndd_prefix.empty() && isdigit(normalized_candidate.at(from_index))) {
-        // This means there is no formatting symbol after the NDC. In this case,
-        // we only accept the number if there is no formatting symbol at all in
-        // the number, except for extensions. This is only important for
-        // countries with national prefixes.
-        string national_significant_number;
-        util.GetNationalSignificantNumber(number, &national_significant_number);
-        return HasPrefixString(normalized_candidate.substr(
-            from_index - formatted_number_groups.at(i).length()),
-            national_significant_number);
-        }
-      }
-    }
-    // The check here makes sure that we haven't mistakenly already used the
-    // extension to match the last group of the subscriber number. Note the
-    // extension cannot have formatting in-between digits.
-    return normalized_candidate.substr(from_index)
-        .find(number.extension()) != string::npos;
-}
-bool LoadAlternateFormats(PhoneMetadataCollection* alternate_formats) {
-#if defined(I18N_PHONENUMBERS_USE_ALTERNATE_FORMATS)
-  if (!alternate_formats->ParseFromArray(alternate_format_get(),
-                                         alternate_format_size())) {
-    LOG(ERROR) << "Could not parse binary data.";
-    return false;
-  }
-  return true;
-#else
-  return false;
-#endif
-}
-}  // namespace
-class PhoneNumberMatcherRegExps : public Singleton<PhoneNumberMatcherRegExps> {
- private:
-  friend class Singleton<PhoneNumberMatcherRegExps>;
-  string opening_parens_;
-  string closing_parens_;
-  string non_parens_;
-  // Limit on the number of pairs of brackets in a phone number.
-  string bracket_pair_limit_;
-  // Helper strings for the matching_brackets_ pattern.
-  // An opening bracket at the beginning may not be closed, but subsequent ones
-  // should be. It's also possible that the leading bracket was dropped, so we
-  // shouldn't be surprised if we see a closing bracket first.
-  string leading_maybe_matched_bracket_;
-  string bracket_pairs_;
-  // Limit on the number of leading (plus) characters.
-  string lead_limit_;
-  // Limit on the number of consecutive punctuation characters.
-  string punctuation_limit_;
-  // The maximum number of digits allowed in a digit-separated block. As we
-  // allow all digits in a single block, this should be set high enough to
-  // accommodate the entire national number and the international country code.
-  int digit_block_limit_;
-  // Limit on the number of blocks separated by punctuation. Uses
-  // kDigitBlockLimit since some formats use spaces to separate each digit.
-  string block_limit_;
-  // A punctuation sequence allowing white space.
-  string punctuation_;
-  // A digits block without punctuation.
-  string digit_sequence_;
-  // Punctuation that may be at the start of a phone number - brackets and plus
-  // signs.
-  string lead_class_chars_;
-  // Same as lead_class_chars_, but enclosed as a character class.
-  string lead_class_;
-  // Extra helper strings that form part of pattern_. These are stored
-  // separately since StrCat has a limit of 12 args.
-  string opening_punctuation_;
-  string optional_extn_pattern_;
- public:
-  // We use two different reg-ex factories here for performance reasons. RE2 is
-  // much faster for smaller reg-ex patterns, but the main pattern cannot be
-  // handled by RE2 in an efficient way.
-  scoped_ptr<const AbstractRegExpFactory> regexp_factory_for_pattern_;
-  scoped_ptr<const AbstractRegExpFactory> regexp_factory_;
-  // Matches strings that look like publication pages. Example:
-  // Computing Complete Answers to Queries in the Presence of Limited Access
-  // Patterns. Chen Li. VLDB J. 12(3): 211-227 (2003).
-  //
-  // The string "211-227 (2003)" is not a telephone number.
-  scoped_ptr<const RegExp> pub_pages_;
-  // Matches strings that look like dates using "/" as a separator. Examples:
-  // 3/10/2011, 31/10/96 or 08/31/95.
-  scoped_ptr<const RegExp> slash_separated_dates_;
-  // Matches timestamps. Examples: "2012-01-02 08:00". Note that the reg-ex does
-  // not include trailing ":\d\d" -- that is covered by time_stamps_suffix_.
-  scoped_ptr<const RegExp> time_stamps_;
-  scoped_ptr<const RegExp> time_stamps_suffix_;
-  // Pattern to check that brackets match. Opening brackets should be closed
-  // within a phone number. This also checks that there is something inside the
-  // brackets. Having no brackets at all is also fine.
-  scoped_ptr<const RegExp> matching_brackets_;
-  // Patterns used to extract phone numbers from a larger phone-number-like
-  // pattern. These are ordered according to specificity. For example,
-  // white-space is last since that is frequently used in numbers, not just to
-  // separate two numbers. We have separate patterns since we don't want to
-  // break up the phone-number-like text on more than one different kind of
-  // symbol at one time, although symbols of the same type (e.g. space) can be
-  // safely grouped together.
-  //
-  // Note that if there is a match, we will always check any text found up to
-  // the first match as well.
-  scoped_ptr<vector<const RegExp*> > inner_matches_;
-  scoped_ptr<const RegExp> capture_up_to_second_number_start_pattern_;
-  scoped_ptr<const RegExp> capturing_ascii_digits_pattern_;
-  // Compiled reg-ex representing lead_class_;
-  scoped_ptr<const RegExp> lead_class_pattern_;
-  // Phone number pattern allowing optional punctuation.
-  scoped_ptr<const RegExp> pattern_;
-  PhoneNumberMatcherRegExps()
-      : opening_parens_("(\\[\xEF\xBC\x88\xEF\xBC\xBB" /* "(\\[（［" */),
-        closing_parens_(")\\]\xEF\xBC\x89\xEF\xBC\xBD" /* ")\\]）］" */),
-        non_parens_(StrCat("[^", opening_parens_, closing_parens_, "]")),
-        bracket_pair_limit_(Limit(0, 3)),
-        leading_maybe_matched_bracket_(StrCat(
-            "(?:[", opening_parens_, "])?",
-            "(?:", non_parens_, "+[", closing_parens_, "])?")),
-        bracket_pairs_(StrCat(
-            "(?:[", opening_parens_, "]", non_parens_, "+",
-            "[", closing_parens_, "])", bracket_pair_limit_)),
-        lead_limit_(Limit(0, 2)),
-        punctuation_limit_(Limit(0, 4)),
-        digit_block_limit_(PhoneNumberUtil::kMaxLengthForNsn +
-                           PhoneNumberUtil::kMaxLengthCountryCode),
-        block_limit_(Limit(0, digit_block_limit_)),
-        punctuation_(StrCat("[", PhoneNumberUtil::kValidPunctuation, "]",
-                            punctuation_limit_)),
-        digit_sequence_(StrCat("\\p{Nd}", Limit(1, digit_block_limit_))),
-        lead_class_chars_(StrCat(opening_parens_, PhoneNumberUtil::kPlusChars)),
-        lead_class_(StrCat("[", lead_class_chars_, "]")),
-        opening_punctuation_(StrCat("(?:", lead_class_, punctuation_, ")")),
-        optional_extn_pattern_(StrCat(
-            "(?i)(?:",
-            PhoneNumberUtil::GetInstance()->GetExtnPatternsForMatching(),
-            ")?")),
-        regexp_factory_for_pattern_(new ICURegExpFactory()),
-#ifdef I18N_PHONENUMBERS_USE_RE2
-        regexp_factory_(new RE2RegExpFactory()),
-#else
-        regexp_factory_(new ICURegExpFactory()),
-#endif  // I18N_PHONENUMBERS_USE_RE2
-        pub_pages_(regexp_factory_->CreateRegExp(
-            "\\d{1,5}-+\\d{1,5}\\s{0,4}\\(\\d{1,4}")),
-        slash_separated_dates_(regexp_factory_->CreateRegExp(
-            "(?:(?:[0-3]?\\d/[01]?\\d)|"
-            "(?:[01]?\\d/[0-3]?\\d))/(?:[12]\\d)?\\d{2}")),
-        time_stamps_(regexp_factory_->CreateRegExp(
-            "[12]\\d{3}[-/]?[01]\\d[-/]?[0-3]\\d +[0-2]\\d$")),
-        time_stamps_suffix_(regexp_factory_->CreateRegExp(":[0-5]\\d")),
-        matching_brackets_(regexp_factory_->CreateRegExp(
-            StrCat(leading_maybe_matched_bracket_, non_parens_, "+",
-                   bracket_pairs_, non_parens_, "*"))),
-        inner_matches_(new vector<const RegExp*>()),
-        capture_up_to_second_number_start_pattern_(
-            regexp_factory_->CreateRegExp(
-                PhoneNumberUtil::kCaptureUpToSecondNumberStart)),
-        capturing_ascii_digits_pattern_(
-            regexp_factory_->CreateRegExp("(\\d+)")),
-        lead_class_pattern_(regexp_factory_->CreateRegExp(lead_class_)),
-        pattern_(regexp_factory_for_pattern_->CreateRegExp(
-            StrCat("(", opening_punctuation_, lead_limit_,
-                   digit_sequence_, "(?:", punctuation_, digit_sequence_, ")",
-                   block_limit_, optional_extn_pattern_, ")"))) {
-    inner_matches_->push_back(
-        // Breaks on the slash - e.g. "651-234-2345/332-445-1234"
-        regexp_factory_->CreateRegExp("/+(.*)"));
-    inner_matches_->push_back(
-        // Note that the bracket here is inside the capturing group, since we
-        // consider it part of the phone number. Will match a pattern like
-        // "(650) 223 3345 (754) 223 3321".
-        regexp_factory_->CreateRegExp("(\\([^(]*)"));
-    inner_matches_->push_back(
-        // Breaks on a hyphen - e.g. "12345 - 332-445-1234 is my number." We
-        // require a space on either side of the hyphen for it to be considered
-        // a separator.
-        regexp_factory_->CreateRegExp("(?:\\p{Z}-|-\\p{Z})\\p{Z}*(.+)"));
-    inner_matches_->push_back(
-        // Various types of wide hyphens. Note we have decided not to enforce a
-        // space here, since it's possible that it's supposed to be used to
-        // break two numbers without spaces, and we haven't seen many instances
-        // of it used within a number.
-        regexp_factory_->CreateRegExp(
-            "[\xE2\x80\x92-\xE2\x80\x95\xEF\xBC\x8D]" /* "‒-―－" */
-            "\\p{Z}*(.+)"));
-    inner_matches_->push_back(
-        // Breaks on a full stop - e.g. "12345. 332-445-1234 is my number."
-        regexp_factory_->CreateRegExp("\\.+\\p{Z}*([^.]+)"));
-    inner_matches_->push_back(
-        // Breaks on space - e.g. "3324451234 8002341234"
-        regexp_factory_->CreateRegExp("\\p{Z}+(\\P{Z}+)"));
-  }
- private:
-  DISALLOW_COPY_AND_ASSIGN(PhoneNumberMatcherRegExps);
-};
-class AlternateFormats : public Singleton<AlternateFormats> {
- public:
-  PhoneMetadataCollection format_data_;
-  map<int, const PhoneMetadata*> calling_code_to_alternate_formats_map_;
-  AlternateFormats()
-      : format_data_(),
-        calling_code_to_alternate_formats_map_() {
-    if (!LoadAlternateFormats(&format_data_)) {
-      LOG(DFATAL) << "Could not parse compiled-in metadata.";
-      return;
-    }
-    for (RepeatedPtrField<PhoneMetadata>::const_iterator it =
-             format_data_.metadata().begin();
-         it != format_data_.metadata().end();
-         ++it) {
-      calling_code_to_alternate_formats_map_.insert(
-          std::make_pair(it->country_code(), &*it));
-    }
-  }
-  const PhoneMetadata* GetAlternateFormatsForCountry(int country_calling_code)
-      const {
-    map<int, const PhoneMetadata*>::const_iterator it =
-        calling_code_to_alternate_formats_map_.find(country_calling_code);
-    if (it != calling_code_to_alternate_formats_map_.end()) {
-      return it->second;
-    }
-    return NULL;
-  }
- private:
-  DISALLOW_COPY_AND_ASSIGN(AlternateFormats);
-};
-PhoneNumberMatcher::PhoneNumberMatcher(const PhoneNumberUtil& util,
-                                       const string& text,
-                                       const string& region_code,
-                                       PhoneNumberMatcher::Leniency leniency,
-                                       int max_tries)
-    : reg_exps_(PhoneNumberMatcherRegExps::GetInstance()),
-      alternate_formats_(AlternateFormats::GetInstance()),
-      phone_util_(util),
-      text_(text),
-      preferred_region_(region_code),
-      leniency_(leniency),
-      max_tries_(max_tries),
-      state_(NOT_READY),
-      last_match_(NULL),
-      search_index_(0) {
-}
-PhoneNumberMatcher::PhoneNumberMatcher(const string& text,
-                                       const string& region_code)
-    : reg_exps_(PhoneNumberMatcherRegExps::GetInstance()),
-      alternate_formats_(NULL),  // Not used.
-      phone_util_(*PhoneNumberUtil::GetInstance()),
-      text_(text),
-      preferred_region_(region_code),
-      leniency_(VALID),
-      max_tries_(numeric_limits<int>::max()),
-      state_(NOT_READY),
-      last_match_(NULL),
-      search_index_(0) {
-}
-PhoneNumberMatcher::~PhoneNumberMatcher() {
-}
-// static
-bool PhoneNumberMatcher::IsLatinLetter(char32 letter) {
-  // Combining marks are a subset of non-spacing-mark.
-  if (!u_isalpha(letter) && (u_charType(letter) != U_NON_SPACING_MARK)) {
-    return false;
-  }
-  UBlockCode block = ublock_getCode(letter);
-  return ((block == UBLOCK_BASIC_LATIN) ||
-      (block == UBLOCK_LATIN_1_SUPPLEMENT) ||
-      (block == UBLOCK_LATIN_EXTENDED_A) ||
-      (block == UBLOCK_LATIN_EXTENDED_ADDITIONAL) ||
-      (block == UBLOCK_LATIN_EXTENDED_B) ||
-      (block == UBLOCK_COMBINING_DIACRITICAL_MARKS));
-}
-bool PhoneNumberMatcher::ParseAndVerify(const string& candidate, int offset,
-                                        PhoneNumberMatch* match) {
-  DCHECK(match);
-  // Check the candidate doesn't contain any formatting which would indicate
-  // that it really isn't a phone number.
-  if (!reg_exps_->matching_brackets_->FullMatch(candidate) ||
-      reg_exps_->pub_pages_->PartialMatch(candidate)) {
-    return false;
-  }
-  // If leniency is set to VALID or stricter, we also want to skip numbers that
-  // are surrounded by Latin alphabetic characters, to skip cases like
-  // abc8005001234 or 8005001234def.
-  if (leniency_ >= VALID) {
-    // If the candidate is not at the start of the text, and does not start with
-    // phone-number punctuation, check the previous character.
-    scoped_ptr<RegExpInput> candidate_input(
-        reg_exps_->regexp_factory_->CreateInput(candidate));
-    if (offset > 0 &&
-        !reg_exps_->lead_class_pattern_->Consume(candidate_input.get())) {
-      char32 previous_char;
-      const char* previous_char_ptr =
-          EncodingUtils::BackUpOneUTF8Character(text_.c_str(),
-                                                text_.c_str() + offset);
-      EncodingUtils::DecodeUTF8Char(previous_char_ptr, &previous_char);
-      // We return false if it is a latin letter or an invalid punctuation
-      // symbol.
-      if (IsInvalidPunctuationSymbol(previous_char) ||
-          IsLatinLetter(previous_char)) {
-        return false;
-      }
-    }
-    size_t lastCharIndex = offset + candidate.length();
-    if (lastCharIndex < text_.length()) {
-      char32 next_char;
-      const char* next_char_ptr =
-          EncodingUtils::AdvanceOneUTF8Character(
-              text_.c_str() + lastCharIndex - 1);
-      EncodingUtils::DecodeUTF8Char(next_char_ptr, &next_char);
-      if (IsInvalidPunctuationSymbol(next_char) || IsLatinLetter(next_char)) {
-        return false;
-      }
-    }
-  }
-  PhoneNumber number;
-  if (phone_util_.ParseAndKeepRawInput(candidate, preferred_region_, &number) !=
-      PhoneNumberUtil::NO_PARSING_ERROR) {
-    return false;
-  }
-  // Check Israel * numbers: these are a special case in that they are
-  // four-digit numbers that our library supports, but they can only be dialled
-  // with a leading *. Since we don't actually store or detect the * in our
-  // phone number library, this means in practice we detect most four digit
-  // numbers as being valid for Israel. We are considering moving these numbers
-  // to ShortNumberInfo instead, in which case this problem would go away, but
-  // in the meantime we want to restrict the false matches so we only allow
-  // these numbers if they are preceded by a star. We enforce this for all
-  // leniency levels even though these numbers are technically accepted by
-  // isPossibleNumber and isValidNumber since we consider it to be a deficiency
-  // in those methods that they accept these numbers without the *.
-  // TODO: Remove this or make it significantly less hacky once
-  // we've decided how to handle these short codes going forward in
-  // ShortNumberInfo. We could use the formatting rules for instance, but that
-  // would be slower.
-  string region_code;
-  phone_util_.GetRegionCodeForCountryCode(number.country_code(), &region_code);
-  if (region_code == "IL") {
-    string national_number;
-    phone_util_.GetNationalSignificantNumber(number, &national_number);
-    if (national_number.length() == 4 &&
-        // Just check the previous char, since * is an ASCII character.
-        (offset == 0 || (offset > 0 && text_[offset - 1] != '*'))) {
-      // No match.
-      return false;
-    }
-  }
-  if (VerifyAccordingToLeniency(leniency_, number, candidate)) {
-    match->set_start(offset);
-    match->set_raw_string(candidate);
-    // We used ParseAndKeepRawInput to create this number, but for now we don't
-    // return the extra values parsed. TODO: stop clearing all values here and
-    // switch all users over to using raw_input() rather than the raw_string()
-    // of PhoneNumberMatch.
-    number.clear_country_code_source();
-    number.clear_preferred_domestic_carrier_code();
-    number.clear_raw_input();
-    match->set_number(number);
-    return true;
-  }
-  return false;
-}
-// Helper method to replace the verification method for each enum in the Java
-// version.
-bool PhoneNumberMatcher::VerifyAccordingToLeniency(
-    Leniency leniency, const PhoneNumber& number,
-    const string& candidate) const {
-  switch (leniency) {
-    case PhoneNumberMatcher::POSSIBLE:
-      return phone_util_.IsPossibleNumber(number);
-    case PhoneNumberMatcher::VALID:
-      if (!phone_util_.IsValidNumber(number) ||
-          !ContainsOnlyValidXChars(number, candidate, phone_util_)) {
-        return false;
-      }
-      return IsNationalPrefixPresentIfRequired(number);
-    case PhoneNumberMatcher::STRICT_GROUPING: {
-      if (!phone_util_.IsValidNumber(number) ||
-          !ContainsOnlyValidXChars(number, candidate, phone_util_) ||
-          ContainsMoreThanOneSlashInNationalNumber(
-              number, candidate, phone_util_) ||
-          !IsNationalPrefixPresentIfRequired(number)) {
-        return false;
-      }
-      ResultCallback4<bool, const PhoneNumberUtil&, const PhoneNumber&,
-                      const string&, const vector<string>&>* callback =
-          NewPermanentCallback(&AllNumberGroupsRemainGrouped);
-      bool is_valid = CheckNumberGroupingIsValid(number, candidate, callback);
-      delete(callback);
-      return is_valid;
-    }
-    case PhoneNumberMatcher::EXACT_GROUPING: {
-      if (!phone_util_.IsValidNumber(number) ||
-          !ContainsOnlyValidXChars(number, candidate, phone_util_) ||
-          ContainsMoreThanOneSlashInNationalNumber(
-              number, candidate, phone_util_) ||
-          !IsNationalPrefixPresentIfRequired(number)) {
-        return false;
-      }
-      ResultCallback4<bool, const PhoneNumberUtil&, const PhoneNumber&,
-                      const string&, const vector<string>&>* callback =
-          NewPermanentCallback(
-              this, &PhoneNumberMatcher::AllNumberGroupsAreExactlyPresent);
-      bool is_valid = CheckNumberGroupingIsValid(number, candidate, callback);
-      delete(callback);
-      return is_valid;
-    }
-    default:
-      LOG(ERROR) << "No implementation defined for verification for leniency "
-                 << static_cast<int>(leniency);
-      return false;
-  }
-}
-bool PhoneNumberMatcher::ExtractInnerMatch(const string& candidate, int offset,
-                                           PhoneNumberMatch* match) {
-  DCHECK(match);
-  for (vector<const RegExp*>::const_iterator regex =
-           reg_exps_->inner_matches_->begin();
-           regex != reg_exps_->inner_matches_->end(); regex++) {
-    scoped_ptr<RegExpInput> candidate_input(
-        reg_exps_->regexp_factory_->CreateInput(candidate));
-    bool is_first_match = true;
-    string group;
-    while ((*regex)->FindAndConsume(candidate_input.get(), &group) &&
-           max_tries_ > 0) {
-      int group_start_index = candidate.length() -
-          candidate_input->ToString().length() - group.length();
-      if (is_first_match) {
-        // We should handle any group before this one too.
-        string first_group_only = candidate.substr(0, group_start_index);
-        phone_util_.TrimUnwantedEndChars(&first_group_only);
-        bool success = ParseAndVerify(first_group_only, offset, match);
-        if (success) {
-          return true;
-        }
-        --max_tries_;
-        is_first_match = false;
-      }
-      phone_util_.TrimUnwantedEndChars(&group);
-      bool success = ParseAndVerify(group, offset + group_start_index, match);
-      if (success) {
-        return true;
-      }
-      --max_tries_;
-    }
-  }
-  return false;
-}
-bool PhoneNumberMatcher::ExtractMatch(const string& candidate, int offset,
-                                      PhoneNumberMatch* match) {
-  DCHECK(match);
-  // Skip a match that is more likely to be a date.
-  if (reg_exps_->slash_separated_dates_->PartialMatch(candidate)) {
-    return false;
-  }
-  // Skip potential time-stamps.
-  if (reg_exps_->time_stamps_->PartialMatch(candidate)) {
-    scoped_ptr<RegExpInput> following_text(
-        reg_exps_->regexp_factory_->CreateInput(
-            text_.substr(offset + candidate.size())));
-    if (reg_exps_->time_stamps_suffix_->Consume(following_text.get())) {
-      return false;
-    }
-  }
-  // Try to come up with a valid match given the entire candidate.
-  if (ParseAndVerify(candidate, offset, match)) {
-    return true;
-  }
-  // If that failed, try to find an "inner match" - there might be a phone
-  // number within this candidate.
-  return ExtractInnerMatch(candidate, offset, match);
-}
-bool PhoneNumberMatcher::HasNext() {
-  if (state_ == NOT_READY) {
-    PhoneNumberMatch temp_match;
-    if (!Find(search_index_, &temp_match)) {
-      state_ = DONE;
-    } else {
-      last_match_.reset(new PhoneNumberMatch(temp_match.start(),
-                                             temp_match.raw_string(),
-                                             temp_match.number()));
-      search_index_ = last_match_->end();
-      state_ = READY;
-    }
-  }
-  return state_ == READY;
-}
-bool PhoneNumberMatcher::Next(PhoneNumberMatch* match) {
-  DCHECK(match);
-  // Check the state and find the next match as a side-effect if necessary.
-  if (!HasNext()) {
-    return false;
-  }
-  match->CopyFrom(*last_match_);
-  state_ = NOT_READY;
-  last_match_.reset(NULL);
-  return true;
-}
-bool PhoneNumberMatcher::Find(int index, PhoneNumberMatch* match) {
-  DCHECK(match);
-  scoped_ptr<RegExpInput> text(
-      reg_exps_->regexp_factory_for_pattern_->CreateInput(text_.substr(index)));
-  string candidate;
-  while ((max_tries_ > 0) &&
-         reg_exps_->pattern_->FindAndConsume(text.get(), &candidate)) {
-    int start = text_.length() - text->ToString().length() - candidate.length();
-    // Check for extra numbers at the end.
-    reg_exps_->capture_up_to_second_number_start_pattern_->
-        PartialMatch(candidate, &candidate);
-    if (ExtractMatch(candidate, start, match)) {
-      return true;
-    }
-    index = start + candidate.length();
-    --max_tries_;
-  }
-  return false;
-}
-bool PhoneNumberMatcher::CheckNumberGroupingIsValid(
-    const PhoneNumber& phone_number,
-    const string& candidate,
-    ResultCallback4<bool, const PhoneNumberUtil&, const PhoneNumber&,
-                    const string&, const vector<string>&>* checker) const {
-  DCHECK(checker);
-  // TODO: Evaluate how this works for other locales (testing has been limited
-  // to NANPA regions) and optimise if necessary.
-  string normalized_candidate =
-      NormalizeUTF8::NormalizeDecimalDigits(candidate);
-  vector<string> formatted_number_groups;
-  GetNationalNumberGroups(phone_number, NULL,  // Use default formatting pattern
-                          &formatted_number_groups);
-  if (checker->Run(phone_util_, phone_number, normalized_candidate,
-                   formatted_number_groups)) {
-    return true;
-  }
-  // If this didn't pass, see if there are any alternate formats, and try them
-  // instead.
-  const PhoneMetadata* alternate_formats =
-    alternate_formats_->GetAlternateFormatsForCountry(
-        phone_number.country_code());
-  if (alternate_formats) {
-    for (RepeatedPtrField<NumberFormat>::const_iterator it =
-             alternate_formats->number_format().begin();
-         it != alternate_formats->number_format().end(); ++it) {
-      formatted_number_groups.clear();
-      GetNationalNumberGroups(phone_number, &*it, &formatted_number_groups);
-      if (checker->Run(phone_util_, phone_number, normalized_candidate,
-                       formatted_number_groups)) {
-        return true;
-      }
-    }
-  }
-  return false;
-}
-// Helper method to get the national-number part of a number, formatted without
-// any national prefix, and return it as a set of digit blocks that would be
-// formatted together.
-void PhoneNumberMatcher::GetNationalNumberGroups(
-    const PhoneNumber& number,
-    const NumberFormat* formatting_pattern,
-    vector<string>* digit_blocks) const {
-  string rfc3966_format;
-  if (!formatting_pattern) {
-    // This will be in the format +CC-DG;ext=EXT where DG represents groups of
-    // digits.
-    phone_util_.Format(number, PhoneNumberUtil::RFC3966, &rfc3966_format);
-    // We remove the extension part from the formatted string before splitting
-    // it into different groups.
-    size_t end_index = rfc3966_format.find(';');
-    if (end_index == string::npos) {
-      end_index = rfc3966_format.length();
-    }
-    // The country-code will have a '-' following it.
-    size_t start_index = rfc3966_format.find('-') + 1;
-    SplitStringUsing(rfc3966_format.substr(start_index,
-                                           end_index - start_index),
-                     "-", digit_blocks);
-  } else {
-    // We format the NSN only, and split that according to the separator.
-    string national_significant_number;
-    phone_util_.GetNationalSignificantNumber(number,
-                                             &national_significant_number);
-    phone_util_.FormatNsnUsingPattern(national_significant_number,
-                                      *formatting_pattern,
-                                      PhoneNumberUtil::RFC3966,
-                                      &rfc3966_format);
-    SplitStringUsing(rfc3966_format, "-", digit_blocks);
-  }
-}
-bool PhoneNumberMatcher::IsNationalPrefixPresentIfRequired(
-    const PhoneNumber& number) const {
-  // First, check how we deduced the country code. If it was written in
-  // international format, then the national prefix is not required.
-  if (number.country_code_source() != PhoneNumber::FROM_DEFAULT_COUNTRY) {
-    return true;
-  }
-  string phone_number_region;
-  phone_util_.GetRegionCodeForCountryCode(
-      number.country_code(), &phone_number_region);
-  const PhoneMetadata* metadata =
-      phone_util_.GetMetadataForRegion(phone_number_region);
-  if (!metadata) {
-    return true;
-  }
-  // Check if a national prefix should be present when formatting this number.
-  string national_number;
-  phone_util_.GetNationalSignificantNumber(number, &national_number);
-  const NumberFormat* format_rule =
-      phone_util_.ChooseFormattingPatternForNumber(metadata->number_format(),
-                                                   national_number);
-  // To do this, we check that a national prefix formatting rule was present and
-  // that it wasn't just the first-group symbol ($1) with punctuation.
-  if (format_rule && !format_rule->national_prefix_formatting_rule().empty()) {
-    if (format_rule->national_prefix_optional_when_formatting()) {
-      // The national-prefix is optional in these cases, so we don't need to
-      // check if it was present.
-      return true;
-    }
-    if (phone_util_.FormattingRuleHasFirstGroupOnly(
-        format_rule->national_prefix_formatting_rule())) {
-      // National Prefix not needed for this number.
-      return true;
-    }
-    // Normalize the remainder.
-    string raw_input_copy(number.raw_input());
-    // Check if we found a national prefix and/or carrier code at the start of
-    // the raw input, and return the result.
-    phone_util_.NormalizeDigitsOnly(&raw_input_copy);
-    return phone_util_.MaybeStripNationalPrefixAndCarrierCode(
-        *metadata,
-        &raw_input_copy,
-        NULL);  // Don't need to keep the stripped carrier code.
-  }
-  return true;
-}
-bool PhoneNumberMatcher::AllNumberGroupsAreExactlyPresent(
-    const PhoneNumberUtil& util,
-    const PhoneNumber& phone_number,
-    const string& normalized_candidate,
-    const vector<string>& formatted_number_groups) const {
-  const scoped_ptr<RegExpInput> candidate_number(
-      reg_exps_->regexp_factory_->CreateInput(normalized_candidate));
-  vector<string> candidate_groups;
-  string digit_block;
-  while (reg_exps_->capturing_ascii_digits_pattern_->FindAndConsume(
-             candidate_number.get(),
-             &digit_block)) {
-    candidate_groups.push_back(digit_block);
-  }
-  // Set this to the last group, skipping it if the number has an extension.
-  int candidate_number_group_index =
-      phone_number.has_extension() ? candidate_groups.size() - 2
-                                   : candidate_groups.size() - 1;
-  // First we check if the national significant number is formatted as a block.
-  // We use find and not equals, since the national significant number may be
-  // present with a prefix such as a national number prefix, or the country code
-  // itself.
-  string national_significant_number;
-  util.GetNationalSignificantNumber(phone_number,
-                                    &national_significant_number);
-  if (candidate_groups.size() == 1 ||
-      candidate_groups.at(candidate_number_group_index).find(
-          national_significant_number) != string::npos) {
-    return true;
-  }
-  // Starting from the end, go through in reverse, excluding the first group,
-  // and check the candidate and number groups are the same.
-  for (int formatted_number_group_index =
-           (formatted_number_groups.size() - 1);
-       formatted_number_group_index > 0 &&
-       candidate_number_group_index >= 0;
-       --formatted_number_group_index, --candidate_number_group_index) {
-    if (candidate_groups.at(candidate_number_group_index) !=
-        formatted_number_groups.at(formatted_number_group_index)) {
-      return false;
-    }
-  }
-  // Now check the first group. There may be a national prefix at the start, so
-  // we only check that the candidate group ends with the formatted number
-  // group.
-  return (candidate_number_group_index >= 0 &&
-          HasSuffixString(candidate_groups.at(candidate_number_group_index),
-                          formatted_number_groups.at(0)));
-}
-// static
-bool PhoneNumberMatcher::ContainsMoreThanOneSlashInNationalNumber(
-    const PhoneNumber& number,
-    const string& candidate,
-    const PhoneNumberUtil& util) {
-  size_t first_slash_in_body = candidate.find('/');
-  if (first_slash_in_body == string::npos) {
-    // No slashes, this is okay.
-    return false;
-  }
-  // Now look for a second one.
-  size_t second_slash_in_body = candidate.find('/', first_slash_in_body + 1);
-  if (second_slash_in_body == string::npos) {
-    // Only one slash, this is okay.
-    return false;
-  }
-  // If the first slash is after the country calling code, this is permitted.
-  if (number.country_code_source() == PhoneNumber::FROM_NUMBER_WITH_PLUS_SIGN ||
-      number.country_code_source() ==
-          PhoneNumber::FROM_NUMBER_WITHOUT_PLUS_SIGN) {
-    string normalized_country_code =
-        candidate.substr(0, first_slash_in_body);
-    util.NormalizeDigitsOnly(&normalized_country_code);
-    if (normalized_country_code == SimpleItoa(number.country_code())) {
-      // Any more slashes and this is illegal.
-      return candidate.find('/', second_slash_in_body + 1) != string::npos;
-    }
-  }
-  return true;
-}
-}  // namespace phonenumbers
-}  // namespace i18n