private static void workOnSingletoBean( MBeanServerConnection server, String jndiName, int numThreads, int numTimes) throws Exception { int singletonBeanInstances = (Integer) server.invoke( new ObjectName("jboss:name=ejb3-test,type=service"), "lookupSingleton", new Object[] {jndiName, numThreads, numTimes}, new String[] { String.class.getName(), Integer.TYPE.getName(), Integer.TYPE.getName() }); System.out.println("Number of singleton bean instances created is: " + singletonBeanInstances); int count = (Integer) server.invoke( new ObjectName("jboss:name=ejb3-test,type=service"), "invokeSingleton", new Object[] {jndiName, numThreads, numTimes}, new String[] { String.class.getName(), Integer.TYPE.getName(), Integer.TYPE.getName() }); System.out.println("Count is: " + count); }
/** * 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); }
/** 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); } }
/** Test retrieving log events */ public void testLogging() throws Exception { LoggingBean bean = new LoggingBean(); ((ServerModelImpl) sm).setLogFormat("%m"); ServerContext serverContext = new ServerContextImpl(bean, sm, new OurHierarchicalRegistry()); OddjobMBean ojmb = new OddjobMBean( bean, OddjobMBeanFactory.objectName(0), new OurServerSession(), serverContext); Logger testLogger = Logger.getLogger(bean.loggerName()); testLogger.setLevel(Level.DEBUG); testLogger.info("Test"); LogEvent[] events = (LogEvent[]) ojmb.invoke( SharedConstants.RETRIEVE_LOG_EVENTS_METHOD, new Object[] {new Long(-1), new Integer(10)}, new String[] {Long.TYPE.getName(), Integer.TYPE.getName()}); assertEquals("num events", 1, events.length); assertEquals("event 0", "Test", events[0].getMessage()); }
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; } }
@SuppressWarnings({"unchecked", "nls"}) public void testGetTypeLabel() throws SecurityException, NoSuchMethodException { Class c = TestClass.class; assertEquals( "java.util.List<java.util.List<java.lang.String>>", ClassParser.getTypeLabel(getGenericReturnType(c, "getNestGenericList"))); assertEquals( "java.util.List<java.util.List<java.util.List>>", ClassParser.getTypeLabel(getGenericReturnType(c, "getNestGenericAndCommonList"))); assertEquals( String.class.getName(), ClassParser.getTypeLabel(getGenericReturnType(c, "getCommonObject"))); assertEquals( Integer.TYPE.getName(), ClassParser.getTypeLabel(getGenericReturnType(c, "getPrimitive"))); assertEquals( ClassParser.class.getName() + "[]", ClassParser.getTypeLabel(getGenericReturnType(c, "getObjects"))); assertEquals("int[]", ClassParser.getTypeLabel(getGenericReturnType(c, "getPrimitives"))); assertEquals( "java.util.List<java.lang.String>[]", ClassParser.getTypeLabel(getGenericReturnType(c, "getArrayListNest"))); assertEquals( "java.util.List<java.lang.String[]>", ClassParser.getTypeLabel(getGenericReturnType(c, "getListArrayNest"))); }
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; } }
/** * 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; }
/** * Tries to convert a string value to a data type given as a parameter. There are few cases, that * can occure. * * <ol> * <li>Given value is null or an empty string. In such case the null is also returned. * <li>Defined class is a java primitive like int, double etc. For these instances the object * representation is returned. It means that for int it returns Integer, for double Double * etc. * <li>Value is well-known object primitive, like Integer, Date etc. In these cases the string * is parsed into given object and returned. * <li>Defined class is complex. In such cases the original string value is returned because * there is not known converter. * </ol> * * <p>Note: When the given class is inherited from some java primitive then the returned object is * that primitive type. For example this can occure for {@link java.sql.Date} which inherits from * {@link java.util.Date} * * @param <T> desired type to be converted to * @param value string representation of converted value * @param type target class of the value * @return converted value if the conversion is defined * @throws ParseException this occures when the date is in bad format. The format can be redefined * in {@link #dateFormat}. * @throws NumberFormatException conversion of string to number has failed. It occures when the * input string is not a number but the target class is. */ public static <T> Object tryToConvertTo(final String value, final Class<T> type) throws ParseException, NumberFormatException { if (value == null || "".equals(value)) { return null; } if (java.util.Date.class.isAssignableFrom(type)) { return (java.util.Date) (new java.text.SimpleDateFormat(dateFormat, java.util.Locale.getDefault()).parse(value)); } else if (String.class.isAssignableFrom(type)) { return type.cast(value); } else if (Integer.class.isAssignableFrom(type) || Integer.TYPE.equals(type)) { return Integer.valueOf(value); } else if (Double.class.isAssignableFrom(type) || Double.TYPE.equals(type)) { return Double.valueOf(value); } else if (Long.class.isAssignableFrom(type) || Long.TYPE.equals(type)) { return Long.valueOf(value); } else if (Boolean.class.isAssignableFrom(type) || Boolean.TYPE.equals(type)) { return (BooleanHelper.isTrue(value) ? Boolean.TRUE : (Boolean.valueOf(value))); } else if (Byte.class.isAssignableFrom(type) || Byte.TYPE.equals(type)) { return Byte.valueOf(value); } else if (type.isEnum()) { for (T enumValue : type.getEnumConstants()) { if (enumValue.toString().equals(value)) { return enumValue; } } return null; } else { return value; } }
private boolean isPrimaryType(Class type) { return Boolean.TYPE.equals(type) || Double.TYPE.equals(type) || Integer.TYPE.equals(type) || Long.TYPE.equals(type) || String.class.equals(type) || JSONObject.class.equals(type) || JSONArray.class.equals(type); }
/** 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); }
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()); }
/** * 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 (Integer.TYPE.equals(abstractObjectDescription.getObjectClass())) { return true; } if (Integer.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; }
private <T> T getJsonValue(JSONObject json, String fieldName, Class<T> type) throws JSONException { if (Boolean.TYPE.equals(type)) { return type.cast(json.getBoolean(fieldName)); } else if (Double.TYPE.equals(type)) { return type.cast(json.getDouble(fieldName)); } else if (Integer.TYPE.equals(type)) { return type.cast(json.getInt(fieldName)); } else if (Long.TYPE.equals(type)) { return type.cast(json.getLong(fieldName)); } else if (String.class.equals(type)) { return type.cast(json.getString(fieldName)); } else if (JSONObject.class.equals(type)) { return (T) json.getJSONObject(fieldName); } else if (JSONArray.class.equals(type)) { return (T) json.getJSONArray(fieldName); } throw new JSONException("Primary type: " + type.getName() + " is not supported"); }
private Object rowCountResult(int rowCount) { final Object result; if (method.returnsVoid()) { result = null; } else if (Integer.class.equals(method.getReturnType()) || Integer.TYPE.equals(method.getReturnType())) { result = Integer.valueOf(rowCount); } else if (Long.class.equals(method.getReturnType()) || Long.TYPE.equals(method.getReturnType())) { result = Long.valueOf(rowCount); } else if (Boolean.class.equals(method.getReturnType()) || Boolean.TYPE.equals(method.getReturnType())) { result = Boolean.valueOf(rowCount > 0); } else { throw new BindingException( "Mapper method '" + command.getName() + "' has an unsupported return type: " + method.getReturnType()); } return result; }
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)); } }
/** @see https://github.com/wordnik/swagger-core/wiki/datatypes */ protected static SwaggerDataType convertToSwaggerType(SwaggerModel models, Class<?> type) { if (Void.TYPE.equals(type)) { return new SwaggerDataType("void"); } else if (Integer.TYPE.equals(type) || Integer.class.isAssignableFrom(type)) { return new SwaggerDataType("integer", "int32"); } else if (Long.TYPE.equals(type) || Long.class.isAssignableFrom(type)) { return new SwaggerDataType("integer", "int64"); } else if (Float.TYPE.equals(type) || Float.class.isAssignableFrom(type)) { return new SwaggerDataType("number", "float"); } else if (Double.TYPE.equals(type) || Double.class.isAssignableFrom(type)) { return new SwaggerDataType("number", "double"); } else if (Byte.TYPE.equals(type) || Byte.class.isAssignableFrom(type)) { return new SwaggerDataType("string", "byte"); } else if (Boolean.TYPE.equals(type) || Boolean.class.isAssignableFrom(type)) { return new SwaggerDataType("boolean"); } else if (Number.class.isAssignableFrom(type)) { return new SwaggerDataType("number"); } else if (String.class.equals(type)) { return new SwaggerDataType("string"); } else if (Date.class.equals(type)) { return new SwaggerDataType("string", "date-time"); } else if (type.isEnum()) { return new SwaggerDataType("string"); } else if (type.isArray() || Collection.class.isAssignableFrom(type)) { return new SwaggerDataType("array"); } else { // it's a custom type, we need to create a model for it (if it does not already exist) String typeName = type.getName(); if (!models.containsKey(typeName)) { // Reserve a spot for this type, avoids circular references to cause a StackOverflow, see // AMDATUWEB-10... models.put(typeName, null); // Overwrite the item with the actual model definition... models.put(typeName, convertToSwaggerModel(models, type)); } return new SwaggerDataType(type.getName()); } }
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 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; }
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; }
/** * 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); } }