jars/icu4j-52_1/main/classes/localespi/src/com/ibm/icu/impl/icuadapter/NumberFormatJDK.java

   1 /*
   2  *******************************************************************************
   3  * Copyright (C) 2008, International Business Machines Corporation and         *
   4  * others. All Rights Reserved.                                                *
   5  *******************************************************************************
   6  */
   7 package com.ibm.icu.impl.icuadapter;
   8
   9 import java.math.RoundingMode;
  10 import java.text.FieldPosition;
  11 import java.text.NumberFormat;
  12 import java.text.ParseException;
  13 import java.text.ParsePosition;
  14
  15 import com.ibm.icu.impl.jdkadapter.NumberFormatICU;
  16 import com.ibm.icu.math.BigDecimal;
  17 import com.ibm.icu.util.Currency;
  18 import com.ibm.icu.util.CurrencyAmount;
  19
  20 /**
  21  * NumberFormatJDK is an adapter class which wraps java.text.NumberFormat and
  22  * implements ICU4J NumberFormat APIs.
  23  */
  24 public class NumberFormatJDK extends com.ibm.icu.text.NumberFormat {
  25
  26     private static final long serialVersionUID = -1739846528146803964L;
  27
  28     private NumberFormat fJdkNfmt;
  29
  30     private NumberFormatJDK(NumberFormat jdkNfmt) {
  31         fJdkNfmt = jdkNfmt;
  32     }
  33
  34     public static com.ibm.icu.text.NumberFormat wrap(NumberFormat jdkNfmt) {
  35         if (jdkNfmt instanceof NumberFormatICU) {
  36             return ((NumberFormatICU)jdkNfmt).unwrap();
  37         }
  38         return new NumberFormatJDK(jdkNfmt);
  39     }
  40
  41     public NumberFormat unwrap() {
  42         return fJdkNfmt;
  43     }
  44
  45     @Override
  46     public Object clone() {
  47         NumberFormatJDK other = (NumberFormatJDK)super.clone();
  48         other.fJdkNfmt = (NumberFormat)fJdkNfmt.clone();
  49         return other;
  50     }
  51
  52     @Override
  53     public boolean equals(Object obj) {
  54         if (obj instanceof NumberFormatJDK) {
  55             return ((NumberFormatJDK)obj).fJdkNfmt.equals(fJdkNfmt);
  56         }
  57         return false;
  58     }
  59
  60     //public String format(java.math.BigDecimal number)
  61     //public String format(BigDecimal number)
  62
  63     @Override
  64     public StringBuffer format(java.math.BigDecimal number, StringBuffer toAppendTo, FieldPosition pos) {
  65         return fJdkNfmt.format(number, toAppendTo, pos);
  66     }
  67
  68     @Override
  69     public StringBuffer format(BigDecimal number, StringBuffer toAppendTo, FieldPosition pos) {
  70         return fJdkNfmt.format(number.toBigDecimal(), toAppendTo, pos);
  71     }
  72
  73     @Override
  74     public StringBuffer format(java.math.BigInteger number, StringBuffer toAppendTo, FieldPosition pos) {
  75         return fJdkNfmt.format(number, toAppendTo, pos);
  76     }
  77
  78     //public String format(java.math.BigInteger number)
  79
  80     //String format(CurrencyAmount currAmt)
  81
  82     @Override
  83     public StringBuffer format(CurrencyAmount currAmt, StringBuffer toAppendTo, FieldPosition pos) {
  84         java.util.Currency save = fJdkNfmt.getCurrency();
  85         String currCode = currAmt.getCurrency().getCurrencyCode();
  86         boolean same = save.getCurrencyCode().equals(currCode);
  87         if (!same) {
  88             fJdkNfmt.setCurrency(java.util.Currency.getInstance(currCode));
  89         }
  90         fJdkNfmt.format(currAmt.getNumber(), toAppendTo, pos);
  91         if (!same) {
  92             fJdkNfmt.setCurrency(save);
  93         }
  94         return toAppendTo;
  95     }
  96
  97     //public String format(double number)
  98
  99     @Override
 100     public StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos) {
 101         return fJdkNfmt.format(number, toAppendTo, pos);
 102     }
 103
 104     //public String format(long number)
 105
 106     @Override
 107     public StringBuffer format(long number, StringBuffer toAppendTo, FieldPosition pos) {
 108         return fJdkNfmt.format(number, toAppendTo, pos);
 109     }
 110
 111     @Override
 112     public StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition pos) {
 113         return fJdkNfmt.format(number, toAppendTo, pos);
 114     }
 115
 116     @Override
 117     public Currency getCurrency() {
 118         java.util.Currency jdkCurrency = fJdkNfmt.getCurrency();
 119         if (jdkCurrency == null) {
 120             return null;
 121         }
 122         return Currency.getInstance(jdkCurrency.getCurrencyCode());
 123     }
 124
 125     //protected Currency getEffectiveCurrency()
 126
 127     @Override
 128     public int getMaximumFractionDigits() {
 129         return fJdkNfmt.getMaximumFractionDigits();
 130     }
 131
 132     @Override
 133     public int getMaximumIntegerDigits() {
 134         return fJdkNfmt.getMaximumIntegerDigits();
 135     }
 136
 137     @Override
 138     public int getMinimumFractionDigits() {
 139         return fJdkNfmt.getMinimumFractionDigits();
 140     }
 141
 142     public int getMinumumIntegerDigits() {
 143         return fJdkNfmt.getMinimumIntegerDigits();
 144     }
 145
 146     @Override
 147     public int getRoundingMode() {
 148         RoundingMode jdkMode = fJdkNfmt.getRoundingMode();
 149         int icuMode = BigDecimal.ROUND_UP;
 150
 151         if (jdkMode.equals(RoundingMode.CEILING)) {
 152             icuMode = BigDecimal.ROUND_CEILING;
 153         } else if (jdkMode.equals(RoundingMode.DOWN)) {
 154             icuMode = BigDecimal.ROUND_DOWN;
 155         } else if (jdkMode.equals(RoundingMode.FLOOR)) {
 156             icuMode = BigDecimal.ROUND_FLOOR;
 157         } else if (jdkMode.equals(RoundingMode.HALF_DOWN)) {
 158             icuMode = BigDecimal.ROUND_HALF_DOWN;
 159         } else if (jdkMode.equals(RoundingMode.HALF_EVEN)) {
 160             icuMode = BigDecimal.ROUND_HALF_EVEN;
 161         } else if (jdkMode.equals(RoundingMode.HALF_UP)) {
 162             icuMode = BigDecimal.ROUND_HALF_UP;
 163         } else if (jdkMode.equals(RoundingMode.UNNECESSARY)) {
 164             icuMode = BigDecimal.ROUND_UNNECESSARY;
 165         } else if (jdkMode.equals(RoundingMode.UP)) {
 166             icuMode = BigDecimal.ROUND_UP;
 167         }
 168         return icuMode;
 169     }
 170
 171     @Override
 172     public int hashCode() {
 173         return fJdkNfmt.hashCode();
 174     }
 175
 176     @Override
 177     public boolean isGroupingUsed() {
 178         return fJdkNfmt.isGroupingUsed();
 179     }
 180
 181     @Override
 182     public boolean isParseIntegerOnly() {
 183         return fJdkNfmt.isParseIntegerOnly();
 184     }
 185
 186     @Override
 187     public boolean isParseStrict() {
 188         // JDK NumberFormat does not support strict parsing
 189         return false;
 190     }
 191
 192     @Override
 193     public Number parse(String text) throws ParseException {
 194         return fJdkNfmt.parse(text);
 195     }
 196
 197     @Override
 198     public Number parse(String text, ParsePosition parsePosition) {
 199         return fJdkNfmt.parse(text, parsePosition);
 200     }
 201
 202     //public Object parseObject(String source, ParsePosition parsePosition)
 203
 204     @Override
 205     public void setCurrency(Currency theCurrency) {
 206         if (theCurrency == null) {
 207             fJdkNfmt.setCurrency(null);
 208             return;
 209         } else {
 210             fJdkNfmt.setCurrency(java.util.Currency.getInstance(theCurrency.getCurrencyCode()));
 211         }
 212     }
 213
 214     @Override
 215     public void setGroupingUsed(boolean newValue) {
 216         fJdkNfmt.setGroupingUsed(newValue);
 217     }
 218
 219     @Override
 220     public void setMaximumFractionDigits(int newValue) {
 221         fJdkNfmt.setMaximumFractionDigits(newValue);
 222     }
 223
 224     @Override
 225     public void setMaximumIntegerDigits(int newValue) {
 226         fJdkNfmt.setMaximumIntegerDigits(newValue);
 227     }
 228
 229     @Override
 230     public void setMinimumFractionDigits(int newValue) {
 231         fJdkNfmt.setMinimumFractionDigits(newValue);
 232     }
 233
 234     @Override
 235     public void setMinimumIntegerDigits(int newValue) {
 236         fJdkNfmt.setMinimumIntegerDigits(newValue);
 237     }
 238
 239     @Override
 240     public void setParseIntegerOnly(boolean value) {
 241         fJdkNfmt.setParseIntegerOnly(value);
 242     }
 243
 244     @Override
 245     public void setParseStrict(boolean value) {
 246         // JDK NumberFormat does not support strict parsing - ignore this operation
 247     }
 248
 249     @Override
 250     public void setRoundingMode(int roundingMode) {
 251         RoundingMode mode = null;
 252         switch (roundingMode) {
 253         case BigDecimal.ROUND_CEILING:
 254             mode = RoundingMode.CEILING;
 255             break;
 256         case BigDecimal.ROUND_DOWN:
 257             mode = RoundingMode.DOWN;
 258             break;
 259         case BigDecimal.ROUND_FLOOR:
 260             mode = RoundingMode.FLOOR;
 261             break;
 262         case BigDecimal.ROUND_HALF_DOWN:
 263             mode = RoundingMode.HALF_DOWN;
 264             break;
 265         case BigDecimal.ROUND_HALF_EVEN:
 266             mode = RoundingMode.HALF_EVEN;
 267             break;
 268         case BigDecimal.ROUND_HALF_UP:
 269             mode = RoundingMode.HALF_UP;
 270             break;
 271         case BigDecimal.ROUND_UNNECESSARY:
 272             mode = RoundingMode.UNNECESSARY;
 273             break;
 274         case BigDecimal.ROUND_UP:
 275             mode = RoundingMode.UP;
 276             break;
 277         }
 278         if (mode == null) {
 279             throw new IllegalArgumentException("Invalid rounding mode: " + roundingMode);
 280         }
 281         fJdkNfmt.setRoundingMode(mode);
 282     }
 283 }