1 /*
2 * reserved comment block
3 * DO NOT REMOVE OR ALTER!
4 */
5 /*
6 * Copyright 2001,2002,2004,2005 The Apache Software Foundation.
7 *
8 * Licensed under the Apache License, Version 2.0 (the "License");
9 * you may not use this file except in compliance with the License.
10 * You may obtain a copy of the License at
11 *
12 * http://www.apache.org/licenses/LICENSE-2.0
13 *
14 * Unless required by applicable law or agreed to in writing, software
15 * distributed under the License is distributed on an "AS IS" BASIS,
16 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
17 * See the License for the specific language governing permissions and
18 * limitations under the License.
19 */
20
21 package com.sun.org.apache.xerces.internal.impl.dv.xs;
22
23 import java.math.BigDecimal;
24 import java.math.BigInteger;
25
26 import com.sun.org.apache.xerces.internal.impl.dv.InvalidDatatypeValueException;
27 import com.sun.org.apache.xerces.internal.impl.dv.ValidationContext;
28 import com.sun.org.apache.xerces.internal.xs.datatypes.XSDecimal;
29 import java.util.Objects;
30
31 /**
32 * Represent the schema type "decimal"
33 *
34 * @xerces.internal
35 *
36 * @author Neeraj Bajaj, Sun Microsystems, inc.
37 * @author Sandy Gao, IBM
38 *
39 */
40 public class DecimalDV extends TypeValidator {
41
42 @Override
43 public final short getAllowedFacets(){
44 return ( XSSimpleTypeDecl.FACET_PATTERN | XSSimpleTypeDecl.FACET_WHITESPACE | XSSimpleTypeDecl.FACET_ENUMERATION |XSSimpleTypeDecl.FACET_MAXINCLUSIVE |XSSimpleTypeDecl.FACET_MININCLUSIVE | XSSimpleTypeDecl.FACET_MAXEXCLUSIVE | XSSimpleTypeDecl.FACET_MINEXCLUSIVE | XSSimpleTypeDecl.FACET_TOTALDIGITS | XSSimpleTypeDecl.FACET_FRACTIONDIGITS);
45 }
46
47 @Override
48 public Object getActualValue(String content, ValidationContext context) throws InvalidDatatypeValueException {
49 try {
50 return new XDecimal(content);
51 } catch (NumberFormatException nfe) {
52 throw new InvalidDatatypeValueException("cvc-datatype-valid.1.2.1", new Object[]{content, "decimal"});
53 }
54 }
55
56 @Override
57 public final int compare(Object value1, Object value2){
58 return ((XDecimal)value1).compareTo((XDecimal)value2);
59 }
60
61 @Override
62 public final int getTotalDigits(Object value){
63 return ((XDecimal)value).totalDigits;
64 }
65
66 @Override
67 public final int getFractionDigits(Object value){
68 return ((XDecimal)value).fracDigits;
69 }
70
71 // Avoid using the heavy-weight java.math.BigDecimal
72 static final class XDecimal implements XSDecimal {
73 // sign: 0 for vlaue 0; 1 for positive values; -1 for negative values
74 int sign = 1;
75 // total digits. >= 1
76 int totalDigits = 0;
77 // integer digits when sign != 0
78 int intDigits = 0;
79 // fraction digits when sign != 0
80 int fracDigits = 0;
81 // the string representing the integer part
82 String ivalue = "";
83 // the string representing the fraction part
84 String fvalue = "";
85 // whether the canonical form contains decimal point
86 boolean integer = false;
87
88 XDecimal(String content) throws NumberFormatException {
89 initD(content);
90 }
91 XDecimal(String content, boolean integer) throws NumberFormatException {
92 if (integer)
93 initI(content);
94 else
95 initD(content);
96 }
97 void initD(String content) throws NumberFormatException {
98 int len = content.length();
99 if (len == 0)
100 throw new NumberFormatException();
101
102 // these 4 variables are used to indicate where the integre/fraction
103 // parts start/end.
104 int intStart = 0, intEnd = 0, fracStart = 0, fracEnd = 0;
105
106 // Deal with leading sign symbol if present
107 if (content.charAt(0) == '+') {
108 // skip '+', so intStart should be 1
109 intStart = 1;
110 }
111 else if (content.charAt(0) == '-') {
112 // keep '-', so intStart is stil 0
113 intStart = 1;
114 sign = -1;
115 }
116
117 // skip leading zeroes in integer part
118 int actualIntStart = intStart;
119 while (actualIntStart < len && content.charAt(actualIntStart) == '0') {
120 actualIntStart++;
121 }
122
123 // Find the ending position of the integer part
124 for (intEnd = actualIntStart;
125 intEnd < len && TypeValidator.isDigit(content.charAt(intEnd));
126 intEnd++);
127
128 // Not reached the end yet
129 if (intEnd < len) {
130 // the remaining part is not ".DDD", error
131 if (content.charAt(intEnd) != '.')
132 throw new NumberFormatException();
133
134 // fraction part starts after '.', and ends at the end of the input
135 fracStart = intEnd + 1;
136 fracEnd = len;
137 }
138
139 // no integer part, no fraction part, error.
140 if (intStart == intEnd && fracStart == fracEnd)
141 throw new NumberFormatException();
142
143 // ignore trailing zeroes in fraction part
144 while (fracEnd > fracStart && content.charAt(fracEnd-1) == '0') {
145 fracEnd--;
146 }
147
148 // check whether there is non-digit characters in the fraction part
149 for (int fracPos = fracStart; fracPos < fracEnd; fracPos++) {
150 if (!TypeValidator.isDigit(content.charAt(fracPos)))
151 throw new NumberFormatException();
152 }
153
154 intDigits = intEnd - actualIntStart;
155 fracDigits = fracEnd - fracStart;
156 totalDigits = intDigits + fracDigits;
157
158 if (intDigits > 0) {
159 ivalue = content.substring(actualIntStart, intEnd);
160 if (fracDigits > 0)
161 fvalue = content.substring(fracStart, fracEnd);
162 }
163 else {
164 if (fracDigits > 0) {
165 fvalue = content.substring(fracStart, fracEnd);
166 }
167 else {
168 // ".00", treat it as "0"
169 sign = 0;
170 }
171 }
172 }
173 void initI(String content) throws NumberFormatException {
174 int len = content.length();
175 if (len == 0)
176 throw new NumberFormatException();
177
178 // these 2 variables are used to indicate where the integre start/end.
179 int intStart = 0, intEnd = 0;
180
181 // Deal with leading sign symbol if present
182 if (content.charAt(0) == '+') {
183 // skip '+', so intStart should be 1
184 intStart = 1;
185 }
186 else if (content.charAt(0) == '-') {
187 // keep '-', so intStart is stil 0
188 intStart = 1;
189 sign = -1;
190 }
191
192 // skip leading zeroes in integer part
193 int actualIntStart = intStart;
194 while (actualIntStart < len && content.charAt(actualIntStart) == '0') {
195 actualIntStart++;
196 }
197
198 // Find the ending position of the integer part
199 for (intEnd = actualIntStart;
200 intEnd < len && TypeValidator.isDigit(content.charAt(intEnd));
201 intEnd++);
202
203 // Not reached the end yet, error
204 if (intEnd < len)
205 throw new NumberFormatException();
206
207 // no integer part, error.
208 if (intStart == intEnd)
209 throw new NumberFormatException();
210
211 intDigits = intEnd - actualIntStart;
212 fracDigits = 0;
213 totalDigits = intDigits;
214
215 if (intDigits > 0) {
216 ivalue = content.substring(actualIntStart, intEnd);
217 }
218 else {
219 // "00", treat it as "0"
220 sign = 0;
221 }
222
223 integer = true;
224 }
225
226 @Override
227 public boolean equals(Object val) {
228 if (val == this)
229 return true;
230
231 if (!(val instanceof XDecimal))
232 return false;
233 XDecimal oval = (XDecimal)val;
234
235 if (sign != oval.sign)
236 return false;
237 if (sign == 0)
238 return true;
239
240 return intDigits == oval.intDigits && fracDigits == oval.fracDigits &&
241 ivalue.equals(oval.ivalue) && fvalue.equals(oval.fvalue);
242 }
243
244 @Override
245 public int hashCode() {
246 int hash = 7;
247 hash = 17 * hash + this.sign;
248 if (this.sign == 0) return hash;
249 hash = 17 * hash + this.intDigits;
250 hash = 17 * hash + this.fracDigits;
251 hash = 17 * hash + Objects.hashCode(this.ivalue);
252 hash = 17 * hash + Objects.hashCode(this.fvalue);
253 return hash;
254 }
255
256 public int compareTo(XDecimal val) {
257 if (sign != val.sign)
258 return sign > val.sign ? 1 : -1;
259 if (sign == 0)
260 return 0;
261 return sign * intComp(val);
262 }
263 private int intComp(XDecimal val) {
264 if (intDigits != val.intDigits)
265 return intDigits > val.intDigits ? 1 : -1;
266 int ret = ivalue.compareTo(val.ivalue);
267 if (ret != 0)
268 return ret > 0 ? 1 : -1;;
269 ret = fvalue.compareTo(val.fvalue);
270 return ret == 0 ? 0 : (ret > 0 ? 1 : -1);
271 }
272
273 private String canonical;
274 @Override
275 public synchronized String toString() {
276 if (canonical == null) {
277 makeCanonical();
278 }
279 return canonical;
280 }
281
282 private void makeCanonical() {
283 if (sign == 0) {
284 if (integer)
285 canonical = "0";
286 else
287 canonical = "0.0";
288 return;
289 }
290 if (integer && sign > 0) {
291 canonical = ivalue;
292 return;
293 }
294 // for -0.1, total digits is 1, so we need 3 extra spots
295 final StringBuilder buffer = new StringBuilder(totalDigits+3);
296 if (sign == -1)
297 buffer.append('-');
298 if (intDigits != 0)
299 buffer.append(ivalue);
300 else
301 buffer.append('0');
302 if (!integer) {
303 buffer.append('.');
304 if (fracDigits != 0) {
305 buffer.append(fvalue);
306 }
307 else {
308 buffer.append('0');
309 }
310 }
311 canonical = buffer.toString();
312 }
313
314 @Override
315 public BigDecimal getBigDecimal() {
316 if (sign == 0) {
317 return new BigDecimal(BigInteger.ZERO);
318 }
319 return new BigDecimal(toString());
320 }
321
322 @Override
323 public BigInteger getBigInteger() throws NumberFormatException {
324 if (fracDigits != 0) {
325 throw new NumberFormatException();
326 }
327 if (sign == 0) {
328 return BigInteger.ZERO;
329 }
330 if (sign == 1) {
331 return new BigInteger(ivalue);
332 }
333 return new BigInteger("-" + ivalue);
334 }
335
336 @Override
337 public long getLong() throws NumberFormatException {
338 if (fracDigits != 0) {
339 throw new NumberFormatException();
340 }
341 if (sign == 0) {
342 return 0L;
343 }
344 if (sign == 1) {
345 return Long.parseLong(ivalue);
346 }
347 return Long.parseLong("-" + ivalue);
348 }
349
350 @Override
351 public int getInt() throws NumberFormatException {
352 if (fracDigits != 0) {
353 throw new NumberFormatException();
354 }
355 if (sign == 0) {
356 return 0;
357 }
358 if (sign == 1) {
359 return Integer.parseInt(ivalue);
360 }
361 return Integer.parseInt("-" + ivalue);
362 }
363
364 @Override
365 public short getShort() throws NumberFormatException {
366 if (fracDigits != 0) {
367 throw new NumberFormatException();
368 }
369 if (sign == 0) {
370 return 0;
371 }
372 if (sign == 1) {
373 return Short.parseShort(ivalue);
374 }
375 return Short.parseShort("-" + ivalue);
376 }
377
378 @Override
379 public byte getByte() throws NumberFormatException {
380 if (fracDigits != 0) {
381 throw new NumberFormatException();
382 }
383 if (sign == 0) {
384 return 0;
385 }
386 if (sign == 1) {
387 return Byte.parseByte(ivalue);
388 }
389 return Byte.parseByte("-" + ivalue);
390 }
391 }
392 } // class DecimalDV