public static boolean isTypeOf(Object val, Class...ts) { return isTypeOf(val.getClass(), ts); }
public static <T> T stringToValue(String str, Class<T> clazz, T defaultValue) { try { return stringToValue(str, clazz); } catch (Exception e) { return defaultValue; } }
public static boolean isPrimitiveTypeForKeyValue(Class type) { if (TypeUtils.isPrimitiveOrWrapper(type)) { return true; } if (TypeUtils.isTypeOf(type, Date.class, Timestamp.class)) { return true; } return false; } }
public Object toValue() { if (TypeUtils.isPrimitiveOrWrapper(type)) { return TypeUtils.stringToValue(value, type); } if (Date.class.isAssignableFrom(type)) { return new Date(value); } if (Timestamp.class.isAssignableFrom(type)) { return new Timestamp(new Date(value).getTime()); } throw new CloudRuntimeException(String.format("unknown type[%s]", type.getName())); }
if (TypeUtils.isPrimitiveOrWrapper(f.getType())) { return; if (TypeUtils.isPrimitiveOrWrapper(gtype)) { return;
public void updateValue(Object val) { if (TypeUtils.nullSafeEquals(value, val)) { return; } String newValue = val == null ? null : val.toString(); update(newValue, true); }
public Object toInventoryFieldObject(String fieldName, Object value) { FieldTypeMapping mapping = typeMappingMap.get(fieldName); if (mapping == null || TypeUtils.isZstackBeanPrimitive(mapping.voFieldType)) { return value; } if (Enum.class.isAssignableFrom(mapping.voFieldType)) { return value.toString(); } throw new CloudRuntimeException(String.format("For the field[%s], fail to convert a vo to a inventory", fieldName)); }
private void checkBoxTypeInInventory() { if (!CoreGlobalProperty.CHECK_BOX_TYPE_IN_INVENTORY) { return; } Set<Class<?>> inventoryClasses = BeanUtils.reflections.getTypesAnnotatedWith(Inventory.class); List<String> errors = new ArrayList<>(); for (Class clz : inventoryClasses) { boolean error = false; StringBuilder sb = new StringBuilder(String.format("inventory class[%s] contains below primitive fields:", clz.getName())); for (Field f : FieldUtils.getAllFields(clz)) { if (f.isAnnotationPresent(APINoSee.class)) { continue; } if (TypeUtils.isPrimitiveType(f.getType())) { error = true; sb.append(String.format("\n%s[%s]", f.getName(), f.getType().getName())); } } if (error) { errors.add(sb.toString()); } } if (!errors.isEmpty()) { throw new CloudRuntimeException(String.format("detected some inventory class using primitive type." + " Please change those primitive type field to corresponding box type:\n %s", StringUtils.join(errors, "\n\n"))); } }
@Override public ErrorCode validateErrorByErrorCode(Object obj) { if (obj instanceof ConditionalValidation) { ConditionalValidation cond = (ConditionalValidation) obj; if (!cond.needValidation()) { return null; } } List<Class> classes = TypeUtils.getAllClassOfObject(obj); for (Class clz : classes) { List<Validator> vs = validators.get(clz); if (vs != null) { for (Validator v : vs) { String err = v.validate(obj); if (err != null) { return inerr(err); } } } } return null; }
private String validate(Object obj, Field f) { try { f.setAccessible(true); Object value = f.get(obj); Validation at = f.getAnnotation(Validation.class); if (at.notNull() && value == null) { return error(obj, f, "field can not be null"); } if (at.notZero() && TypeUtils.isTypeOf(value, Integer.TYPE, Integer.class, Long.TYPE, Long.class)) { if (value != null) { long intValue = Long.valueOf(value.toString()); if (intValue == 0) { return error(obj, f, "field can not be zero"); } } } return null; } catch (Exception e) { throw new CloudRuntimeException(e); } }
public <T> T defaultValue(Class<T> clz) { return TypeUtils.stringToValue(defaultValue, clz); }
public static boolean isZstackBeanPrimitive(Class clazz) { return isPrimitiveOrWrapper(clazz) || isTypeOf(clazz, Timestamp.class); }
if (value != null && param.numberRange().length > 0 && TypeUtils.isTypeOf(value, Integer.TYPE, Integer.class, Long.TYPE, Long.class)) { DebugUtils.Assert(param.numberRange().length == 2, String.format("invalid field[%s], Param.numberRange must have and only have 2 items.", f.getName())); long low = param.numberRange()[0];
public <T> T value(Class<T> clz) { return TypeUtils.stringToValue(value(), clz); }
if (TypeUtils.isTypeOf(clazz, APISearchMessage.class, APIGetMessage.class, APIListMessage.class)) { continue;
private Object doNormalizeValue(String value) { try { Class entityType = getEntityFieldType(); if (Timestamp.class.isAssignableFrom(entityType)) { return Timestamp.valueOf(value); } else if (Enum.class.isAssignableFrom(entityType)) { Method valueOf = entityType.getMethod("valueOf", String.class); return valueOf.invoke(entityType, value); } else if (Boolean.class.isAssignableFrom(entityType) || Boolean.TYPE.isAssignableFrom(entityType)) { return Boolean.valueOf(value); } else { return TypeUtils.stringToValue(value, entityType); } } catch (Exception e) { throw new CloudRuntimeException(String.format("failed to parse value[%s], error: [%s]", value, e.getMessage()), e); } }
continue; if (TypeUtils.isTypeOf(clazz, APISearchMessage.class, APIListMessage.class, APIGetMessage.class)) { continue;
Object queryParameterToApiFieldValue(String name, String[] vals) throws RestException { Field f = allApiClassFields.get(name); if (f == null) { return null; } if (Collection.class.isAssignableFrom(f.getType())) { Class gtype = FieldUtils.getGenericType(f); List lst = new ArrayList(); for (String v : vals) { lst.add(TypeUtils.stringToValue(v, gtype)); } return lst; } else { if (vals.length > 1) { throw new RestException(HttpStatus.BAD_REQUEST.value(), String.format("Invalid query parameter[%s], only one value is allowed for the parameter but" + " multiple values found", name)); } return TypeUtils.stringToValue(vals[0], f.getType()); } } }
if (TypeUtils.isTypeOf(clazz, APISearchMessage.class, APIGetMessage.class, APIListMessage.class)) { continue;