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:com.manydesigns.elements.util.Util.java

public static boolean isNumericType(Class type) {
    return Number.class.isAssignableFrom(type) || type == Integer.TYPE || type == Byte.TYPE
            || type == Short.TYPE || type == Long.TYPE || type == Float.TYPE || type == Double.TYPE;
}

From source file:com.epam.catgenome.manager.externaldb.bindings.ExternalDBBindingTest.java

private Object createParam(Class type)
        throws IllegalAccessException, InvocationTargetException, InstantiationException {
    Object param;//from ww w.  j  av  a2 s  .co  m
    if (type == String.class) {
        param = "test";
    } else if (type == Integer.class || type == Integer.TYPE) {
        param = RandomUtils.nextInt();
    } else if (type == Long.class || type == Long.TYPE) {
        param = RandomUtils.nextLong();
    } else if (type == Float.class || type == Float.TYPE) {
        param = RandomUtils.nextFloat();
    } else if (type == Double.class || type == Double.TYPE) {
        param = RandomUtils.nextDouble();
    } else if (type == Boolean.class || type == Boolean.TYPE) {
        param = RandomUtils.nextBoolean();
    } else if (type == BigInteger.class) {
        param = new BigInteger(TEST_BIGINTEGER);
    } else if (type == List.class) {
        param = new ArrayList<>();
    } else if (type == XMLGregorianCalendar.class) {
        try {
            param = DatatypeFactory.newInstance().newXMLGregorianCalendar();
        } catch (DatatypeConfigurationException e) {
            throw new IllegalArgumentException(e.getMessage(), e);
        }
    } else {
        Constructor[] constructors = type.getConstructors();
        param = constructors[0].newInstance();
    }

    return param;
}

From source file:org.javelin.sws.ext.bind.internal.BuiltInMappings.java

/**
 * @param patterns/*  w  ww  .  j  a va2  s. c om*/
 */
public static <T> void initialize(Map<Class<?>, TypedPattern<?>> patterns,
        Map<QName, TypedPattern<?>> patternsForTypeQNames) {
    // see: com.sun.xml.bind.v2.model.impl.RuntimeBuiltinLeafInfoImpl<T> and inner
    // com.sun.xml.bind.v2.model.impl.RuntimeBuiltinLeafInfoImpl.StringImpl<T> implementations

    // we have two places where XSD -> Java mapping is defined:
    // - JAX-RPC 1.1, section 4.2.1 Simple Types
    // - JAXB 2, section 6.2.2 Atomic Datatype

    // XML Schema (1.0) Part 2: Datatypes Second Edition, or/and
    // W3C XML Schema Definition Language (XSD) 1.1 Part 2: Datatypes

    // conversion of primitive types should be base on "Lexical Mapping" of simple types defined in XSD part 2

    // 3.2 Special Built-in Datatypes (#special-datatypes)
    // 3.2.1 anySimpleType (#anySimpleType)
    // 3.2.2 anyAtomicType (#anyAtomicType)

    // 3.3 Primitive Datatypes (#built-in-primitive-datatypes)

    // 3.3.1 string (#string)
    {
        SimpleContentPattern<String> pattern = SimpleContentPattern.newValuePattern(SweJaxbConstants.XSD_STRING,
                String.class);
        patterns.put(pattern.getJavaType(), pattern);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
    }

    // 3.3.2 boolean (#boolean)
    {
        SimpleContentPattern<Boolean> pattern = SimpleContentPattern
                .newValuePattern(SweJaxbConstants.XSD_BOOLEAN, Boolean.class);
        patterns.put(Boolean.TYPE, pattern);
        patterns.put(pattern.getJavaType(), pattern);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<Boolean>() {
            @Override
            public String print(Boolean object, Locale locale) {
                return Boolean.toString(object);
            }

            @Override
            public Boolean parse(String text, Locale locale) throws ParseException {
                // TODO: should allow "true", "false", "1", "0"
                return Boolean.parseBoolean(text);
            }
        });
    }

    // 3.3.3 decimal (#decimal)
    {
        SimpleContentPattern<BigDecimal> pattern = SimpleContentPattern
                .newValuePattern(SweJaxbConstants.XSD_DECIMAL, BigDecimal.class);
        patterns.put(pattern.getJavaType(), pattern);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<BigDecimal>() {
            @Override
            public String print(BigDecimal object, Locale locale) {
                return object.toPlainString();
            }

            @Override
            public BigDecimal parse(String text, Locale locale) throws ParseException {
                // TODO: should allow (\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)
                return new BigDecimal(text);
            }
        });
    }

    // 3.3.4 float (#float)
    {
        SimpleContentPattern<Float> pattern = SimpleContentPattern.newValuePattern(SweJaxbConstants.XSD_FLOAT,
                Float.class);
        patterns.put(Float.TYPE, pattern);
        patterns.put(pattern.getJavaType(), pattern);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<Float>() {
            @Override
            public String print(Float object, Locale locale) {
                return Float.toString(object);
            }

            @Override
            public Float parse(String text, Locale locale) throws ParseException {
                // TODO: should allow (\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)([Ee](\+|-)?[0-9]+)?|(\+|-)?INF|NaN
                return Float.parseFloat(text);
            }
        });
    }

    // 3.3.5 double (#double)
    {
        SimpleContentPattern<Double> pattern = SimpleContentPattern.newValuePattern(SweJaxbConstants.XSD_DOUBLE,
                Double.class);
        patterns.put(Double.TYPE, pattern);
        patterns.put(pattern.getJavaType(), pattern);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<Double>() {
            @Override
            public String print(Double object, Locale locale) {
                return Double.toString(object);
            }

            @Override
            public Double parse(String text, Locale locale) throws ParseException {
                // TODO: should allow (\+|-)?([0-9]+(\.[0-9]*)?|\.[0-9]+)([Ee](\+|-)?[0-9]+)?|(\+|-)?INF|NaN
                return Double.parseDouble(text);
            }
        });
    }

    // 3.3.6 duration (#duration)
    // 3.3.7 dateTime (#dateTime)
    {
        SimpleContentPattern<DateTime> pattern = SimpleContentPattern
                .newValuePattern(SweJaxbConstants.XSD_DATETIME, DateTime.class);
        patterns.put(pattern.getJavaType(), pattern);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<DateTime>() {
            private final DateTimeFormatter DTMS = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSSZZ");
            private final DateTimeFormatter DT = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ssZZ");
            private final DateTimeFormatter DTZMS = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss.SSS'Z'");
            private final DateTimeFormatter DTZ = DateTimeFormat.forPattern("yyyy-MM-dd'T'HH:mm:ss'Z'");

            @Override
            public DateTime parse(String text, Locale locale) throws ParseException {
                return null;
            }

            @Override
            public String print(DateTime object, Locale locale) {
                if (object.getMillisOfSecond() == 0) {
                    return object.getZone() == DateTimeZone.UTC ? DTZ.print(object) : DT.print(object);
                } else {
                    return object.getZone() == DateTimeZone.UTC ? DTZMS.print(object) : DTMS.print(object);
                }
            }
        });
    }
    // 3.3.8 time (#time)
    {
        SimpleContentPattern<DateTime> pattern = SimpleContentPattern.newValuePattern(SweJaxbConstants.XSD_TIME,
                DateTime.class);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<DateTime>() {
            private final DateTimeFormatter TMS = DateTimeFormat.forPattern("HH:mm:ss.SSS");
            private final DateTimeFormatter T = DateTimeFormat.forPattern("HH:mm:ss");

            @Override
            public DateTime parse(String text, Locale locale) throws ParseException {
                return null;
            }

            @Override
            public String print(DateTime object, Locale locale) {
                // TODO: should allow (([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](\.[0-9]+)?|(24:00:00(\.0+)?))(Z|(\+|-)((0[0-9]|1[0-3]):[0-5][0-9]|14:00))?
                if (object.getMillisOfSecond() == 0)
                    return T.print(object);
                else
                    return TMS.print(object);
            }
        });
    }
    // 3.3.9 date (#date)
    {
        SimpleContentPattern<DateTime> pattern = SimpleContentPattern.newValuePattern(SweJaxbConstants.XSD_DATE,
                DateTime.class);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<DateTime>() {
            private final DateTimeFormatter DT = DateTimeFormat.forPattern("yyyy-MM-ddZZ");
            private final DateTimeFormatter DTZ = DateTimeFormat.forPattern("yyyy-MM-dd'Z'");

            @Override
            public DateTime parse(String text, Locale locale) throws ParseException {
                return null;
            }

            @Override
            public String print(DateTime object, Locale locale) {
                return object.getZone() == DateTimeZone.UTC ? DTZ.print(object) : DT.print(object);
            }
        });
    }
    // 3.3.10 gYearMonth (#gYearMonth)
    // 3.3.11 gYear (#gYear)
    // 3.3.12 gMonthDay (#gMonthDay)
    // 3.3.13 gDay (#gDay)
    // 3.3.14 gMonth (#gMonth)
    // 3.3.15 hexBinary (#hexBinary)
    // 3.3.16 base64Binary (#base64Binary)
    // 3.3.17 anyURI (#anyURI)
    // 3.3.18 QName (#QName)
    // 3.3.19 NOTATION (#NOTATION)

    // 3.4 Other Built-in Datatypes (#ordinary-built-ins)

    // 3.4.1 normalizedString (#normalizedString)
    // 3.4.2 token (#token)
    // 3.4.3 language (#language)
    // 3.4.4 NMTOKEN (#NMTOKEN)
    // 3.4.5 NMTOKENS (#NMTOKENS)
    // 3.4.6 Name (#Name)
    // 3.4.7 NCName (#NCName)
    // 3.4.8 ID (#ID)
    // 3.4.9 IDREF (#IDREF)
    // 3.4.10 IDREFS (#IDREFS)
    // 3.4.11 ENTITY (#ENTITY)
    // 3.4.12 ENTITIES (#ENTITIES)
    // 3.4.13 integer (#integer)
    // 3.4.14 nonPositiveInteger (#nonPositiveInteger)
    // 3.4.15 negativeInteger (#negativeInteger)
    // 3.4.16 long (#long)
    {
        SimpleContentPattern<Long> pattern = SimpleContentPattern.newValuePattern(SweJaxbConstants.XSD_LONG,
                Long.class);
        patterns.put(Long.TYPE, pattern);
        patterns.put(pattern.getJavaType(), pattern);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<Long>() {
            @Override
            public String print(Long object, Locale locale) {
                return Long.toString(object);
            }

            @Override
            public Long parse(String text, Locale locale) throws ParseException {
                return Long.parseLong(text);
            }
        });
    }
    // 3.4.17 int (#int)
    {
        SimpleContentPattern<Integer> pattern = SimpleContentPattern.newValuePattern(SweJaxbConstants.XSD_INT,
                Integer.class);
        patterns.put(Integer.TYPE, pattern);
        patterns.put(pattern.getJavaType(), pattern);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<Integer>() {
            @Override
            public String print(Integer object, Locale locale) {
                return Integer.toString(object);
            }

            @Override
            public Integer parse(String text, Locale locale) throws ParseException {
                return Integer.parseInt(text);
            }
        });
    }
    // 3.4.18 short (#short)
    {
        SimpleContentPattern<Short> pattern = SimpleContentPattern.newValuePattern(SweJaxbConstants.XSD_SHORT,
                Short.class);
        patterns.put(Short.TYPE, pattern);
        patterns.put(pattern.getJavaType(), pattern);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<Short>() {
            @Override
            public String print(Short object, Locale locale) {
                return Short.toString(object);
            }

            @Override
            public Short parse(String text, Locale locale) throws ParseException {
                return Short.parseShort(text);
            }
        });
    }
    // 3.4.19 byte (#byte)
    {
        SimpleContentPattern<Byte> pattern = SimpleContentPattern.newValuePattern(SweJaxbConstants.XSD_BYTE,
                Byte.class);
        patterns.put(Byte.TYPE, pattern);
        patterns.put(pattern.getJavaType(), pattern);
        patternsForTypeQNames.put(pattern.getSchemaType(), pattern);
        pattern.setFormatter(new Formatter<Byte>() {
            @Override
            public String print(Byte object, Locale locale) {
                return Byte.toString(object);
            }

            @Override
            public Byte parse(String text, Locale locale) throws ParseException {
                return Byte.parseByte(text);
            }
        });
    }
    // 3.4.20 nonNegativeInteger (#nonNegativeInteger)
    // 3.4.21 unsignedLong (#unsignedLong)
    // 3.4.22 unsignedInt (#unsignedInt)
    // 3.4.23 unsignedShort (#unsignedShort)
    // 3.4.24 unsignedByte (#unsignedByte)
    // 3.4.25 positiveInteger (#positiveInteger)
    // 3.4.26 yearMonthDuration (#yearMonthDuration)
    // 3.4.27 dayTimeDuration (#dayTimeDuration)
    // 3.4.28 dateTimeStamp (#dateTimeStamp)

    // other simple types
    // JAXB2 (static):
    /*
       class [B
       class char
       class java.awt.Image
       class java.io.File
       class java.lang.Character
       class java.lang.Class
       class java.lang.Void
       class java.math.BigDecimal
       class java.math.BigInteger
       class java.net.URI
       class java.net.URL
       class java.util.Calendar
       class java.util.Date
       class java.util.GregorianCalendar
       class java.util.UUID
       class javax.activation.DataHandler
       class javax.xml.datatype.Duration
       class javax.xml.datatype.XMLGregorianCalendar
       class javax.xml.namespace.QName
       interface javax.xml.transform.Source
       class void
     */
    // JAXB2 (additional mappings available at runtime):
    /*
     * class com.sun.xml.bind.api.CompositeStructure
     * class java.lang.Object
     * class javax.xml.bind.JAXBElement
     */
}

From source file:com.github.michalbednarski.intentslab.Utils.java

public static Object getDefaultValueForPrimitveClass(Class<?> aClass) {
    if (aClass == Boolean.TYPE) {
        return false;
    } else if (aClass == Byte.TYPE) {
        return (byte) 0;
    } else if (aClass == Character.TYPE) {
        return 0;
    } else if (aClass == Short.TYPE) {
        return (short) 0;
    } else if (aClass == Integer.TYPE) {
        return 0;
    } else if (aClass == Long.TYPE) {
        return (long) 0;
    } else if (aClass == Float.TYPE) {
        return 0;
    } else if (aClass == Double.TYPE) {
        return 0;
    } else {/* www.  j av  a  2  s.  co  m*/
        throw new RuntimeException("Not primitive type");
    }
}

From source file:org.onebusaway.gtfs_transformer.deferred.DeferredValueConverter.java

private boolean isPrimitiveAssignable(Class<?> expectedValueType, Class<?> actualValueType) {
    if (!expectedValueType.isPrimitive()) {
        return false;
    }/*from  w w  w .j  a v  a 2  s .  c o  m*/
    return expectedValueType == Double.TYPE
            && (actualValueType == Double.class || actualValueType == Float.class)
            || expectedValueType == Long.TYPE && (actualValueType == Long.class
                    || actualValueType == Integer.class || actualValueType == Short.class)
            || expectedValueType == Integer.TYPE
                    && (actualValueType == Integer.class || actualValueType == Short.class)
            || expectedValueType == Short.TYPE && (actualValueType == Short.class)
            || expectedValueType == Boolean.TYPE && (actualValueType == Boolean.class);
}

From source file:org.openflexo.antar.binding.TypeUtils.java

public static boolean isDouble(Type type) {
    if (type == null) {
        return false;
    }/*from  ww  w  .  ja  v a2 s  .  co m*/
    return type.equals(Double.class) || type.equals(Double.TYPE);
}

From source file:cc.aileron.accessor.TypeConvertorImpl.java

/**
 * default constractor/*from ww w.j a va 2  s .  c om*/
 */
@Inject
public TypeConvertorImpl() {
    map.put(Boolean.TYPE, new C() {
        @Override
        public Boolean convert(final java.lang.Number number) {
            return number.intValue() != 0;
        }
    });
    map.put(Byte.TYPE, new C() {

        @Override
        public Byte convert(final java.lang.Number number) {
            return number.byteValue();
        }
    });
    map.put(Short.TYPE, new C() {

        @Override
        public Short convert(final java.lang.Number number) {
            return number.shortValue();
        }
    });
    map.put(Integer.TYPE, new C() {
        @Override
        public Integer convert(final java.lang.Number number) {
            return number.intValue();
        }

    });
    map.put(Long.TYPE, new C() {

        @Override
        public Long convert(final java.lang.Number number) {
            return number.longValue();
        }
    });
    map.put(Float.TYPE, new C() {

        @Override
        public Float convert(final java.lang.Number number) {
            return number.floatValue();
        }
    });
    map.put(Double.TYPE, new C() {

        @Override
        public Double convert(final java.lang.Number number) {
            return number.doubleValue();
        }
    });
}

From source file:uk.ac.imperial.presage2.db.json.JsonStorage.java

private <T> T returnAsType(JsonNode n, Class<T> type) {
    if (type == String.class)
        return type.cast(n.textValue());
    else if (type == Integer.class || type == Integer.TYPE)
        return type.cast(n.asInt());
    else if (type == Double.class || type == Double.TYPE)
        return type.cast(n.asDouble());
    else if (type == Boolean.class || type == Boolean.TYPE)
        return type.cast(n.asBoolean());
    else if (type == Long.class || type == Long.TYPE)
        return type.cast(n.asLong());

    throw new RuntimeException("Unknown type cast request");
}

From source file:org.soybeanMilk.SbmUtils.java

/**
 * ?<code>type</code>?/*from ww  w  .  j a  va2s .c o m*/
 * @param type
 * @return
 * @date 2010-12-31
 */
public static Type wrapType(Type type) {
    if (!isClassType(type))
        return type;
    else if (!narrowToClass(type).isPrimitive())
        return type;
    else if (Byte.TYPE.equals(type))
        return Byte.class;
    else if (Short.TYPE.equals(type))
        return Short.class;
    else if (Integer.TYPE.equals(type))
        return Integer.class;
    else if (Long.TYPE.equals(type))
        return Long.class;
    else if (Float.TYPE.equals(type))
        return Float.class;
    else if (Double.TYPE.equals(type))
        return Double.class;
    else if (Boolean.TYPE.equals(type))
        return Boolean.class;
    else if (Character.TYPE.equals(type))
        return Character.class;
    else
        return type;
}

From source file:org.hyperic.hq.agent.server.monitor.AgentMonitorSimple.java

/**
 * Get a value of monitorKeys//from  w ww . j a v a2  s .  co  m
 *
 * @param monitorKeys Keys that the monitor recognizes
 * @return A value for each monitorKey presented
 */
public AgentMonitorValue[] getMonitorValues(String[] monitorKeys) {
    Object[] noArgs = new Object[0];
    AgentMonitorValue[] res;

    res = new AgentMonitorValue[monitorKeys.length];
    for (int i = 0; i < monitorKeys.length; i++) {
        String key = monitorKeys[i];
        Method m = (Method) this.methodMap.get(key);
        AgentMonitorValue val;

        val = new AgentMonitorValue();
        if (m == null) {
            val.setErrCode(AgentMonitorValue.ERR_BADKEY);
        } else {
            try {
                Object invokeRes;
                Class resClass;

                invokeRes = m.invoke(this, noArgs);
                resClass = invokeRes.getClass();
                if (resClass.equals(String.class)) {
                    val.setValue((String) invokeRes);
                } else if (resClass.equals(Double.TYPE) || resClass.equals(Double.class)) {
                    val.setValue(((Double) invokeRes).doubleValue());
                } else if (resClass.equals(String[].class)) {
                    val.setValue((String[]) invokeRes);
                } else if (resClass.equals(int[].class)) {
                    val.setValue((int[]) invokeRes);
                } else {
                    throw new IllegalStateException("Unhandled res type: " + resClass);
                }
            } catch (IllegalAccessException exc) {
                this.log.error("Unable to access monitor method '" + key + "': " + exc.getMessage(), exc);
                val.setErrCode(AgentMonitorValue.ERR_INTERNAL);
            } catch (IllegalArgumentException exc) {
                // Should never occur
                this.log.error(
                        "Invalid arguments passed to monitor " + "method '" + key + "': " + exc.getMessage(),
                        exc);
                val.setErrCode(AgentMonitorValue.ERR_INTERNAL);
            } catch (InvocationTargetException exc) {
                Throwable tExc = exc.getTargetException();

                if (tExc instanceof AgentMonitorIncalculableException) {
                    val.setErrCode(AgentMonitorValue.ERR_INCALCULABLE);
                } else if (tExc instanceof AgentMonitorInternalException) {
                    val.setErrCode(AgentMonitorValue.ERR_INTERNAL);
                } else {
                    val.setErrCode(AgentMonitorValue.ERR_INTERNAL);
                    this.log.error(
                            "Monitor method '" + key + "' threw " + "a runtime exception: " + tExc.getMessage(),
                            tExc);
                }
            }
        }

        res[i] = val;
    }
    return res;
}