NumberUtils.java
/*
* CSVeed (https://github.com/42BV/CSVeed)
*
* Copyright 2013-2023 CSVeed.
*
* All rights reserved. This program and the accompanying materials
* are made available under the terms of The Apache Software License,
* Version 2.0 which accompanies this distribution, and is available at
* https://www.apache.org/licenses/LICENSE-2.0.txt
*/
package org.csveed.bean.conversion;
import static org.csveed.bean.conversion.ConversionUtil.trimAllWhitespace;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
/**
* The Class NumberUtils.
*/
public abstract class NumberUtils {
/**
* Instantiates a new number utils.
*/
private NumberUtils() {
// Do not allow instantiation of static utils class
}
/**
* Convert number to target class.
*
* @param <T>
* the generic type
* @param number
* the number
* @param targetClass
* the target class
*
* @return the t
*
* @throws IllegalArgumentException
* the illegal argument exception
*/
@SuppressWarnings("unchecked")
public static <T extends Number> T convertNumberToTargetClass(Number number, Class<T> targetClass)
throws IllegalArgumentException {
if (targetClass.isInstance(number)) {
return (T) number;
}
if (targetClass.equals(Byte.class)) {
long value = number.longValue();
if (value < Byte.MIN_VALUE || value > Byte.MAX_VALUE) {
raiseOverflowException(number, targetClass);
}
return (T) Byte.valueOf(number.byteValue());
}
if (targetClass.equals(Short.class)) {
long value = number.longValue();
if (value < Short.MIN_VALUE || value > Short.MAX_VALUE) {
raiseOverflowException(number, targetClass);
}
return (T) Short.valueOf(number.shortValue());
}
if (targetClass.equals(Integer.class)) {
long value = number.longValue();
if (value < Integer.MIN_VALUE || value > Integer.MAX_VALUE) {
raiseOverflowException(number, targetClass);
}
return (T) Integer.valueOf(number.intValue());
}
if (targetClass.equals(Long.class)) {
return (T) Long.valueOf(number.longValue());
}
if (targetClass.equals(BigInteger.class)) {
if (number instanceof BigDecimal) {
// do not lose precision - use BigDecimal's own conversion
return (T) ((BigDecimal) number).toBigInteger();
}
// original value is not a Big* number - use standard long conversion
return (T) BigInteger.valueOf(number.longValue());
}
if (targetClass.equals(Float.class)) {
return (T) Float.valueOf(number.floatValue());
}
if (targetClass.equals(Double.class)) {
return (T) Double.valueOf(number.doubleValue());
}
if (targetClass.equals(BigDecimal.class)) {
// always use BigDecimal(String) here to avoid unpredictability of BigDecimal(double)
// (see BigDecimal javadoc for details)
return (T) new BigDecimal(number.toString());
}
throw new IllegalArgumentException("Could not convert number [" + number + "] of type ["
+ number.getClass().getName() + "] to unknown target class [" + targetClass.getName() + "]");
}
/**
* Raise overflow exception.
*
* @param number
* the number
* @param targetClass
* the target class
*/
private static void raiseOverflowException(Number number, Class targetClass) {
throw new IllegalArgumentException("Could not convert number [" + number + "] of type ["
+ number.getClass().getName() + "] to target class [" + targetClass.getName() + "]: overflow");
}
/**
* Parses the number.
*
* @param <T>
* the generic type
* @param text
* the text
* @param targetClass
* the target class
*
* @return the t
*/
@SuppressWarnings("unchecked")
public static <T extends Number> T parseNumber(String text, Class<T> targetClass) {
String trimmed = trimAllWhitespace(text);
if (targetClass.equals(Byte.class)) {
return (T) (isHexNumber(trimmed) ? Byte.decode(trimmed) : Byte.valueOf(trimmed));
}
if (targetClass.equals(Short.class)) {
return (T) (isHexNumber(trimmed) ? Short.decode(trimmed) : Short.valueOf(trimmed));
}
if (targetClass.equals(Integer.class)) {
return (T) (isHexNumber(trimmed) ? Integer.decode(trimmed) : Integer.valueOf(trimmed));
}
if (targetClass.equals(Long.class)) {
return (T) (isHexNumber(trimmed) ? Long.decode(trimmed) : Long.valueOf(trimmed));
}
if (targetClass.equals(BigInteger.class)) {
return (T) (isHexNumber(trimmed) ? decodeBigInteger(trimmed) : new BigInteger(trimmed));
}
if (targetClass.equals(Float.class)) {
return (T) Float.valueOf(trimmed);
}
if (targetClass.equals(Double.class)) {
return (T) Double.valueOf(trimmed);
}
if (targetClass.equals(BigDecimal.class) || targetClass.equals(Number.class)) {
return (T) new BigDecimal(trimmed);
}
throw new IllegalArgumentException(
"Cannot convert String [" + text + "] to target class [" + targetClass.getName() + "]");
}
/**
* Parses the number.
*
* @param <T>
* the generic type
* @param text
* the text
* @param targetClass
* the target class
* @param numberFormat
* the number format
*
* @return the t
*/
public static <T extends Number> T parseNumber(String text, Class<T> targetClass, NumberFormat numberFormat) {
if (numberFormat != null) {
DecimalFormat decimalFormat = null;
boolean resetBigDecimal = false;
if (numberFormat instanceof DecimalFormat) {
decimalFormat = (DecimalFormat) numberFormat;
if (BigDecimal.class.equals(targetClass) && !decimalFormat.isParseBigDecimal()) {
decimalFormat.setParseBigDecimal(true);
resetBigDecimal = true;
}
}
try {
Number number = numberFormat.parse(trimAllWhitespace(text));
return convertNumberToTargetClass(number, targetClass);
} catch (ParseException ex) {
throw new IllegalArgumentException("Could not parse number: " + ex.getMessage());
} finally {
if (resetBigDecimal && decimalFormat != null) {
decimalFormat.setParseBigDecimal(false);
}
}
}
return parseNumber(text, targetClass);
}
/**
* Checks if is hex number.
*
* @param value
* the value
*
* @return true, if is hex number
*/
private static boolean isHexNumber(String value) {
int index = value.startsWith("-") ? 1 : 0;
return value.startsWith("0x", index) || value.startsWith("0X", index) || value.startsWith("#", index);
}
/**
* Decode big integer.
*
* @param value
* the value
*
* @return the big integer
*/
private static BigInteger decodeBigInteger(String value) {
int radix = 10;
int index = 0;
boolean negative = false;
// Handle minus sign, if present.
if (value.startsWith("-")) {
negative = true;
index++;
}
// Handle radix specifier, if present.
if (value.startsWith("0x", index) || value.startsWith("0X", index)) {
index += 2;
radix = 16;
} else if (value.startsWith("#", index)) {
index++;
radix = 16;
} else if (value.startsWith("0", index) && value.length() > 1 + index) {
index++;
radix = 8;
}
BigInteger result = new BigInteger(value.substring(index), radix);
return negative ? result.negate() : result;
}
}