Allow a NumberFormat to be passed a currency name/symbol at creation

pkg/intl/lib/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 57 matching lines @@
    * is helpful in debugging.
    */
   String _pattern;
 
   /** The locale in which we print numbers. */
   final String _locale;
 
   /** Caches the symbols used for our locale. */
   NumberSymbols _symbols;
 
+  /** The name (or symbol) of the currency to print. */
+  String currencyName;
+
   /**
    * Transient internal state in which to build up the result of the format
    * operation. We can have this be just an instance variable because Dart is
    * single-threaded and unless we do an asynchronous operation in the process
    * of formatting then there will only ever be one number being formatted
    * at a time. In languages with threads we'd need to pass this on the stack.
    */
   final StringBuffer _buffer = new StringBuffer();
 
   /**
    * Create a number format that prints using [newPattern] as it applies in
    * [locale].
    */
   factory NumberFormat([String newPattern, String locale]) =>
       new NumberFormat._forPattern(locale, (x) => newPattern);
 
   /** Create a number format that prints as DECIMAL_PATTERN. */
   NumberFormat.decimalPattern([String locale]) :
       this._forPattern(locale, (x) => x.DECIMAL_PATTERN);
 
   /** Create a number format that prints as PERCENT_PATTERN. */
   NumberFormat.percentPattern([String locale]) :
     this._forPattern(locale, (x) => x.PERCENT_PATTERN);
 
   /** Create a number format that prints as SCIENTIFIC_PATTERN. */
   NumberFormat.scientificPattern([String locale]) :
     this._forPattern(locale, (x) => x.SCIENTIFIC_PATTERN);
 
   /** Create a number format that prints as CURRENCY_PATTERN. */
-  NumberFormat.currencyPattern([String locale]) :
-    this._forPattern(locale, (x) => x.CURRENCY_PATTERN);
+  NumberFormat.currencyPattern([String locale, String currency]) :
+    this._forPattern(locale, (x) => x.CURRENCY_PATTERN, currency);
 
   /**
    * Create a number format that prints in a pattern we get from
    * the [getPattern] function using the locale [locale].
    */
-  NumberFormat._forPattern(String locale, Function getPattern) :
-      _locale = Intl.verifiedLocale(locale, localeExists) {
+  NumberFormat._forPattern(String locale, Function getPattern,
+      [this.currencyName]) :
+        _locale = Intl.verifiedLocale(locale, localeExists) {
     _symbols = numberFormatSymbols[_locale];
+    if (currencyName == null) {
+      currencyName = _symbols.DEF_CURRENCY_CODE;
+    }
     _setPattern(getPattern(_symbols));
   }
 
   /**
    * Return the locale code in which we operate, e.g. 'en_US' or 'pt'.
    */
   String get locale => _locale;
 
   /**
    * Return true if the locale exists, or if it is null. The null case
@@ skipping 230 matching lines @@
   /**
    * 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;
 
   void _setPattern(String newPattern) {
     if (newPattern == null) return;
     // Make spaces non-breaking
     _pattern = newPattern.replaceAll(' ', '\u00a0');
-    var parser = new _NumberFormatParser(this, newPattern);
+    var parser =
+        new _NumberFormatParser(this, newPattern, currencyName);
     parser.parse();
   }
 
   String toString() => "NumberFormat($_locale, $_pattern)";
 }
 
 /**
  * Private class that parses the numeric formatting pattern and sets the
  * variables in [format] to appropriate values. Instances of this are
  * transient and store parsing state in instance variables, so can only be used
@@ skipping 16 matching lines @@
   static const _PATTERN_PERCENT = '%';
   static const _PATTERN_EXPONENT = 'E';
   static const _PATTERN_PLUS = '+';
 
   /** The format whose state we are setting. */
   final NumberFormat format;
 
   /** The pattern we are parsing. */
   final _StringIterator pattern;
 
+  /** We can be passed a specific currency symbol, regardless of the locale. */
+  String currencyName;
+
   /**
    * Create a new [_NumberFormatParser] for a particular [NumberFormat] and
    * [input] pattern.
    */
-  _NumberFormatParser(this.format, input) : pattern = _iterator(input) {
-    pattern.moveNext();
+  _NumberFormatParser(this.format, input, this.currencyName) :
+    pattern = _iterator(input) {
+        pattern.moveNext();
   }
 
   /** The [NumberSymbols] for the locale in which our [format] prints. */
   NumberSymbols get symbols => format.symbols;
 
   /** Parse the input pattern and set the values. */
   void parse() {
     format._positivePrefix = _parseAffix();
     var trunk = _parseTrunk();
     format._positiveSuffix = _parseAffix();
@@ skipping 59 matching lines @@
     } else {
       switch (ch) {
         case _PATTERN_DIGIT:
         case _PATTERN_ZERO_DIGIT:
         case _PATTERN_GROUPING_SEPARATOR:
         case _PATTERN_DECIMAL_SEPARATOR:
         case _PATTERN_SEPARATOR:
           return false;
         case _PATTERN_CURRENCY_SIGN:
           // TODO(alanknight): Handle the local/global/portable currency signs
-          affix.write(symbols.DEF_CURRENCY_CODE);
+          affix.write(currencyName);
           break;
         case _PATTERN_PERCENT:
           if (format._multiplier != 1) {
             throw new FormatException('Too many percent/permill');
           }
           format._multiplier = 100;
           affix.write(symbols.PERCENT);
           break;
         case _PATTERN_PER_MILLE:
           if (format._multiplier != 1) {
@@ skipping 203 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;
   }
 
 }