List of usage examples for java.lang Byte TYPE
Class TYPE
To view the source code for java.lang Byte TYPE.
Click Source Link
From source file:com.sun.faces.config.ManagedBeanFactory.java
private Class getValueClassConsideringPrimitives(String valueClass) throws ClassNotFoundException { Class valueType = java.lang.String.class; if (null != valueClass && 0 < valueClass.length()) { if (valueClass.equals(Boolean.TYPE.getName())) { valueType = Boolean.TYPE; } else if (valueClass.equals(Byte.TYPE.getName())) { valueType = Byte.TYPE; } else if (valueClass.equals(Double.TYPE.getName())) { valueType = Double.TYPE; } else if (valueClass.equals(Float.TYPE.getName())) { valueType = Float.TYPE; } else if (valueClass.equals(Integer.TYPE.getName())) { valueType = Integer.TYPE; } else if (valueClass.equals(Character.TYPE.getName())) { valueType = Character.TYPE; } else if (valueClass.equals(Short.TYPE.getName())) { valueType = Short.TYPE; } else if (valueClass.equals(Long.TYPE.getName())) { valueType = Long.TYPE; } else {// w w w . j av a 2 s. co m valueType = Util.loadClass(valueClass, this); } } return valueType; }
From source file:objenome.util.ClassUtils.java
/** * <p>Checks if one {@code Class} can be assigned to a variable of * another {@code Class}.</p>// w ww .ja va 2s . c o m * * <p>Unlike the {@link Class#isAssignableFrom(Class)} method, * this method takes into account widenings of primitive classes and * {@code null}s.</p> * * <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> * * <p>{@code Null} may be assigned to any reference type. This method * will return {@code true} if {@code null} is passed in and the * toClass is non-primitive.</p> * * <p>Specifically, this method tests whether the type represented by the * specified {@code Class} parameter can be converted to the type * represented by this {@code Class} object via an identity conversion * widening primitive or widening reference conversion. See * <em><a href="http://docs.oracle.com/javase/specs/">The Java Language Specification</a></em>, * sections 5.1.1, 5.1.2 and 5.1.4 for details.</p> * * @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} 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()) { 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); }
From source file:javadz.beanutils.ConvertUtilsBean.java
/** * Register array converters.// ww w . ja v a 2s .c o m * * @param throwException <code>true</code> if the converters should * throw an exception when a conversion error occurs, otherwise <code> * <code>false</code> if a default value should be used. * @param defaultArraySize The size of the default array value for array converters * (N.B. This values is ignored if <code>throwException</code> is <code>true</code>). * Specifying a value less than zero causes a <code>null<code> value to be used for * the default. */ private void registerArrays(boolean throwException, int defaultArraySize) { // Primitives registerArrayConverter(Boolean.TYPE, new BooleanConverter(), throwException, defaultArraySize); registerArrayConverter(Byte.TYPE, new ByteConverter(), throwException, defaultArraySize); registerArrayConverter(Character.TYPE, new CharacterConverter(), throwException, defaultArraySize); registerArrayConverter(Double.TYPE, new DoubleConverter(), throwException, defaultArraySize); registerArrayConverter(Float.TYPE, new FloatConverter(), throwException, defaultArraySize); registerArrayConverter(Integer.TYPE, new IntegerConverter(), throwException, defaultArraySize); registerArrayConverter(Long.TYPE, new LongConverter(), throwException, defaultArraySize); registerArrayConverter(Short.TYPE, new ShortConverter(), throwException, defaultArraySize); // Standard registerArrayConverter(BigDecimal.class, new BigDecimalConverter(), throwException, defaultArraySize); registerArrayConverter(BigInteger.class, new BigIntegerConverter(), throwException, defaultArraySize); registerArrayConverter(Boolean.class, new BooleanConverter(), throwException, defaultArraySize); registerArrayConverter(Byte.class, new ByteConverter(), throwException, defaultArraySize); registerArrayConverter(Character.class, new CharacterConverter(), throwException, defaultArraySize); registerArrayConverter(Double.class, new DoubleConverter(), throwException, defaultArraySize); registerArrayConverter(Float.class, new FloatConverter(), throwException, defaultArraySize); registerArrayConverter(Integer.class, new IntegerConverter(), throwException, defaultArraySize); registerArrayConverter(Long.class, new LongConverter(), throwException, defaultArraySize); registerArrayConverter(Short.class, new ShortConverter(), throwException, defaultArraySize); registerArrayConverter(String.class, new StringConverter(), throwException, defaultArraySize); // Other registerArrayConverter(Class.class, new ClassConverter(), throwException, defaultArraySize); registerArrayConverter(java.util.Date.class, new DateConverter(), throwException, defaultArraySize); registerArrayConverter(Calendar.class, new DateConverter(), throwException, defaultArraySize); registerArrayConverter(File.class, new FileConverter(), throwException, defaultArraySize); registerArrayConverter(java.sql.Date.class, new SqlDateConverter(), throwException, defaultArraySize); registerArrayConverter(java.sql.Time.class, new SqlTimeConverter(), throwException, defaultArraySize); registerArrayConverter(Timestamp.class, new SqlTimestampConverter(), throwException, defaultArraySize); registerArrayConverter(URL.class, new URLConverter(), throwException, defaultArraySize); }
From source file:com.sun.faces.config.ManagedBeanFactory.java
private Object getConvertedValueConsideringPrimitives(Object value, Class valueType) throws FacesException { if (null != value && null != valueType) { if (valueType == Boolean.TYPE || valueType == java.lang.Boolean.class) { value = Boolean.valueOf(value.toString().toLowerCase()); } else if (valueType == Byte.TYPE || valueType == java.lang.Byte.class) { value = new Byte(value.toString()); } else if (valueType == Double.TYPE || valueType == java.lang.Double.class) { value = new Double(value.toString()); } else if (valueType == Float.TYPE || valueType == java.lang.Float.class) { value = new Float(value.toString()); } else if (valueType == Integer.TYPE || valueType == java.lang.Integer.class) { value = new Integer(value.toString()); } else if (valueType == Character.TYPE || valueType == java.lang.Character.class) { value = new Character(value.toString().charAt(0)); } else if (valueType == Short.TYPE || valueType == java.lang.Short.class) { value = new Short(value.toString()); } else if (valueType == Long.TYPE || valueType == java.lang.Long.class) { value = new Long(value.toString()); } else if (valueType == String.class) { } else if (!valueType.isAssignableFrom(value.getClass())) { throw new FacesException( Util.getExceptionMessageString(Util.MANAGED_BEAN_TYPE_CONVERSION_ERROR_ID, new Object[] { value.toString(), value.getClass(), valueType, managedBean.getManagedBeanName() })); }/*from w ww . jav a 2s. co m*/ } return value; }
From source file:ResultSetIterator.java
/** * Convert a <code>ResultSet</code> column into an object. Simple * implementations could just call <code>rs.getObject(index)</code> while * more complex implementations could perform type manipulation to match * the column's type to the bean property type. * /*from ww w.j a v a 2s.co m*/ * <p> * This implementation calls the appropriate <code>ResultSet</code> getter * method for the given property type to perform the type conversion. If * the property type doesn't match one of the supported * <code>ResultSet</code> types, <code>getObject</code> is called. * </p> * * @param rs The <code>ResultSet</code> currently being processed. It is * positioned on a valid row before being passed into this method. * * @param index The current column index being processed. * * @param propType The bean property type that this column needs to be * converted into. * * @throws SQLException if a database access error occurs * * @return The object from the <code>ResultSet</code> at the given column * index after optional type processing or <code>null</code> if the column * value was SQL NULL. */ protected Object processColumn(ResultSet rs, int index, Class propType) throws SQLException { if (!propType.isPrimitive() && rs.getObject(index) == null) { return null; } if (propType.equals(String.class)) { return rs.getString(index); } else if (propType.equals(Integer.TYPE) || propType.equals(Integer.class)) { return new Integer(rs.getInt(index)); } else if (propType.equals(Boolean.TYPE) || propType.equals(Boolean.class)) { return new Boolean(rs.getBoolean(index)); } else if (propType.equals(Long.TYPE) || propType.equals(Long.class)) { return new Long(rs.getLong(index)); } else if (propType.equals(Double.TYPE) || propType.equals(Double.class)) { return new Double(rs.getDouble(index)); } else if (propType.equals(Float.TYPE) || propType.equals(Float.class)) { return new Float(rs.getFloat(index)); } else if (propType.equals(Short.TYPE) || propType.equals(Short.class)) { return new Short(rs.getShort(index)); } else if (propType.equals(Byte.TYPE) || propType.equals(Byte.class)) { return new Byte(rs.getByte(index)); } else if (propType.equals(Timestamp.class)) { return rs.getTimestamp(index); } else { return rs.getObject(index); } }
From source file:alice.tuprolog.lib.OOLibrary.java
/** * get the value of the field//from w w w .j a va2 s .c o m */ private boolean java_get(PTerm objId, PTerm fieldTerm, PTerm what) { if (!fieldTerm.isAtom()) { return false; } String fieldName = ((Struct) fieldTerm).getName(); Object obj = null; try { Class<?> cl = null; if (objId.isCompound() && ((Struct) objId).getName().equals("class")) { String clName = null; if (((Struct) objId).getArity() == 1) clName = alice.util.Tools.removeApices(((Struct) objId).getArg(0).toString()); if (clName != null) { try { cl = Class.forName(clName, true, dynamicLoader); } catch (ClassNotFoundException ex) { getEngine().logger.warn("Java class not found: " + clName); return false; } catch (Exception ex) { getEngine().logger.warn("Static field " + fieldName + " not found in class " + alice.util.Tools.removeApices(((Struct) objId).getArg(0).toString())); return false; } } } else { String objName = alice.util.Tools.removeApices(objId.toString()); obj = currentObjects.get(objName); if (obj == null) { return false; } cl = obj.getClass(); } Field field = cl.getField(fieldName); Class<?> fc = field.getType(); field.setAccessible(true); if (fc.equals(Integer.TYPE) || fc.equals(Byte.TYPE)) { int value = field.getInt(obj); return unify(what, new alice.tuprolog.Int(value)); } else if (fc.equals(java.lang.Long.TYPE)) { long value = field.getLong(obj); return unify(what, new alice.tuprolog.Long(value)); } else if (fc.equals(java.lang.Float.TYPE)) { float value = field.getFloat(obj); return unify(what, new alice.tuprolog.Float(value)); } else if (fc.equals(java.lang.Double.TYPE)) { double value = field.getDouble(obj); return unify(what, new alice.tuprolog.Double(value)); } else { // the field value is an object Object res = field.get(obj); return bindDynamicObject(what, res); } } catch (NoSuchFieldException ex) { getEngine().logger.warn("Field " + fieldName + " not found in class " + objId); return false; } catch (Exception ex) { getEngine().logger.warn("Generic error in accessing the field"); return false; } }
From source file:javadz.beanutils.LazyDynaBean.java
/** * Is an object of the source class assignable to the destination class? * * @param dest Destination class//from w w w . j a v a 2 s . com * @param source Source class * @return <code>true<code> if the source class is assignable to the * destination class, otherwise <code>false</code> */ protected boolean isAssignable(Class dest, Class source) { if (dest.isAssignableFrom(source) || ((dest == Boolean.TYPE) && (source == Boolean.class)) || ((dest == Byte.TYPE) && (source == Byte.class)) || ((dest == Character.TYPE) && (source == Character.class)) || ((dest == Double.TYPE) && (source == Double.class)) || ((dest == Float.TYPE) && (source == Float.class)) || ((dest == Integer.TYPE) && (source == Integer.class)) || ((dest == Long.TYPE) && (source == Long.class)) || ((dest == Short.TYPE) && (source == Short.class))) { return (true); } else { return (false); } }
From source file:org.romaframework.core.schema.SchemaHelper.java
/** * Resolve class object for java types./*from w ww.j av a 2s . c om*/ * * @param iEntityName * Java type name * @return Class object if found, otherwise null */ public static Class<?> getClassForJavaTypes(String iEntityName) { if (iEntityName.equals("String")) return String.class; else if (iEntityName.equals("Integer")) return Integer.class; else if (iEntityName.equals("int")) return Integer.TYPE; else if (iEntityName.equals("Long")) return Long.class; else if (iEntityName.equals("long")) return Long.TYPE; else if (iEntityName.equals("Short")) return Short.class; else if (iEntityName.equals("short")) return Short.TYPE; else if (iEntityName.equals("Boolean")) return Boolean.class; else if (iEntityName.equals("boolean")) return Boolean.TYPE; else if (iEntityName.equals("BigDecimal")) return BigDecimal.class; else if (iEntityName.equals("Float")) return Float.class; else if (iEntityName.equals("float")) return Float.TYPE; else if (iEntityName.equals("Double")) return Double.class; else if (iEntityName.equals("Number")) return Number.class; else if (iEntityName.equals("double")) return Double.TYPE; else if (iEntityName.equals("Character")) return Character.class; else if (iEntityName.equals("char")) return Character.TYPE; else if (iEntityName.equals("Byte")) return Byte.class; else if (iEntityName.equals("byte")) return Byte.TYPE; else if (iEntityName.equals("Object")) return Object.class; else if (iEntityName.equals("Collection")) return Collection.class; else if (iEntityName.equals("List")) return List.class; else if (iEntityName.equals("Set")) return Set.class; else if (iEntityName.equals("Map")) return Map.class; else if (iEntityName.equals("Date")) return Date.class; else if (iEntityName.equals("Map$Entry")) return Map.Entry.class; else if (iEntityName.equals("HashMap$Entry")) return Map.Entry.class; else if (iEntityName.equals("LinkedHashMap$Entry")) return Map.Entry.class; return null; }
From source file:com.sun.faces.el.impl.Coercions.java
/** * Returns true if the given class is of an integer type */// ww w.jav a 2 s . c o m public static boolean isIntegerType(Class pClass) { return pClass == Byte.class || pClass == Byte.TYPE || pClass == Short.class || pClass == Short.TYPE || pClass == Character.class || pClass == Character.TYPE || pClass == Integer.class || pClass == Integer.TYPE || pClass == Long.class || pClass == Long.TYPE; }
From source file:org.apache.sling.models.impl.ModelAdapterFactory.java
private static boolean isAcceptableType(Class<?> type, Type genericType, Object value) { if (type.isInstance(value)) { if ((type == Collection.class || type == List.class) && genericType instanceof ParameterizedType && value instanceof Collection) { Iterator<?> it = ((Collection<?>) value).iterator(); if (!it.hasNext()) { // empty collection, so it doesn't really matter return true; } else { // this is not an ideal way to get the actual component type, but erasure... Class<?> actualComponentType = it.next().getClass(); Class<?> desiredComponentType = (Class<?>) ((ParameterizedType) genericType) .getActualTypeArguments()[0]; return desiredComponentType.isAssignableFrom(actualComponentType); }/*from w ww . j av a2 s . c o m*/ } else { return true; } } if (type == Integer.TYPE) { return Integer.class.isInstance(value); } if (type == Long.TYPE) { return Long.class.isInstance(value); } if (type == Boolean.TYPE) { return Boolean.class.isInstance(value); } if (type == Double.TYPE) { return Double.class.isInstance(value); } if (type == Float.TYPE) { return Float.class.isInstance(value); } if (type == Short.TYPE) { return Short.class.isInstance(value); } if (type == Byte.TYPE) { return Byte.class.isInstance(value); } if (type == Character.TYPE) { return Character.class.isInstance(value); } return false; }