/** * Render this property as given <code>renderType</code> if a suitable {@link PropertyRenderer} for given rendering * type is available from the {@link PropertyRendererRegistry} obtained from current {@link Context} or from the * default one for current ClassLoader. * @param <R> Rendered object type * @param renderType Render type * @return Rendered property as given render type, or an empty Optional if a suitable PropertyRenderer is not * available */ default <R> Optional<R> renderIfAvailable(Class<R> renderType) { return PropertyRendererRegistry.get().getRenderer(renderType, this).map(r -> r.render(this)); }
/** * Render given property as a {@link Input}. * @param <T> Property type * @param property Property to render * @return Rendered input */ @SuppressWarnings("unchecked") protected <T> Optional<Input<T>> render(Property<T> property) { // check custom renderer final PropertyConfiguration<T> cfg = getPropertyConfiguration(property); if (cfg.getRenderer().isPresent()) { final PropertyRenderer<Input<T>, T> r = cfg.getRenderer().get(); // check render type if (!Input.class.isAssignableFrom(r.getRenderType())) { throw new IllegalStateException( "Renderer for property [" + property + "] is not of Input type: [" + r.getRenderType() + "]"); } return Optional.ofNullable(r.render(property)); } // use registry return property.renderIfAvailable(Input.class).map(i -> i); }
@Override public <R, T> void register(Predicate<Property<? extends T>> condition, PropertyRenderer<R, T> renderer) { ObjectUtils.argumentNotNull(condition, "Condition must be not null"); ObjectUtils.argumentNotNull(renderer, "PropertyRenderer must be not null"); ObjectUtils.argumentNotNull(renderer.getRenderType(), "PropertyRenderer rendering type must be not null"); renderers.putIfAbsent(renderer.getRenderType(), new HashMap<>(4)); renderers.get(renderer.getRenderType()).put(condition, renderer); LOGGER.debug(() -> "DefaultPropertyRendererRegistry: registered renderer [" + renderer + "] bound to condition [" + condition + "]"); }
public void render() { PropertyRenderer<MyRenderingType, Object> myRenderer = PropertyRenderer.create(MyRenderingType.class, p -> new MyRenderingType(p.getType())); // <2> PropertyRendererRegistry.get().register(p -> true, myRenderer); // <3> final PathProperty<Long> ID = PathProperty.create("id", Long.class); MyRenderingType rendered = ID.render(MyRenderingType.class); // <4> } // end::renderer[]
@Override public <T, F extends T> B bind(Property<T> property, PropertyRenderer<ViewComponent<F>, T> renderer) { ObjectUtils.argumentNotNull(renderer, "PropertyRenderer must be not null"); return bind(property, p -> renderer.render(p)); }
/** * Render given property as a {@link Input}. * @param <T> Property type * @param property Property to render * @return Rendered input */ @SuppressWarnings("unchecked") protected <T> Optional<Input<T>> render(Property<T> property) { // check custom renderer final PropertyConfiguration<T> cfg = getPropertyConfiguration(property); if (cfg.getRenderer().isPresent()) { final PropertyRenderer<Input<T>, T> r = cfg.getRenderer().get(); // check render type if (!Input.class.isAssignableFrom(r.getRenderType())) { throw new IllegalStateException( "Renderer for property [" + property + "] is not of Input type: [" + r.getRenderType() + "]"); } return Optional.ofNullable(r.render(property)); } // use registry return property.renderIfAvailable(Input.class).map(i -> i); }
@Override public <T, F extends T> B bind(Property<T> property, PropertyRenderer<ViewComponent<F>, T> renderer) { ObjectUtils.argumentNotNull(renderer, "PropertyRenderer must be not null"); return bind(property, p -> renderer.render(p)); }
@Override public Input render(Property<? extends T> property) { ObjectUtils.argumentNotNull(property, "Property must be not null"); @SuppressWarnings("unchecked") final Property<T> p = (Property<T>) property; // try to render as Field and convert to Input return PropertyRendererRegistry.get().getRenderer(Field.class, p).map(r -> r.render(p)) .map(field -> asInput(field)).orElse(null); }
@Override public Input render(Property<? extends T> property) { ObjectUtils.argumentNotNull(property, "Property must be not null"); @SuppressWarnings("unchecked") final Property<T> p = (Property<T>) property; // try to render as Field and convert to Input return PropertyRendererRegistry.get().getRenderer(Field.class, p).map(r -> r.render(p)) .map(field -> asInput(field)).orElse(null); }
@SuppressWarnings("unchecked") @Override protected <V> Optional<Input<V>> buildPropertyEditor(ItemListingColumn<Property<?>, PropertyBox, V> configuration) { final Property<V> property = (Property<V>) configuration.getProperty(); // check custom renderer Optional<Input<V>> component = configuration.getEditorInputRenderer().map(r -> r.render(property)); if (component.isPresent()) { return component; } // check specific registry if (getPropertyRendererRegistry().isPresent()) { return getPropertyRendererRegistry().get().getRenderer(Input.class, property).map(r -> r.render(property)); } else { // use default return property.renderIfAvailable(Input.class).map(c -> (Input<V>) c); } }
@SuppressWarnings("unchecked") @Override protected <V> Optional<Input<V>> buildPropertyEditor(ItemListingColumn<String, T, V> configuration) { return propertySet.getProperty(configuration.getProperty()).flatMap(p -> { final Property<V> property = (Property<V>) p; // check custom renderer Optional<Input<V>> component = configuration.getEditorInputRenderer().map(r -> r.render(property)); if (component.isPresent()) { return component; } // check specific registry if (getPropertyRendererRegistry().isPresent()) { return getPropertyRendererRegistry().get().getRenderer(Input.class, property) .map(r -> r.render(property)); } else { // use default return property.renderIfAvailable(Input.class).map(c -> (Input<V>) c); } }); }
/** * Render given property configuration as a {@link ViewComponent}. * @param <T> Property type * @param propertyConfiguration Property configuration * @return Optional rendered component */ @SuppressWarnings("unchecked") protected <T> Optional<Input<T>> render(InputPropertyConfiguration<T> propertyConfiguration) { // check custom renderer Optional<Input<T>> component = propertyConfiguration.getRenderer() .map(r -> r.render(propertyConfiguration.getProperty())); if (component.isPresent()) { return component; } // check specific registry if (getPropertyRendererRegistry().isPresent()) { return getPropertyRendererRegistry().get().getRenderer(Input.class, propertyConfiguration.getProperty()) .map(r -> r.render(propertyConfiguration.getProperty())); } else { // use default return propertyConfiguration.getProperty().renderIfAvailable(Input.class).map(c -> (Input<T>) c); } }
/** * Render given property configuration as a {@link ViewComponent}. * @param <T> Property type * @param propertyConfiguration Property configuration * @return Optional rendered component */ @SuppressWarnings("unchecked") protected <T> Optional<ViewComponent<T>> render(ViewComponentPropertyConfiguration<T> propertyConfiguration) { // check custom renderer Optional<ViewComponent<T>> component = propertyConfiguration.getRenderer() .map(r -> r.render(propertyConfiguration.getProperty())); if (component.isPresent()) { return component; } // check specific registry if (getPropertyRendererRegistry().isPresent()) { return getPropertyRendererRegistry().get() .getRenderer(ViewComponent.class, propertyConfiguration.getProperty()) .map(r -> r.render(propertyConfiguration.getProperty())); } else { // use default return propertyConfiguration.getProperty().renderIfAvailable(ViewComponent.class) .map(c -> (ViewComponent<T>) c); } }