Example usage for java.lang Double TYPE

List of usage examples for java.lang Double TYPE

Introduction

In this page you can find the example usage for java.lang Double TYPE.

Prototype

Class TYPE

To view the source code for java.lang Double TYPE.

Click Source Link

Document

The Class instance representing the primitive type double .

Usage

From source file:org.yestech.jmlnitrate.transformation.inbound.BaseInboundTransformation.java

/**
 *  Returns the Class Type for a Primitive type.
 *
 * @param  classType Description of the Parameter
 * @return  the Class Type//from www.  j  a va2s .  c o  m
 * @exception  Exception Description of the Exception
 */
private Class getClass(String classType) throws Exception {
    TransformationParameter classParameter = TransformationParameter.getByName(classType);
    Class type = null;
    if (classParameter != null) {
        if (classParameter.equals(TransformationParameter.INT)) {
            //int
            type = Integer.TYPE;
        } else if (classParameter.equals(TransformationParameter.LONG)) {
            //long
            type = Long.TYPE;
        } else if (classParameter.equals(TransformationParameter.FLOAT)) {
            //float
            type = Float.TYPE;
        } else if (classParameter.equals(TransformationParameter.DOUBLE)) {
            //double
            type = Double.TYPE;
        } else if (classParameter.equals(TransformationParameter.BOOLEAN)) {
            //boolean
            type = Boolean.TYPE;
        } else if (classParameter.equals(TransformationParameter.CHAR)) {
            //char
            type = Character.TYPE;
        } else if (classParameter.equals(TransformationParameter.BYTE)) {
            //byte
            type = Byte.TYPE;
        } else {
            logger.error("Not a valid Class Type...");
            throw new IllegalArgumentException("Not a valid Class Type...");
        }
    } else {
        type = Clazz.getClass(classType);
    }
    return type;
}

From source file:org.fhcrc.cpl.toolbox.filehandler.TabLoader.java

private void initColumnInfos(Class clazz) {
    PropertyDescriptor origDescriptors[] = PropertyUtils.getPropertyDescriptors(clazz);
    HashMap<String, PropertyDescriptor> mappedPropNames = new HashMap<String, PropertyDescriptor>();
    for (PropertyDescriptor origDescriptor : origDescriptors) {
        if (origDescriptor.getName().equals("class"))
            continue;

        mappedPropNames.put(origDescriptor.getName().toLowerCase(), origDescriptor);
    }//from  w ww  . j  a va2  s.  c  om

    boolean isMapClass = java.util.Map.class.isAssignableFrom(clazz);
    for (ColumnDescriptor column : _columns) {
        PropertyDescriptor prop = mappedPropNames.get(column.name.toLowerCase());
        if (null != prop) {
            column.name = prop.getName();
            column.clazz = prop.getPropertyType();
            column.isProperty = true;
            column.setter = prop.getWriteMethod();
            if (column.clazz.isPrimitive()) {
                if (Float.TYPE.equals(column.clazz))
                    column.missingValues = 0.0F;
                else if (Double.TYPE.equals(column.clazz))
                    column.missingValues = 0.0;
                else if (Boolean.TYPE.equals(column.clazz))
                    column.missingValues = Boolean.FALSE;
                else
                    column.missingValues = 0; //Will get converted.
            }
        } else if (isMapClass) {
            column.isProperty = false;
        } else {
            column.load = false;
        }
    }
}

From source file:iing.uabc.edu.mx.persistencia.util.JSON.java

private static void stringifyObject(JsonGenerator generator, BeanManager manager) {

    String keyName;/*  ww  w . j av a2 s  .  c  o m*/

    Field[] fields = manager.getFields();

    //Read every field and transform  it to a json property string
    for (Field field : fields) {
        Class fieldType = manager.getType(field.getName());
        keyName = field.getName();
        Object value = manager.getProperty(keyName);

        System.out.println("KeyName: " + keyName);
        System.out.println("Valor " + keyName + ": " + value);

        if (value == null) {
            //Set to null the property
            generator.writeNull(keyName);
            continue;
        }
        //Is a String
        if (fieldType == String.class) {
            generator.write(keyName, String.valueOf(value));
        } //Is a Date
        else if (fieldType == Date.class) {
            String date = DateFormatUtils.ISO_DATETIME_TIME_ZONE_FORMAT.format(value);

            generator.write(keyName, date);

        } //Is a integer
        else if (fieldType == Integer.class || fieldType == Integer.TYPE) {
            generator.write(keyName, (int) value);
        } //Is a double
        else if (fieldType == Double.class || fieldType == Double.TYPE) {
            generator.write(keyName, (double) value);
        } //Is boolean
        else if (fieldType == Boolean.class || fieldType == Boolean.TYPE) {
            generator.write(keyName, (boolean) value);
        } //Is a collection
        else if (value instanceof Collection) {
            Class elementClass = manager.getCollectionElementType(keyName);

            System.out.println("Nueva Colleccion [] de clase: " + elementClass.getSimpleName());

            generator.writeStartArray(keyName);

            //Create new collection manager with the given class
            CollectionManager collectionManager = new CollectionManager((Collection) value, elementClass);

            stringifyArray(generator, collectionManager);

            generator.writeEnd();
        } else {
            //Is a object... probably
            BeanManager objectManager = new BeanManager(value);

            System.out.println("Nuevo Objecto {}: " + value.getClass().getSimpleName());
            generator.writeStartObject(keyName);

            stringifyObject(generator, objectManager);

            generator.writeEnd();
        }
    }

}

From source file:org.xmlsh.util.JavaUtils.java

public static Class<?> fromPrimativeName(String name) {

    switch (name) {
    case "boolean":
        return java.lang.Boolean.TYPE;
    case "char":
        return java.lang.Character.TYPE;
    case "byte":
        return java.lang.Byte.TYPE;
    case "short":
        return java.lang.Short.TYPE;
    case "int":
        return java.lang.Integer.TYPE;
    case "long":
        return java.lang.Long.TYPE;
    case "float":
        return java.lang.Float.TYPE;
    case "double":
        return java.lang.Double.TYPE;
    case "void":
        return java.lang.Void.TYPE;
    default://from   w  w  w. j  a  v  a  2 s .c  om
        return null;
    }

}

From source file:com.github.gekoh.yagen.util.FieldInfo.java

private static List<FieldInfo> convertFields(List<FieldInfo> fields, Class baseEntity) {

    for (Field field : baseEntity.getDeclaredFields()) {
        FieldInfo fi;/*  w w w .jav  a 2  s.c  om*/
        Class type = field.getType();
        String name = field.getName();
        Column column = field.getAnnotation(Column.class);
        if (field.isAnnotationPresent(Embedded.class)) {
            if (field.isAnnotationPresent(AttributeOverride.class)) {
                fi = new FieldInfo(type, name, field.getAnnotation(AttributeOverride.class));
            } else {
                fi = new FieldInfo(type, name, field.getAnnotation(AttributeOverrides.class));
            }
        } else if (field.isAnnotationPresent(Enumerated.class)) {
            fi = new FieldInfo(type, name, true, column);
        } else if (column != null && !field.isAnnotationPresent(CollectionTable.class)) {
            if (type.isPrimitive()) {
                if (type.equals(Boolean.TYPE)) {
                    type = Boolean.class;
                } else if (type.equals(Long.TYPE)) {
                    type = Long.class;
                } else if (type.equals(Integer.TYPE)) {
                    type = Integer.class;
                } else if (type.equals(Short.TYPE)) {
                    type = Short.class;
                } else if (type.equals(Byte.TYPE)) {
                    type = Byte.class;
                } else if (type.equals(Double.TYPE)) {
                    type = Double.class;
                } else if (type.equals(Float.TYPE)) {
                    type = Float.class;
                } else if (type.equals(Character.TYPE)) {
                    type = Character.class;
                }
            }
            fi = new FieldInfo(type, name, false, column);
        } else if ((field.isAnnotationPresent(ManyToOne.class) && !field.isAnnotationPresent(JoinTable.class))
                || (field.isAnnotationPresent(OneToOne.class)
                        && StringUtils.isEmpty(field.getAnnotation(OneToOne.class).mappedBy()))) {
            String columnName = field.isAnnotationPresent(JoinColumn.class)
                    ? field.getAnnotation(JoinColumn.class).name()
                    : field.getName();
            fi = getIdFieldInfo(type, name, columnName);
        } else if (!field.isAnnotationPresent(Transient.class)
                && (Collection.class.isAssignableFrom(type) || Map.class.isAssignableFrom(type))
                && (field.isAnnotationPresent(JoinColumn.class) || field.isAnnotationPresent(JoinTable.class)
                        || field.isAnnotationPresent(CollectionTable.class))) {
            fi = new FieldInfo(type, name);
        } else {
            continue;
        }
        if (field.isAnnotationPresent(Type.class)) {
            fi.addAnnotation(field.getAnnotation(Type.class));
        }
        fi.setField(field);
        fields.add(fi);
    }

    return fields;
}

From source file:com.nonninz.robomodel.RoboModel.java

void saveField(Field field, TypedContentValues cv) {
    final Class<?> type = field.getType();
    final boolean wasAccessible = field.isAccessible();
    field.setAccessible(true);//www.  j a  v a2  s.  c o  m

    try {
        if (type == String.class) {
            cv.put(field.getName(), (String) field.get(this));
        } else if (type == Boolean.TYPE) {
            cv.put(field.getName(), field.getBoolean(this));
        } else if (type == Byte.TYPE) {
            cv.put(field.getName(), field.getByte(this));
        } else if (type == Double.TYPE) {
            cv.put(field.getName(), field.getDouble(this));
        } else if (type == Float.TYPE) {
            cv.put(field.getName(), field.getFloat(this));
        } else if (type == Integer.TYPE) {
            cv.put(field.getName(), field.getInt(this));
        } else if (type == Long.TYPE) {
            cv.put(field.getName(), field.getLong(this));
        } else if (type == Short.TYPE) {
            cv.put(field.getName(), field.getShort(this));
        } else if (type.isEnum()) {
            final Object value = field.get(this);
            if (value != null) {
                final Method method = type.getMethod("name");
                final String str = (String) method.invoke(value);
                cv.put(field.getName(), str);
            }
        } else {
            // Try to JSONify it (db column must be of type text)
            final String json = mMapper.writeValueAsString(field.get(this));
            cv.put(field.getName(), json);
        }
    } catch (final IllegalAccessException e) {
        final String msg = String.format("Field %s is not accessible", type, field.getName());
        throw new IllegalArgumentException(msg);
    } catch (final JsonProcessingException e) {
        Ln.w(e, "Error while dumping %s of type %s to Json", field.getName(), type);
        final String msg = String.format("Field %s is not accessible", type, field.getName());
        throw new IllegalArgumentException(msg);
    } catch (final NoSuchMethodException e) {
        // Should not happen
        throw new RuntimeException(e);
    } catch (final InvocationTargetException e) {
        // Should not happen
        throw new RuntimeException(e);
    } finally {
        field.setAccessible(wasAccessible);
    }
}

From source file:com.initialxy.cordova.themeablebrowser.ThemeableBrowserUnmarshaller.java

/**
 * Gracefully convert given Object to given class given the precondition
 * that both are primitives or one of the classes associated with
 * primitives. eg. If val is of type Double and cls is of type int, return
 * Integer type with appropriate value truncation so that it can be assigned
 * to field with field.set().//from   w  w w. j  a va  2s.  c  o  m
 *
 * @param cls
 * @param val
 * @return
 * @throws com.initialxy.cordova.themeablebrowser.ThemeableBrowserUnmarshaller.TypeMismatchException
 */
private static Object convertToPrimitiveFieldObj(Object val, Class<?> cls) {
    Class<?> valClass = val.getClass();
    Object result = null;

    try {
        Method getter = null;
        if (cls.isAssignableFrom(Byte.class) || cls.isAssignableFrom(Byte.TYPE)) {
            getter = valClass.getMethod("byteValue");
        } else if (cls.isAssignableFrom(Short.class) || cls.isAssignableFrom(Short.TYPE)) {
            getter = valClass.getMethod("shortValue");
        } else if (cls.isAssignableFrom(Integer.class) || cls.isAssignableFrom(Integer.TYPE)) {
            getter = valClass.getMethod("intValue");
        } else if (cls.isAssignableFrom(Long.class) || cls.isAssignableFrom(Long.TYPE)) {
            getter = valClass.getMethod("longValue");
        } else if (cls.isAssignableFrom(Float.class) || cls.isAssignableFrom(Float.TYPE)) {
            getter = valClass.getMethod("floatValue");
        } else if (cls.isAssignableFrom(Double.class) || cls.isAssignableFrom(Double.TYPE)) {
            getter = valClass.getMethod("doubleValue");
        } else if (cls.isAssignableFrom(Boolean.class) || cls.isAssignableFrom(Boolean.TYPE)) {
            if (val instanceof Boolean) {
                result = val;
            } else {
                throw new TypeMismatchException(cls, val.getClass());
            }
        } else if (cls.isAssignableFrom(Character.class) || cls.isAssignableFrom(Character.TYPE)) {
            if (val instanceof String && ((String) val).length() == 1) {
                char c = ((String) val).charAt(0);
                result = Character.valueOf(c);
            } else if (val instanceof String) {
                throw new TypeMismatchException(
                        "Expected Character, " + "but received String with length other than 1.");
            } else {
                throw new TypeMismatchException(
                        String.format("Expected Character, accept String, but got %s.", val.getClass()));
            }
        }

        if (getter != null) {
            result = getter.invoke(val);
        }
    } catch (NoSuchMethodException e) {
        throw new TypeMismatchException(String.format("Cannot convert %s to %s.", val.getClass(), cls));
    } catch (SecurityException e) {
        throw new TypeMismatchException(String.format("Cannot convert %s to %s.", val.getClass(), cls));
    } catch (IllegalAccessException e) {
        throw new TypeMismatchException(String.format("Cannot convert %s to %s.", val.getClass(), cls));
    } catch (InvocationTargetException e) {
        throw new TypeMismatchException(String.format("Cannot convert %s to %s.", val.getClass(), cls));
    }

    return result;
}

From source file:com.nway.spring.jdbc.bean.JavassistBeanProcessor.java

private Object processColumn(ResultSet rs, int index, Class<?> propType, String writer, StringBuilder handler)
        throws SQLException {
    if (propType.equals(String.class)) {
        handler.append("bean.").append(writer).append("(").append("$1.getString(").append(index).append("));");
        return rs.getString(index);
    } else if (propType.equals(Integer.TYPE)) {
        handler.append("bean.").append(writer).append("(").append("$1.getInt(").append(index).append("));");
        return rs.getInt(index);
    } else if (propType.equals(Integer.class)) {
        handler.append("bean.").append(writer).append("(").append("integerValue($1.getInt(").append(index)
                .append("),$1.wasNull()));");
        return JdbcUtils.getResultSetValue(rs, index, Integer.class);
    } else if (propType.equals(Long.TYPE)) {
        handler.append("bean.").append(writer).append("(").append("$1.getLong(").append(index).append("));");
        return rs.getLong(index);
    } else if (propType.equals(Long.class)) {
        handler.append("bean.").append(writer).append("(").append("longValue($1.getLong(").append(index)
                .append("),$1.wasNull()));");
        return JdbcUtils.getResultSetValue(rs, index, Long.class);
    } else if (propType.equals(java.sql.Date.class)) {
        handler.append("bean.").append(writer).append("(").append("$1.getDate(").append(index).append("));");
        return rs.getDate(index);
    } else if (propType.equals(java.util.Date.class) || propType.equals(Timestamp.class)) {
        handler.append("bean.").append(writer).append("(").append("$1.getTimestamp(").append(index)
                .append("));");
        return rs.getTimestamp(index);
    } else if (propType.equals(Double.TYPE)) {
        handler.append("bean.").append(writer).append("(").append("$1.getDouble(").append(index).append("));");
        return rs.getDouble(index);
    } else if (propType.equals(Double.class)) {
        handler.append("bean.").append(writer).append("(").append("doubleValue($1.getDouble(").append(index)
                .append("),$1.wasNull()));");
        return JdbcUtils.getResultSetValue(rs, index, Double.class);
    } else if (propType.equals(Float.TYPE)) {
        handler.append("bean.").append(writer).append("(").append("$1.getFloat(").append(index).append("));");
        return rs.getFloat(index);
    } else if (propType.equals(Float.class)) {
        handler.append("bean.").append(writer).append("(").append("floatValue($1.getFloat(").append(index)
                .append("),$1.wasNull()));");
        return JdbcUtils.getResultSetValue(rs, index, Float.class);
    } else if (propType.equals(Time.class)) {
        handler.append("bean.").append(writer).append("(").append("$1.getTime(").append(index).append("));");
        return rs.getTime(index);
    } else if (propType.equals(Boolean.TYPE)) {
        handler.append("bean.").append(writer).append("(").append("$1.getBoolean(").append(index).append("));");
        return rs.getBoolean(index);
    } else if (propType.equals(Boolean.class)) {
        handler.append("bean.").append(writer).append("(").append("booleanValue($1.getBoolean(").append(index)
                .append("),$1.wasNull()));");
        return JdbcUtils.getResultSetValue(rs, index, Boolean.class);
    } else if (propType.equals(byte[].class)) {
        handler.append("bean.").append(writer).append("(").append("$1.getBytes(").append(index).append("));");
        return rs.getBytes(index);
    } else if (BigDecimal.class.equals(propType)) {
        handler.append("bean.").append(writer).append("(").append("$1.getBigDecimal(").append(index)
                .append("));");
        return rs.getBigDecimal(index);
    } else if (Blob.class.equals(propType)) {
        handler.append("bean.").append(writer).append("(").append("$1.getBlob(").append(index).append("));");
        return rs.getBlob(index);
    } else if (Clob.class.equals(propType)) {
        handler.append("bean.").append(writer).append("(").append("$1.getClob(").append(index).append("));");
        return rs.getClob(index);
    } else if (propType.equals(Short.TYPE)) {
        handler.append("bean.").append(writer).append("(").append("$1.getShort(").append(index).append("));");
        return rs.getShort(index);
    } else if (propType.equals(Short.class)) {
        handler.append("bean.").append(writer).append("(").append("shortValue($1.getShort(").append(index)
                .append("),$1.wasNull()));");
        return JdbcUtils.getResultSetValue(rs, index, Short.class);
    } else if (propType.equals(Byte.TYPE)) {
        handler.append("bean.").append(writer).append("(").append("$1.getByte(").append(index).append("));");
        return rs.getByte(index);
    } else if (propType.equals(Byte.class)) {
        handler.append("bean.").append(writer).append("(").append("byteValue($1.getByte(").append(index)
                .append("),$1.wasNull()));");
        return JdbcUtils.getResultSetValue(rs, index, Byte.class);
    } else {/*from  w w w .ja  v  a2s  . c o  m*/
        handler.append("bean.").append(writer).append("(").append("(").append(propType.getName()).append(")")
                .append("$1.getObject(").append(index).append("));");
        return rs.getObject(index);
    }
}

From source file:com.sun.faces.el.impl.Coercions.java

/**
 * Returns true if the given class is Byte, Short, Integer, Long,
 * Float, Double, BigInteger, or BigDecimal
 *///from w w w  .j  av a 2  s .c  om
static boolean isNumberClass(Class pClass) {
    return pClass == Byte.class || pClass == Byte.TYPE || pClass == Short.class || pClass == Short.TYPE
            || pClass == Integer.class || pClass == Integer.TYPE || pClass == Long.class || pClass == Long.TYPE
            || pClass == Float.class || pClass == Float.TYPE || pClass == Double.class || pClass == Double.TYPE
            || pClass == BigInteger.class || pClass == BigDecimal.class;
}

From source file:at.alladin.rmbt.shared.hstoreparser.HstoreParser.java

/**
 * get a specific key from json by preserving the fields type
 * @param json//from  ww  w.  ja  v  a2 s . c  o  m
 * @param key
 * @param toField
 * @return
 * @throws JSONException 
 */
public static Object getFromJsonByField(JSONObject json, String key, Field toField) throws JSONException {
    final Object o = json.get(key);
    if (o != JSONObject.NULL) {
        if (toField.getType().equals(Integer.class) || toField.getType().equals(Integer.TYPE)) {
            return Integer.parseInt(String.valueOf(o));
        } else if (toField.getType().equals(String.class)) {
            return o;
        } else if (toField.getType().equals(Long.class) || toField.getType().equals(Long.TYPE)) {
            return Long.parseLong(String.valueOf(o));
        } else if (toField.getType().equals(Boolean.class) || toField.getType().equals(Boolean.TYPE)) {
            return Boolean.parseBoolean(String.valueOf(o));
        } else if (toField.getType().equals(Float.class) || toField.getType().equals(Float.TYPE)) {
            return Float.parseFloat(String.valueOf(o));
        } else if (toField.getType().equals(Double.class) || toField.getType().equals(Double.TYPE)) {
            return Double.parseDouble(String.valueOf(o));
        } else {
            return o;
        }
    }

    return JSONObject.NULL;
}