V8 detect changed property name

Vaadin 6 / 7 / 8
41

yes, that is exactly how we used it before

42

String propertyName = (String) binder.getPropertyId((Field<?>) valueChangeEvent.getProperty());

43

For now I am going to construct the Field->PropertyName map from boundProperties

44

Yeah, the difference here would be that event.getSource() would return the source Component, but that doesn’t matter with your usage

45

Yes, I dont care what it is

46

Something you can already do is binder.getBinding(propertyName).get().getField().addValueChangeListener(listener)

47

First i need to get the property name

48

binder.getBoundProperties().forEach((propertyName, binding) → {
propertyNamesToFields.put(propertyName, binding.getField());
fieldsToPropertyNames.put(binding.getField(), propertyName);
});

49

Sry I need to leave now

50

String propertyName = fieldsToPropertyNames.get(valueChangeEvent.getComponent());

51

Not tested yet

52

:wave: We have a similar use case, we bind fields by definitions (in your case property names) https://git.magnolia-cms.com/projects/PLATFORM/repos/ui.pub/browse/magnolia-ui-framework/src/main/java/info/magnolia/ui/editor/FormPresenter.java#206, so we can get it later by definition https://git.magnolia-cms.com/projects/PLATFORM/repos/ui.pub/browse/magnolia-ui-framework/src/main/java/info/magnolia/ui/editor/FormPresenter.java#211 (it would be the other way around in your case, right?)

53

Hello @inclusive-camel , do you always call forField directly or it is called by all other Binder methods? Nice idea, going to have a look at it

54

I guess you call it directly

55

we rely on auto-binding by reflection

56

Hey, yes we call it directly but I think you can do something like:

57 
 private static class PropertyAwareBinder<BEAN> extends Binder<BEAN> {

        private final Map<HasValue<?>, Binding<BEAN, ?>> boundProperties = new HashMap<>();

        private PropertyAwareBinder(Class<BEAN> beanClass) {
            super(beanClass);
        }

        @Override
        public <FIELDVALUE> BindingBuilder<BEAN, FIELDVALUE> forField(HasValue<FIELDVALUE> field) {
            return new BindingBuilderWrapper<>(super.forField(field)) {
                @Override
                public Binder.Binding<BEAN, FIELDVALUE> bind(String propertyName) {
                    var binding = wrapped.bind(propertyName);
                    boundProperties.put(getField(), binding);
                    return binding;
                }
            };
        }

        public Optional<Binding<BEAN, ?>> getBinding(HasValue<?> hasValue) {
            return Optional.ofNullable(boundProperties.get(hasValue));
        }
    }
    @AllArgsConstructor
    private static abstract class BindingBuilderWrapper<BEAN, TARGET> implements Binder.BindingBuilder<BEAN, TARGET> {
        @Delegate(excludes = BindMethodInterface.class)
        Binder.BindingBuilder<BEAN, TARGET> wrapped;

        private interface BindMethodInterface<BEAN, TARGET> {
            Binder.Binding<BEAN, TARGET> bind(String propertyName);
        }
    }
58

there is some lombok to simplify the wrapper object but at least you don’t need to use reflection to access a private object

59

Thank s for inputs, for now I guess we will be happy with exposing boundProperties