View Javadoc
1   /*
2    * reserved comment block
3    * DO NOT REMOVE OR ALTER!
4    */
5   /*
6    * Copyright 2004 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  package com.sun.org.apache.xerces.internal.impl.dv.xs;
21  
22  import com.sun.org.apache.xerces.internal.impl.dv.InvalidDatatypeValueException;
23  import com.sun.org.apache.xerces.internal.impl.dv.ValidationContext;
24  
25  /**
26   * Validator for <precisionDecimal> datatype (W3C Schema 1.1)
27   *
28   * @xerces.experimental
29   *
30   * @author Ankit Pasricha, IBM
31   *
32   */
33  class PrecisionDecimalDV extends TypeValidator {
34  
35      static final class XPrecisionDecimal {
36  
37          // sign: 0 for absent; 1 for positive values; -1 for negative values (except in case of INF, -INF)
38          int sign = 1;
39          // total digits. >= 1
40          int totalDigits = 0;
41          // integer digits when sign != 0
42          int intDigits = 0;
43          // fraction digits when sign != 0
44          int fracDigits = 0;
45          //precision
46          //int precision = 0;
47          // the string representing the integer part
48          String ivalue = "";
49          // the string representing the fraction part
50          String fvalue = "";
51  
52          int pvalue = 0;
53  
54  
55          XPrecisionDecimal(String content) throws NumberFormatException {
56              if(content.equals("NaN")) {
57                  ivalue = content;
58                  sign = 0;
59              }
60              if(content.equals("+INF") || content.equals("INF") || content.equals("-INF")) {
61                  ivalue = content.charAt(0) == '+' ? content.substring(1) : content;
62                  return;
63              }
64              initD(content);
65          }
66  
67          void initD(String content) throws NumberFormatException {
68              int len = content.length();
69              if (len == 0)
70                  throw new NumberFormatException();
71  
72              // these 4 variables are used to indicate where the integre/fraction
73              // parts start/end.
74              int intStart = 0, intEnd = 0, fracStart = 0, fracEnd = 0;
75  
76              // Deal with leading sign symbol if present
77              if (content.charAt(0) == '+') {
78                  // skip '+', so intStart should be 1
79                  intStart = 1;
80              }
81              else if (content.charAt(0) == '-') {
82                  intStart = 1;
83                  sign = -1;
84              }
85  
86              // skip leading zeroes in integer part
87              int actualIntStart = intStart;
88              while (actualIntStart < len && content.charAt(actualIntStart) == '0') {
89                  actualIntStart++;
90              }
91  
92              // Find the ending position of the integer part
93              for (intEnd = actualIntStart; intEnd < len && TypeValidator.isDigit(content.charAt(intEnd)); intEnd++);
94  
95              // Not reached the end yet
96              if (intEnd < len) {
97                  // the remaining part is not ".DDD" or "EDDD" or "eDDD", error
98                  if (content.charAt(intEnd) != '.' && content.charAt(intEnd) != 'E' && content.charAt(intEnd) != 'e')
99                      throw new NumberFormatException();
100 
101                 if(content.charAt(intEnd) == '.') {
102                     // fraction part starts after '.', and ends at the end of the input
103                     fracStart = intEnd + 1;
104 
105                     // find location of E or e (if present)
106                     // Find the ending position of the fracion part
107                     for (fracEnd = fracStart;
108                     fracEnd < len && TypeValidator.isDigit(content.charAt(fracEnd));
109                     fracEnd++);
110                 }
111                 else {
112                     pvalue = Integer.parseInt(content.substring(intEnd + 1, len));
113                 }
114             }
115 
116             // no integer part, no fraction part, error.
117             if (intStart == intEnd && fracStart == fracEnd)
118                 throw new NumberFormatException();
119 
120             // ignore trailing zeroes in fraction part
121             /*while (fracEnd > fracStart && content.charAt(fracEnd-1) == '0') {
122              fracEnd--;
123              }*/
124 
125             // check whether there is non-digit characters in the fraction part
126             for (int fracPos = fracStart; fracPos < fracEnd; fracPos++) {
127                 if (!TypeValidator.isDigit(content.charAt(fracPos)))
128                     throw new NumberFormatException();
129             }
130 
131             intDigits = intEnd - actualIntStart;
132             fracDigits = fracEnd - fracStart;
133 
134             if (intDigits > 0) {
135                 ivalue = content.substring(actualIntStart, intEnd);
136             }
137 
138             if (fracDigits > 0) {
139                 fvalue = content.substring(fracStart, fracEnd);
140                 if(fracEnd < len) {
141                     pvalue = Integer.parseInt(content.substring(fracEnd + 1, len));
142                 }
143             }
144             totalDigits = intDigits + fracDigits;
145         }
146 
147         // Construct a canonical String representation of this number
148         // for the purpose of deriving a hashCode value compliant with
149         // equals.
150         // The toString representation will be:
151         // NaN for NaN, INF for +infinity, -INF for -infinity, 0 for zero,
152         // and [1-9].[0-9]*[1-9]?(E[1-9][0-9]*)? for other numbers.
153         private static String canonicalToStringForHashCode(String ivalue, String fvalue, int sign, int pvalue) {
154             if ("NaN".equals(ivalue)) {
155                 return "NaN";
156             }
157             if ("INF".equals(ivalue)) {
158                 return sign < 0 ? "-INF" : "INF";
159             }
160             final StringBuilder builder = new StringBuilder();
161             final int ilen = ivalue.length();
162             final int flen0 = fvalue.length();
163             int lastNonZero;
164             for (lastNonZero = flen0; lastNonZero > 0 ; lastNonZero--) {
165                 if (fvalue.charAt(lastNonZero -1 ) != '0') break;
166             }
167             final int flen = lastNonZero;
168             int iStart;
169             int exponent = pvalue;
170             for (iStart = 0; iStart < ilen; iStart++) {
171                 if (ivalue.charAt(iStart) != '0') break;
172             }
173             int fStart = 0;
174             if (iStart < ivalue.length()) {
175                 builder.append(sign == -1 ? "-" : "");
176                 builder.append(ivalue.charAt(iStart));
177                 iStart++;
178             } else {
179                 if (flen > 0) {
180                     for (fStart = 0; fStart < flen; fStart++) {
181                         if (fvalue.charAt(fStart) != '0') break;
182                     }
183                     if (fStart < flen) {
184                         builder.append(sign == -1 ? "-" : "");
185                         builder.append(fvalue.charAt(fStart));
186                         exponent -= ++fStart;
187                     } else {
188                         return "0";
189                     }
190                 } else {
191                     return "0";
192                 }
193             }
194 
195             if (iStart < ilen || fStart < flen) {
196                 builder.append('.');
197             }
198             while (iStart < ilen) {
199                 builder.append(ivalue.charAt(iStart++));
200                 exponent++;
201             }
202             while (fStart < flen) {
203                 builder.append(fvalue.charAt(fStart++));
204             }
205             if (exponent != 0) {
206                 builder.append("E").append(exponent);
207             }
208             return builder.toString();
209         }
210 
211         @Override
212         public boolean equals(Object val) {
213             if (val == this)
214                 return true;
215 
216             if (!(val instanceof XPrecisionDecimal))
217                 return false;
218             XPrecisionDecimal oval = (XPrecisionDecimal)val;
219 
220             return this.compareTo(oval) == EQUAL;
221         }
222 
223         @Override
224         public int hashCode() {
225             // There's nothing else we can use easily, because equals could
226             // return true for widely different representation of the
227             // same number - and we don't have any canonical representation.
228             // The problem here is that we must ensure that if two numbers
229             // are equals then their hash code must also be equals.
230             // hashCode for 1.01E1 should be the same as hashCode for 0.101E2
231             // So we call cannonicalToStringForHashCode - which implements an
232             // algorithm that invents a normalized string representation
233             // for this number, and we return a hash for that.
234             return canonicalToStringForHashCode(ivalue, fvalue, sign, pvalue).hashCode();
235         }
236 
237         /**
238          * @return
239          */
240         private int compareFractionalPart(XPrecisionDecimal oval) {
241             if(fvalue.equals(oval.fvalue))
242                 return EQUAL;
243 
244             StringBuffer temp1 = new StringBuffer(fvalue);
245             StringBuffer temp2 = new StringBuffer(oval.fvalue);
246 
247             truncateTrailingZeros(temp1, temp2);
248             return temp1.toString().compareTo(temp2.toString());
249         }
250 
251         private void truncateTrailingZeros(StringBuffer fValue, StringBuffer otherFValue) {
252             for(int i = fValue.length() - 1;i >= 0; i--)
253                 if(fValue.charAt(i) == '0')
254                     fValue.deleteCharAt(i);
255                 else
256                     break;
257 
258             for(int i = otherFValue.length() - 1;i >= 0; i--)
259                 if(otherFValue.charAt(i) == '0')
260                     otherFValue.deleteCharAt(i);
261                 else
262                     break;
263         }
264 
265         public int compareTo(XPrecisionDecimal val) {
266 
267             // seen NaN
268             if(sign == 0)
269                 return INDETERMINATE;
270 
271             //INF is greater than everything and equal to itself
272             if(ivalue.equals("INF") || val.ivalue.equals("INF")) {
273                 if(ivalue.equals(val.ivalue))
274                     return EQUAL;
275                 else if(ivalue.equals("INF"))
276                     return GREATER_THAN;
277                 return LESS_THAN;
278             }
279 
280             //-INF is smaller than everything and equal itself
281             if(ivalue.equals("-INF") || val.ivalue.equals("-INF")) {
282                 if(ivalue.equals(val.ivalue))
283                     return EQUAL;
284                 else if(ivalue.equals("-INF"))
285                     return LESS_THAN;
286                 return GREATER_THAN;
287             }
288 
289             if (sign != val.sign)
290                 return sign > val.sign ? GREATER_THAN : LESS_THAN;
291 
292             return sign * compare(val);
293         }
294 
295         // To enable comparison - the exponent part of the decimal will be limited
296         // to the max value of int.
297         private int compare(XPrecisionDecimal val) {
298 
299             if(pvalue != 0 || val.pvalue != 0) {
300                 if(pvalue == val.pvalue)
301                     return intComp(val);
302                 else {
303 
304                     if(intDigits + pvalue != val.intDigits + val.pvalue)
305                         return intDigits + pvalue > val.intDigits + val.pvalue ? GREATER_THAN : LESS_THAN;
306 
307                     //otherwise the 2 combined values are the same
308                     if(pvalue > val.pvalue) {
309                         int expDiff = pvalue - val.pvalue;
310                         StringBuffer buffer = new StringBuffer(ivalue);
311                         StringBuffer fbuffer = new StringBuffer(fvalue);
312                         for(int i = 0;i < expDiff; i++) {
313                             if(i < fracDigits) {
314                                 buffer.append(fvalue.charAt(i));
315                                 fbuffer.deleteCharAt(i);
316                             }
317                             else
318                                 buffer.append('0');
319                         }
320                         return compareDecimal(buffer.toString(), val.ivalue, fbuffer.toString(), val.fvalue);
321                     }
322                     else {
323                         int expDiff = val.pvalue - pvalue;
324                         StringBuffer buffer = new StringBuffer(val.ivalue);
325                         StringBuffer fbuffer = new StringBuffer(val.fvalue);
326                         for(int i = 0;i < expDiff; i++) {
327                             if(i < val.fracDigits) {
328                                 buffer.append(val.fvalue.charAt(i));
329                                 fbuffer.deleteCharAt(i);
330                             }
331                             else
332                                 buffer.append('0');
333                         }
334                         return compareDecimal(ivalue, buffer.toString(), fvalue, fbuffer.toString());
335                     }
336                 }
337             }
338             else {
339                 return intComp(val);
340             }
341         }
342 
343         /**
344          * @param val
345          * @return
346          */
347         private int intComp(XPrecisionDecimal val) {
348             if (intDigits != val.intDigits)
349                 return intDigits > val.intDigits ? GREATER_THAN : LESS_THAN;
350 
351             return compareDecimal(ivalue, val.ivalue, fvalue, val.fvalue);
352         }
353 
354         /**
355          * @param val
356          * @return
357          */
358         private int compareDecimal(String iValue, String fValue, String otherIValue, String otherFValue) {
359             int ret = iValue.compareTo(otherIValue);
360             if (ret != 0)
361                 return ret > 0 ? GREATER_THAN : LESS_THAN;
362 
363             if(fValue.equals(otherFValue))
364                 return EQUAL;
365 
366             StringBuffer temp1=new StringBuffer(fValue);
367             StringBuffer temp2=new StringBuffer(otherFValue);
368 
369             truncateTrailingZeros(temp1, temp2);
370             ret = temp1.toString().compareTo(temp2.toString());
371             return ret == 0 ? EQUAL : (ret > 0 ? GREATER_THAN : LESS_THAN);
372         }
373 
374         private String canonical;
375 
376         @Override
377         public synchronized String toString() {
378             if (canonical == null) {
379                 makeCanonical();
380             }
381             return canonical;
382         }
383 
384         private void makeCanonical() {
385             // REVISIT: to be determined by working group
386             canonical = "TBD by Working Group";
387         }
388 
389         /**
390          * @param decimal
391          * @return
392          */
393         public boolean isIdentical(XPrecisionDecimal decimal) {
394             if(ivalue.equals(decimal.ivalue) && (ivalue.equals("INF") || ivalue.equals("-INF") || ivalue.equals("NaN")))
395                 return true;
396 
397             if(sign == decimal.sign && intDigits == decimal.intDigits && fracDigits == decimal.fracDigits && pvalue == decimal.pvalue
398                     && ivalue.equals(decimal.ivalue) && fvalue.equals(decimal.fvalue))
399                 return true;
400             return false;
401         }
402 
403     }
404     /* (non-Javadoc)
405      * @see com.sun.org.apache.xerces.internal.impl.dv.xs.TypeValidator#getAllowedFacets()
406      */
407     @Override
408     public short getAllowedFacets() {
409         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);
410     }
411 
412     /* (non-Javadoc)
413      * @see com.sun.org.apache.xerces.internal.impl.dv.xs.TypeValidator#getActualValue(java.lang.String, com.sun.org.apache.xerces.internal.impl.dv.ValidationContext)
414      */
415     @Override
416     public Object getActualValue(String content, ValidationContext context)
417     throws InvalidDatatypeValueException {
418         try {
419             return new XPrecisionDecimal(content);
420         } catch (NumberFormatException nfe) {
421             throw new InvalidDatatypeValueException("cvc-datatype-valid.1.2.1", new Object[]{content, "precisionDecimal"});
422         }
423     }
424 
425     @Override
426     public int compare(Object value1, Object value2) {
427         return ((XPrecisionDecimal)value1).compareTo((XPrecisionDecimal)value2);
428     }
429 
430     @Override
431     public int getFractionDigits(Object value) {
432         return ((XPrecisionDecimal)value).fracDigits;
433     }
434 
435     @Override
436     public int getTotalDigits(Object value) {
437         return ((XPrecisionDecimal)value).totalDigits;
438     }
439 
440     @Override
441     public boolean isIdentical(Object value1, Object value2) {
442         if(!(value2 instanceof XPrecisionDecimal) || !(value1 instanceof XPrecisionDecimal))
443             return false;
444         return ((XPrecisionDecimal)value1).isIdentical((XPrecisionDecimal)value2);
445     }
446 }