@Override
public <FIELDVALUE> BeanBinding<BEAN, FIELDVALUE, FIELDVALUE> forField(
HasValue<FIELDVALUE> field) {
- return createBinding(field, Converter.identity(),
- this::handleValidationStatus);
+ BeanBindingImpl<BEAN, FIELDVALUE, FIELDVALUE> binding = createBinding(
+ field, Converter.identity(), this::handleValidationStatus);
+ return binding.withConverter(fieldValue -> fieldValue,
+ modelValue -> modelValue != null ? modelValue
+ : field.getEmptyValue());
}
@Override
exception -> errorMessage));
}
+ /**
+ * Maps binding value {@code null} to given null representation and back
+ * to {@code null} when converting back to model value.
+ *
+ * @param nullRepresentation
+ * the value to use instead of {@code null}
+ * @return a new binding with null representation handling.
+ */
+ public default Binding<BEAN, FIELDVALUE, TARGET> withNullRepresentation(
+ TARGET nullRepresentation) {
+ return withConverter(
+ fieldValue -> Objects.equals(fieldValue, nullRepresentation)
+ ? null : fieldValue,
+ modelValue -> Objects.equals(modelValue, null)
+ ? nullRepresentation : modelValue);
+ }
+
/**
* Gets the field the binding uses.
*
return validationStatus;
}
- private void setBeanValue(BEAN bean, TARGET value) {
- setter.accept(bean, value);
- }
-
private void notifyStatusHandler(ValidationStatus<?> status) {
statusHandler.accept(status);
}
* {@link Binding#bind(Function, BiConsumer) Binding.bind} which completes
* the binding. Until {@code Binding.bind} is called, the binding has no
* effect.
+ * <p>
+ * <strong>Note:</strong> Not all {@link HasValue} implementations support
+ * passing {@code null} as the value. For these the Binder will
+ * automatically change {@code null} to a null representation provided by
+ * {@link HasValue#getEmptyValue()}. This conversion is one-way only, if you
+ * want to have a two-way mapping back to {@code null}, use
+ * {@link Binding#withNullRepresentation(Object))}.
*
* @param <FIELDVALUE>
* the value type of the field
clearError(field);
getStatusLabel().ifPresent(label -> label.setValue(""));
- return createBinding(field, Converter.identity(),
- this::handleValidationStatus);
+ BindingImpl<BEAN, FIELDVALUE, FIELDVALUE> createBinding = createBinding(
+ field, Converter.identity(), this::handleValidationStatus);
+
+ return createBinding.withConverter(fieldValue -> fieldValue,
+ modelValue -> modelValue != null ? modelValue
+ : field.getEmptyValue());
}
/**
* Use the {@link #forField(HasValue)} overload instead if you want to
* further configure the new binding.
* <p>
+ * <strong>Note:</strong> Not all {@link HasValue} implementations support
+ * passing {@code null} as the value. For these the Binder will
+ * automatically change {@code null} to a null representation provided by
+ * {@link HasValue#getEmptyValue()}. This conversion is one-way only, if you
+ * want to have a two-way mapping back to {@code null}, use
+ * {@link #forField(HasValue)} and
+ * {@link Binding#withNullRepresentation(Object))}.
+ * <p>
* When a bean is bound with {@link Binder#bind(BEAN)}, the field value is
* set to the return value of the given getter. The property value is then
* updated via the given setter whenever the field value changes. The setter
* <pre>
* class Feature {
* public enum Browser { CHROME, EDGE, FIREFOX, IE, OPERA, SAFARI }
-
+
* public Set<Browser> getSupportedBrowsers() { ... }
* public void setSupportedBrowsers(Set<Browser> title) { ... }
* }
// Save old bean values so we can restore them if validators fail
Map<Binding<BEAN, ?, ?>, Object> oldValues = new HashMap<>();
- bindings.forEach(binding -> oldValues.put(binding,
- binding.convertDataToFieldType(bean)));
+ bindings.forEach(
+ binding -> oldValues.put(binding, binding.getter.apply(bean)));
bindings.forEach(binding -> binding.storeFieldValue(bean));
// Now run bean level validation against the updated bean
.findAny().isPresent();
if (hasErrors) {
// Bean validator failed, revert values
- bindings.forEach((BindingImpl binding) -> binding.setBeanValue(bean,
- oldValues.get(binding)));
+ bindings.forEach((BindingImpl binding) -> binding.setter
+ .accept(bean, oldValues.get(binding)));
} else {
// Save successful, reset hasChanges to false
setHasChanges(false);
import java.io.Serializable;
import java.lang.reflect.Method;
+import java.util.Objects;
+import java.util.function.BiConsumer;
+import java.util.function.Function;
import com.vaadin.event.ConnectorEvent;
import com.vaadin.event.EventListener;
* @see Registration
*/
@FunctionalInterface
- public interface ValueChangeListener<V> extends
- EventListener<ValueChange<V>> {
+ public interface ValueChangeListener<V>
+ extends EventListener<ValueChange<V>> {
@Deprecated
public static final Method VALUE_CHANGE_METHOD = ReflectTools
*/
public Registration addValueChangeListener(
ValueChangeListener<? super V> listener);
+
+ /**
+ * Returns the value that represents an empty value.
+ * <p>
+ * By default {@link HasValue} is expected to support {@code null} as empty
+ * values. Specific implementations might not support this.
+ *
+ * @return empty value
+ * @see Binder#bind(HasValue, Function, BiConsumer)
+ */
+ public default V getEmptyValue() {
+ return null;
+ }
+
+ /**
+ * Returns whether this {@code HasValue} is considered to be empty.
+ * <p>
+ * By default this is an equality check between current value and empty
+ * value.
+ *
+ * @return {@code true} if considered empty; {@code false} if not
+ */
+ public default boolean isEmpty() {
+ return Objects.equals(getValue(), getEmptyValue());
+ }
}
package com.vaadin.ui;
import java.util.Collection;
+import java.util.Objects;
import org.jsoup.nodes.Attributes;
import org.jsoup.nodes.Element;
@Override
public void setValue(String value) {
- if (value == null) {
- setValue("", false);
- } else {
- setValue(value, false);
- }
+ Objects.requireNonNull(value, "Null value not supported");
+ setValue(value, false);
}
/**
setValue("");
}
- /**
- * Checks if the field is empty.
- *
- * @return <code>true</code> if the field value is an empty string,
- * <code>false</code> otherwise
- */
- public boolean isEmpty() {
- return "".equals(getValue());
- }
-
@Override
public void writeDesign(Element design, DesignContext designContext) {
super.writeDesign(design, designContext);
customAttributes.add("cursor-position");
return customAttributes;
}
+
+ @Override
+ public String getEmptyValue() {
+ return "";
+ }
}
/*
* Copyright 2000-2016 Vaadin Ltd.
- *
+ *
* Licensed under the Apache License, Version 2.0 (the "License"); you may not
* use this file except in compliance with the License. You may obtain a copy of
* the License at
- *
+ *
* http://www.apache.org/licenses/LICENSE-2.0
- *
+ *
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
import org.junit.Test;
import com.vaadin.data.Binder.Binding;
+import com.vaadin.data.util.converter.StringToIntegerConverter;
import com.vaadin.data.validator.NotEmptyValidator;
import com.vaadin.server.AbstractErrorMessage;
import com.vaadin.server.ErrorMessage;
import com.vaadin.ui.Label;
import com.vaadin.ui.TextField;
-public class BinderConverterValidatorTest extends
- BinderTestBase<Binder<Person>, Person> {
+public class BinderConverterValidatorTest
+
extends BinderTestBase<Binder<Person>, Person> {
private static class StatusBean {
private String status;
.bind(Person::getAge, Person::setAge);
binder.bind(item);
}
+
+ @Test(expected = ValidationException.class)
+ public void save_beanValidationErrorsWithConverter()
+ throws ValidationException {
+ Binder<Person> binder = new Binder<>();
+ binder.forField(ageField)
+ .withConverter(new StringToIntegerConverter("Can't convert"))
+ .bind(Person::getAge, Person::setAge);
+
+ binder.withValidator(Validator.from(person -> false, "b"));
+
+ Person person = new Person();
+ ageField.setValue("1");
+ try {
+ binder.save(person);
+ } finally {
+ // Bean should have been updated for item validation but reverted
+ Assert.assertEquals(0, person.getAge());
+ }
+ }
}
import org.junit.Test;
import com.vaadin.tests.data.bean.Person;
+import com.vaadin.tests.data.bean.Sex;
+import com.vaadin.ui.TextField;
public class BinderTest extends BinderTestBase<Binder<Person>, Person> {
binder.bind(nameField, Person::getFirstName, Person::setFirstName);
binder.bind(item);
}
-}
+
+ @Test
+ public void binding_with_null_representation() {
+ String nullRepresentation = "Some arbitrary text";
+ String realName = "John";
+ Person namelessPerson = new Person(null, "Doe", "", 25, Sex.UNKNOWN,
+ null);
+
+ binder.forField(nameField).withNullRepresentation(nullRepresentation)
+ .bind(Person::getFirstName, Person::setFirstName);
+
+ binder.bind(namelessPerson);
+ Assert.assertEquals(nullRepresentation, nameField.getValue());
+
+ nameField.setValue(realName);
+ Assert.assertEquals(realName, namelessPerson.getFirstName());
+
+ nameField.setValue(nullRepresentation);
+ Assert.assertEquals(null, namelessPerson.getFirstName());
+ }
+
+ @Test
+ public void binding_with_default_null_representation() {
+ TextField nullTextField = new TextField() {
+ @Override
+ public String getEmptyValue() {
+ return "null";
+ }
+ };
+
+ Person namelessPerson = new Person(null, "Doe", "", 25, Sex.UNKNOWN,
+ null);
+ binder.bind(nullTextField, Person::getFirstName, Person::setFirstName);
+ binder.bind(namelessPerson);
+
+ Assert.assertTrue(nullTextField.isEmpty());
+ Assert.assertEquals(null, namelessPerson.getFirstName());
+
+ // Change to something and back to null representation
+ nullTextField.setValue("");
+ nullTextField.setValue("null");
+ Assert.assertTrue(nullTextField.isEmpty());
+ Assert.assertEquals("null", namelessPerson.getFirstName());
+ }
+}
\ No newline at end of file
projects / vaadin-framework.git / commitdiff