/** * Check parameter field type * @param type Field type * @return <code>true</code> if type is admitted as view parameter value */ private static boolean isAdmittedParameterFieldType(Class<?> type) { return TypeUtils.isString(type) || TypeUtils.isNumber(type) || TypeUtils.isBoolean(type) || TypeUtils.isDate(type) || TypeUtils.isLocalTemporal(type) || TypeUtils.isEnum(type); }
if (value != null) { if (TypeUtils.isString(definition.getType()) && !TypeUtils.isString(value.getClass())) { return value.toString(); if (!TypeUtils.isString(definition.getType()) && TypeUtils.isString(value.getClass())) { return ConversionUtils.convertStringValue((String) value, definition.getType()); if (TypeUtils.isNumber(definition.getType()) && TypeUtils.isNumber(value.getClass())) { return ConversionUtils.convertNumberToTargetClass((Number) value, (Class<Number>) definition.getType()); if (TypeUtils.isEnum(definition.getType()) && !TypeUtils.isEnum(value.getClass())) { return ConversionUtils.convertEnumValue((Class<Enum>) definition.getType(), value); if (!TypeUtils.isAssignable(value.getClass(), definition.getType())) { throw new ViewConfigurationException("Value type " + value.getClass().getName() + " doesn't match view parameter type " + definition.getType().getName());
if (TypeUtils.isString(targetType)) { return value; if (TypeUtils.isBoolean(targetType)) { return Boolean.parseBoolean(value); if (TypeUtils.isEnum(targetType)) { if (TypeUtils.isIntegerNumber(targetType)) { Number parsed = FormDataFormats.INTEGER_FORMAT.parse(value); return ConversionUtils.convertNumberToTargetClass(parsed, (Class<Number>) targetType); if (TypeUtils.isDecimalNumber(targetType)) { Number parsed = FormDataFormats.DECIMAL_FORMAT.parse(value); return ConversionUtils.convertNumberToTargetClass(parsed, (Class<Number>) targetType); if (TypeUtils.isDate(targetType)) { return parseDateValue(property, value); if (TypeUtils.isCalendar(targetType)) { Date d = parseDateValue(property, value); Calendar calendar = Calendar.getInstance();
private static boolean isIntrospectable(Class<?> propertyClass) { return propertyClass != Object.class && !propertyClass.isArray() && !propertyClass.isPrimitive() && !propertyClass.isEnum() && !TypeUtils.isString(propertyClass) && !TypeUtils.isNumber(propertyClass) && !TypeUtils.isTemporalOrCalendar(propertyClass) && !TypeUtils.isBoolean(propertyClass) && !Collection.class.isAssignableFrom(propertyClass); }
if (TypeUtils.isCharSequence(value.getClass())) { return value.toString(); if (TypeUtils.isBoolean(value.getClass())) { return Boolean.toString((Boolean) value); if (TypeUtils.isNumber(value.getClass())) { if (TypeUtils.isDecimalNumber(value.getClass())) { return FormDataFormats.DECIMAL_FORMAT.format(value); if (TypeUtils.isEnum(value.getClass())) { return String.valueOf(((Enum<?>) value).ordinal());
if (TypeUtils.isBoolean(valueType)) { if (TypeUtils.isCharSequence(valueType)) { if (TypeUtils.isEnum(valueType)) { if (TypeUtils.isTemporal(valueType)) { if (TypeUtils.isDate(valueType) || TypeUtils.isCalendar(valueType)) { return convertDate(TypeUtils.isCalendar(valueType) ? ((Calendar) value).getTime() : (Date) value, parameters.getParameter(TEMPORAL_TYPE, TemporalType.DATE)); if (TypeUtils.isNumber(valueType)) { features.toArray(new NumberFormatFeature[0])); if (TypeUtils.isAssignable(value.getClass(), Localizable.class)) {
if (TypeUtils.isString(type)) { return (T) value; if (TypeUtils.isCharacter(type)) { if (value.length() > 1) { throw new IllegalArgumentException( if (TypeUtils.isBoolean(type)) { String bv = value.toLowerCase(); if (BOOLEAN_TRUE_VALUES.contains(bv)) { if (TypeUtils.isEnum(type)) { Class<?> enumType = type; while (enumType != null && !enumType.isEnum()) { if (TypeUtils.isNumber(type)) { return (T) parseNumber(value, (Class<? extends Number>) type);
@SuppressWarnings("unchecked") @Override public <T> Optional<T> getParameter(String name, Class<T> type) { ObjectUtils.argumentNotNull(name, "Parameter name must be not null"); ObjectUtils.argumentNotNull(type, "Parameter type must be not null"); Object value = getParameterValue(name); if (value != null && !TypeUtils.isAssignable(value.getClass(), type)) { throw new TypeMismatchException("Value type " + value.getClass().getName() + " is not compatible with required type " + type.getName()); } return Optional.ofNullable((T) value); }
if (TypeUtils.isEnum(value.getClass())) { try { return (T) value; throw new IllegalArgumentException(e); } else if (TypeUtils.isNumber(value.getClass())) { Integer ordinal = convertNumberToTargetClass((Number) value, int.class); Enum[] enmValues = enm.getEnumConstants(); } else if (TypeUtils.isString(value.getClass())) { return (T) Enum.valueOf(enm, (String) value); } else {
final Class<? extends T> type = path.getType(); try { if (TypeUtils.isEnum(type)) { return (T) ConversionUtils.convertEnumValue((Class<Enum>) type, value); if (TypeUtils.isNumber(type) && TypeUtils.isNumber(value.getClass())) { return (T) ConversionUtils.convertNumberToTargetClass((Number) value, (Class<Number>) type); if (TypeUtils.isDate(value.getClass()) && path.getTemporalType().orElse(TemporalType.DATE_TIME) == TemporalType.DATE) {
/** * Get the decimal separator character, if available * @return the decimal separator character, or empty if the number type is not a decimal number */ @Override public Optional<Character> getDecimalSymbol() { if (!TypeUtils.isDecimalNumber(getNumberType())) { return Optional.empty(); } return getDecimalFormatSymbols().map(dfs -> dfs.getDecimalSeparator()); }
if (v != null) { if (!v.getClass().isArray() && !TypeUtils.isNumber(v.getClass()) && !CharSequence.class.isAssignableFrom(v.getClass()) && !Collection.class.isAssignableFrom(v.getClass()) if (TypeUtils.isNumber(v.getClass())) { if (TypeUtils.isDecimalNumber(v.getClass())) { if (((Number) v).doubleValue() > max) { throw new ValidationException(message, messageCode, max);
@SuppressWarnings("unchecked") @Override public <T> T getProperty(String key, Class<T> targetType) throws IllegalArgumentException { ObjectUtils.argumentNotNull(key, "Property name must be not null"); ObjectUtils.argumentNotNull(targetType, "Property type must be not null"); Object value = properties.get(key); if (value != null) { if (TypeUtils.isAssignable(value.getClass(), targetType)) { return (T) value; } else if (TypeUtils.isString(value.getClass())) { return ConversionUtils.convertStringValue(value.toString(), targetType); } else { throw new IllegalArgumentException( "Property " + key + " type is not consistent " + "with required type: " + targetType.getName() + " (got type: " + value.getClass().getName() + ")"); } } return null; }
@Override public Optional<ValidatorDescriptor> getDescriptor() { if (TypeUtils.isNumber(compareTo.getClass())) { return Optional.of(ValidatorDescriptor.builder().min(((Number) compareTo)).build()); } return Optional.empty(); } };
if (value == null && valueType != null && TypeUtils.isBoolean(valueType)) { valueToPresent = Boolean.FALSE; } else { if (valueType != null && !TypeUtils.isAssignable(valueToPresent.getClass(), valueType)) { throw new TypeMismatchException("Value type " + valueToPresent.getClass().getName() + " doesn't match given type " + valueType.getName()); } else if (TypeUtils.isAssignable(type, Collection.class)) {
/** * Generate a property id for given property. * @param property Property (not null) * @return Property id */ protected String generatePropertyId(PROPERTY property) { String id = (TypeUtils.isString(property.getClass())) ? (String) property : "property"; // check duplicates Integer count = generatedPropertyIds.get(id); if (count != null && count > 0) { int sequence = count.intValue() + 1; generatedPropertyIds.put(id, sequence); return id + sequence; } else { generatedPropertyIds.put(id, 1); return id; } }
if (TypeUtils.isDate(value.getClass()) || TypeUtils.isCalendar(value.getClass())) { final Date date = TypeUtils.isCalendar(value.getClass()) ? ((Calendar) value).getTime() : (Date) value; temporalType = (property != null) ? property.getConfiguration().getTemporalType().orElse(TemporalType.DATE_TIME)
throws ViewConfigurationException { if (value != null && !value.trim().equals("")) { if (TypeUtils.isDate(requiredType)) { try { return new SimpleDateFormat(ViewParameter.DEFAULT_DATE_PATTERN).parse(value); if (TypeUtils.isLocalTemporal(requiredType)) { TemporalType type = TemporalType.DATE; if (LocalTime.class.isAssignableFrom(requiredType)) {
/** * Set a new resolution for the slider. The resolution is the number of digits after the decimal point. * @param resolution The resolution to set. Ignored for integer value types */ public void setResolution(int resolution) { if (!TypeUtils.isIntegerNumber(getType())) { getInternalField().setResolution(resolution); } }
Property<?> property, String name) { if (TypeUtils.isDate(property.getType()) && schema instanceof AbstractProperty) { property.getTemporalType().ifPresent(tt -> { switch (tt) {