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/asyoutypeformatter.h DELETED

@@ -1,243 +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.
-// A formatter which formats phone numbers as they are entered.
-//
-// An AsYouTypeFormatter can be created by invoking the GetAsYouTypeFormatter
-// method of the PhoneNumberUtil. After that digits can be added by invoking the
-// InputDigit method on the formatter instance, and the partially formatted
-// phone number will be returned each time a digit is added. The Clear method
-// can be invoked before a new number needs to be formatted.
-//
-// See AYTF_US, AYTF_GBFixedLine and AYTF_DE test functions in
-// asyoutypeformatter_test.cc for more details on how the formatter is to be
-// used.
-//
-// This is a direct port from AsYouTypeFormatter.java.
-// Changes to this class should also happen to the Java version, whenever it
-// makes sense.
-//
-// This class is NOT THREAD SAFE.
-#ifndef I18N_PHONENUMBERS_ASYOUTYPEFORMATTER_H_
-#define I18N_PHONENUMBERS_ASYOUTYPEFORMATTER_H_
-#include <list>
-#include <string>
-#include "phonenumbers/base/basictypes.h"
-#include "phonenumbers/base/memory/scoped_ptr.h"
-#include "phonenumbers/regexp_adapter.h"
-#include "phonenumbers/regexp_cache.h"
-#include "phonenumbers/phonemetadata.pb.h"
-#include "phonenumbers/unicodestring.h"
-namespace i18n {
-namespace phonenumbers {
-using std::list;
-using std::string;
-class PhoneNumberUtil;
-class AsYouTypeFormatter {
- public:
-  ~AsYouTypeFormatter() {}
-  // Formats a phone number on-the-fly as each digit is entered.
-  // next_char is the most recently entered digit of a phone number. Formatting
-  // characters are allowed, but as soon as they are encountered this method
-  // formats the number as entered and not "as you type" anymore. Full width
-  // digits and Arabic-indic digits are allowed, and will be shown as they are.
-  // Returns the partially formatted phone number (which is a reference to the
-  // given string parameter for convenience).
-  const string& InputDigit(char32 next_char, string* result);
-  // Same as InputDigit, but remembers the position where next_char is inserted,
-  // so that it could be retrieved later by using GetRememberedPosition(). The
-  // remembered position will be automatically adjusted if additional formatting
-  // characters are later inserted/removed in front of next_char.
-  // Returns the partially formatted phone number (which is a reference to the
-  // given string parameter for convenience).
-  const string& InputDigitAndRememberPosition(char32 next_char, string* result);
-  // Returns the current position in the partially formatted phone number of the
-  // character which was previously passed in as the parameter of
-  // InputDigitAndRememberPosition().
-  int GetRememberedPosition() const;
-  // Clears the internal state of the formatter, so it could be reused.
-  void Clear();
- private:
-  // Constructs an as-you-type formatter. Should be obtained from
-  // PhoneNumberUtil::GetAsYouTypeFormatter().
-  explicit AsYouTypeFormatter(const string& region_code);
-  // Returns the metadata corresponding to the given region code or empty
-  // metadata if it is unsupported.
-  const PhoneMetadata* GetMetadataForRegion(const string& region_code) const;
-  // Returns true if a new template is created as opposed to reusing the
-  // existing template.
-  bool MaybeCreateNewTemplate();
-  void GetAvailableFormats(const string& leading_digits);
-  void NarrowDownPossibleFormats(const string& leading_digits);
-  // Calculates whether we should be adding a space after the national prefix
-  // for this formatting rule or not.
-  void SetShouldAddSpaceAfterNationalPrefix(const NumberFormat& format);
-  bool CreateFormattingTemplate(const NumberFormat& format);
-  // Gets a formatting template which could be used to efficiently format a
-  // partial number where digits are added one by one.
-  void GetFormattingTemplate(const string& number_pattern,
-                             const string& number_format,
-                             UnicodeString* formatting_template);
-  void InputDigitWithOptionToRememberPosition(char32 next_char,
-                                              bool remember_position,
-                                              string* phone_number);
-  void AttemptToChoosePatternWithPrefixExtracted(string* formatted_number);
-  const string& GetExtractedNationalPrefix() const;
-  // Some national prefixes are a substring of others. If extracting the
-  // shorter NDD doesn't result in a number we can format, we try to see if we
-  // can extract a longer version here.
-  bool AbleToExtractLongerNdd();
-  // Check to see if there is an exact pattern match for these digits. If so, we
-  // should use this instead of any other formatting template whose
-  // leadingDigitsPattern also matches the input.
-  void AttemptToFormatAccruedDigits(string* formatted_number);
-  // Combines the national number with any prefix (IDD/+ and country code or
-  // national prefix) that was collected. A space will be inserted between them
-  // if the current formatting template indicates this to be suitable.
-  // The result will be stored in phone_number.
-  void AppendNationalNumber(const string& national_number,
-                            string* phone_number) const;
-  // Attempts to set the formatting template and assigns the passed-in string
-  // parameter to the formatted version of the digits entered so far.
-  void AttemptToChooseFormattingPattern(string* formatted_number);
-  // Invokes InputDigitHelper on each digit of the national number accrued, and
-  // assigns the passed-in string parameter to a formatted string in the end.
-  void InputAccruedNationalNumber(string* number);
-  // Returns true if the current country is a NANPA country and the national
-  // number begins with the national prefix.
-  bool IsNanpaNumberWithNationalPrefix() const;
-  // Extracts the national prefix into national_prefix, or sets it to empty
-  // string if a national prefix is not present.
-  void RemoveNationalPrefixFromNationalNumber(string* national_prefix);
-  // Extracts IDD and plus sign to prefix_before_national_number_ when they are
-  // available, and places the remaining input into national_number_.
-  bool AttemptToExtractIdd();
-  // Extracts country code from the begining of national_number_ to
-  // prefix_before_national_number_ when they are available, and places the
-  // remaining input into national_number_.
-  // Returns true when a valid country code can be found.
-  bool AttemptToExtractCountryCode();
-  // Accrues digits and the plus sign to accrued_input_without_formatting for
-  // later use. If next_char contains a digit in non-ASCII format (e.g the
-  // full-width version of digits), it is first normalized to the ASCII
-  // version. The return value is next_char itself, or its normalized version,
-  // if next_char is a digit in non-ASCII format.
-  char NormalizeAndAccrueDigitsAndPlusSign(char32 next_char,
-                                           bool remember_position);
-  void InputDigitHelper(char next_char, string* number);
-  // Converts UnicodeString position to std::string position.
-  static int ConvertUnicodeStringPosition(const UnicodeString& s, int pos);
-  // Class attributes.
-  const scoped_ptr<const AbstractRegExpFactory> regexp_factory_;
-  RegExpCache regexp_cache_;
-  string current_output_;
-  UnicodeString formatting_template_;
-  string current_formatting_pattern_;
-  UnicodeString accrued_input_;
-  UnicodeString accrued_input_without_formatting_;
-  // This indicates whether AsYouTypeFormatter is currently doing the
-  // formatting.
-  bool able_to_format_;
-  // Set to true when users enter their own formatting. AsYouTypeFormatter will
-  // do no formatting at all when this is set to true.
-  bool input_has_formatting_;
-  // This is set to true when we know the user is entering a full national
-  // significant number, since we have either detected a national prefix or an
-  // international dialing prefix. When this is true, we will no longer use
-  // local number formatting patterns.
-  bool is_complete_number_;
-  bool is_expecting_country_code_;
-  const PhoneNumberUtil& phone_util_;
-  const string default_country_;
-  const PhoneMetadata empty_metadata_;
-  const PhoneMetadata* const default_metadata_;
-  const PhoneMetadata* current_metadata_;
-  int last_match_position_;
-  // The position of a digit upon which InputDigitAndRememberPosition is most
-  // recently invoked, as found in the original sequence of characters the user
-  // entered.
-  int original_position_;
-  // The position of a digit upon which InputDigitAndRememberPosition is most
-  // recently invoked, as found in AccruedInputWithoutFormatting.
-  int position_to_remember_;
-  // This contains anything that has been entered so far preceding the national
-  // significant number, and it is formatted (e.g. with space inserted). For
-  // example, this can contain IDD, country code, and/or NDD, etc.
-  string prefix_before_national_number_;
-  bool should_add_space_after_national_prefix_;
-  // This contains the national prefix that has been extracted. It contains only
-  // digits without formatting.
-  string extracted_national_prefix_;
-  string national_number_;
-  list<const NumberFormat*> possible_formats_;
-  friend class PhoneNumberUtil;
-  friend class AsYouTypeFormatterTest;
-  // Disallow copy and assign since this class uses RegExpCache which can't be
-  // copied.
-  DISALLOW_COPY_AND_ASSIGN(AsYouTypeFormatter);
-};
-}  // namespace phonenumbers
-}  // namespace i18n
-#endif  // I18N_PHONENUMBERS_ASYOUTYPEFORMATTER_H_

data/data/libphonenumber/cpp/src/phonenumbers/base/basictypes.h DELETED

@@ -1,263 +0,0 @@
-// Copyright (c) 2010 The Chromium Authors. All rights reserved.
-// Use of this source code is governed by a BSD-style license that can be
-// found in the LICENSE file.
-#ifndef I18N_PHONENUMBERS_BASE_BASICTYPES_H_
-#define I18N_PHONENUMBERS_BASE_BASICTYPES_H_
-#include <limits.h>         // So we can set the bounds of our types
-#include <stddef.h>         // For size_t
-#include <string.h>         // for memcpy
-#if !defined(_WIN32)
-// stdint.h is part of C99 but MSVC doesn't have it.
-#include <stdint.h>         // For intptr_t.
-#endif
-namespace i18n {
-namespace phonenumbers {
-#ifdef INT64_MAX
-// INT64_MAX is defined if C99 stdint.h is included; use the
-// native types if available.
-typedef int8_t int8;
-typedef int16_t int16;
-typedef int32_t int32;
-typedef int64_t int64;
-typedef uint8_t uint8;
-typedef uint16_t uint16;
-typedef uint32_t uint32;
-typedef uint64_t uint64;
-const uint8  kuint8max  = UINT8_MAX;
-const uint16 kuint16max = UINT16_MAX;
-const uint32 kuint32max = UINT32_MAX;
-const uint64 kuint64max = UINT64_MAX;
-const  int8  kint8min   = INT8_MIN;
-const  int8  kint8max   = INT8_MAX;
-const  int16 kint16min  = INT16_MIN;
-const  int16 kint16max  = INT16_MAX;
-const  int32 kint32min  = INT32_MIN;
-const  int32 kint32max  = INT32_MAX;
-const  int64 kint64min  = INT64_MIN;
-const  int64 kint64max  = INT64_MAX;
-#else // !INT64_MAX
-typedef signed char         int8;
-typedef short               int16;
-// TODO: Remove these type guards.  These are to avoid conflicts with
-// obsolete/protypes.h in the Gecko SDK.
-#ifndef _INT32
-#define _INT32
-typedef int                 int32;
-#endif
-// The NSPR system headers define 64-bit as |long| when possible.  In order to
-// not have typedef mismatches, we do the same on LP64.
-#if __LP64__
-typedef long                int64;
-#else
-typedef long long           int64;
-#endif
-// NOTE: unsigned types are DANGEROUS in loops and other arithmetical
-// places.  Use the signed types unless your variable represents a bit
-// pattern (eg a hash value) or you really need the extra bit.  Do NOT
-// use 'unsigned' to express "this value should always be positive";
-// use assertions for this.
-typedef unsigned char      uint8;
-typedef unsigned short     uint16;
-// TODO: Remove these type guards.  These are to avoid conflicts with
-// obsolete/protypes.h in the Gecko SDK.
-#ifndef _UINT32
-#define _UINT32
-typedef unsigned int       uint32;
-#endif
-// See the comment above about NSPR and 64-bit.
-#if __LP64__
-typedef unsigned long uint64;
-#else
-typedef unsigned long long uint64;
-#endif
-#endif // !INT64_MAX
-typedef signed char         schar;
-// A type to represent a Unicode code-point value. As of Unicode 4.0,
-// such values require up to 21 bits.
-// (For type-checking on pointers, make this explicitly signed,
-// and it should always be the signed version of whatever int32 is.)
-typedef signed int         char32;
-// A macro to disallow the copy constructor and operator= functions
-// This should be used in the private: declarations for a class
-#if !defined(DISALLOW_COPY_AND_ASSIGN)
-#define DISALLOW_COPY_AND_ASSIGN(TypeName) \
-  TypeName(const TypeName&);               \
-  void operator=(const TypeName&)
-#endif
-// The arraysize(arr) macro returns the # of elements in an array arr.
-// The expression is a compile-time constant, and therefore can be
-// used in defining new arrays, for example.  If you use arraysize on
-// a pointer by mistake, you will get a compile-time error.
-//
-// One caveat is that arraysize() doesn't accept any array of an
-// anonymous type or a type defined inside a function.  In these rare
-// cases, you have to use the unsafe ARRAYSIZE_UNSAFE() macro below.  This is
-// due to a limitation in C++'s template system.  The limitation might
-// eventually be removed, but it hasn't happened yet.
-// This template function declaration is used in defining arraysize.
-// Note that the function doesn't need an implementation, as we only
-// use its type.
-template <typename T, size_t N>
-char (&ArraySizeHelper(T (&array)[N]))[N];
-// That gcc wants both of these prototypes seems mysterious. VC, for
-// its part, can't decide which to use (another mystery). Matching of
-// template overloads: the final frontier.
-#ifndef _MSC_VER
-template <typename T, size_t N>
-char (&ArraySizeHelper(const T (&array)[N]))[N];
-#endif
-#if !defined(arraysize)
-#define arraysize(array) (sizeof(ArraySizeHelper(array)))
-#endif
-// ARRAYSIZE_UNSAFE performs essentially the same calculation as arraysize,
-// but can be used on anonymous types or types defined inside
-// functions.  It's less safe than arraysize as it accepts some
-// (although not all) pointers.  Therefore, you should use arraysize
-// whenever possible.
-//
-// The expression ARRAYSIZE_UNSAFE(a) is a compile-time constant of type
-// size_t.
-//
-// ARRAYSIZE_UNSAFE catches a few type errors.  If you see a compiler error
-//
-//   "warning: division by zero in ..."
-//
-// when using ARRAYSIZE_UNSAFE, you are (wrongfully) giving it a pointer.
-// You should only use ARRAYSIZE_UNSAFE on statically allocated arrays.
-//
-// The following comments are on the implementation details, and can
-// be ignored by the users.
-//
-// ARRAYSIZE_UNSAFE(arr) works by inspecting sizeof(arr) (the # of bytes in
-// the array) and sizeof(*(arr)) (the # of bytes in one array
-// element).  If the former is divisible by the latter, perhaps arr is
-// indeed an array, in which case the division result is the # of
-// elements in the array.  Otherwise, arr cannot possibly be an array,
-// and we generate a compiler error to prevent the code from
-// compiling.
-//
-// Since the size of bool is implementation-defined, we need to cast
-// !(sizeof(a) & sizeof(*(a))) to size_t in order to ensure the final
-// result has type size_t.
-//
-// This macro is not perfect as it wrongfully accepts certain
-// pointers, namely where the pointer size is divisible by the pointee
-// size.  Since all our code has to go through a 32-bit compiler,
-// where a pointer is 4 bytes, this means all pointers to a type whose
-// size is 3 or greater than 4 will be (righteously) rejected.
-#if !defined(ARRAYSIZE_UNSAFE)
-#define ARRAYSIZE_UNSAFE(a) \
-  ((sizeof(a) / sizeof(*(a))) / \
-   static_cast<size_t>(!(sizeof(a) % sizeof(*(a)))))
-#endif
-// The COMPILE_ASSERT macro can be used to verify that a compile time
-// expression is true. For example, you could use it to verify the
-// size of a static array:
-//
-//   COMPILE_ASSERT(ARRAYSIZE_UNSAFE(content_type_names) == CONTENT_NUM_TYPES,
-//                  content_type_names_incorrect_size);
-//
-// or to make sure a struct is smaller than a certain size:
-//
-//   COMPILE_ASSERT(sizeof(foo) < 128, foo_too_large);
-//
-// The second argument to the macro is the name of the variable. If
-// the expression is false, most compilers will issue a warning/error
-// containing the name of the variable.
-#if __cplusplus >= 201103L
-// Under C++11, just use static_assert.
-#define COMPILE_ASSERT(expr, msg) static_assert(expr, #msg)
-#else
-template <bool>
-struct CompileAssert {
-};
-// Annotate a variable indicating it's ok if the variable is not used.
-// (Typically used to silence a compiler warning when the assignment
-// is important for some other reason.)
-// Use like:
-//   int x ALLOW_UNUSED = ...;
-#if defined(__GNUC__)
-#define ALLOW_UNUSED __attribute__((unused))
-#else
-#define ALLOW_UNUSED
-#endif
-#define COMPILE_ASSERT(expr, msg) \
-  typedef CompileAssert<(bool(expr))> msg[bool(expr) ? 1 : -1] ALLOW_UNUSED
-// Implementation details of COMPILE_ASSERT:
-//
-// - COMPILE_ASSERT works by defining an array type that has -1
-//   elements (and thus is invalid) when the expression is false.
-//
-// - The simpler definition
-//
-//     #define COMPILE_ASSERT(expr, msg) typedef char msg[(expr) ? 1 : -1]
-//
-//   does not work, as gcc supports variable-length arrays whose sizes
-//   are determined at run-time (this is gcc's extension and not part
-//   of the C++ standard).  As a result, gcc fails to reject the
-//   following code with the simple definition:
-//
-//     int foo;
-//     COMPILE_ASSERT(foo, msg); // not supposed to compile as foo is
-//                               // not a compile-time constant.
-//
-// - By using the type CompileAssert<(bool(expr))>, we ensures that
-//   expr is a compile-time constant.  (Template arguments must be
-//   determined at compile-time.)
-//
-// - The outer parentheses in CompileAssert<(bool(expr))> are necessary
-//   to work around a bug in gcc 3.4.4 and 4.0.1.  If we had written
-//
-//     CompileAssert<bool(expr)>
-//
-//   instead, these compilers will refuse to compile
-//
-//     COMPILE_ASSERT(5 > 0, some_message);
-//
-//   (They seem to think the ">" in "5 > 0" marks the end of the
-//   template argument list.)
-//
-// - The array size is (bool(expr) ? 1 : -1), instead of simply
-//
-//     ((expr) ? 1 : -1).
-//
-//   This is to avoid running into a bug in MS VC 7.1, which
-//   causes ((0.0) ? 1 : -1) to incorrectly evaluate to 1.
-#endif
-}  // namespace phonenumbers
-}  // namespace i18n
-#endif  // I18N_PHONENUMBERS_BASE_BASICTYPES_H_