com.sun.org.apache.xpath.internal.objects.XNumber Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of jaxp-ri Show documentation
Show all versions of jaxp-ri Show documentation
Java API for XML Processing Reference Implementation
The newest version!
/*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
*
* Copyright (c) 1997-2010 Oracle and/or its affiliates. All rights reserved.
*
* The contents of this file are subject to the terms of either the GNU
* General Public License Version 2 only ("GPL") or the Common Development
* and Distribution License("CDDL") (collectively, the "License"). You
* may not use this file except in compliance with the License. You can
* obtain a copy of the License at
* https://glassfish.dev.java.net/public/CDDL+GPL_1_1.html
* or packager/legal/LICENSE.txt. See the License for the specific
* language governing permissions and limitations under the License.
*
* When distributing the software, include this License Header Notice in each
* file and include the License file at packager/legal/LICENSE.txt.
*
* GPL Classpath Exception:
* Oracle designates this particular file as subject to the "Classpath"
* exception as provided by Oracle in the GPL Version 2 section of the License
* file that accompanied this code.
*
* Modifications:
* If applicable, add the following below the License Header, with the fields
* enclosed by brackets [] replaced by your own identifying information:
* "Portions Copyright [year] [name of copyright owner]"
*
* Contributor(s):
* If you wish your version of this file to be governed by only the CDDL or
* only the GPL Version 2, indicate your decision by adding "[Contributor]
* elects to include this software in this distribution under the [CDDL or GPL
* Version 2] license." If you don't indicate a single choice of license, a
* recipient has the option to distribute your version of this file under
* either the CDDL, the GPL Version 2 or to extend the choice of license to
* its licensees as provided above. However, if you add GPL Version 2 code
* and therefore, elected the GPL Version 2 license, then the option applies
* only if the new code is made subject to such option by the copyright
* holder.
*
*
* This file incorporates work covered by the following copyright and
* permission notice:
*
* 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.
*/
/*
* $Id: XNumber.java,v 1.9 2010-11-01 04:35:16 joehw Exp $
*/
package com.sun.org.apache.xpath.internal.objects;
import com.sun.org.apache.xpath.internal.ExpressionOwner;
import com.sun.org.apache.xpath.internal.XPathContext;
import com.sun.org.apache.xpath.internal.XPathVisitor;
/**
* This class represents an XPath number, and is capable of
* converting the number to other types, such as a string.
* @xsl.usage general
*/
public class XNumber extends XObject
{
static final long serialVersionUID = -2720400709619020193L;
/** Value of the XNumber object.
* @serial */
double m_val;
/**
* Construct a XNodeSet object.
*
* @param d Value of the object
*/
public XNumber(double d)
{
super();
m_val = d;
}
/**
* Construct a XNodeSet object.
*
* @param num Value of the object
*/
public XNumber(Number num)
{
super();
m_val = num.doubleValue();
setObject(num);
}
/**
* Tell that this is a CLASS_NUMBER.
*
* @return node type CLASS_NUMBER
*/
public int getType()
{
return CLASS_NUMBER;
}
/**
* Given a request type, return the equivalent string.
* For diagnostic purposes.
*
* @return type string "#NUMBER"
*/
public String getTypeString()
{
return "#NUMBER";
}
/**
* Cast result object to a number.
*
* @return the value of the XNumber object
*/
public double num()
{
return m_val;
}
/**
* Evaluate expression to a number.
*
* @return 0.0
*
* @throws javax.xml.transform.TransformerException
*/
public double num(XPathContext xctxt)
throws javax.xml.transform.TransformerException
{
return m_val;
}
/**
* Cast result object to a boolean.
*
* @return false if the value is NaN or equal to 0.0
*/
public boolean bool()
{
return (Double.isNaN(m_val) || (m_val == 0.0)) ? false : true;
}
// /**
// * Cast result object to a string.
// *
// * @return "NaN" if the number is NaN, Infinity or -Infinity if
// * the number is infinite or the string value of the number.
// */
// private static final int PRECISION = 16;
// public String str()
// {
//
// if (Double.isNaN(m_val))
// {
// return "NaN";
// }
// else if (Double.isInfinite(m_val))
// {
// if (m_val > 0)
// return "Infinity";
// else
// return "-Infinity";
// }
//
// long longVal = (long)m_val;
// if ((double)longVal == m_val)
// return Long.toString(longVal);
//
//
// String s = Double.toString(m_val);
// int len = s.length();
//
// if (s.charAt(len - 2) == '.' && s.charAt(len - 1) == '0')
// {
// return s.substring(0, len - 2);
// }
//
// int exp = 0;
// int e = s.indexOf('E');
// if (e != -1)
// {
// exp = Integer.parseInt(s.substring(e + 1));
// s = s.substring(0,e);
// len = e;
// }
//
// // Calculate Significant Digits:
// // look from start of string for first digit
// // look from end for last digit
// // significant digits = end - start + (0 or 1 depending on decimal location)
//
// int decimalPos = -1;
// int start = (s.charAt(0) == '-') ? 1 : 0;
// findStart: for( ; start < len; start++ )
// {
// switch (s.charAt(start))
// {
// case '0':
// break;
// case '.':
// decimalPos = start;
// break;
// default:
// break findStart;
// }
// }
// int end = s.length() - 1;
// findEnd: for( ; end > start; end-- )
// {
// switch (s.charAt(end))
// {
// case '0':
// break;
// case '.':
// decimalPos = end;
// break;
// default:
// break findEnd;
// }
// }
//
// int sigDig = end - start;
//
// // clarify decimal location if it has not yet been found
// if (decimalPos == -1)
// decimalPos = s.indexOf('.');
//
// // if decimal is not between start and end, add one to sigDig
// if (decimalPos < start || decimalPos > end)
// ++sigDig;
//
// // reduce significant digits to PRECISION if necessary
// if (sigDig > PRECISION)
// {
// // re-scale BigDecimal in order to get significant digits = PRECISION
// BigDecimal num = new BigDecimal(s);
// int newScale = num.scale() - (sigDig - PRECISION);
// if (newScale < 0)
// newScale = 0;
// s = num.setScale(newScale, BigDecimal.ROUND_HALF_UP).toString();
//
// // remove trailing '0's; keep track of decimalPos
// int truncatePoint = s.length();
// while (s.charAt(--truncatePoint) == '0')
// ;
//
// if (s.charAt(truncatePoint) == '.')
// {
// decimalPos = truncatePoint;
// }
// else
// {
// decimalPos = s.indexOf('.');
// truncatePoint += 1;
// }
//
// s = s.substring(0, truncatePoint);
// len = s.length();
// }
//
// // Account for exponent by adding zeros as needed
// // and moving the decimal place
//
// if (exp == 0)
// return s;
//
// start = 0;
// String sign;
// if (s.charAt(0) == '-')
// {
// sign = "-";
// start++;
// }
// else
// sign = "";
//
// String wholePart = s.substring(start, decimalPos);
// String decimalPart = s.substring(decimalPos + 1);
//
// // get the number of digits right of the decimal
// int decimalLen = decimalPart.length();
//
// if (exp >= decimalLen)
// return sign + wholePart + decimalPart + zeros(exp - decimalLen);
//
// if (exp > 0)
// return sign + wholePart + decimalPart.substring(0, exp) + "."
// + decimalPart.substring(exp);
//
// return sign + "0." + zeros(-1 - exp) + wholePart + decimalPart;
// }
/**
* Cast result object to a string.
*
* @return "NaN" if the number is NaN, Infinity or -Infinity if
* the number is infinite or the string value of the number.
*/
public String str()
{
if (Double.isNaN(m_val))
{
return "NaN";
}
else if (Double.isInfinite(m_val))
{
if (m_val > 0)
return "Infinity";
else
return "-Infinity";
}
double num = m_val;
String s = Double.toString(num);
int len = s.length();
if (s.charAt(len - 2) == '.' && s.charAt(len - 1) == '0')
{
s = s.substring(0, len - 2);
if (s.equals("-0"))
return "0";
return s;
}
int e = s.indexOf('E');
if (e < 0)
{
if (s.charAt(len - 1) == '0')
return s.substring(0, len - 1);
else
return s;
}
int exp = Integer.parseInt(s.substring(e + 1));
String sign;
if (s.charAt(0) == '-')
{
sign = "-";
s = s.substring(1);
--e;
}
else
sign = "";
int nDigits = e - 2;
if (exp >= nDigits)
return sign + s.substring(0, 1) + s.substring(2, e)
+ zeros(exp - nDigits);
// Eliminate trailing 0's - bugzilla 14241
while (s.charAt(e-1) == '0')
e--;
if (exp > 0)
return sign + s.substring(0, 1) + s.substring(2, 2 + exp) + "."
+ s.substring(2 + exp, e);
return sign + "0." + zeros(-1 - exp) + s.substring(0, 1)
+ s.substring(2, e);
}
/**
* Return a string of '0' of the given length
*
*
* @param n Length of the string to be returned
*
* @return a string of '0' with the given length
*/
static private String zeros(int n)
{
if (n < 1)
return "";
char[] buf = new char[n];
for (int i = 0; i < n; i++)
{
buf[i] = '0';
}
return new String(buf);
}
/**
* Return a java object that's closest to the representation
* that should be handed to an extension.
*
* @return The value of this XNumber as a Double object
*/
public Object object()
{
if(null == m_obj)
setObject(new Double(m_val));
return m_obj;
}
/**
* Tell if two objects are functionally equal.
*
* @param obj2 Object to compare this to
*
* @return true if the two objects are equal
*
* @throws javax.xml.transform.TransformerException
*/
public boolean equals(XObject obj2)
{
// In order to handle the 'all' semantics of
// nodeset comparisons, we always call the
// nodeset function.
int t = obj2.getType();
try
{
if (t == XObject.CLASS_NODESET)
return obj2.equals(this);
else if(t == XObject.CLASS_BOOLEAN)
return obj2.bool() == bool();
else
return m_val == obj2.num();
}
catch(javax.xml.transform.TransformerException te)
{
throw new com.sun.org.apache.xml.internal.utils.WrappedRuntimeException(te);
}
}
/**
* Tell if this expression returns a stable number that will not change during
* iterations within the expression. This is used to determine if a proximity
* position predicate can indicate that no more searching has to occur.
*
*
* @return true if the expression represents a stable number.
*/
public boolean isStableNumber()
{
return true;
}
/**
* @see com.sun.org.apache.xpath.internal.XPathVisitable#callVisitors(ExpressionOwner, XPathVisitor)
*/
public void callVisitors(ExpressionOwner owner, XPathVisitor visitor)
{
visitor.visitNumberLiteral(owner, this);
}
}