@Override public ValueProvider<T, V> getGetter() { return bean -> { Method readMethod = getDescriptor().getReadMethod(); Object value = invokeWrapExceptions(readMethod, parent.getGetter().apply(bean)); return getType().cast(value); }; }
private boolean handleProperty(Field field, Object objectWithMemberFields, BiFunction<String, Class<?>, Boolean> propertyHandler) { Optional<PropertyDefinition<BEAN, ?>> descriptor = getPropertyDescriptor( field); if (!descriptor.isPresent()) { return false; } String propertyName = descriptor.get().getName(); if (boundProperties.containsKey(propertyName)) { return false; } BindingBuilder<BEAN, ?> tentativeBinding = getIncompleteMemberFieldBinding( field, objectWithMemberFields); if (tentativeBinding != null) { tentativeBinding.bind(propertyName); return false; } Boolean isPropertyBound = propertyHandler.apply(propertyName, descriptor.get().getType()); assert boundProperties.containsKey(propertyName); return isPropertyBound; }
.isAssignableFrom(definition.getType())) { throw new IllegalArgumentException( renderer + " cannot be used with a property of type " + definition.getType().getName()); Column<T, ?> column = addColumn(definition.getGetter(), (AbstractRenderer) renderer).setId(definition.getName()) .setCaption(definition.getCaption());
@Override @SuppressWarnings({ "unchecked", "rawtypes" }) public Binding<BEAN, TARGET> bind(String propertyName) { Objects.requireNonNull(propertyName, "Property name cannot be null"); checkUnbound(); PropertyDefinition<BEAN, ?> definition = getBinder().propertySet .getProperty(propertyName) .orElseThrow(() -> new IllegalArgumentException( "Could not resolve property name " + propertyName + " from " + getBinder().propertySet)); ValueProvider<BEAN, ?> getter = definition.getGetter(); Setter<BEAN, ?> setter = definition.getSetter().orElse(null); if (setter == null) { getLogger().fine(() -> propertyName + " does not have an accessible setter"); } BindingBuilder<BEAN, ?> finalBinding = withConverter( createConverter(definition.getType()), false); finalBinding = getBinder().configureBinding(finalBinding, definition); try { Binding binding = ((BindingBuilder) finalBinding).bind(getter, setter); getBinder().boundProperties.put(propertyName, binding); return binding; } finally { getBinder().incompleteMemberFieldBindings.remove(getField()); } }
/** * Refreshes the item detail. * This method is triggered by {@link ItemPreviewComponent#onValueChange(Object)} in case of value changes. */ protected Component refreshItemDetail(T item) { FormLayout itemDetail = new FormLayout(); itemDetail.addStyleName("file-details"); getPropertySet().getProperties() .map(property -> this.createDetailComponent(property.getName(), property.getGetter().apply(item))) .forEach(itemDetail::addComponent); return itemDetail; }
/** * Gets the top level name of this property. * * @return the top level property name, not <code>null</code> * @since 8.3 */ public default String getTopLevelName() { return getName(); }
public NestedBeanPropertyDefinition(BeanPropertySet<T> propertySet, PropertyDefinition<T, ?> parent, PropertyDescriptor descriptor) { super(propertySet, parent.getType(), descriptor); this.parent = parent; }
private void configureRequired(BindingBuilder<BEAN, ?> binding, PropertyDefinition<BEAN, ?> definition, BeanValidator validator) { assert requiredConfigurator != null; Class<?> propertyHolderType = definition.getPropertyHolderType(); BeanDescriptor descriptor = validator.getJavaxBeanValidator() .getConstraintsForClass(propertyHolderType); PropertyDescriptor propertyDescriptor = descriptor .getConstraintsForProperty(definition.getTopLevelName()); if (propertyDescriptor == null) { return; } if (propertyDescriptor.getConstraintDescriptors().stream() .map(ConstraintDescriptor::getAnnotation) .anyMatch(requiredConfigurator)) { binding.getField().setRequiredIndicatorVisible(true); } }
@Override protected BindingBuilder<BEAN, ?> configureBinding( BindingBuilder<BEAN, ?> binding, PropertyDefinition<BEAN, ?> definition) { Class<?> actualBeanType = findBeanType(beanType, definition); BeanValidator validator = new BeanValidator(actualBeanType, definition.getTopLevelName()); if (requiredConfigurator != null) { configureRequired(binding, definition, validator); } return binding.withValidator(validator); }
@Override public String getName() { return parent.getName() + "." + super.getName(); }
/** * Finds the bean type containing the property the given definition refers * to. * * @param beanType * the root beanType * @param definition * the definition for the property * @return the bean type containing the given property */ @SuppressWarnings({ "rawtypes" }) private Class<?> findBeanType(Class<BEAN> beanType, PropertyDefinition<BEAN, ?> definition) { if (definition instanceof NestedBeanPropertyDefinition) { return ((NestedBeanPropertyDefinition) definition).getParent() .getType(); } else { // Non nested properties must be defined in the main type return beanType; } }
/** * Constructor. * @param beanType Bean type (not null) */ public DefaultBeanListingBuilder(Class<T> beanType) { super(new DefaultBeanListing<>(beanType), String.class); this.beanType = beanType; // read bean property names getInstance().getPropertyDefinitions().forEach(p -> { dataSourceBuilder.withProperty(p.getName(), p.getType(), false); dataSourceBuilder.propertyId(p.getName(), p.getName()); if (p.isReadOnly()) { dataSourceBuilder.readOnly(p.getName(), true); } if (p.getBeanProperty().isPresent()) { dataSourceBuilder.sortable(p.getName(), true); } }); PropertySet<T> propertySet = BeanPropertySet.get(beanType); propertySet.getProperties().forEach(p -> { dataSourceBuilder.withProperty(p.getName(), p.getType()); }); }
.getProperties().filter(p -> p.getName().equals(id)) .findFirst(); Column<T, ?> column;
@Override public Optional<Setter<T, V>> getSetter() { if (getDescriptor().getWriteMethod() == null) { return Optional.empty(); } Setter<T, V> setter = (bean, value) -> { // Do not "optimize" this getter call, // if its done outside the code block, that will produce // NotSerializableException because of some lambda compilation // magic Method innerSetter = getDescriptor().getWriteMethod(); invokeWrapExceptions(innerSetter, parent.getGetter().apply(bean), value); }; return Optional.of(setter); }
PropertyDefinition<T, ?> parentProperty = parentDefinitions .get(parentPropertyKey); Class<?> type = parentProperty.getType(); if (type.getPackage() == null || type.isEnum()) { continue;
/** * Get the default column ids of this listing, i.e. the ids of all detected bean property columns and any added * virtual column. * @return the default column ids */ protected List<String> getDefaultColumnIds() { return propertySet.getProperties().map(p -> p.getName()).collect(Collectors.toList()); }
@SuppressWarnings("unchecked") public <BEAN> ValueDefinition<BEAN, FIELD> build( final TableDefinition<BEAN> tableDefinition) { PropertyDefinition definition = tableDefinition.getPropertySet() .getProperty(propertyName).orElseThrow(() -> new RuntimeException("The property " + propertyName + " does not exist on bean")); ValueDefinition<BEAN, FIELD> def = new ValueDefinition<BEAN, FIELD>(propertyName, definition.getGetter()); // def.withSetter(setter); def.withFormatter(formatter); return def; } }