jars/icu4j-52_1/main/classes/localespi/src/com/ibm/icu/impl/jdkadapter/NumberFormatICU.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.jdkadapter;
   8
   9 import java.math.RoundingMode;
  10 import java.text.FieldPosition;
  11 import java.text.ParseException;
  12 import java.text.ParsePosition;
  13 import java.util.Currency;
  14
  15 import com.ibm.icu.impl.icuadapter.NumberFormatJDK;
  16 import com.ibm.icu.text.NumberFormat;
  17
  18 /**
  19  * NumberFormatICU is an adapter class which wraps ICU4J NumberFormat and
  20  * implements java.text.NumberFormat APIs.
  21  */
  22 public class NumberFormatICU extends java.text.NumberFormat {
  23
  24     private static final long serialVersionUID = 4892903815641574060L;
  25
  26     private NumberFormat fIcuNfmt;
  27
  28     private NumberFormatICU(NumberFormat icuNfmt) {
  29         fIcuNfmt = icuNfmt;
  30     }
  31
  32     public static java.text.NumberFormat wrap(NumberFormat icuNfmt) {
  33         if (icuNfmt instanceof NumberFormatJDK) {
  34             return ((NumberFormatJDK)icuNfmt).unwrap();
  35         }
  36         return new NumberFormatICU(icuNfmt);
  37     }
  38
  39     public NumberFormat unwrap() {
  40         return fIcuNfmt;
  41     }
  42
  43     @Override
  44     public Object clone() {
  45         NumberFormatICU other = (NumberFormatICU)super.clone();
  46         other.fIcuNfmt = (NumberFormat)fIcuNfmt.clone();
  47         return other;
  48     }
  49
  50     @Override
  51     public boolean equals(Object obj) {
  52         if (obj instanceof NumberFormatICU) {
  53             return ((NumberFormatICU)obj).fIcuNfmt.equals(fIcuNfmt);
  54         }
  55         return false;
  56     }
  57
  58     //public String format(double number)
  59
  60     @Override
  61     public StringBuffer format(double number, StringBuffer toAppendTo, FieldPosition pos) {
  62         return fIcuNfmt.format(number, toAppendTo, pos);
  63     }
  64
  65     //public String format(long number);
  66
  67     @Override
  68     public StringBuffer format(long number, StringBuffer toAppendTo, FieldPosition pos) {
  69         return fIcuNfmt.format(number, toAppendTo, pos);
  70     }
  71
  72     @Override
  73     public StringBuffer format(Object number, StringBuffer toAppendTo, FieldPosition pos) {
  74         return fIcuNfmt.format(number, toAppendTo, pos);
  75     }
  76
  77     @Override
  78     public Currency getCurrency() {
  79         com.ibm.icu.util.Currency icuCurrency = fIcuNfmt.getCurrency();
  80         if (icuCurrency == null) {
  81             return null;
  82         }
  83         return Currency.getInstance(icuCurrency.getCurrencyCode());
  84     }
  85
  86     @Override
  87     public int getMaximumFractionDigits() {
  88         return fIcuNfmt.getMaximumFractionDigits();
  89     }
  90
  91     @Override
  92     public int getMaximumIntegerDigits() {
  93         return fIcuNfmt.getMaximumIntegerDigits();
  94     }
  95
  96     @Override
  97     public int getMinimumFractionDigits() {
  98         return fIcuNfmt.getMinimumFractionDigits();
  99     }
 100
 101     @Override
 102     public int getMinimumIntegerDigits() {
 103         return fIcuNfmt.getMinimumIntegerDigits();
 104     }
 105
 106     @Override
 107     public RoundingMode getRoundingMode() {
 108         int icuMode = fIcuNfmt.getRoundingMode();
 109         RoundingMode mode = RoundingMode.UP;
 110         switch (icuMode) {
 111         case com.ibm.icu.math.BigDecimal.ROUND_CEILING:
 112             mode = RoundingMode.CEILING;
 113             break;
 114         case com.ibm.icu.math.BigDecimal.ROUND_DOWN:
 115             mode = RoundingMode.DOWN;
 116             break;
 117         case com.ibm.icu.math.BigDecimal.ROUND_FLOOR:
 118             mode = RoundingMode.FLOOR;
 119             break;
 120         case com.ibm.icu.math.BigDecimal.ROUND_HALF_DOWN:
 121             mode = RoundingMode.HALF_DOWN;
 122             break;
 123         case com.ibm.icu.math.BigDecimal.ROUND_HALF_EVEN:
 124             mode = RoundingMode.HALF_EVEN;
 125             break;
 126         case com.ibm.icu.math.BigDecimal.ROUND_HALF_UP:
 127             mode = RoundingMode.HALF_UP;
 128             break;
 129         case com.ibm.icu.math.BigDecimal.ROUND_UNNECESSARY:
 130             mode = RoundingMode.UNNECESSARY;
 131             break;
 132         case com.ibm.icu.math.BigDecimal.ROUND_UP:
 133             mode = RoundingMode.UP;
 134             break;
 135         }
 136         return mode;
 137     }
 138
 139     @Override
 140     public int hashCode() {
 141         return fIcuNfmt.hashCode();
 142     }
 143
 144     @Override
 145     public boolean isGroupingUsed() {
 146         return fIcuNfmt.isGroupingUsed();
 147     }
 148
 149     @Override
 150     public boolean isParseIntegerOnly() {
 151         return fIcuNfmt.isParseIntegerOnly();
 152     }
 153
 154     @Override
 155     public Number parse(String source) throws ParseException {
 156         return fIcuNfmt.parse(source);
 157     }
 158
 159     @Override
 160     public Number parse(String source, ParsePosition parsePosition) {
 161         return fIcuNfmt.parse(source, parsePosition);
 162     }
 163
 164     //public Object parseObject(String source, ParsePosition pos)
 165
 166     @Override
 167     public void setCurrency(Currency currency) {
 168         if (currency == null) {
 169             fIcuNfmt.setCurrency(null);
 170         } else {
 171             fIcuNfmt.setCurrency(com.ibm.icu.util.Currency.getInstance(currency.getCurrencyCode()));
 172         }
 173     }
 174
 175     @Override
 176     public void setGroupingUsed(boolean newValue) {
 177         fIcuNfmt.setGroupingUsed(newValue);
 178     }
 179
 180     @Override
 181     public void setMaximumFractionDigits(int newValue) {
 182         fIcuNfmt.setMaximumFractionDigits(newValue);
 183     }
 184
 185     @Override
 186     public void setMaximumIntegerDigits(int newValue) {
 187         fIcuNfmt.setMaximumIntegerDigits(newValue);
 188     }
 189
 190     @Override
 191     public void setMinimumFractionDigits(int newValue) {
 192         fIcuNfmt.setMinimumFractionDigits(newValue);
 193     }
 194
 195     @Override
 196     public void setMinimumIntegerDigits(int newValue) {
 197         fIcuNfmt.setMinimumIntegerDigits(newValue);
 198     }
 199
 200     @Override
 201     public void setParseIntegerOnly(boolean value) {
 202         fIcuNfmt.setParseIntegerOnly(value);
 203     }
 204
 205     @Override
 206     public void setRoundingMode(RoundingMode roundingMode) {
 207         if (roundingMode.equals(RoundingMode.CEILING)) {
 208             fIcuNfmt.setRoundingMode(com.ibm.icu.math.BigDecimal.ROUND_CEILING);
 209         } else if (roundingMode.equals(RoundingMode.DOWN)) {
 210             fIcuNfmt.setRoundingMode(com.ibm.icu.math.BigDecimal.ROUND_DOWN);
 211         } else if (roundingMode.equals(RoundingMode.FLOOR)) {
 212             fIcuNfmt.setRoundingMode(com.ibm.icu.math.BigDecimal.ROUND_FLOOR);
 213         } else if (roundingMode.equals(RoundingMode.HALF_DOWN)) {
 214             fIcuNfmt.setRoundingMode(com.ibm.icu.math.BigDecimal.ROUND_HALF_DOWN);
 215         } else if (roundingMode.equals(RoundingMode.HALF_EVEN)) {
 216             fIcuNfmt.setRoundingMode(com.ibm.icu.math.BigDecimal.ROUND_HALF_EVEN);
 217         } else if (roundingMode.equals(RoundingMode.HALF_UP)) {
 218             fIcuNfmt.setRoundingMode(com.ibm.icu.math.BigDecimal.ROUND_HALF_UP);
 219         } else if (roundingMode.equals(RoundingMode.UNNECESSARY)) {
 220             fIcuNfmt.setRoundingMode(com.ibm.icu.math.BigDecimal.ROUND_UNNECESSARY);
 221         } else if (roundingMode.equals(RoundingMode.UP)) {
 222             fIcuNfmt.setRoundingMode(com.ibm.icu.math.BigDecimal.ROUND_UP);
 223         } else {
 224             throw new IllegalArgumentException("Invalid rounding mode was specified.");
 225         }
 226     }
 227 }