• Home
• io.fastjson
• boon
• 0.20
• source code
• Conversions.java

×

Project download

Many resources are needed to download a project. Please understand that we have to compensate our server costs. Thank you in advance.
Project price only 1 $

You can buy this project and download/modify it how often you want.

org.boon.core.Conversions Maven / Gradle / Ivy

/*
 * Copyright 2013-2014 Richard M. Hightower
 * Licensed 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.
 *
 * __________                              _____          __   .__
 * \______   \ ____   ____   ____   /\    /     \ _____  |  | _|__| ____    ____
 *  |    |  _//  _ \ /  _ \ /    \  \/   /  \ /  \\__  \ |  |/ /  |/    \  / ___\
 *  |    |   (  <_> |  <_> )   |  \ /\  /    Y    \/ __ \|    <|  |   |  \/ /_/  >
 *  |______  /\____/ \____/|___|  / \/  \____|__  (____  /__|_ \__|___|  /\___  /
 *         \/                   \/              \/     \/     \/       \//_____/
 *      ____.                     ___________   _____    ______________.___.
 *     |    |____ ___  _______    \_   _____/  /  _  \  /   _____/\__  |   |
 *     |    \__  \\  \/ /\__  \    |    __)_  /  /_\  \ \_____  \  /   |   |
 * /\__|    |/ __ \\   /  / __ \_  |        \/    |    \/        \ \____   |
 * \________(____  /\_/  (____  / /_______  /\____|__  /_______  / / ______|
 *               \/           \/          \/         \/        \/  \/
 */

package org.boon.core;

import org.boon.*;
import org.boon.core.reflection.*;
import org.boon.primitive.Arry;

import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.text.DateFormat;
import java.text.ParseException;
import java.util.*;
import java.util.concurrent.ConcurrentHashMap;
import java.util.logging.Logger;

import static org.boon.Boon.sputs;
import static org.boon.Exceptions.die;
import static org.boon.Exceptions.handle;
import static org.boon.core.Typ.getComponentType;
import static org.boon.core.Typ.isArray;


public class Conversions {

    private static final Logger log = Logger.getLogger(Conversions.class.getName());


    public static BigDecimal toBigDecimal(Object obj) {
        if (obj instanceof BigDecimal) {
            return (BigDecimal) obj;
        }

        if (obj instanceof Value) {
            return ((Value) obj).bigDecimalValue();
        } else if (obj instanceof String) {
            return new BigDecimal((String) obj);
        } else if (obj instanceof Number) {
            double val = ((Number) obj).doubleValue();
            return BigDecimal.valueOf(val);
        }

        return null;
    }


    public static BigInteger toBigInteger(Object obj) {
        if (obj instanceof BigInteger) {
            return (BigInteger) obj;
        }

        if (obj instanceof Value) {
            return ((Value) obj).bigIntegerValue();
        } else if (obj instanceof String) {
            return new BigInteger((String) obj);
        } else if (obj instanceof Number) {
            long val = ((Number) obj).longValue();
            return BigInteger.valueOf(val);
        }

        return null;

    }


    public static int toInt(Object obj) {
        return toInt(obj, Integer.MIN_VALUE);
    }

    public static int toInt(Object obj, int defaultValue) {
        if (obj.getClass() == int.class) {
            return int.class.cast(obj);
        }
        if (obj instanceof Number) {
            return ((Number) obj).intValue();
        } else if (obj instanceof Boolean || obj.getClass() == Boolean.class) {
            boolean value = toBoolean(obj);
            return value ? 1 : 0;
        } else if (obj instanceof CharSequence) {
            try {
                return Integer.parseInt(Str.toString(obj));
            } catch (Exception ex) {
                return defaultValue;
            }
        }
        return defaultValue;

    }


    public static byte toByte(Object obj) {
        return toByte(obj, Byte.MIN_VALUE);
    }

    public static byte toByte(Object obj, byte defaultByte) {
        if (obj.getClass() == byte.class) {
            return byte.class.cast(obj);
        } else if (obj instanceof Number) {
            return ((Number) obj).byteValue();
        } else {
            return (byte) toInt(obj, defaultByte);
        }
    }

    public static short toShort(Object obj) {
        return toShort(obj, Short.MIN_VALUE);
    }

    public static short toShort(Object obj, final short shortDefault) {

        if (obj.getClass() == short.class) {
            return short.class.cast(obj);
        } else if (obj instanceof Number) {
            return ((Number) obj).shortValue();
        } else {
            return (short) toInt(obj, shortDefault);
        }
    }

    public static char toChar(Object obj) {
        return toChar(obj, (char) 0);
    }

    public static char toChar(Object obj, final char defaultChar) {
        if (obj.getClass() == char.class) {
            return char.class.cast(obj);
        } else if (obj instanceof Character) {
            return ((Character) obj).charValue();
        } else if (obj instanceof CharSequence) {
            return obj.toString().charAt(0);
        } else if (obj instanceof Number) {
            return (char) toInt(obj);
        } else if (obj instanceof Boolean || obj.getClass() == Boolean.class) {
            boolean value = toBoolean(obj);
            return value ? 'T' : 'F';
        } else if (obj.getClass().isPrimitive()) {
            return (char) toInt(obj);
        } else {
            String str = toString(obj);
            if (str.length() > 0) {
                return str.charAt(0);
            } else {
                return defaultChar;
            }
        }
    }

    public static long toLong(Object obj) {
        return toLong(obj, Long.MIN_VALUE);
    }


    public static long toLongOrDie(Object obj) {
        long l = toLong(obj, Long.MIN_VALUE);
        if (l == Long.MIN_VALUE) {
            die("Cannot convert", obj, "into long value", obj);
        }
        return l;
    }

    public static long toLong(Object obj, final long longDefault) {

        if (obj instanceof Long) {
            return (Long) obj;
        }

        if (obj instanceof Number) {
            return ((Number) obj).longValue();
        } else if (obj instanceof CharSequence) {
            String str = Str.toString(obj);
            if (Dates.isJsonDate(str)) {
                return Dates.fromJsonDate(str).getTime();
            }

            try {
                return Long.parseLong(str);
            } catch (Exception ex) {
                return longDefault;
            }
        } else if (obj instanceof Date) {
            return ((Date) obj).getTime();
        } else {
            return toInt(obj);
        }

    }

    public static Currency toCurrency(Object obj) {
        if (obj instanceof Currency) {
            return (Currency) obj;
        }

        if (obj instanceof String) {
            String str = Str.toString(obj);
            return Currency.getInstance(str);
        }

        return null;
    }

    /**
     * Converts the value to boolean.
     *
     * @param value value
     * @return value converted to boolean
     */
    public static boolean toBoolean(Object value) {
        return toBoolean(value, false);
    }


    /**
     * Converts the value to boolean, and if it is null, it uses the default value passed.
     *
     * @param obj          value to convert to boolean
     * @param defaultValue default value
     * @return obj converted to boolean
     */
    public static boolean toBoolean(Object obj, boolean defaultValue) {

        if (obj == null) {
            return defaultValue;
        }

        if (obj instanceof Boolean) {
            return ((Boolean) obj).booleanValue();
        } else if (obj instanceof Number || obj.getClass().isPrimitive()) {
            int value = toInt(obj);
            return value != 0 ? true : false;
        } else if (obj instanceof String || obj instanceof CharSequence) {
            String str = Conversions.toString(obj);
            if (str.length() == 0) {
                return false;
            }
            if (str.equals("false")) {
                return false;
            } else {
                return true;
            }
        } else if (Boon.isArray(obj)) {
            return Boon.len(obj) > 0;
        } else if (obj instanceof Collection) {
            List list = Lists.list((Collection) obj);
            while (list.remove(null)) {

            }
            return Lists.len(list) > 0;
        } else {
            return toBoolean(Conversions.toString(obj));
        }
    }

    public static boolean toBooleanOrDie(Object obj) {

        if (obj == null) {
            die("Can't convert boolean from a null");
        }

        if (obj instanceof Boolean) {
            return ((Boolean) obj).booleanValue();
        } else if (obj instanceof String || obj instanceof CharSequence) {
            String str = Conversions.toString(obj);
            if (str.length() == 0) {
                return false;
            }
            if (str.equals("false")) {
                return false;
            } else if (str.equals("true")) {
                return true;
            }
            die("Can't convert string", obj, "to boolean ");
            return false;
        } else {
            die("Can't convert", obj, "to boolean ");
            return false;

        }
    }

    public static double toDouble(Object obj) {

        try {
            if (obj instanceof Double) {
                return (Double) obj;
            } else if (obj instanceof Number) {
                return ((Number) obj).doubleValue();
            } else if (obj instanceof CharSequence) {
                try {
                    return Double.parseDouble(((CharSequence) obj).toString());
                } catch (Exception ex) {
                    die(String.format("Unable to convert %s to a double", obj.getClass()));
                    return Double.MIN_VALUE;
                }
            } else {
            }
        } catch (Exception ex) {
            log.warning(String.format(
                    "unable to convert to double and there was an exception %s",
                    ex.getMessage()));
        }

        die(String.format("Unable to convert %s to a double", obj.getClass()));
        return Double.MIN_VALUE; // die throws an exception

    }

    public static float toFloat(Object obj) {
        if (obj.getClass() == float.class) {
            return (Float) obj;
        }

        try {
            if (obj instanceof Float) {
                return (Float) obj;
            } else if (obj instanceof Number) {
                return ((Number) obj).floatValue();
            } else if (obj instanceof CharSequence) {
                try {
                    return Float.parseFloat(Str.toString(obj));
                } catch (Exception ex) {
                    die(String.format("Unable to convert %s to a float", obj.getClass()));
                    return Float.MIN_VALUE;
                }
            } else {
            }
        } catch (Exception ex) {

            log.warning(String.format(
                    "unable to convert to float and there was an exception %s",
                    ex.getMessage()));
        }

        die(String.format("Unable to convert %s to a float", obj.getClass()));
        return Float.MIN_VALUE;

    }


    public static  T coerce(Class clz, Object value) {
        if (value != null) {
            if (clz == value.getClass()) {
                return (T) value;
            }
        }

        return coerce(Type.getType(clz), clz, value);
    }

    public static  T createFromArg(Class clz, Object value) {
        if (value == null) {
            return Reflection.newInstance(clz);
        }
        ClassMeta meta = ClassMeta.classMeta(clz);
        List constructors = meta.oneArgumentConstructors();

        if (constructors.size() == 0) {
            return null;
        } else if (constructors.size() == 1) {
            ConstructorAccess constructorAccess = constructors.get(0);
            Class arg1Type = constructorAccess.parameterTypes()[0];
            if (arg1Type.isInstance(value)) {
                return (T) constructorAccess.create(value);
            } else {
                return (T) constructorAccess.create(coerce(arg1Type, value));
            }
        } else {
            for (ConstructorAccess c : constructors) {
                Class arg1Type = c.parameterTypes()[0];
                if (arg1Type.isInstance(value)) {
                    return (T) c.create(value);
                }
            }


            for (ConstructorAccess c : constructors) {
                Class arg1Type = c.parameterTypes()[0];
                if (arg1Type.isAssignableFrom(value.getClass())) {
                    return (T) c.create(value);
                }
            }
        }
        return null;
    }

    public static  T coerce(Type coerceTo, Class clz, Object value) {
        if (value == null) {
            if (coerceTo != Type.INSTANCE && !clz.isPrimitive()) {

                return null;
            } else if (clz.isPrimitive()) {
                if (clz == boolean.class) {
                    return (T) (Boolean) false;
                }
                return (T) (Number) 0;
            }
        }

        switch (coerceTo) {
            case STRING:
            case CHAR_SEQUENCE:
                return (T) value.toString();


            case INT:
            case INTEGER_WRAPPER:
                Integer i = toInt(value);
                return (T) i;

            case SHORT:
            case SHORT_WRAPPER:
                Short s = toShort(value);
                return (T) s;


            case BYTE:
            case BYTE_WRAPPER:
                Byte by = toByte(value);
                return (T) by;


            case CHAR:
            case CHAR_WRAPPER:
                Character ch = toChar(value);
                return (T) ch;

            case LONG:
            case LONG_WRAPPER:
                Long l = toLong(value);
                return (T) l;

            case DOUBLE:
            case DOUBLE_WRAPPER:
                Double d = toDouble(value);
                return (T) d;


            case FLOAT:
            case FLOAT_WRAPPER:
                Float f = toFloat(value);
                return (T) f;


            case DATE:
                return (T) toDate(value);

            case BIG_DECIMAL:
                return (T) toBigDecimal(value);


            case BIG_INT:
                return (T) toBigInteger(value);

            case CALENDAR:
                return (T) toCalendar(toDate(value));

            case BOOLEAN:
            case BOOLEAN_WRAPPER:
                return (T) (Boolean) toBoolean(value);

            case MAP:
                if (value instanceof Map) {
                    return (T) value;
                }
                return (T) toMap(value);

            case ARRAY:
                return toPrimitiveArrayIfPossible(clz, value);


            case LIST:
            case SET:
            case COLLECTION:
                return toCollection(clz, value);

            case INSTANCE:
                if (value instanceof Map) {
                    return MapObjectConversion.fromMap((Map) value, clz);
                } else if (value instanceof List) {
                    return MapObjectConversion.fromList((List