private void setFieldIfNotNull(Field field, Object instance, Object val) { try { if (val != null) { Object convertedValue = typeConverter.convertIfNecessary(val, configField.getType()); field.set(instance, convertedValue); } } catch (IllegalAccessException e) { throw bomb("Error setting configField: " + field.getName(), e); } }
@Override public Object convert(Object source, TypeDescriptor sourceType, TypeDescriptor targetType) { SimpleTypeConverter typeConverter = this.typeConverter; return typeConverter.convertIfNecessary(source, targetType.getType()); }
private void setValue(Object val) { try { ConfigAttributeValue configAttributeValue = field.getType().getAnnotation(ConfigAttributeValue.class); if (configAttributeValue != null) { if (val != null || configAttributeValue.createForNull()) { Constructor<?> constructor = field.getType().getConstructor(String.class); field.set(instance, constructor.newInstance(new Object[]{val})); } } else if (val != null) { Object convertedValue = typeConverter.convertIfNecessary(val, field.getType()); field.set(instance, convertedValue); } } catch (IllegalAccessException e) { throw bomb("Error setting configField: " + field.getName(), e); } catch (TypeMismatchException e) { final String message = format("Could not set value [{0}] on Field [{1}] of type [{2}] ", val, field.getName(), field.getType()); throw bomb(message, e); } catch (NoSuchMethodException e) { throw bomb("Error setting configField: " + field.getName() + " as " + field.getType(), e); } catch (InstantiationException | InvocationTargetException e) { throw bomb("Error creating configAttribute: " + field.getName() + " as " + field.getType(), e); } }
@Override public Object convertValue(Object value, TypeDescriptor sourceType, TypeDescriptor targetType) { if (targetType.getType() == Void.class || targetType.getType() == Void.TYPE) { return null; } if (conversionService.canConvert(sourceType, targetType)) { return conversionService.convert(value, sourceType, targetType); } if (!String.class.isAssignableFrom(sourceType.getType())) { PropertyEditor editor = delegate.findCustomEditor(sourceType.getType(), null); editor.setValue(value); return editor.getAsText(); } return delegate.convertIfNecessary(value, targetType.getType()); }
public <T> T convertIfNecessary(Object value, Class<T> requiredType) throws TypeMismatchException { return convertIfNecessary(value, requiredType, null); }
public boolean isSatisfied(PipelineStates pipelineStates) { assertNotNull(expression, "no expression"); ExpressionContext expressionContext = new PipelineExpressionContext(pipelineStates); Object value = expression.evaluate(expressionContext); if (value == null) { return false; } else if (value instanceof Boolean) { return (Boolean) value; } else { try { return (Boolean) new SimpleTypeConverter().convertIfNecessary(value, Boolean.class); } catch (TypeMismatchException e) { throw new PipelineException( "Failed to evaluating expression for JexlCondition into a boolean value: \"" + getEscapedExpression(expressionString) + "\"", e); } } }
public boolean isSatisfied(PipelineStates pipelineStates) { assertNotNull(expression, "no expression"); ExpressionContext expressionContext = new PipelineExpressionContext(pipelineStates); Object value = expression.evaluate(expressionContext); if (value == null) { return false; } else if (value instanceof Boolean) { return (Boolean) value; } else { try { return (Boolean) new SimpleTypeConverter().convertIfNecessary(value, Boolean.class); } catch (TypeMismatchException e) { throw new PipelineException( "Failed to evaluating expression for JexlCondition into a boolean value: \"" + getEscapedExpression(expressionString) + "\"", e); } } }
return typeConverter.convertIfNecessary(toConvert, metaData.getParamType()); SimpleTypeConverter typeConverter = SafedTypeConverterFactory .getCurrentConverter(); return typeConverter.convertIfNecessary("0", metaData.getParamType());
public static Object typeConverter(Object value, Class type) { return converter.convertIfNecessary(value, type); }
return this.delegate.convertIfNecessary(value, targetType.getType());
public static Object typeConverter(Object value, String className) { try { Class clazz = Class.forName(className); return converter.convertIfNecessary(value, clazz); } catch (ClassNotFoundException e) { LOGGER.errorMessage("get Class error with className:" + className, e); throw new RuntimeException(e); } }
public static void setFieldValue(Field field, Object bean, Object value) throws IllegalAccessException { // Set it on the field field.setAccessible(true); // Perform type conversion if possible.. SimpleTypeConverter converter = new SimpleTypeConverter(); try { value = converter.convertIfNecessary(value, field.getType()); } catch (ConversionNotSupportedException e) { // If conversion isn't supported, ignore and try and set anyway. } field.set(bean, value); }
public void doWith(Field field) throws IllegalArgumentException, IllegalAccessException { Property annotation = field.getAnnotation(Property.class); if (annotation != null) { if (Modifier.isStatic(field.getModifiers())) { throw new IllegalStateException( "PropertyAutowired annotation is not supported on static fields"); } Object strValue = valueResolver.resolveStringValue("${" + annotation.value() + "}"); if (strValue != null) { Object value = typeConverter.convertIfNecessary(strValue, field.getType()); ReflectionUtils.makeAccessible(field); field.set(bean, value); } } }
public boolean setProperty(String name, Object value) { if (name == null) { throw new IllegalArgumentException("name cannot be null for setting configuration"); } boolean changed = false; if (value == null) { changed = this.configuration.remove(name) != null; log.info("Cleared the configuration setting for name ("+name+")"); } else { SimpleTypeConverter converter = new SimpleTypeConverter(); String sVal = (String)converter.convertIfNecessary(value, String.class); changed = loadConfig(name, sVal); } return changed; }
private boolean retrieveBoolean(Object param, String key) { boolean value = false; if (isMapWithValue(param, key)) { value = new SimpleTypeConverter().convertIfNecessary(((Map)param).get(key), Boolean.class); } return value; }
private Object convertBooleanValue(final ComparisonNode node, final String value, final Class<? extends Object> javaType) { try { return simpleTypeConverter.convertIfNecessary(value, javaType); } catch (final TypeMismatchException e) { throw new RSQLParameterSyntaxException( "The value of the given search parameter field {" + node.getSelector() + "} is not well formed. Only a boolean (true or false) value will be expected {", e); } }
private Object convertBooleanValue(final ComparisonNode node, final String value, final Class<? extends Object> javaType) { try { return simpleTypeConverter.convertIfNecessary(value, javaType); } catch (final TypeMismatchException e) { throw new RSQLParameterSyntaxException( "The value of the given search parameter field {" + node.getSelector() + "} is not well formed. Only a boolean (true or false) value will be expected {", e); } }
private int retrieveInt(Object param, String key) { if (isMapWithValue(param, key)) { return new SimpleTypeConverter().convertIfNecessary(((Map) param).get(key),Integer.class); } if (isIntegerOrLong(param)) { return ((Number)param).intValue(); } return -1; }
private boolean useCache(Object[] args) { boolean useCache = getHibernateTemplate().isCacheQueries(); if (args.length > 1 && args[args.length - 1] instanceof Map) { Object param = args[args.length - 1]; String key = GrailsHibernateUtil.ARGUMENT_CACHE; boolean value = false; if ((param instanceof Map) && ((Map)param).containsKey(key)) { SimpleTypeConverter converter = new SimpleTypeConverter(); value = converter.convertIfNecessary(((Map)param).get(key), Boolean.class); } useCache = value; } return useCache; } });
/** * Returns the actual typed id. Looks up an available customly registered {@link PropertyEditor} from the * {@link PropertyEditorRegistry} before falling back on a {@link SimpleTypeConverter} to translate the {@link String} * id into the type one. * * @param idAsString * @return */ @SuppressWarnings("unchecked") private ID getId(String idAsString) { Class<ID> idClass = information.getIdType(); PropertyEditor idEditor = registry.findCustomEditor(idClass, null); if (idEditor != null) { idEditor.setAsText(idAsString); return (ID) idEditor.getValue(); } return new SimpleTypeConverter().convertIfNecessary(idAsString, idClass); }