NumberConverters.java

/*******************************************************************************
 * 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 org.apache.ofbiz.base.conversion;

import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DecimalFormat;
import java.text.NumberFormat;
import java.text.ParseException;
import java.util.Locale;
import java.util.TimeZone;

import org.apache.ofbiz.base.util.StringUtil;

/** Number Converter classes. */
public class NumberConverters implements ConverterLoader {

    protected static Number fromString(String str, Locale locale) throws ConversionException {
        NumberFormat nf = NumberFormat.getNumberInstance(locale);
        if (nf instanceof DecimalFormat) {
            ((DecimalFormat) nf).setParseBigDecimal(true);
        }
        try {
            return nf.parse(str);
        } catch (ParseException e) {
            throw new ConversionException(e);
        }
    }

    public static abstract class AbstractStringToNumberConverter<N extends Number> extends AbstractNumberConverter<String, N> {
        public AbstractStringToNumberConverter(Class<N> targetClass) {
            super(String.class, targetClass);
        }

        public N convert(String obj, Locale locale, TimeZone timeZone) throws ConversionException {
            String trimStr = StringUtil.removeSpaces(obj);
            if (trimStr.length() == 0) {
                return null;
            }
            return convert(fromString(trimStr, locale));
        }

        protected abstract N convert(Number number) throws ConversionException;
    }

    public static abstract class AbstractNumberConverter<S, T> extends AbstractLocalizedConverter<S, T> {
        protected AbstractNumberConverter(Class<S> sourceClass, Class<T> targetClass) {
            super(sourceClass, targetClass);
        }

        public T convert(S obj, Locale locale, TimeZone timeZone, String formatString) throws ConversionException {
            return convert(obj, locale, null);
        }
    }

    public static abstract class AbstractNumberToStringConverter<N extends Number> extends AbstractNumberConverter<N, String> {
        public AbstractNumberToStringConverter(Class<N> sourceClass) {
            super(sourceClass, String.class);
        }

        public String convert(N obj) throws ConversionException {
            return obj.toString();
        }

        public String convert(N obj, Locale locale, TimeZone timeZone) throws ConversionException {
            return format(obj, NumberFormat.getNumberInstance(locale));
        }

        protected abstract String format(N obj, NumberFormat nf) throws ConversionException;
    }

    public static class GenericNumberToDouble<N extends Number> extends AbstractConverter<N, Double> {
        public GenericNumberToDouble(Class<N> sourceClass) {
            super(sourceClass, Double.class);
        }

        public Double convert(N obj) throws ConversionException {
            return obj.doubleValue();
        }
    }

    public static class GenericNumberToFloat<N extends Number> extends AbstractConverter<N, Float> {
        public GenericNumberToFloat(Class<N> sourceClass) {
            super(sourceClass, Float.class);
        }

        public Float convert(N obj) throws ConversionException {
            return obj.floatValue();
        }
    }

    public static class GenericNumberToInteger<N extends Number> extends AbstractConverter<N, Integer> {
        public GenericNumberToInteger(Class<N> sourceClass) {
            super(sourceClass, Integer.class);
        }

        public Integer convert(N obj) throws ConversionException {
            return obj.intValue();
        }
    }

    public static class GenericNumberToLong<N extends Number> extends AbstractConverter<N, Long> {
        public GenericNumberToLong(Class<N> sourceClass) {
            super(sourceClass, Long.class);
        }

        public Long convert(N obj) throws ConversionException {
            return obj.longValue();
        }
    }

    public static class GenericNumberToShort<N extends Number> extends AbstractConverter<N, Short> {
        public GenericNumberToShort(Class<N> sourceClass) {
            super(sourceClass, Short.class);
        }

        public Short convert(N obj) throws ConversionException {
            return obj.shortValue();
        }
    }

    public static class BigDecimalToString extends AbstractNumberToStringConverter<BigDecimal> {
        public BigDecimalToString() {
            super(BigDecimal.class);
        }

        @Override
        protected String format(BigDecimal obj, NumberFormat nf) throws ConversionException {
            return nf.format(obj.doubleValue());
        }
    }

    public static class DoubleToBigDecimal extends AbstractConverter<Double, BigDecimal> {
        public DoubleToBigDecimal() {
            super(Double.class, BigDecimal.class);
        }

        public BigDecimal convert(Double obj) throws ConversionException {
            return BigDecimal.valueOf(obj.doubleValue());
        }
    }

    public static class BigIntegerToString extends AbstractNumberToStringConverter<BigInteger> {
        public BigIntegerToString() {
            super(BigInteger.class);
        }

        @Override
        protected String format(BigInteger obj, NumberFormat nf) throws ConversionException {
            return nf.format(obj.doubleValue());
        }
    }

    public static class ByteToString extends AbstractNumberToStringConverter<Byte> {
        public ByteToString() {
            super(Byte.class);
        }

        @Override
        protected String format(Byte obj, NumberFormat nf) throws ConversionException {
            return nf.format(obj.floatValue());
        }
    }

    public static class StringToBigInteger extends AbstractStringToNumberConverter<BigInteger> {
        public StringToBigInteger() {
            super(BigInteger.class);
        }

        public BigInteger convert(String obj) throws ConversionException {
            return new BigInteger(obj);
        }

        @Override
        protected BigInteger convert(Number number) throws ConversionException {
            return BigInteger.valueOf(number.longValue());
        }
    }

    public static class DoubleToString extends AbstractNumberToStringConverter<Double> {
        public DoubleToString() {
            super(Double.class);
        }

        @Override
        protected String format(Double obj, NumberFormat nf) throws ConversionException {
            return nf.format(obj.doubleValue());
        }
    }

    public static class FloatToBigDecimal extends AbstractConverter<Float, BigDecimal> {
        public FloatToBigDecimal() {
            super(Float.class, BigDecimal.class);
        }

        public BigDecimal convert(Float obj) throws ConversionException {
            return BigDecimal.valueOf(obj.doubleValue());
        }
    }

    public static class FloatToString extends AbstractNumberToStringConverter<Float> {
        public FloatToString() {
            super(Float.class);
        }

        @Override
        protected String format(Float obj, NumberFormat nf) throws ConversionException {
            return nf.format(obj.floatValue());
        }
    }

    public static class IntegerToBigDecimal extends AbstractConverter<Integer, BigDecimal> {
        public IntegerToBigDecimal() {
            super(Integer.class, BigDecimal.class);
        }

        public BigDecimal convert(Integer obj) throws ConversionException {
            return BigDecimal.valueOf(obj.intValue());
        }
    }

    public static class IntegerToByte extends AbstractConverter<Integer, Byte> {
        public IntegerToByte() {
            super(Integer.class, Byte.class);
        }

        public Byte convert(Integer obj) throws ConversionException {
            return obj.byteValue();
        }
    }

    public static class IntegerToString extends AbstractNumberToStringConverter<Integer> {
        public IntegerToString() {
            super(Integer.class);
        }

        @Override
        protected String format(Integer obj, NumberFormat nf) throws ConversionException {
            return nf.format(obj.intValue());
        }
    }

    public static class LongToBigDecimal extends AbstractConverter<Long, BigDecimal> {
        public LongToBigDecimal() {
            super(Long.class, BigDecimal.class);
        }

        public BigDecimal convert(Long obj) throws ConversionException {
            return BigDecimal.valueOf(obj.longValue());
        }
    }

    public static class LongToByte extends AbstractConverter<Long, Byte> {
        public LongToByte() {
            super(Long.class, Byte.class);
        }

        public Byte convert(Long obj) throws ConversionException {
            return obj.byteValue();
        }
    }

    public static class LongToString extends AbstractNumberToStringConverter<Long> {
        public LongToString() {
            super(Long.class);
        }

        @Override
        protected String format(Long obj, NumberFormat nf) throws ConversionException {
            return nf.format(obj.longValue());
        }
    }

    public static class ShortToString extends AbstractNumberToStringConverter<Short> {
        public ShortToString() {
            super(Short.class);
        }

        @Override
        protected String format(Short obj, NumberFormat nf) throws ConversionException {
            return nf.format(obj.floatValue());
        }
    }

    public static class StringToBigDecimal extends AbstractStringToNumberConverter<BigDecimal> {
        public StringToBigDecimal() {
            super(BigDecimal.class);
        }

        public BigDecimal convert(String obj) throws ConversionException {
            return new BigDecimal(obj);
        }

        @Override
        protected BigDecimal convert(Number number) throws ConversionException {
            if (number instanceof BigDecimal) {
                return (BigDecimal) number;
            }
            return BigDecimal.valueOf(number.doubleValue());
        }
    }

    public static class StringToByte extends AbstractConverter<String, Byte> {
        public StringToByte() {
            super(String.class, Byte.class);
        }

        public Byte convert(String obj) throws ConversionException {
            return Byte.valueOf(obj);
        }
    }

    public static class StringToDouble extends AbstractStringToNumberConverter<Double> {
        public StringToDouble() {
            super(Double.class);
        }

        public Double convert(String obj) throws ConversionException {
            return Double.valueOf(obj);
        }

        @Override
        protected Double convert(Number number) throws ConversionException {
            return number.doubleValue();
        }
    }

    public static class StringToFloat extends AbstractStringToNumberConverter<Float> {
        public StringToFloat() {
            super(Float.class);
        }

        public Float convert(String obj) throws ConversionException {
            return Float.valueOf(obj);
        }

        @Override
        protected Float convert(Number number) throws ConversionException {
            return number.floatValue();
        }
    }

    public static class StringToInteger extends AbstractStringToNumberConverter<Integer> {
        public StringToInteger() {
            super(Integer.class);
        }

        public Integer convert(String obj) throws ConversionException {
            return Integer.valueOf(obj);
        }

        @Override
        protected Integer convert(Number number) throws ConversionException {
            return number.intValue();
        }
    }

    public static class StringToLong extends AbstractStringToNumberConverter<Long> {
        public StringToLong() {
            super(Long.class);
        }

        public Long convert(String obj) throws ConversionException {
            return Long.valueOf(obj);
        }

        @Override
        protected Long convert(Number number) throws ConversionException {
            return number.longValue();
        }
    }

    public static class StringToShort extends AbstractConverter<String, Short> {
        public StringToShort() {
            super(String.class, Short.class);
        }

        public Short convert(String obj) throws ConversionException {
            return Short.valueOf(obj);
        }
    }

    public void loadConverters() {
        Converters.loadContainedConverters(NumberConverters.class);

        Converters.registerConverter(new GenericNumberToDouble<BigDecimal>(BigDecimal.class));
        Converters.registerConverter(new GenericNumberToDouble<BigInteger>(BigInteger.class));
        Converters.registerConverter(new GenericNumberToDouble<Byte>(Byte.class));
        Converters.registerConverter(new GenericNumberToDouble<Float>(Float.class));
        Converters.registerConverter(new GenericNumberToDouble<Integer>(Integer.class));
        Converters.registerConverter(new GenericNumberToDouble<Long>(Long.class));
        Converters.registerConverter(new GenericNumberToDouble<Short>(Short.class));

        Converters.registerConverter(new GenericNumberToFloat<BigDecimal>(BigDecimal.class));
        Converters.registerConverter(new GenericNumberToFloat<BigInteger>(BigInteger.class));
        Converters.registerConverter(new GenericNumberToFloat<Byte>(Byte.class));
        Converters.registerConverter(new GenericNumberToFloat<Double>(Double.class));
        Converters.registerConverter(new GenericNumberToFloat<Integer>(Integer.class));
        Converters.registerConverter(new GenericNumberToFloat<Long>(Long.class));
        Converters.registerConverter(new GenericNumberToFloat<Short>(Short.class));

        Converters.registerConverter(new GenericNumberToInteger<BigDecimal>(BigDecimal.class));
        Converters.registerConverter(new GenericNumberToInteger<BigInteger>(BigInteger.class));
        Converters.registerConverter(new GenericNumberToInteger<Byte>(Byte.class));
        Converters.registerConverter(new GenericNumberToInteger<Double>(Double.class));
        Converters.registerConverter(new GenericNumberToInteger<Float>(Float.class));
        Converters.registerConverter(new GenericNumberToInteger<Long>(Long.class));
        Converters.registerConverter(new GenericNumberToInteger<Short>(Short.class));

        Converters.registerConverter(new GenericSingletonToList<BigDecimal>(BigDecimal.class));
        Converters.registerConverter(new GenericSingletonToList<BigInteger>(BigInteger.class));
        Converters.registerConverter(new GenericSingletonToList<Byte>(Byte.class));
        Converters.registerConverter(new GenericSingletonToList<Double>(Double.class));
        Converters.registerConverter(new GenericSingletonToList<Float>(Float.class));
        Converters.registerConverter(new GenericSingletonToList<Integer>(Integer.class));
        Converters.registerConverter(new GenericSingletonToList<Long>(Long.class));
        Converters.registerConverter(new GenericSingletonToList<Short>(Short.class));

        Converters.registerConverter(new GenericNumberToLong<BigDecimal>(BigDecimal.class));
        Converters.registerConverter(new GenericNumberToLong<BigInteger>(BigInteger.class));
        Converters.registerConverter(new GenericNumberToLong<Byte>(Byte.class));
        Converters.registerConverter(new GenericNumberToLong<Double>(Double.class));
        Converters.registerConverter(new GenericNumberToLong<Float>(Float.class));
        Converters.registerConverter(new GenericNumberToLong<Integer>(Integer.class));
        Converters.registerConverter(new GenericNumberToLong<Short>(Short.class));

        Converters.registerConverter(new GenericSingletonToSet<BigDecimal>(BigDecimal.class));
        Converters.registerConverter(new GenericSingletonToSet<BigInteger>(BigInteger.class));
        Converters.registerConverter(new GenericSingletonToSet<Byte>(Byte.class));
        Converters.registerConverter(new GenericSingletonToSet<Double>(Double.class));
        Converters.registerConverter(new GenericSingletonToSet<Float>(Float.class));
        Converters.registerConverter(new GenericSingletonToSet<Integer>(Integer.class));
        Converters.registerConverter(new GenericSingletonToSet<Long>(Long.class));
        Converters.registerConverter(new GenericSingletonToSet<Short>(Short.class));

        Converters.registerConverter(new GenericNumberToShort<Integer>(Integer.class));
        Converters.registerConverter(new GenericNumberToShort<Long>(Long.class));
    }
}