Make number formatting in Intl able to work with Int64 or other types.

pkg/intl/lib/src/intl/number_format.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of intl;
 /**
  * Provides the ability to format a number in a locale-specific way. The
  * format is specified as a pattern using a subset of the ICU formatting
  * patterns.
  *
@@ skipping 53 matching lines @@
   bool _decimalSeparatorAlwaysShown = false;
   bool _useSignForPositiveExponent = false;
   bool _useExponentialNotation = false;
 
   int maximumIntegerDigits = 40;
   int minimumIntegerDigits = 1;
   int maximumFractionDigits = 3;
   int minimumFractionDigits = 0;
   int minimumExponentDigits = 0;
 
-  int _multiplier = 1;
+  /**
+   * For percent and permille, what are we multiplying by in order to
+   * get the printed value, e.g. 100 for percent.
+   */
+  int get _multiplier => _internalMultiplier;
+  set _multiplier(int x) {
+    _internalMultiplier = x;
+    _multiplierDigits = (log(_multiplier) / LN10).round();
+  }
+  int _internalMultiplier = 1;
+
+  /** How many digits are there in the [_multiplier]. */
+  int _multiplierDigits = 0;
 
   /**
    * Stores the pattern used to create this format. This isn't used, but
    * is helpful in debugging.
    */
   String _pattern;
 
   /** The locale in which we print numbers. */
   final String _locale;
 
@@ skipping 70 matching lines @@
 
   /**
    * Return the symbols which are used in our locale. Cache them to avoid
    * repeated lookup.
    */
   NumberSymbols get symbols => _symbols;
 
   /**
    * Format [number] according to our pattern and return the formatted string.
    */
-  String format(num number) {
-    // TODO(alanknight): Do we have to do anything for printing numbers bidi?
-    // Or are they always printed left to right?
-    if (number.isNaN) return symbols.NAN;
-    if (number.isInfinite) return "${_signPrefix(number)}${symbols.INFINITY}";
+  String format(number) {
+    if (_isNaN(number)) return symbols.NAN;
+    if (_isInfinite(number)) return "${_signPrefix(number)}${symbols.INFINITY}";
 
     _add(_signPrefix(number));
-    _formatNumber(number.abs() * _multiplier);
+    _formatNumber(number.abs());
     _add(_signSuffix(number));
 
     var result = _buffer.toString();
     _buffer.clear();
     return result;
   }
 
   /**
    * Parse the number represented by the string. If it's not
    * parseable, throws a [FormatException].
    */
   num parse(String text) => new _NumberParser(this, text).value;
 
   /**
    * Format the main part of the number in the form dictated by the pattern.
    */
-  void _formatNumber(num number) {
+  void _formatNumber(number) {
     if (_useExponentialNotation) {
       _formatExponential(number);
     } else {
       _formatFixed(number);
     }
   }
 
   /** Format the number in exponential notation. */
   void _formatExponential(num number) {
     if (number == 0.0) {
@@ skipping 43 matching lines @@
     } else if (_useSignForPositiveExponent) {
       _add(symbols.PLUS_SIGN);
     }
     _pad(minimumExponentDigits, exponent.toString());
   }
 
   /** Used to test if we have exceeded Javascript integer limits. */
   final _maxInt = pow(2, 52);
 
   /**
+   * Helpers to check numbers that don't conform to the [num] interface,
+   * e.g. Int64
+   */
+  _isInfinite(number) => number is num ? number.isInfinite : false;
+  _isNaN(number) => number is num ? number.isNaN : false;
+  _round(number) => number is num ? number.round() : number;
+  _floor(number) => number is num ? number.floor() : number;
+
+  /**
    * Format the basic number portion, inluding the fractional digits.
    */
-  void _formatFixed(num number) {
-    // Very fussy math to get integer and fractional parts.
-    var power = pow(10, maximumFractionDigits);
-    var shiftedNumber = (number * power);
-    // We must not roundToDouble() an int or it will lose precision. We must not
-    // round() a large double or it will take its loss of precision and
-    // preserve it in an int, which we will then print to the right
-    // of the decimal place. Therefore, only roundToDouble if we are already
-    // a double.
-    if (shiftedNumber is double) {
-      shiftedNumber = shiftedNumber.roundToDouble();
+  void _formatFixed(number) {
+    var integerPart;
+    int fractionPart;
+    int extraIntegerDigits;
+
+    final power = pow(10, maximumFractionDigits);
+    final digitMultiplier = power * _multiplier;
+
+    if (_isInfinite(number)) {
+      integerPart = number.toInt();
+      extraIntegerDigits = 0;
+      fractionPart = 0;
+    } else {
+      // We have three possible pieces. First, the basic integer part. If this
+      // is a percent or permille, the additional 2 or 3 digits. Finally the
+      // fractional part.
+      // We avoid multiplying the number because it might overflow if we have
+      // a fixed-size integer type, so we extract each of the three as an
+      // integer pieces.
+      integerPart = _floor(number);
+      var fraction = number - integerPart;
+      // Multiply out to the number of decimal places and the percent, then
+      // round. For fixed-size integer types this should always be zero, so
+      // multiplying is OK.
+      var remainingDigits = _round(fraction * digitMultiplier).toInt();
+      // However, in rounding we may overflow into the main digits.
+      if (remainingDigits >= digitMultiplier) {
+        integerPart++;
+        remainingDigits -= digitMultiplier;
+      }
+      // Separate out the extra integer parts from the fraction part.
+      extraIntegerDigits = remainingDigits ~/ power;
+      fractionPart = remainingDigits % power;
     }
-    var intValue, fracValue;
-    if (shiftedNumber.isInfinite) {
-      intValue = number.toInt();
-      fracValue = 0;
-    } else {
-      intValue = shiftedNumber.round() ~/ power;
-      fracValue = (shiftedNumber - intValue * power).floor();
-    }
-    var fractionPresent = minimumFractionDigits > 0 || fracValue > 0;
+    var fractionPresent = minimumFractionDigits > 0 || fractionPart > 0;
 
-    // If the int part is larger than 2^52 and we're on Javascript (so it's
-    // really a float) it will lose precision, so pad out the rest of it
-    // with zeros. Check for Javascript by seeing if an integer is double.
-    var paddingDigits = '';
-    if (1 is double && intValue > _maxInt) {
-      var howManyDigitsTooBig = (log(intValue) / LN10).ceil() - 16;
-      var divisor = pow(10, howManyDigitsTooBig).round();
-      paddingDigits = symbols.ZERO_DIGIT * howManyDigitsTooBig.toInt();
-
-      intValue = (intValue / divisor).truncate();
-    }
-    var integerDigits = "${intValue}${paddingDigits}".codeUnits;
+    var integerDigits = _integerDigits(integerPart, extraIntegerDigits);
     var digitLength = integerDigits.length;
 
-    if (_hasPrintableIntegerPart(intValue)) {
+    if (_hasPrintableIntegerPart(integerPart)) {
       _pad(minimumIntegerDigits - digitLength);
       for (var i = 0; i < digitLength; i++) {
-        _addDigit(integerDigits[i]);
+        _addDigit(integerDigits.codeUnitAt(i));
         _group(digitLength, i);
       }
     } else if (!fractionPresent) {
       // If neither fraction nor integer part exists, just print zero.
       _addZero();
     }
 
     _decimalSeparator(fractionPresent);
-    _formatFractionPart((fracValue + power).toString());
+    _formatFractionPart((fractionPart + power).toString());
   }
 
   /**
+   * Compute the raw integer digits which will then be printed with
+   * grouping and translated to localized digits.
+   */
+  String _integerDigits(integerPart, extraIntegerDigits) {
+    // If the int part is larger than 2^52 and we're on Javascript (so it's
+    // really a float) it will lose precision, so pad out the rest of it
+    // with zeros. Check for Javascript by seeing if an integer is double.
+    var paddingDigits = '';
+    if (1 is double && integerPart is num && integerPart > _maxInt) {
+      var howManyDigitsTooBig = (log(integerPart) / LN10).ceil() - 16;
+      var divisor = pow(10, howManyDigitsTooBig).round();
+      paddingDigits = symbols.ZERO_DIGIT * howManyDigitsTooBig.toInt();
+      integerPart = (integerPart / divisor).truncate();
+    }
+
+    var extra = extraIntegerDigits == 0 ? '' : extraIntegerDigits.toString();
+    var intDigits = _mainIntegerDigits(integerPart);
+    var paddedExtra =
+        intDigits.isEmpty ? extra : extra.padLeft(_multiplierDigits, '0');
+    return "${intDigits}${paddedExtra}${paddingDigits}";
+  }
+
+  /**
+   * The digit string of the integer part. This is the empty string if the
+   * integer part is zero and otherwise is the toString() of the integer
+   * part, stripping off any minus sign.
+   */
+  String _mainIntegerDigits(integer) {
+    if (integer == 0) return '';
+    var digits = integer.toString();
+    // If we have a fixed-length int representation, it can have a negative
+    // number whose negation is also negative, e.g. 2^-63 in 64-bit.
+    // Remove the minus sign.
+    return digits.startsWith('-') ? digits.substring(1) : digits;
+  }
+
+  /**
    * Format the part after the decimal place in a fixed point number.
    */
   void _formatFractionPart(String fractionPart) {
     var fractionCodes = fractionPart.codeUnits;
     var fractionLength = fractionPart.length;
     while (fractionCodes[fractionLength - 1] == _zero &&
         fractionLength > minimumFractionDigits + 1) {
       fractionLength--;
     }
     for (var i = 1; i < fractionLength; i++) {
       _addDigit(fractionCodes[i]);
     }
   }
 
   /** Print the decimal separator if appropriate. */
   void _decimalSeparator(bool fractionPresent) {
     if (_decimalSeparatorAlwaysShown || fractionPresent) {
       _add(symbols.DECIMAL_SEP);
     }
   }
 
   /**
    * Return true if we have a main integer part which is printable, either
    * because we have digits left of the decimal point, or because there are
    * a minimum number of printable digits greater than 1.
    */
-  bool _hasPrintableIntegerPart(int intValue) =>
-      intValue > 0 || minimumIntegerDigits > 0;
+  bool _hasPrintableIntegerPart(x) =>
+      x > 0 || minimumIntegerDigits > 0;
 
   /** A group of methods that provide support for writing digits and other
    * required characters into [_buffer] easily.
    */
   void _add(String x) { _buffer.write(x);}
   void _addCharCode(int x) { _buffer.writeCharCode(x);}
   void _addZero() { _buffer.write(symbols.ZERO_DIGIT);}
   void _addDigit(int x) { _buffer.writeCharCode(_localeZero + x - _zero);}
 
   /** Print padding up to [numberOfDigits] above what's included in [basic]. */
@@ skipping 32 matching lines @@
   // Note that there is a slight risk of a locale's zero digit not fitting
   // into a single code unit, but it seems very unlikely, and if it did,
   // there's a pretty good chance that our assumptions about being able to do
   // arithmetic on it would also be invalid.
   get _localeZero => symbols.ZERO_DIGIT.codeUnits.first;
 
   /**
    * Returns the prefix for [x] based on whether it's positive or negative.
    * In en_US this would be '' and '-' respectively.
    */
-  String _signPrefix(num x) => x.isNegative ? _negativePrefix : _positivePrefix;
+  String _signPrefix(x) => x.isNegative ? _negativePrefix : _positivePrefix;
 
   /**
    * Returns the suffix for [x] based on wether it's positive or negative.
    * In en_US there are no suffixes for positive or negative.
    */
-  String _signSuffix(num x) => x.isNegative ? _negativeSuffix : _positiveSuffix;
+  String _signSuffix(x) => x.isNegative ? _negativeSuffix : _positiveSuffix;
 
   void _setPattern(String newPattern) {
     if (newPattern == null) return;
     // Make spaces non-breaking
     _pattern = newPattern.replaceAll(' ', '\u00a0');
     var parser = new _NumberFormatParser(this, newPattern, currencyName);
     parser.parse();
   }
 
   String toString() => "NumberFormat($_locale, $_pattern)";
@@ skipping 597 matching lines @@
   String get peek => nextIndex >= input.length ? null : input[nextIndex];
 
   Iterator<String> get iterator => this;
 
   static String _validate(input) {
     if (input is! String) throw new ArgumentError(input);
     return input;
   }
 
 }