text: package com.github.ltsopensource.core.json;
  
  import com.github.ltsopensource.core.commons.utils.Base64;
  
  import java.lang.reflect.Array;
  import java.lang.reflect.Method;
  import java.math.BigDecimal;
  import java.math.BigInteger;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.Calendar;
  import java.util.Collection;
  import java.util.Date;
  import java.util.Map;
  
  /**
   * from fastjson
   * @author Robert HG (254963746@qq.com) on 11/21/15.
   */
  public class TypeUtils {
  
      public static final String castToString(Object value) {
          if (value == null) {
              return null;
          }
  
          return value.toString();
      }
  
      public static final Byte castToByte(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof Number) {
              return ((Number) value).byteValue();
          }
  
          if (value instanceof String) {
              String strVal = (String) value;
              if (strVal.length() == 0) {
                  return null;
              }
              return Byte.parseByte(strVal);
          }
  
          throw new JSONException("can not cast to byte, value : " + value);
      }
  
      public static final Short castToShort(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof Number) {
              return ((Number) value).shortValue();
          }
  
          if (value instanceof String) {
              String strVal = (String) value;
              if (strVal.length() == 0) {
                  return null;
              }
              return Short.parseShort(strVal);
          }
  
          throw new JSONException("can not cast to short, value : " + value);
      }
  
      public static final BigDecimal castToBigDecimal(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof BigDecimal) {
              return (BigDecimal) value;
          }
  
          if (value instanceof BigInteger) {
              return new BigDecimal((BigInteger) value);
          }
  
          String strVal = value.toString();
          if (strVal.length() == 0) {
              return null;
          }
  
          return new BigDecimal(strVal);
      }
  
      public static final BigInteger castToBigInteger(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof BigInteger) {
              return (BigInteger) value;
          }
  
          if (value instanceof Float || value instanceof Double) {
              return BigInteger.valueOf(((Number) value).longValue());
          }
  
          String strVal = value.toString();
          if (strVal.length() == 0) {
              return null;
          }
  
          return new BigInteger(strVal);
      }
  
      public static final Float castToFloat(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof Number) {
              return ((Number) value).floatValue();
          }
  
          if (value instanceof String) {
              String strVal = value.toString();
              if (strVal.length() == 0) {
                  return null;
              }
  
              return Float.parseFloat(strVal);
          }
  
          throw new JSONException("can not cast to float, value : " + value);
      }
  
      public static final Double castToDouble(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof Number) {
              return ((Number) value).doubleValue();
          }
  
          if (value instanceof String) {
              String strVal = value.toString();
              if (strVal.length() == 0) {
                  return null;
              }
              return Double.parseDouble(strVal);
          }
  
          throw new JSONException("can not cast to double, value : " + value);
      }
  
      public static final Date castToDate(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof Calendar) {
              return ((Calendar) value).getTime();
          }
  
          if (value instanceof Date) {
              return (Date) value;
          }
  
          long longValue = -1;
  
          if (value instanceof Number) {
              longValue = ((Number) value).longValue();
          }
  
          if (value instanceof String) {
              String strVal = (String) value;
  
              if (strVal.indexOf('-') != -1) {
                  String format;
                  if (strVal.length() == 10) {
                      format = "yyyy-MM-dd";
                  } else if (strVal.length() == "yyyy-MM-dd HH:mm:ss".length()) {
                      format = "yyyy-MM-dd HH:mm:ss";
                  } else {
                      format = "yyyy-MM-dd HH:mm:ss.SSS";
                  }
  
                  SimpleDateFormat dateFormat = new SimpleDateFormat(format);
                  try {
                      return (Date) dateFormat.parse(strVal);
                  } catch (ParseException e) {
                      throw new JSONException("can not cast to Date, value : " + strVal);
                  }
              }
  
              if (strVal.length() == 0) {
                  return null;
              }
  
              longValue = Long.parseLong(strVal);
          }
  
          if (longValue < 0) {
              throw new JSONException("can not cast to Date, value : " + value);
          }
  
          return new Date(longValue);
      }
  
      public static final java.sql.Date castToSqlDate(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof Calendar) {
              return new java.sql.Date(((Calendar) value).getTimeInMillis());
          }
  
          if (value instanceof java.sql.Date) {
              return (java.sql.Date) value;
          }
  
          if (value instanceof java.util.Date) {
              return new java.sql.Date(((java.util.Date) value).getTime());
          }
  
          long longValue = 0;
  
          if (value instanceof Number) {
              longValue = ((Number) value).longValue();
          }
  
          if (value instanceof String) {
              String strVal = (String) value;
              if (strVal.length() == 0) {
                  return null;
              }
  
              longValue = Long.parseLong(strVal);
          }
  
          if (longValue <= 0) {
              throw new JSONException("can not cast to Date, value : " + value);
          }
  
          return new java.sql.Date(longValue);
      }
  
      public static final java.sql.Timestamp castToTimestamp(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof Calendar) {
              return new java.sql.Timestamp(((Calendar) value).getTimeInMillis());
          }
  
          if (value instanceof java.sql.Timestamp) {
              return (java.sql.Timestamp) value;
          }
  
          if (value instanceof java.util.Date) {
              return new java.sql.Timestamp(((java.util.Date) value).getTime());
          }
  
          long longValue = 0;
  
          if (value instanceof Number) {
              longValue = ((Number) value).longValue();
          }
  
          if (value instanceof String) {
              String strVal = (String) value;
              if (strVal.length() == 0) {
                  return null;
              }
  
              longValue = Long.parseLong(strVal);
          }
  
          if (longValue <= 0) {
              throw new JSONException("can not cast to Date, value : " + value);
          }
  
          return new java.sql.Timestamp(longValue);
      }
  
      public static final Long castToLong(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof Number) {
              return ((Number) value).longValue();
          }
  
          if (value instanceof String) {
              String strVal = (String) value;
              if (strVal.length() == 0) {
                  return null;
              }
  
              try {
                  return Long.parseLong(strVal);
              } catch (NumberFormatException ex) {
                  //
              }
          }
  
          throw new JSONException("can not cast to long, value : " + value);
      }
  
      public static final Integer castToInt(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof Integer) {
              return (Integer) value;
          }
  
          if (value instanceof Number) {
              return ((Number) value).intValue();
          }
  
          if (value instanceof String) {
              String strVal = (String) value;
              if (strVal.length() == 0) {
                  return null;
              }
  
              return Integer.parseInt(strVal);
          }
  
          throw new JSONException("can not cast to int, value : " + value);
      }
  
      public static final byte[] castToBytes(Object value) {
          if (value instanceof byte[]) {
              return (byte[]) value;
          }
  
          if (value instanceof String) {
              return Base64.decodeFast((String) value);
          }
          throw new JSONException("can not cast to int, value : " + value);
      }
  
      public static final Boolean castToBoolean(Object value) {
          if (value == null) {
              return null;
          }
  
          if (value instanceof Boolean) {
              return (Boolean) value;
          }
  
          if (value instanceof Number) {
              return ((Number) value).intValue() == 1;
          }
  
          if (value instanceof String) {
              String str = (String) value;
              if (str.length() == 0) {
                  return null;
              }
  
              if ("true".equals(str)) {
                  return Boolean.TRUE;
              }
              if ("false".equals(str)) {
                  return Boolean.FALSE;
              }
  
              if ("1".equals(str)) {
                  return Boolean.TRUE;
              }
          }
  
          throw new JSONException("can not cast to int, value : " + value);
      }
  
      public static final <T> T castToJavaBean(Object obj, Class<T> clazz) {
          return cast(obj, clazz);
      }
  
      @SuppressWarnings({"unchecked", "rawtypes"})
      public static final <T> T cast(Object obj, Class<T> clazz) {
          if (obj == null) {
              return null;
          }
  
          if (clazz == null) {
              throw new IllegalArgumentException("clazz is null");
          }
  
          if (clazz == obj.getClass()) {
              return (T) obj;
          }
  
          if (obj instanceof Map) {
              if (clazz == Map.class) {
                  return (T) obj;
              }
  
              return castToJavaBean(obj, clazz);
          }
  
          if (clazz.isArray()) {
              if (obj instanceof Collection) {
  
                  Collection collection = (Collection) obj;
                  int index = 0;
                  Object array = Array.newInstance(clazz.getComponentType(), collection.size());
                  for (Object item : collection) {
                      Object value = cast(item, clazz.getComponentType());
                      Array.set(array, index, value);
                      index++;
                  }
  
                  return (T) array;
              }
          }
  
          if (clazz.isAssignableFrom(obj.getClass())) {
              return (T) obj;
          }
  
          if (clazz == boolean.class || clazz == Boolean.class) {
              return (T) castToBoolean(obj);
          }
  
          if (clazz == byte.class || clazz == Byte.class) {
              return (T) castToByte(obj);
          }
  
          // if (clazz == char.class || clazz == Character.class) {
          // return (T) castToCharacter(obj);
          // }
  
          if (clazz == short.class || clazz == Short.class) {
              return (T) castToShort(obj);
          }
  
          if (clazz == int.class || clazz == Integer.class) {
              return (T) castToInt(obj);
          }
  
          if (clazz == long.class || clazz == Long.class) {
              return (T) castToLong(obj);
          }
  
          if (clazz == float.class || clazz == Float.class) {
              return (T) castToFloat(obj);
          }
  
          if (clazz == double.class || clazz == Double.class) {
              return (T) castToDouble(obj);
          }
  
          if (clazz == String.class) {
              return (T) castToString(obj);
          }
  
          if (clazz == BigDecimal.class) {
              return (T) castToBigDecimal(obj);
          }
  
          if (clazz == BigInteger.class) {
              return (T) castToBigInteger(obj);
          }
  
          if (clazz == Date.class) {
              return (T) castToDate(obj);
          }
  
          if (clazz == java.sql.Date.class) {
              return (T) castToSqlDate(obj);
          }
  
          if (clazz == java.sql.Timestamp.class) {
              return (T) castToTimestamp(obj);
          }
  
          if (clazz.isEnum()) {
              return (T) castToEnum(obj, clazz);
          }
  
          if (Calendar.class.isAssignableFrom(clazz)) {
              Date date = castToDate(obj);
              Calendar calendar;
              if (clazz == Calendar.class) {
                  calendar = Calendar.getInstance();
              } else {
                  try {
                      calendar = (Calendar) clazz.newInstance();
                  } catch (Exception e) {
                      throw new JSONException("can not cast to : " + clazz.getName(), e);
                  }
              }
              calendar.setTime(date);
              return (T) calendar;
          }
  
          if (obj instanceof String) {
              String strVal = (String) obj;
              if (strVal.length() == 0) {
                  return null;
              }
          }
  
          throw new JSONException("can not cast to : " + clazz.getName());
      }
  
      @SuppressWarnings({"unchecked", "rawtypes"})
      public static final <T> T castToEnum(Object obj, Class<T> clazz) {
          try {
              if (obj instanceof String) {
                  String name = (String) obj;
                  if (name.length() == 0) {
                      return null;
                  }
  
                  return (T) Enum.valueOf((Class<? extends Enum>) clazz, name);
              }
  
              if (obj instanceof Number) {
                  int ordinal = ((Number) obj).intValue();
  
                  Method method = clazz.getMethod("values");
                  Object[] values = (Object[]) method.invoke(null);
                  for (Object value : values) {
                      Enum e = (Enum) value;
                      if (e.ordinal() == ordinal) {
                          return (T) e;
                      }
                  }
              }
          } catch (Exception ex) {
              throw new JSONException("can not cast to : " + clazz.getName(), ex);
          }
  
          throw new JSONException("can not cast to : " + clazz.getName());
      }
  
  }
  