List of usage examples for java.beans PropertyEditor setAsText
void setAsText(String text) throws java.lang.IllegalArgumentException;
From source file:org.springframework.beans.TypeConverterDelegate.java
/** * Convert the given text value using the given property editor. * @param oldValue the previous value, if available (may be {@code null}) * @param newTextValue the proposed text value * @param editor the PropertyEditor to use * @return the converted value/*from w ww .ja v a 2 s. c om*/ */ private Object doConvertTextValue(@Nullable Object oldValue, String newTextValue, PropertyEditor editor) { try { editor.setValue(oldValue); } catch (Exception ex) { if (logger.isDebugEnabled()) { logger.debug("PropertyEditor [" + editor.getClass().getName() + "] does not support setValue call", ex); } // Swallow and proceed. } editor.setAsText(newTextValue); return editor.getValue(); }
From source file:net.sf.juffrou.reflect.JuffrouTypeConverterDelegate.java
/** * Convert the given text value using the given property editor. * //from ww w .ja va2s.com * @param oldValue * the previous value, if available (may be <code>null</code>) * @param newTextValue * the proposed text value * @param editor * the PropertyEditor to use * @return the converted value */ private Object doConvertTextValue(Object oldValue, String newTextValue, PropertyEditor editor) { try { editor.setValue(oldValue); } catch (Exception ex) { if (logger.isDebugEnabled()) { logger.debug("PropertyEditor [" + editor.getClass().getName() + "] does not support setValue call", ex); } // Swallow and proceed. } editor.setAsText(newTextValue); return editor.getValue(); }
From source file:org.apache.jmeter.testbeans.gui.GenericTestBeanCustomizer.java
void clearGuiFields() { for (int i = 0; i < editors.length; i++) { PropertyEditor propertyEditor = editors[i]; // might be null (e.g. in testing) if (propertyEditor != null) { try { if (propertyEditor instanceof ClearGui) { ((ClearGui) propertyEditor).clearGui(); } else if (propertyEditor instanceof WrapperEditor) { WrapperEditor we = (WrapperEditor) propertyEditor; String[] tags = we.getTags(); if (tags != null && tags.length > 0) { we.setAsText(tags[0]); } else { we.resetValue(); }// w ww . j av a 2s .c om } else { propertyEditor.setAsText(""); } } catch (IllegalArgumentException ex) { log.error("Failed to set field " + descriptors[i].getName(), ex); } } } }
From source file:com.interface21.beans.BeanWrapperImpl.java
/** * Convert the value to the required type (if necessary from a String). * Conversions from String to any type use the setAsText() method of * the PropertyEditor class. Note that a PropertyEditor must be registered * for this class for this to work. This is a standard Java Beans API. * A number of property editors are automatically registered by this class. * @param target target bean//from w w w . j a v a 2s . c o m * @param propertyName name of the property * @param oldValue previous value, if available. May be null. * @param newValue proposed change value. * @param requiredType type we must convert to * @throws BeansException if there is an internal error * @return new value, possibly the result of type convertion. */ public Object doTypeConversionIfNecessary(Object target, String propertyName, Object oldValue, Object newValue, Class requiredType) throws BeansException { // Only need to cast if value isn't null if (newValue != null) { // We may need to change the value of newValue // custom editor for this type? PropertyEditor pe = findCustomEditor(requiredType, propertyName); if ((pe != null || !requiredType.isAssignableFrom(newValue.getClass())) && (newValue instanceof String)) { if (logger.isDebugEnabled()) logger.debug("Convert: String to " + requiredType); if (pe == null) { // no custom editor -> check BeanWrapper's default editors pe = (PropertyEditor) defaultEditors.get(requiredType); if (pe == null) { // no BeanWrapper default editor -> check standard editors pe = PropertyEditorManager.findEditor(requiredType); } } if (logger.isDebugEnabled()) logger.debug("Using property editor [" + pe + "]"); if (pe != null) { try { pe.setAsText((String) newValue); newValue = pe.getValue(); } catch (IllegalArgumentException ex) { throw new TypeMismatchException( new PropertyChangeEvent(target, propertyName, oldValue, newValue), requiredType, ex); } } } } return newValue; }
From source file:com.p5solutions.core.json.JsonDeserializer.java
/** * Sets the value. May also use the {@link ConversionService} to convert * types, such as {@link Date} using the {@link DateTimeFormat}. @see * //from w ww . j a v a 2s. c o m * @param method * the method * @param fieldName * the field name * @param target * the target * @param value * the value * @param binder * the binder {@link ConversionService} and implementation of custom * converters by implementing {@link GenericConverter} * @throws Exception */ protected void setValue(Method method, String fieldName, Object target, Object value, WebRequest webRequest, WebDataBinder binder) { // Expose the real method, if proxied, since annotations need to be found. Method realMethod = method; if (target instanceof Targetable) { Targetable proxy = (Targetable) target; Class<?> clazz = proxy.getTarget().getClass(); realMethod = ReflectionUtility.findMethod(clazz, realMethod.getName()); } // TODO expose TrackStateUtility as part of Core?? // Method realMethod = TrackStateUtility.exposeRealMethod(method, target); if (realMethod == null && method == null) { // if there are any binding, or formatting issues, put an error // in the model state. Object tempState = webRequest.getAttribute(ModelState.MODEL_STATE, WebRequest.SCOPE_REQUEST); if (tempState == null) { tempState = new ModelState(); } ModelState modelState = (ModelState) tempState; modelState.add(fieldName, "Cannot bind value " + value + " to target object " + (target != null ? target.getClass() : "<null>"), new RuntimeException( "Field " + fieldName + " does not exist for " + target.getClass().getName())); webRequest.setAttribute(ModelState.MODEL_STATE, modelState, WebRequest.SCOPE_REQUEST); } // get the nullable property annotation, if any JsonNotNullProperty jnullpt = ReflectionUtility.findAnnotation(realMethod, JsonNotNullProperty.class); // get the json property, if any JsonProperty jpt = ReflectionUtility.findAnnotation(realMethod, JsonProperty.class); Class<?> returnType = method.getReturnType(); if (ReflectionUtility.isNumberClass(returnType)) { try { Object numeric = NumberUtils.valueOf(value.toString(), returnType); ReflectionUtility.setValue(fieldName, target, numeric); } catch (NumberFormatException nfe) { // if there are any binding, or formatting issues, put an error // in the model state. Object tempState = webRequest.getAttribute(ModelState.MODEL_STATE, WebRequest.SCOPE_REQUEST); if (tempState == null) { tempState = new ModelState(); } ModelState modelState = (ModelState) tempState; modelState.add(fieldName, "Cannot bind value " + value + " to target object " + (target != null ? target.getClass() : "<null>"), nfe); webRequest.setAttribute(ModelState.MODEL_STATE, modelState, WebRequest.SCOPE_REQUEST); } } else if (ReflectionUtility.isStringClass(returnType)) { // set empty values to null String sv = (String) value; sv = Comparison.isEmpty(sv) ? null : sv; // if the Nullable property is et with emptyNull to false // then actually set the value, even if its empty. if (jnullpt != null) { sv = (String) value; } // unescape the sting character. sv = unescape(sv); sv = unnull(sv); ReflectionUtility.setValue(fieldName, target, sv); } else if (!attemptListMapping(fieldName, target, value, returnType, jpt, webRequest, binder)) { // / attempt to map of Map<?,?> if (!attemptMapMapping(fieldName, target, value, returnType, jpt, webRequest, binder)) { // attempt to simple map the object if (!attemptSimpleMapping(fieldName, target, value, returnType, webRequest, binder)) { // Use the Spring Conversion service and try to map the // values TypeDescriptor sourceType = TypeDescriptor.forObject(value); // specify the method, -1 such that it uses the return value // type MethodParameter mp = new MethodParameter(realMethod, -1); // setup the type descriptor and pass it to the converter TypeDescriptor targetType = new TypeDescriptor(mp); // PropertyValue pv = new PropertyValue(fieldName, value); Object converted = null; PropertyEditor editor = null; if (binder != null) { editor = binder.findCustomEditor(returnType, null); } if (editor != null) { editor.setAsText(value.toString()); converted = editor.getValue(); } else if (conversionService != null) { // use the conversion service to translate the value converted = this.conversionService.convert(value, sourceType, targetType); } // set the converted value, if any ReflectionUtility.setValue(fieldName, target, converted); } } } }
From source file:org.nextframework.controller.ExtendedBeanWrapper.java
/** * Convert the value to the required type (if necessary from a String), * for the specified property./* w ww .java 2 s .c o m*/ * @param propertyName name of the property * @param oldValue previous value, if available (may be <code>null</code>) * @param newValue proposed change value * @param requiredType the type we must convert to * (or <code>null</code> if not known, for example in case of a collection element) * @return the new value, possibly the result of type conversion * @throws TypeMismatchException if type conversion failed */ protected Object doTypeConversionIfNecessary(String propertyName, String fullPropertyName, Object oldValue, Object newValue, Class requiredType) throws TypeMismatchException { Object convertedValue = newValue; if (convertedValue != null) { // Custom editor for this type? PropertyEditor pe = findCustomEditor(requiredType, fullPropertyName); // Value not of required type? if (pe != null || (requiredType != null && (requiredType.isArray() || !requiredType.isAssignableFrom(convertedValue.getClass())))) { if (requiredType != null) { if (pe == null) { // No custom editor -> check BeanWrapperImpl's default editors. pe = (PropertyEditor) this.defaultEditors.get(requiredType); if (pe == null) { // No BeanWrapper default editor -> check standard JavaBean editors. pe = PropertyEditorManager.findEditor(requiredType); } } } if (pe != null && !(convertedValue instanceof String)) { // Not a String -> use PropertyEditor's setValue. // With standard PropertyEditors, this will return the very same object; // we just want to allow special PropertyEditors to override setValue // for type conversion from non-String values to the required type. try { pe.setValue(convertedValue); Object newConvertedValue = pe.getValue(); if (newConvertedValue != convertedValue) { convertedValue = newConvertedValue; // Reset PropertyEditor: It already did a proper conversion. // Don't use it again for a setAsText call. pe = null; } } catch (IllegalArgumentException ex) { throw new TypeMismatchException( createPropertyChangeEvent(fullPropertyName, oldValue, newValue), requiredType, ex); } } if (requiredType != null && !requiredType.isArray() && convertedValue instanceof String[]) { // Convert String array to a comma-separated String. // Only applies if no PropertyEditor converted the String array before. // The CSV String will be passed into a PropertyEditor's setAsText method, if any. if (logger.isDebugEnabled()) { logger.debug("Converting String array to comma-delimited String [" + convertedValue + "]"); } convertedValue = StringUtils.arrayToCommaDelimitedString((String[]) convertedValue); } if (pe != null && convertedValue instanceof String) { // Use PropertyEditor's setAsText in case of a String value. if (logger.isDebugEnabled()) { logger.debug( "Converting String to [" + requiredType + "] using property editor [" + pe + "]"); } try { pe.setValue(oldValue); pe.setAsText((String) convertedValue); convertedValue = pe.getValue(); } catch (IllegalArgumentException ex) { throw new TypeMismatchException( createPropertyChangeEvent(fullPropertyName, oldValue, newValue), requiredType, ex); } } if (requiredType != null) { // Array required -> apply appropriate conversion of elements. if (requiredType.isArray()) { Class componentType = requiredType.getComponentType(); if (convertedValue instanceof Collection) { // Convert Collection elements to array elements. Collection coll = (Collection) convertedValue; Object result = Array.newInstance(componentType, coll.size()); int i = 0; for (Iterator it = coll.iterator(); it.hasNext(); i++) { Object value = doTypeConversionIfNecessary(propertyName, propertyName + PROPERTY_KEY_PREFIX + i + PROPERTY_KEY_SUFFIX, null, it.next(), componentType); Array.set(result, i, value); } return result; } else if (convertedValue != null && convertedValue.getClass().isArray()) { // Convert Collection elements to array elements. int arrayLength = Array.getLength(convertedValue); Object result = Array.newInstance(componentType, arrayLength); for (int i = 0; i < arrayLength; i++) { Object value = doTypeConversionIfNecessary(propertyName, propertyName + PROPERTY_KEY_PREFIX + i + PROPERTY_KEY_SUFFIX, null, Array.get(convertedValue, i), componentType); Array.set(result, i, value); } return result; } else { // A plain value: convert it to an array with a single component. Object result = Array.newInstance(componentType, 1); Object value = doTypeConversionIfNecessary(propertyName, propertyName + PROPERTY_KEY_PREFIX + 0 + PROPERTY_KEY_SUFFIX, null, convertedValue, componentType); Array.set(result, 0, value); return result; } } // If the resulting value definitely doesn't match the required type, // try field lookup as fallback. If no matching field found, // throw explicit TypeMismatchException with full context information. if (convertedValue != null && !requiredType.isPrimitive() && !requiredType.isAssignableFrom(convertedValue.getClass())) { // In case of String value, try to find matching field (for JDK 1.5 // enum or custom enum with values defined as static fields). if (convertedValue instanceof String) { try { Field enumField = requiredType.getField((String) convertedValue); return enumField.get(null); } catch (Exception ex) { logger.debug("Field [" + convertedValue + "] isn't an enum value", ex); } } // Definitely doesn't match: throw TypeMismatchException. throw new TypeMismatchException( createPropertyChangeEvent(fullPropertyName, oldValue, newValue), requiredType); } } } } if (requiredType != null && List.class.isAssignableFrom(requiredType)) { //treat conventions of enum lists Type genericReturnType = getPropertyDescriptorInternal(fullPropertyName).getReadMethod() .getGenericReturnType(); if (genericReturnType instanceof ParameterizedType) { Type actualType = ((ParameterizedType) genericReturnType).getActualTypeArguments()[0]; if (actualType instanceof Class && convertedValue != null) { List list = (List) convertedValue; for (int i = 0; i < list.size(); i++) { Object o = list.remove(i); o = doTypeConversionIfNecessary(o, (Class) actualType); list.add(i, o); } } } } return convertedValue; }