/*
* reserved comment block
* DO NOT REMOVE OR ALTER!
*/
/*
* Licensed to the Apache Software Foundation (ASF) under one or more
* contributor license agreements. See the NOTICE file distributed with
* this work for additional information regarding copyright ownership.
* The ASF licenses this file to You under the Apache License, Version 2.0
* (the "License"); you may not use this file except in compliance with
* the License. You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.sun.org.apache.xerces.internal.impl.dv.xs;
import com.sun.org.apache.xerces.internal.impl.dv.InvalidDatatypeValueException;
import com.sun.org.apache.xerces.internal.impl.dv.ValidationContext;
import com.sun.org.apache.xerces.internal.xs.datatypes.XSDouble;
Represent the schema type "double"
Author: Neeraj Bajaj, Sun Microsystems, inc., Sandy Gao, IBM @xerces.internal
/**
* Represent the schema type "double"
*
* @xerces.internal
*
* @author Neeraj Bajaj, Sun Microsystems, inc.
* @author Sandy Gao, IBM
*
*/
public class DoubleDV extends TypeValidator {
public short getAllowedFacets(){
return ( XSSimpleTypeDecl.FACET_PATTERN | XSSimpleTypeDecl.FACET_WHITESPACE | XSSimpleTypeDecl.FACET_ENUMERATION |XSSimpleTypeDecl.FACET_MAXINCLUSIVE |XSSimpleTypeDecl.FACET_MININCLUSIVE | XSSimpleTypeDecl.FACET_MAXEXCLUSIVE | XSSimpleTypeDecl.FACET_MINEXCLUSIVE );
}//getAllowedFacets()
//convert a String to Double form, we have to take care of cases specified in spec like INF, -INF and NaN
public Object getActualValue(String content, ValidationContext context) throws InvalidDatatypeValueException {
try{
return new XDouble(content);
} catch (NumberFormatException ex){
throw new InvalidDatatypeValueException("cvc-datatype-valid.1.2.1", new Object[]{content, "double"});
}
}//getActualValue()
// Can't call Double#compareTo method, because it's introduced in jdk 1.2
public int compare(Object value1, Object value2) {
return ((XDouble)value1).compareTo((XDouble)value2);
}//compare()
//distinguishes between identity and equality for double datatype
//0.0 is equal but not identical to -0.0
public boolean isIdentical (Object value1, Object value2) {
if (value2 instanceof XDouble) {
return ((XDouble)value1).isIdentical((XDouble)value2);
}
return false;
}//isIdentical()
Returns true if it's possible that the given
string represents a valid floating point value
(excluding NaN, INF and -INF).
/**
* Returns true if it's possible that the given
* string represents a valid floating point value
* (excluding NaN, INF and -INF).
*/
static boolean isPossibleFP(String val) {
final int length = val.length();
for (int i = 0; i < length; ++i) {
char c = val.charAt(i);
if (!(c >= '0' && c <= '9' || c == '.' ||
c == '-' || c == '+' || c == 'E' || c == 'e')) {
return false;
}
}
return true;
}
private static final class XDouble implements XSDouble {
private final double value;
public XDouble(String s) throws NumberFormatException {
if (isPossibleFP(s)) {
value = Double.parseDouble(s);
}
else if ( s.equals("INF") ) {
value = Double.POSITIVE_INFINITY;
}
else if ( s.equals("-INF") ) {
value = Double.NEGATIVE_INFINITY;
}
else if ( s.equals("NaN" ) ) {
value = Double.NaN;
}
else {
throw new NumberFormatException(s);
}
}
public boolean equals(Object val) {
if (val == this)
return true;
if (!(val instanceof XDouble))
return false;
XDouble oval = (XDouble)val;
// NOTE: we don't distinguish 0.0 from -0.0
if (value == oval.value)
return true;
if (value != value && oval.value != oval.value)
return true;
return false;
}
public int hashCode() {
// This check is necessary because doubleToLongBits(+0) != doubleToLongBits(-0)
if (value == 0d) {
return 0;
}
long v = Double.doubleToLongBits(value);
return (int) (v ^ (v >>> 32));
}
// NOTE: 0.0 is equal but not identical to -0.0
public boolean isIdentical (XDouble val) {
if (val == this) {
return true;
}
if (value == val.value) {
return (value != 0.0d ||
(Double.doubleToLongBits(value) == Double.doubleToLongBits(val.value)));
}
if (value != value && val.value != val.value)
return true;
return false;
}
private int compareTo(XDouble val) {
double oval = val.value;
// this < other
if (value < oval)
return -1;
// this > other
if (value > oval)
return 1;
// this == other
// NOTE: we don't distinguish 0.0 from -0.0
if (value == oval)
return 0;
// one of the 2 values or both is/are NaN(s)
if (value != value) {
// this = NaN = other
if (oval != oval)
return 0;
// this is NaN <> other
return INDETERMINATE;
}
// other is NaN <> this
return INDETERMINATE;
}
private String canonical;
public synchronized String toString() {
if (canonical == null) {
if (value == Double.POSITIVE_INFINITY)
canonical = "INF";
else if (value == Double.NEGATIVE_INFINITY)
canonical = "-INF";
else if (value != value)
canonical = "NaN";
// NOTE: we don't distinguish 0.0 from -0.0
else if (value == 0)
canonical = "0.0E1";
else {
// REVISIT: use the java algorithm for now, because we
// don't know what to output for 1.1d (which is no
// actually 1.1)
canonical = Double.toString(value);
// if it contains 'E', then it should be a valid schema
// canonical representation
if (canonical.indexOf('E') == -1) {
int len = canonical.length();
// at most 3 longer: E, -, 9
char[] chars = new char[len+3];
canonical.getChars(0, len, chars, 0);
// expected decimal point position
int edp = chars[0] == '-' ? 2 : 1;
// for non-zero integer part
if (value >= 1 || value <= -1) {
// decimal point position
int dp = canonical.indexOf('.');
// move the digits: ddd.d --> d.ddd
for (int i = dp; i > edp; i--) {
chars[i] = chars[i-1];
}
chars[edp] = '.';
// trim trailing zeros: d00.0 --> d.000 --> d.
while (chars[len-1] == '0')
len--;
// add the last zero if necessary: d. --> d.0
if (chars[len-1] == '.')
len++;
// append E: d.dd --> d.ddE
chars[len++] = 'E';
// how far we shifted the decimal point
int shift = dp - edp;
// append the exponent --> d.ddEd
// the exponent is at most 7
chars[len++] = (char)(shift + '0');
}
else {
// non-zero digit point
int nzp = edp + 1;
// skip zeros: 0.003
while (chars[nzp] == '0')
nzp++;
// put the first non-zero digit to the left of '.'
chars[edp-1] = chars[nzp];
chars[edp] = '.';
// move other digits (non-zero) to the right of '.'
for (int i = nzp+1, j = edp+1; i < len; i++, j++)
chars[j] = chars[i];
// adjust the length
len -= nzp - edp;
// append 0 if nessary: 0.03 --> 3. --> 3.0
if (len == edp + 1)
chars[len++] = '0';
// append E-: d.dd --> d.ddE-
chars[len++] = 'E';
chars[len++] = '-';
// how far we shifted the decimal point
int shift = nzp - edp;
// append the exponent --> d.ddEd
// the exponent is at most 3
chars[len++] = (char)(shift + '0');
}
canonical = new String(chars, 0, len);
}
}
}
return canonical;
}
public double getValue() {
return value;
}
}
} // class DoubleDV