/** * Checks if one <code>Class</code> can be assigned to a variable of another <code>Class</code>. * * <p>Unlike the {@link Class#isAssignableFrom(java.lang.Class)} method, this method takes into * account widenings of primitive classes and <code>null</code>s. * * <p>Primitive widenings allow an int to be assigned to a long, float or double. This method * returns the correct result for these cases. * * <p><code>Null</code> may be assigned to any reference type. This method will return <code>true * </code> if <code>null</code> is passed in and the toClass is non-primitive. * * <p>Specifically, this method tests whether the type represented by the specified <code>Class * </code> parameter can be converted to the type represented by this <code>Class</code> object * via an identity conversion widening primitive or widening reference conversion. See <em><a * href="http://java.sun.com/docs/books/jls/">The Java Language Specification</a></em>, sections * 5.1.1, 5.1.2 and 5.1.4 for details. * * @param cls the Class to check, may be null * @param toClass the Class to try to assign into, returns false if null * @return <code>true</code> if assignment possible */ public static boolean isAssignable(Class cls, Class toClass) { if (toClass == null) { return false; } // have to check for null, as isAssignableFrom doesn't if (cls == null) { return !(toClass.isPrimitive()); } if (cls.equals(toClass)) { return true; } if (cls.isPrimitive()) { if (toClass.isPrimitive() == false) { return false; } if (Integer.TYPE.equals(cls)) { return Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass); } if (Long.TYPE.equals(cls)) { return Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass); } if (Boolean.TYPE.equals(cls)) { return false; } if (Double.TYPE.equals(cls)) { return false; } if (Float.TYPE.equals(cls)) { return Double.TYPE.equals(toClass); } if (Character.TYPE.equals(cls)) { return Integer.TYPE.equals(toClass) || Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass); } if (Short.TYPE.equals(cls)) { return Integer.TYPE.equals(toClass) || Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass); } if (Byte.TYPE.equals(cls)) { return Short.TYPE.equals(toClass) || Integer.TYPE.equals(toClass) || Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass); } // should never get here return false; } return toClass.isAssignableFrom(cls); }
protected Class<?> autoBoxing(Class<?> c) { if (!c.isPrimitive()) { return c; } // 8 elements // Boolean.TYPE, Character.TYPE, Byte.TYPE, Short.TYPE, // Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE if (Boolean.TYPE.equals(c)) { return Boolean.class; } else if (Character.TYPE.equals(c)) { return Character.class; } else if (Byte.TYPE.equals(c)) { return Byte.class; } else if (Short.TYPE.equals(c)) { return Short.class; } else if (Integer.TYPE.equals(c)) { return Integer.class; } else if (Long.TYPE.equals(c)) { return Long.class; } else if (Float.TYPE.equals(c)) { return Float.class; } else if (Double.TYPE.equals(c)) { return Double.class; } else { return c; } }
/** Write a class using safe encoding to workaround java 1.3 serialization bug. */ private void writeAnyClass(Class clazz, ObjectOutputStream out) throws IOException { // safely write out any class int primitiveType = 0; if (Boolean.TYPE.equals(clazz)) { primitiveType = BOOLEAN_TYPE; } else if (Byte.TYPE.equals(clazz)) { primitiveType = BYTE_TYPE; } else if (Character.TYPE.equals(clazz)) { primitiveType = CHAR_TYPE; } else if (Double.TYPE.equals(clazz)) { primitiveType = DOUBLE_TYPE; } else if (Float.TYPE.equals(clazz)) { primitiveType = FLOAT_TYPE; } else if (Integer.TYPE.equals(clazz)) { primitiveType = INT_TYPE; } else if (Long.TYPE.equals(clazz)) { primitiveType = LONG_TYPE; } else if (Short.TYPE.equals(clazz)) { primitiveType = SHORT_TYPE; } if (primitiveType == 0) { // then it's not a primitive type out.writeBoolean(false); out.writeObject(clazz); } else { // we'll write out a constant instead out.writeBoolean(true); out.writeInt(primitiveType); } }
/** * Retrieves the SNMP data type corresponding to an object instance. * * @param object * @return a class */ private static Class<?> retrieveDataTypeFromObject(final Object object) { if (object instanceof String || String.class.equals(object)) { return OctetString.class; } else if (Number.class.isInstance(object)) { return Integer32.class; } else if (object instanceof Class) { Class<?> clz = (Class<?>) object; if (clz.isPrimitive()) { if (Integer.TYPE.equals(clz) || Long.TYPE.equals(clz) || Byte.TYPE.equals(clz) || Short.TYPE.equals(clz)) { return Integer32.class; } } else { if (Integer.class.equals(clz) || Long.class.equals(clz) || Byte.class.equals(clz) || Short.class.equals(clz)) { return Integer32.class; } } } return null; }
private static Encoder getEncoder(final Class<?> type) throws IntrospectionException { if (CharSequence.class.isAssignableFrom(type) || Character.class.equals(type) || Character.TYPE.equals(type) || UUID.class.equals(type)) { return StringEncoder.INSTANCE; } else if (Number.class.isAssignableFrom(type) || Byte.TYPE.equals(type) || Short.TYPE.equals(type) || Integer.TYPE.equals(type) || Long.TYPE.equals(type) || Boolean.TYPE.equals(type) || Boolean.class.equals(type)) { return PlainFormEncoder.INSTANCE; } else if (type.isArray()) { return new ArrayEncoder(getEncoder(type.getComponentType())); } else if (Iterable.class.isAssignableFrom(type)) { return IterableEncoder.INSTANCE; } else if (Map.class.isAssignableFrom(type)) { return MapEncoder.INSTANCE; } else if (Date.class.isAssignableFrom(type)) { return DateEncoder.INSTANCE; } else { ObjectEncoder encoder = encoderCache.get(type); if (encoder == null) { encoder = new ObjectEncoder(type); encoderCache.put(type, encoder); } return encoder; } }
static { UIBindingsUtils.BOXED2PRIMITIVE.put(Boolean.class.getName(), Boolean.TYPE.getName()); UIBindingsUtils.BOXED2PRIMITIVE.put(Character.class.getName(), Character.TYPE.getName()); UIBindingsUtils.BOXED2PRIMITIVE.put(Byte.class.getName(), Byte.TYPE.getName()); UIBindingsUtils.BOXED2PRIMITIVE.put(Short.class.getName(), Short.TYPE.getName()); UIBindingsUtils.BOXED2PRIMITIVE.put(Integer.class.getName(), Integer.TYPE.getName()); UIBindingsUtils.BOXED2PRIMITIVE.put(Long.class.getName(), Long.TYPE.getName()); UIBindingsUtils.BOXED2PRIMITIVE.put(Float.class.getName(), Float.TYPE.getName()); UIBindingsUtils.BOXED2PRIMITIVE.put(Double.class.getName(), Double.TYPE.getName()); }
/** Tests if Class represents a primitive number or wrapper.<br> */ public static boolean isNumber(Class clazz) { return clazz != null && (Byte.TYPE.isAssignableFrom(clazz) || Short.TYPE.isAssignableFrom(clazz) || Integer.TYPE.isAssignableFrom(clazz) || Long.TYPE.isAssignableFrom(clazz) || Float.TYPE.isAssignableFrom(clazz) || Double.TYPE.isAssignableFrom(clazz) || Number.class.isAssignableFrom(clazz)); }
/** * 是否数值 * * @param clazz * @return */ public static boolean isNumber(Class<?> clazz) { return (clazz != null) && ((Byte.TYPE.isAssignableFrom(clazz)) || (Short.TYPE.isAssignableFrom(clazz)) || (Integer.TYPE.isAssignableFrom(clazz)) || (Long.TYPE.isAssignableFrom(clazz)) || (Float.TYPE.isAssignableFrom(clazz)) || (Double.TYPE.isAssignableFrom(clazz)) || (Number.class.isAssignableFrom(clazz))); }
static { primitiveTypes.put(Boolean.TYPE.getName(), Boolean.TYPE); primitiveTypes.put(Byte.TYPE.getName(), Byte.TYPE); primitiveTypes.put(Short.TYPE.getName(), Short.TYPE); primitiveTypes.put(Character.TYPE.getName(), Character.TYPE); primitiveTypes.put(Integer.TYPE.getName(), Integer.TYPE); primitiveTypes.put(Long.TYPE.getName(), Long.TYPE); primitiveTypes.put(Float.TYPE.getName(), Float.TYPE); primitiveTypes.put(Double.TYPE.getName(), Double.TYPE); }
/** * Converts the specified value to the target class. If the class is a primitive type * (Integer.TYPE, Boolean.TYPE, etc) the value returned will use the wrapper type (Integer.class, * Boolean.class, etc). * * @param cls the target class of the converted value * @param value the value to convert * @param params optional parameters used for the conversion * @return the converted value * @throws ConversionException if the value is not compatible with the requested type * @since 1.5 */ static Object to(Class<?> cls, Object value, Object[] params) throws ConversionException { if (cls.isInstance(value)) { return value; // no conversion needed } if (Boolean.class.equals(cls) || Boolean.TYPE.equals(cls)) { return toBoolean(value); } else if (Character.class.equals(cls) || Character.TYPE.equals(cls)) { return toCharacter(value); } else if (Number.class.isAssignableFrom(cls) || cls.isPrimitive()) { if (Integer.class.equals(cls) || Integer.TYPE.equals(cls)) { return toInteger(value); } else if (Long.class.equals(cls) || Long.TYPE.equals(cls)) { return toLong(value); } else if (Byte.class.equals(cls) || Byte.TYPE.equals(cls)) { return toByte(value); } else if (Short.class.equals(cls) || Short.TYPE.equals(cls)) { return toShort(value); } else if (Float.class.equals(cls) || Float.TYPE.equals(cls)) { return toFloat(value); } else if (Double.class.equals(cls) || Double.TYPE.equals(cls)) { return toDouble(value); } else if (BigInteger.class.equals(cls)) { return toBigInteger(value); } else if (BigDecimal.class.equals(cls)) { return toBigDecimal(value); } } else if (Date.class.equals(cls)) { return toDate(value, (String) params[0]); } else if (Calendar.class.equals(cls)) { return toCalendar(value, (String) params[0]); } else if (URL.class.equals(cls)) { return toURL(value); } else if (Locale.class.equals(cls)) { return toLocale(value); } else if (isEnum(cls)) { return convertToEnum(cls, value); } else if (Color.class.equals(cls)) { return toColor(value); } else if (cls.getName().equals(INTERNET_ADDRESS_CLASSNAME)) { return toInternetAddress(value); } else if (InetAddress.class.isAssignableFrom(cls)) { return toInetAddress(value); } throw new ConversionException( "The value '" + value + "' (" + value.getClass() + ")" + " can't be converted to a " + cls.getName() + " object"); }
static { PRIMITIVE_TYPES.put(Boolean.TYPE.getName(), Boolean.TYPE); PRIMITIVE_TYPES.put(Character.TYPE.getName(), Character.TYPE); PRIMITIVE_TYPES.put(Byte.TYPE.getName(), Byte.TYPE); PRIMITIVE_TYPES.put(Short.TYPE.getName(), Short.TYPE); PRIMITIVE_TYPES.put(Integer.TYPE.getName(), Integer.TYPE); PRIMITIVE_TYPES.put(Long.TYPE.getName(), Long.TYPE); PRIMITIVE_TYPES.put(Float.TYPE.getName(), Float.TYPE); PRIMITIVE_TYPES.put(Double.TYPE.getName(), Double.TYPE); PRIMITIVE_TYPES.put(Void.TYPE.getName(), Void.TYPE); }
/** * Is the given {@code object} a primitive type or wrapper for a primitive type? * * @param object The object to check for primitive-ness. * @return {@code true} if {@code object} is a primitive type or wrapper for a primitive type, * {@code false} otherwise. */ static boolean isPrimitive(Object object) { if (object == null) return false; Class<?> type = object.getClass(); return (object instanceof Integer || Integer.TYPE.equals(type)) || (object instanceof Boolean || Boolean.TYPE.equals(type)) || (object instanceof Long || Long.TYPE.equals(type)) || (object instanceof Double || Double.TYPE.equals(type)) || (object instanceof Float || Float.TYPE.equals(type)) || (object instanceof Byte || Byte.TYPE.equals(type)) || (object instanceof Short || Short.TYPE.equals(type)) || (object instanceof Character || Character.TYPE.equals(type)); }
public static void addAll(Map map) { IntegerSerializer integerserializer = new IntegerSerializer(); map.put(java / lang / Integer.getName(), integerserializer); map.put(Integer.TYPE.getName(), integerserializer); map.put(java / lang / Long.getName(), LongSerializer.instance); map.put(Long.TYPE.getName(), LongSerializer.instance); map.put(java / lang / Byte.getName(), IntLikeSerializer.instance); map.put(Byte.TYPE.getName(), IntLikeSerializer.instance); map.put(java / lang / Short.getName(), IntLikeSerializer.instance); map.put(Short.TYPE.getName(), IntLikeSerializer.instance); map.put(java / lang / Float.getName(), FloatSerializer.instance); map.put(Float.TYPE.getName(), FloatSerializer.instance); map.put(java / lang / Double.getName(), DoubleSerializer.instance); map.put(Double.TYPE.getName(), DoubleSerializer.instance); }
/** * Tests for equality. * * @param o the object to test. * @return A boolean. */ public boolean equals(final Object o) { if (this == o) { return true; } if (!(o instanceof AbstractObjectDescription)) { return false; } final AbstractObjectDescription abstractObjectDescription = (AbstractObjectDescription) o; if (Short.TYPE.equals(abstractObjectDescription.getObjectClass())) { return true; } if (Short.class.equals(abstractObjectDescription.getObjectClass())) { return true; } return false; }
protected Class loadClass(String className) { Class valueType = String.class; if (null != className && 0 < className.length()) { if (className.equals(Boolean.TYPE.getName())) { valueType = Boolean.TYPE; } else if (className.equals(Byte.TYPE.getName())) { valueType = Byte.TYPE; } else if (className.equals(Double.TYPE.getName())) { valueType = Double.TYPE; } else if (className.equals(Float.TYPE.getName())) { valueType = Float.TYPE; } else if (className.equals(Integer.TYPE.getName())) { valueType = Integer.TYPE; } else if (className.equals(Character.TYPE.getName())) { valueType = Character.TYPE; } else if (className.equals(Short.TYPE.getName())) { valueType = Short.TYPE; } else if (className.equals(Long.TYPE.getName())) { valueType = Long.TYPE; } else { try { valueType = Util.loadClass(className, this); } catch (ClassNotFoundException cnfe) { String message = MessageUtils.getExceptionMessageString( MessageUtils.MANAGED_BEAN_CLASS_NOT_FOUND_ERROR_ID, className, beanInfo.getName()); throw new ManagedBeanPreProcessingException(message, cnfe); } catch (NoClassDefFoundError ncdfe) { String message = MessageUtils.getExceptionMessageString( MessageUtils.MANAGED_BEAN_CLASS_DEPENDENCY_NOT_FOUND_ERROR_ID, className, beanInfo.getName(), ncdfe.getMessage()); throw new ManagedBeanPreProcessingException(message, ncdfe); } } } return valueType; }
public static void setField(Field f, Object o, String t) throws NumberFormatException, IllegalArgumentException, IllegalAccessException { Class type = f.getType(); if (String.class.equals(type)) { f.set(o, t); } else if (Double.class.equals(type)) { f.set(o, Double.valueOf(t)); } else if (Float.class.equals(type)) { f.set(o, Float.valueOf(t)); } else if (Long.class.equals(type)) { f.set(o, Long.valueOf(t)); } else if (Integer.class.equals(type)) { f.set(o, Integer.valueOf(t)); } else if (Character.class.equals(type)) { f.set(o, Character.valueOf(t.charAt(0))); } else if (Short.class.equals(type)) { f.set(o, Short.valueOf(t)); } else if (Byte.class.equals(type)) { f.set(o, Byte.valueOf(t)); } else if (Boolean.class.equals(type)) { f.set(o, Boolean.valueOf(t)); } else if (Double.TYPE.equals(type)) { f.setDouble(o, Double.parseDouble(t)); } else if (Float.TYPE.equals(type)) { f.setFloat(o, Float.parseFloat(t)); } else if (Long.TYPE.equals(type)) { f.setLong(o, Long.parseLong(t)); } else if (Integer.TYPE.equals(type)) { f.setInt(o, Integer.parseInt(t)); } else if (Character.TYPE.equals(type)) { f.setChar(o, t.charAt(0)); } else if (Short.TYPE.equals(type)) { f.setShort(o, Short.parseShort(t)); } else if (Byte.TYPE.equals(type)) { f.setByte(o, Byte.parseByte(t)); } else if (Boolean.TYPE.equals(type)) { f.setBoolean(o, Boolean.parseBoolean(t)); } }
public static ArrayProperty createArrayProperty(Property componentProperty, Class type) throws JAXBException { if (!type.isPrimitive()) return new ObjectArrayProperty(componentProperty, type); if (Double.TYPE.equals(type)) return DoubleArrayProperty.PROPERTY; if (Float.TYPE.equals(type)) return FloatArrayProperty.PROPERTY; if (Integer.TYPE.equals(type)) return IntegerArrayProperty.PROPERTY; if (Long.TYPE.equals(type)) return LongArrayProperty.PROPERTY; if (Boolean.TYPE.equals(type)) return BooleanArrayProperty.PROPERTY; if (Character.TYPE.equals(type)) return CharacterArrayProperty.PROPERTY; if (Short.TYPE.equals(type)) return ShortArrayProperty.PROPERTY; /* XXX if (Byte.TYPE.equals(type)) return ByteArrayProperty.PROPERTY; */ throw new JAXBException(L.l("{0} is neither primitive, nor non-primitive!", type)); }
private static void assertExpectedPrimitiveArrays( String message, Object expected, Object actual, Class expectedInnerType, Class actualInnerType) { if (Boolean.TYPE.isAssignableFrom(expectedInnerType)) { if (Boolean.TYPE.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (boolean[]) expected, (boolean[]) actual); } else if (Boolean.class.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (boolean[]) expected, (Boolean[]) actual); } else if (!actualInnerType.isPrimitive()) { ArrayAssertions.assertEquals(message, (boolean[]) expected, (Object[]) actual); } else { failNotEquals(message, expected, actual); } } else if (Byte.TYPE.isAssignableFrom(expectedInnerType)) { if (Byte.TYPE.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (byte[]) expected, (byte[]) actual); } else if (Byte.class.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (byte[]) expected, (Byte[]) actual); } else if (!actualInnerType.isPrimitive()) { ArrayAssertions.assertEquals(message, (byte[]) expected, (Object[]) actual); } else { failNotEquals(message, expected, actual); } } else if (Short.TYPE.isAssignableFrom(expectedInnerType)) { if (Short.TYPE.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (short[]) expected, (short[]) actual); } else if (Short.class.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (short[]) expected, (Short[]) actual); } else if (!actualInnerType.isPrimitive()) { ArrayAssertions.assertEquals(message, (short[]) expected, (Object[]) actual); } else { failNotEquals(message, expected, actual); } } else if (Integer.TYPE.isAssignableFrom(expectedInnerType)) { if (Integer.TYPE.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (int[]) expected, (int[]) actual); } else if (Integer.class.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (int[]) expected, (Integer[]) actual); } else if (!actualInnerType.isPrimitive()) { ArrayAssertions.assertEquals(message, (int[]) expected, (Object[]) actual); } else { failNotEquals(message, expected, actual); } } else if (Long.TYPE.isAssignableFrom(expectedInnerType)) { if (Long.TYPE.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (long[]) expected, (long[]) actual); } else if (Long.class.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (long[]) expected, (Long[]) actual); } else if (!actualInnerType.isPrimitive()) { ArrayAssertions.assertEquals(message, (long[]) expected, (Object[]) actual); } else { failNotEquals(message, expected, actual); } } else if (Float.TYPE.isAssignableFrom(expectedInnerType)) { if (Float.TYPE.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (float[]) expected, (float[]) actual); } else if (Float.class.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (float[]) expected, (Float[]) actual); } else if (!actualInnerType.isPrimitive()) { ArrayAssertions.assertEquals(message, (float[]) expected, (Object[]) actual); } else { failNotEquals(message, expected, actual); } } else if (Double.TYPE.isAssignableFrom(expectedInnerType)) { if (Double.TYPE.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (double[]) expected, (double[]) actual); } else if (Double.class.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (double[]) expected, (Double[]) actual); } else if (!actualInnerType.isPrimitive()) { ArrayAssertions.assertEquals(message, (double[]) expected, (Object[]) actual); } else { failNotEquals(message, expected, actual); } } else if (Character.TYPE.isAssignableFrom(expectedInnerType)) { if (Character.TYPE.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (char[]) expected, (char[]) actual); } else if (Character.class.isAssignableFrom(actualInnerType)) { ArrayAssertions.assertEquals(message, (char[]) expected, (Character[]) actual); } else if (!actualInnerType.isPrimitive()) { ArrayAssertions.assertEquals(message, (char[]) expected, (Object[]) actual); } else { failNotEquals(message, expected, actual); } } }
private boolean compare_PrimitiveArray( int operation, Class<?> type, Object primarray, Object value2) { if (Integer.TYPE.isAssignableFrom(type)) { int[] array = (int[]) primarray; for (int value1 : array) { if (compare_Integer(operation, value1, value2)) { return true; } } return false; } if (Long.TYPE.isAssignableFrom(type)) { long[] array = (long[]) primarray; for (long value1 : array) { if (compare_Long(operation, value1, value2)) { return true; } } return false; } if (Byte.TYPE.isAssignableFrom(type)) { byte[] array = (byte[]) primarray; for (byte value1 : array) { if (compare_Byte(operation, value1, value2)) { return true; } } return false; } if (Short.TYPE.isAssignableFrom(type)) { short[] array = (short[]) primarray; for (short value1 : array) { if (compare_Short(operation, value1, value2)) { return true; } } return false; } if (Character.TYPE.isAssignableFrom(type)) { char[] array = (char[]) primarray; for (char value1 : array) { if (compare_Character(operation, value1, value2)) { return true; } } return false; } if (Float.TYPE.isAssignableFrom(type)) { float[] array = (float[]) primarray; for (float value1 : array) { if (compare_Float(operation, value1, value2)) { return true; } } return false; } if (Double.TYPE.isAssignableFrom(type)) { double[] array = (double[]) primarray; for (double value1 : array) { if (compare_Double(operation, value1, value2)) { return true; } } return false; } if (Boolean.TYPE.isAssignableFrom(type)) { boolean[] array = (boolean[]) primarray; for (boolean value1 : array) { if (compare_Boolean(operation, value1, value2)) { return true; } } return false; } return false; }
private static Map<String, Class<?>> createCommonJavaClassesMap() { Map<String, Class<?>> m = new HashMap<>(); m.put("java.lang.String", java.lang.String.class); m.put("String", java.lang.String.class); m.put("java.lang.CharSequence", java.lang.CharSequence.class); m.put("CharSequence", java.lang.CharSequence.class); m.put("java.sql.Timestamp", java.sql.Timestamp.class); m.put("Timestamp", java.sql.Timestamp.class); m.put("java.sql.Time", java.sql.Time.class); m.put("Time", java.sql.Time.class); m.put("java.sql.Date", java.sql.Date.class); m.put("Date", java.sql.Date.class); m.put("java.util.Locale", java.util.Locale.class); m.put("java.util.TimeZone", java.util.TimeZone.class); m.put("java.lang.Byte", java.lang.Byte.class); m.put("java.lang.Character", java.lang.Character.class); m.put("java.lang.Integer", java.lang.Integer.class); m.put("Integer", java.lang.Integer.class); m.put("java.lang.Long", java.lang.Long.class); m.put("Long", java.lang.Long.class); m.put("java.lang.Short", java.lang.Short.class); m.put("java.lang.Float", java.lang.Float.class); m.put("Float", java.lang.Float.class); m.put("java.lang.Double", java.lang.Double.class); m.put("Double", java.lang.Double.class); m.put("java.math.BigDecimal", java.math.BigDecimal.class); m.put("BigDecimal", java.math.BigDecimal.class); m.put("java.math.BigInteger", java.math.BigInteger.class); m.put("BigInteger", java.math.BigInteger.class); m.put("java.lang.Boolean", java.lang.Boolean.class); m.put("Boolean", java.lang.Boolean.class); m.put("java.lang.Object", java.lang.Object.class); m.put("Object", java.lang.Object.class); m.put("java.sql.Blob", java.sql.Blob.class); m.put("Blob", java.sql.Blob.class); m.put("java.nio.ByteBuffer", java.nio.ByteBuffer.class); m.put("java.sql.Clob", java.sql.Clob.class); m.put("Clob", java.sql.Clob.class); m.put("java.util.Date", java.util.Date.class); m.put("java.util.Collection", java.util.Collection.class); m.put("Collection", java.util.Collection.class); m.put("java.util.List", java.util.List.class); m.put("List", java.util.List.class); m.put("java.util.ArrayList", java.util.ArrayList.class); m.put("ArrayList", java.util.ArrayList.class); m.put("java.util.Map", java.util.Map.class); m.put("Map", java.util.Map.class); m.put("java.util.HashMap", java.util.HashMap.class); m.put("java.util.Set", java.util.Set.class); m.put("Set", java.util.Set.class); m.put("java.util.HashSet", java.util.HashSet.class); m.put("groovy.util.Node", groovy.util.Node.class); m.put("Node", groovy.util.Node.class); m.put("org.moqui.util.MNode", org.moqui.util.MNode.class); m.put("MNode", org.moqui.util.MNode.class); m.put(Boolean.TYPE.getName(), Boolean.TYPE); m.put(Short.TYPE.getName(), Short.TYPE); m.put(Integer.TYPE.getName(), Integer.TYPE); m.put(Long.TYPE.getName(), Long.TYPE); m.put(Float.TYPE.getName(), Float.TYPE); m.put(Double.TYPE.getName(), Double.TYPE); m.put(Byte.TYPE.getName(), Byte.TYPE); m.put(Character.TYPE.getName(), Character.TYPE); m.put("long[]", long[].class); m.put("char[]", char[].class); return m; }
/** * Checks if one <code>Class</code> can be assigned to a variable of another <code>Class</code>. * * <p>Unlike the {@link Class#isAssignableFrom(java.lang.Class)} method, this method takes into * account widenings of primitive classes and <code>null</code>s. * * <p>Primitive widenings allow an int to be assigned to a long, float or double. This method * returns the correct result for these cases. * * <p><code>Null</code> may be assigned to any reference type. This method will return <code>true * </code> if <code>null</code> is passed in and the toClass is non-primitive. * * <p>Specifically, this method tests whether the type represented by the specified <code>Class * </code> parameter can be converted to the type represented by this <code>Class</code> object * via an identity conversion widening primitive or widening reference conversion. See <em><a * href="http://java.sun.com/docs/books/jls/">The Java Language Specification</a></em>, sections * 5.1.1, 5.1.2 and 5.1.4 for details. * * @param cls the Class to check, may be null * @param toClass the Class to try to assign into, returns false if null * @param autoboxing whether to use implicit autoboxing/unboxing between primitives and wrappers * @return <code>true</code> if assignment possible */ public static boolean isAssignable(Class<?> cls, Class<?> toClass, boolean autoboxing) { if (toClass == null) { return false; } // have to check for null, as isAssignableFrom doesn't if (cls == null) { return !(toClass.isPrimitive()); } // autoboxing: if (autoboxing) { if (cls.isPrimitive() && !toClass.isPrimitive()) { cls = primitiveToWrapper(cls); if (cls == null) { return false; } } if (toClass.isPrimitive() && !cls.isPrimitive()) { cls = wrapperToPrimitive(cls); if (cls == null) { return false; } } } if (cls.equals(toClass)) { return true; } if (cls.isPrimitive()) { if (toClass.isPrimitive() == false) { return false; } if (Integer.TYPE.equals(cls)) { return Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass); } if (Long.TYPE.equals(cls)) { return Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass); } if (Boolean.TYPE.equals(cls)) { return false; } if (Double.TYPE.equals(cls)) { return false; } if (Float.TYPE.equals(cls)) { return Double.TYPE.equals(toClass); } if (Character.TYPE.equals(cls)) { return Integer.TYPE.equals(toClass) || Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass); } if (Short.TYPE.equals(cls)) { return Integer.TYPE.equals(toClass) || Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass); } if (Byte.TYPE.equals(cls)) { return Short.TYPE.equals(toClass) || Integer.TYPE.equals(toClass) || Long.TYPE.equals(toClass) || Float.TYPE.equals(toClass) || Double.TYPE.equals(toClass); } // should never get here return false; } return toClass.isAssignableFrom(cls); }
/** @generated */ protected Object getValidNewValue(EAttribute feature, Object value) { EClassifier type = feature.getEType(); if (type instanceof EDataType) { Class iClass = type.getInstanceClass(); if (Boolean.TYPE.equals(iClass)) { if (value instanceof Boolean) { // ok } else if (value instanceof String) { value = Boolean.valueOf((String) value); } else { value = new InvalidValue( NLS.bind(Messages.AbstractParser_UnexpectedValueType, iClass.getName())); } } else if (Character.TYPE.equals(iClass)) { if (value instanceof Character) { // ok } else if (value instanceof String) { String s = (String) value; if (s.length() == 0) { value = null; } else { value = new Character(s.charAt(0)); } } else { value = new InvalidValue( NLS.bind(Messages.AbstractParser_UnexpectedValueType, iClass.getName())); } } else if (Byte.TYPE.equals(iClass)) { if (value instanceof Byte) { // ok } else if (value instanceof Number) { value = new Byte(((Number) value).byteValue()); } else if (value instanceof String) { String s = (String) value; if (s.length() == 0) { value = null; } else { try { value = Byte.valueOf(s); } catch (NumberFormatException nfe) { value = new InvalidValue( NLS.bind(Messages.AbstractParser_WrongStringConversion, iClass.getName())); } } } else { value = new InvalidValue( NLS.bind(Messages.AbstractParser_UnexpectedValueType, iClass.getName())); } } else if (Short.TYPE.equals(iClass)) { if (value instanceof Short) { // ok } else if (value instanceof Number) { value = new Short(((Number) value).shortValue()); } else if (value instanceof String) { String s = (String) value; if (s.length() == 0) { value = null; } else { try { value = Short.valueOf(s); } catch (NumberFormatException nfe) { value = new InvalidValue( NLS.bind(Messages.AbstractParser_WrongStringConversion, iClass.getName())); } } } else { value = new InvalidValue( NLS.bind(Messages.AbstractParser_UnexpectedValueType, iClass.getName())); } } else if (Integer.TYPE.equals(iClass)) { if (value instanceof Integer) { // ok } else if (value instanceof Number) { value = new Integer(((Number) value).intValue()); } else if (value instanceof String) { String s = (String) value; if (s.length() == 0) { value = null; } else { try { value = Integer.valueOf(s); } catch (NumberFormatException nfe) { value = new InvalidValue( NLS.bind(Messages.AbstractParser_WrongStringConversion, iClass.getName())); } } } else { value = new InvalidValue( NLS.bind(Messages.AbstractParser_UnexpectedValueType, iClass.getName())); } } else if (Long.TYPE.equals(iClass)) { if (value instanceof Long) { // ok } else if (value instanceof Number) { value = new Long(((Number) value).longValue()); } else if (value instanceof String) { String s = (String) value; if (s.length() == 0) { value = null; } else { try { value = Long.valueOf(s); } catch (NumberFormatException nfe) { value = new InvalidValue( NLS.bind(Messages.AbstractParser_WrongStringConversion, iClass.getName())); } } } else { value = new InvalidValue( NLS.bind(Messages.AbstractParser_UnexpectedValueType, iClass.getName())); } } else if (Float.TYPE.equals(iClass)) { if (value instanceof Float) { // ok } else if (value instanceof Number) { value = new Float(((Number) value).floatValue()); } else if (value instanceof String) { String s = (String) value; if (s.length() == 0) { value = null; } else { try { value = Float.valueOf(s); } catch (NumberFormatException nfe) { value = new InvalidValue( NLS.bind(Messages.AbstractParser_WrongStringConversion, iClass.getName())); } } } else { value = new InvalidValue( NLS.bind(Messages.AbstractParser_UnexpectedValueType, iClass.getName())); } } else if (Double.TYPE.equals(iClass)) { if (value instanceof Double) { // ok } else if (value instanceof Number) { value = new Double(((Number) value).doubleValue()); } else if (value instanceof String) { String s = (String) value; if (s.length() == 0) { value = null; } else { try { value = Double.valueOf(s); } catch (NumberFormatException nfe) { value = new InvalidValue( NLS.bind(Messages.AbstractParser_WrongStringConversion, iClass.getName())); } } } else { value = new InvalidValue( NLS.bind(Messages.AbstractParser_UnexpectedValueType, iClass.getName())); } } else if (type instanceof EEnum) { if (value instanceof String) { EEnumLiteral literal = ((EEnum) type).getEEnumLiteralByLiteral((String) value); if (literal == null) { value = new InvalidValue(NLS.bind(Messages.AbstractParser_UnknownLiteral, value)); } else { value = literal.getInstance(); } } else { value = new InvalidValue( NLS.bind(Messages.AbstractParser_UnexpectedValueType, String.class.getName())); } } } return value; }
static { try { valueParsers.put( Boolean.class.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getBoolean", String.class)); valueParsers.put( Boolean.TYPE.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getBoolean", String.class)); valueParsers.put( Byte.class.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getByte", String.class)); valueParsers.put( Byte.TYPE.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getByte", String.class)); valueParsers.put( Character.class.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getChar", String.class)); valueParsers.put( Character.TYPE.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getChar", String.class)); valueParsers.put( Short.class.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getShort", String.class)); valueParsers.put( Short.TYPE.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getShort", String.class)); valueParsers.put( Integer.class.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getInt", String.class)); valueParsers.put( Integer.TYPE.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getInt", String.class)); valueParsers.put( Long.class.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getLong", String.class)); valueParsers.put( Long.TYPE.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getLong", String.class)); valueParsers.put( Float.class.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getFloat", String.class)); valueParsers.put( Float.TYPE.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getFloat", String.class)); valueParsers.put( Double.class.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getDouble", String.class)); valueParsers.put( Double.TYPE.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getDouble", String.class)); valueParsers.put( Locale.class.getCanonicalName(), SimpleAnnotationBasedHandler.class.getDeclaredMethod("getLocale", String.class)); } catch (Exception e) { log.error("Error setting up value parsers", e); throw new RuntimeException("Error setting up value parsers", e); } }
public Coercer<Short> accept(final Class<?> clazz) { if (Short.class.isAssignableFrom(clazz) || Short.TYPE.isAssignableFrom(clazz)) { return DefaultCoercibles.SHORT_COERCER; } return null; }
private boolean compare_PrimitiveArray( int operation, Class type, Object primarray, Object value2) { if (Integer.TYPE.isAssignableFrom(type)) { int[] array = (int[]) primarray; for (int i = 0, size = array.length; i < size; i++) { if (compare_Integer(operation, array[i], value2)) { return true; } } return false; } if (Long.TYPE.isAssignableFrom(type)) { long[] array = (long[]) primarray; for (int i = 0, size = array.length; i < size; i++) { if (compare_Long(operation, array[i], value2)) { return true; } } return false; } if (Byte.TYPE.isAssignableFrom(type)) { byte[] array = (byte[]) primarray; for (int i = 0, size = array.length; i < size; i++) { if (compare_Byte(operation, array[i], value2)) { return true; } } return false; } if (Short.TYPE.isAssignableFrom(type)) { short[] array = (short[]) primarray; for (int i = 0, size = array.length; i < size; i++) { if (compare_Short(operation, array[i], value2)) { return true; } } return false; } if (Character.TYPE.isAssignableFrom(type)) { char[] array = (char[]) primarray; for (int i = 0, size = array.length; i < size; i++) { if (compare_Character(operation, array[i], value2)) { return true; } } return false; } if (Float.TYPE.isAssignableFrom(type)) { float[] array = (float[]) primarray; for (int i = 0, size = array.length; i < size; i++) { if (compare_Float(operation, array[i], value2)) { return true; } } return false; } if (Double.TYPE.isAssignableFrom(type)) { double[] array = (double[]) primarray; for (int i = 0, size = array.length; i < size; i++) { if (compare_Double(operation, array[i], value2)) { return true; } } return false; } if (Boolean.TYPE.isAssignableFrom(type)) { boolean[] array = (boolean[]) primarray; for (int i = 0, size = array.length; i < size; i++) { if (compare_Boolean(operation, array[i], value2)) { return true; } } return false; } return false; }
/** * {@inheritDoc} * * @see org.teiid.designer.core.properties.PropertyDefinition#isValidValue(java.lang.String) */ @Override public String isValidValue(String newValue) { // if empty must have a value or a default value if required if (StringUtilities.isEmpty(newValue)) { // invalid if required and no default value if (isRequired() && StringUtilities.isEmpty(getDefaultValue())) { return Util.getString("invalidNullPropertyValue", getDisplayName()); // $NON-NLS-1$ } // OK to be null/empty return null; } if (Boolean.class.getName().equals(this.className) || Boolean.TYPE.getName().equals(this.className)) { if (!newValue.equalsIgnoreCase(Boolean.TRUE.toString()) && !newValue.equalsIgnoreCase(Boolean.FALSE.toString())) { return Util.getString( "invalidPropertyValueForType", newValue, Boolean.TYPE.getName()); // $NON-NLS-1$ } } else if (Character.class.getName().equals(this.className) || Character.TYPE.getName().equals(this.className)) { if (newValue.length() != 1) { return Util.getString( "invalidPropertyValueForType", newValue, Character.TYPE.getName()); // $NON-NLS-1$ } } else if (Byte.class.getName().equals(this.className) || Byte.TYPE.getName().equals(this.className)) { try { Byte.parseByte(newValue); } catch (Exception e) { return Util.getString( "invalidPropertyValueForType", newValue, Byte.TYPE.getName()); // $NON-NLS-1$ } } else if (Short.class.getName().equals(this.className) || Short.TYPE.getName().equals(this.className)) { try { Short.parseShort(newValue); } catch (Exception e) { return Util.getString( "invalidPropertyValueForType", newValue, Short.TYPE.getName()); // $NON-NLS-1$ } } else if (Integer.class.getName().equals(this.className) || Integer.TYPE.getName().equals(this.className)) { try { Integer.parseInt(newValue); } catch (Exception e) { return Util.getString( "invalidPropertyValueForType", newValue, Integer.TYPE.getName()); // $NON-NLS-1$ } } else if (Long.class.getName().equals(this.className) || Long.TYPE.getName().equals(this.className)) { try { Long.parseLong(newValue); } catch (Exception e) { return Util.getString( "invalidPropertyValueForType", newValue, Long.TYPE.getName()); // $NON-NLS-1$ } } else if (Float.class.getName().equals(this.className) || Float.TYPE.getName().equals(this.className)) { try { Float.parseFloat(newValue); } catch (Exception e) { return Util.getString( "invalidPropertyValueForType", newValue, Float.TYPE.getName()); // $NON-NLS-1$ } } else if (Double.class.getName().equals(this.className) || Double.TYPE.getName().equals(this.className)) { try { Double.parseDouble(newValue); } catch (Exception e) { return Util.getString( "invalidPropertyValueForType", newValue, Double.TYPE.getName()); // $NON-NLS-1$ } } else if (!String.class.getName().equals(this.className)) { return Util.getString( "unknownPropertyType", this.displayName, this.className); // $NON-NLS-1$ } // valid value return null; }