1/*
2 *******************************************************************************
3 * Copyright (C) 2008, International Business Machines Corporation and         *
4 * others. All Rights Reserved.                                                *
5 *******************************************************************************
6 */
7package com.ibm.icu.impl.jdkadapter;
8
9import java.math.RoundingMode;
10import java.text.FieldPosition;
11import java.text.ParseException;
12import java.text.ParsePosition;
13import java.util.Currency;
14
15import com.ibm.icu.impl.icuadapter.NumberFormatJDK;
16import 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 */
22public 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}
228