| // *************************************************************************************************************************** |
| // * Licensed to the Apache Software Foundation (ASF) under one or more contributor license agreements. See the NOTICE file * |
| // * distributed with this work for additional information regarding copyright ownership. The ASF licenses this file * |
| // * to you 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 License for the * |
| // * specific language governing permissions and limitations under the License. * |
| // *************************************************************************************************************************** |
| package org.apache.juneau.transform; |
| |
| import static org.apache.juneau.internal.StringUtils.*; |
| import static java.util.Arrays.*; |
| |
| import java.beans.*; |
| import java.util.*; |
| |
| import org.apache.juneau.*; |
| import org.apache.juneau.annotation.*; |
| import org.apache.juneau.reflect.*; |
| |
| /** |
| * Builder class for {@link BeanFilter} objects. |
| * |
| * <p> |
| * This class is the programmatic equivalent to the {@link Bean @Bean} annotation. |
| * |
| * <p> |
| * The general approach to defining bean filters is to create subclasses from this class and call methods to |
| * set various attributes |
| * <p class='bcode w800'> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * |
| * <jc>// Must provide a no-arg constructor!</jc> |
| * <jk>public</jk> MyFilter() { |
| * |
| * <jc>// Call one or more configuration methods.</jc> |
| * bpi(<js>"foo,bar,baz"</js>); |
| * sortProperties(); |
| * propertyNamer(PropertyNamerULC.<jk>class</jk>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a serializer or parser.</jc> |
| * WriterSerializer s = JsonSerializer |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='link'>{@doc juneau-marshall.Transforms.BeanFilters} |
| * </ul> |
| * |
| * @param <T> The bean type that this filter applies to. |
| */ |
| public class BeanFilterBuilder<T> { |
| |
| Class<?> beanClass; |
| String typeName; |
| Set<String> |
| bpi = new LinkedHashSet<>(), |
| bpx = new LinkedHashSet<>(), |
| bpro = new LinkedHashSet<>(), |
| bpwo = new LinkedHashSet<>(); |
| Class<?> interfaceClass, stopClass; |
| boolean sortProperties, fluentSetters; |
| Object propertyNamer; |
| List<Class<?>> dictionary; |
| Object propertyFilter; |
| |
| /** |
| * Constructor. |
| * |
| * <p> |
| * Bean class is determined through reflection of the parameter type. |
| */ |
| protected BeanFilterBuilder() { |
| beanClass = ClassInfo.of(this.getClass()).getParameterType(0, BeanFilterBuilder.class); |
| } |
| |
| /** |
| * Constructor. |
| * |
| * @param beanClass The bean class that this filter applies to. |
| */ |
| protected BeanFilterBuilder(Class<?> beanClass) { |
| this.beanClass = beanClass; |
| } |
| |
| /** |
| * Configuration property: Bean dictionary type name. |
| * |
| * <p> |
| * Specifies the dictionary type name for this bean. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * typeName(<js>"mybean"</js>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a serializer or parser.</jc> |
| * WriterSerializer s = JsonSerializer |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Produces: "{_type:'mybean', ...}"</jc> |
| * String json = s.serialize(<jk>new</jk> MyBean()); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#typeName()} |
| * </ul> |
| * |
| * @param value The new value for this setting. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> typeName(String value) { |
| this.typeName = value; |
| return this; |
| } |
| |
| /** |
| * Configuration property: Bean property includes. |
| * |
| * @deprecated Use {@link #bpi(String...)} |
| */ |
| @SuppressWarnings("javadoc") |
| @Deprecated public BeanFilterBuilder<T> properties(String...value) { |
| this.bpi = new LinkedHashSet<>(); |
| for (String v : value) |
| bpi.addAll(asList(split(v))); |
| return this; |
| } |
| |
| /** |
| * Configuration property: Bean property excludes. |
| * |
| * @deprecated Use {@link #bpx(String...)} |
| */ |
| @SuppressWarnings("javadoc") |
| @Deprecated public BeanFilterBuilder<T> excludeProperties(String...value) { |
| this.bpx = new LinkedHashSet<>(); |
| for (String v : value) |
| bpx.addAll(asList(split(v))); |
| return this; |
| } |
| |
| /** |
| * Configuration property: Bean interface class. |
| * |
| * Identifies a class to be used as the interface class for this and all subclasses. |
| * |
| * <p> |
| * When specified, only the list of properties defined on the interface class will be used during serialization. |
| * <br>Additional properties on subclasses will be ignored. |
| * |
| * <p class='bcode w800'> |
| * <jc>// Parent class</jc> |
| * <jk>public abstract class</jk> A { |
| * <jk>public</jk> String <jf>f0</jf> = <js>"f0"</js>; |
| * } |
| * |
| * <jc>// Sub class</jc> |
| * <jk>public class</jk> A1 <jk>extends</jk> A { |
| * <jk>public</jk> String <jf>f1</jf> = <js>"f1"</js>; |
| * } |
| * |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> AFilter <jk>extends</jk> BeanFilterBuilder<A> { |
| * <jk>public</jk> AFilter() { |
| * interfaceClass(A.<jk>class</jk>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a serializer.</jc> |
| * WriterSerializer s = JsonSerializer |
| * .<jsm>create</jsm>() |
| * .beanFilters(AFilter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Use it.</jc> |
| * A1 a1 = <jk>new</jk> A1(); |
| * String r = s.serialize(a1); |
| * <jsm>assertEquals</jsm>(<js>"{f0:'f0'}"</js>, r); <jc>// Note f1 is not serialized</jc> |
| * </p> |
| * |
| * <p> |
| * Note that this filter can be used on the parent class so that it filters to all child classes, or can be set |
| * individually on the child classes. |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#interfaceClass()} |
| * <li class='jf'>{@link BeanContext#BEAN_beanFilters} |
| * </ul> |
| * |
| * @param value The new value for this setting. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> interfaceClass(Class<?> value) { |
| this.interfaceClass = value; |
| return this; |
| } |
| |
| /** |
| * Configuration property: Bean stop class. |
| * |
| * <p> |
| * Identifies a stop class for this class and all subclasses. |
| * |
| * <p> |
| * Identical in purpose to the stop class specified by {@link Introspector#getBeanInfo(Class, Class)}. |
| * <br>Any properties in the stop class or in its base classes will be ignored during analysis. |
| * |
| * <p> |
| * For example, in the following class hierarchy, instances of <c>C3</c> will include property <c>p3</c>, |
| * but not <c>p1</c> or <c>p2</c>. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jk>public class</jk> C1 { |
| * <jk>public int</jk> getP1(); |
| * } |
| * |
| * <jk>public class</jk> C2 <jk>extends</jk> C1 { |
| * <jk>public int</jk> getP2(); |
| * } |
| * |
| * <jk>public class</jk> C3 <jk>extends</jk> C2 { |
| * <jk>public int</jk> getP3(); |
| * } |
| * |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> C3Filter <jk>extends</jk> BeanFilterBuilder<C3> { |
| * <jk>public</jk> C3Filter() { |
| * stopClass(C2.<jk>class</jk>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a serializer.</jc> |
| * WriterSerializer s = JsonSerializer |
| * .<jsm>create</jsm>() |
| * .beanFilters(C3Filter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Serializes property 'p3', but NOT 'p1' or 'p2'.</jc> |
| * String json = s.serialize(<jk>new</jk> C3()); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#stopClass()} |
| * </ul> |
| * |
| * @param value The new value for this setting. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> stopClass(Class<?> value) { |
| this.stopClass = value; |
| return this; |
| } |
| |
| /** |
| * Configuration property: Sort bean properties. |
| * |
| * <p> |
| * When <jk>true</jk>, all bean properties will be serialized and access in alphabetical order. |
| * <br>Otherwise, the natural order of the bean properties is used which is dependent on the JVM vendor. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * sortProperties(); |
| * } |
| * } |
| * |
| * <jc>// Register it with a serializer.</jc> |
| * WriterSerializer s = JsonSerializer |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Properties will be sorted alphabetically.</jc> |
| * String json = s.serialize(<jk>new</jk> MyBean()); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#sort()} |
| * <li class='jf'>{@link BeanContext#BEAN_sortProperties} |
| * </ul> |
| * |
| * @param value |
| * The new value for this property. |
| * <br>The default is <jk>false</jk>. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> sortProperties(boolean value) { |
| this.sortProperties = value; |
| return this; |
| } |
| |
| /** |
| * Configuration property: Sort bean properties. |
| * |
| * <p> |
| * Shortcut for calling <code>sortProperties(<jk>true</jk>)</code>. |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#sort()} |
| * <li class='jf'>{@link BeanContext#BEAN_sortProperties} |
| * </ul> |
| * |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> sortProperties() { |
| this.sortProperties = true; |
| return this; |
| } |
| |
| /** |
| * Configuration property: Find fluent setters. |
| * |
| * <p> |
| * When enabled, fluent setters are detected on beans. |
| * |
| * <p> |
| * Fluent setters must have the following attributes: |
| * <ul> |
| * <li>Public. |
| * <li>Not static. |
| * <li>Take in one parameter. |
| * <li>Return the bean itself. |
| * </ul> |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * fluentSetters(); |
| * } |
| * } |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#fluentSetters()} |
| * <li class='jf'>{@link BeanContext#BEAN_fluentSetters} |
| * </ul> |
| * |
| * @param value |
| * The new value for this property. |
| * <br>The default is <jk>false</jk>. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> fluentSetters(boolean value) { |
| this.fluentSetters = value; |
| return this; |
| } |
| |
| /** |
| * Configuration property: Find fluent setters. |
| * |
| * <p> |
| * Shortcut for calling <code>fluentSetters(<jk>true</jk>)</code>. |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#fluentSetters()} |
| * <li class='jf'>{@link BeanContext#BEAN_fluentSetters} |
| * </ul> |
| * |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> fluentSetters() { |
| this.fluentSetters = true; |
| return this; |
| } |
| |
| /** |
| * Configuration property: Bean property namer |
| * |
| * <p> |
| * The class to use for calculating bean property names. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * <jc>// Use Dashed-Lower-Case property names.</jc> |
| * <jc>// (e.g. "foo-bar-url" instead of "fooBarURL")</jc> |
| * propertyNamer(PropertyNamerDLC.<jk>class</jk>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a serializer or parser.</jc> |
| * WriterSerializer s = JsonSerializer |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Properties names will be Dashed-Lower-Case.</jc> |
| * String json = s.serialize(<jk>new</jk> MyBean()); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#propertyNamer()} |
| * <li class='jf'>{@link BeanContext#BEAN_propertyNamer} |
| * <li class='jc'>{@link PropertyNamer} |
| * </ul> |
| * |
| * @param value |
| * The new value for this setting. |
| * <br>The default is {@link PropertyNamerDefault}. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> propertyNamer(Class<? extends PropertyNamer> value) { |
| this.propertyNamer = value; |
| return this; |
| } |
| |
| /** |
| * Configuration property: Bean dictionary. |
| * |
| * <p> |
| * Adds to the list of classes that make up the bean dictionary for this bean. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * <jc>// Our bean contains generic collections of Foo and Bar objects.</jc> |
| * beanDictionary(Foo.<jk>class</jk>, Bar.<jk>class</jk>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a parser.</jc> |
| * ReaderParser p = JsonParser |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Instantiate our bean.</jc> |
| * MyBean myBean = p.parse(json); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#dictionary()} |
| * <li class='jf'>{@link BeanContext#BEAN_beanDictionary} |
| * </ul> |
| * |
| * @param values |
| * The values to add to this property. |
| * @return This object (for method chaining). |
| * @deprecated Use {@link #dictionary(Class...)}. |
| */ |
| @Deprecated |
| public BeanFilterBuilder<T> beanDictionary(Class<?>...values) { |
| if (dictionary == null) |
| dictionary = new ArrayList<>(Arrays.asList(values)); |
| else for (Class<?> cc : values) |
| dictionary.add(cc); |
| return this; |
| } |
| |
| /** |
| * Configuration property: Bean property includes. |
| * |
| * <p> |
| * Specifies the set and order of names of properties associated with the bean class. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * bpi(<js>"foo,bar,baz"</js>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a serializer.</jc> |
| * WriterSerializer s = JsonSerializer |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Only serializes the properties 'foo', 'bar', and 'baz'.</jc> |
| * String json = s.serialize(<jk>new</jk> MyBean()); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#bpi()} |
| * <li class='jf'>{@link BeanContext#BEAN_bpi} |
| * </ul> |
| * |
| * @param value |
| * The new value for this setting. |
| * <br>Values can contain comma-delimited list of property names. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> bpi(String...value) { |
| this.bpi = new LinkedHashSet<>(); |
| for (String v : value) |
| bpi.addAll(asList(split(v))); |
| return this; |
| } |
| |
| /** |
| * Configuration property: Bean property excludes. |
| * |
| * <p> |
| * Specifies properties to exclude from the bean class. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * bpx(<js>"foo,bar"</js>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a serializer.</jc> |
| * WriterSerializer s = JsonSerializer |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Serializes all properties except for 'foo' and 'bar'.</jc> |
| * String json = s.serialize(<jk>new</jk> MyBean()); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#bpx()} |
| * <li class='jf'>{@link BeanContext#BEAN_bpx} |
| * </ul> |
| * |
| * @param value |
| * The new value for this setting. |
| * <br>Values can contain comma-delimited list of property names. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> bpx(String...value) { |
| this.bpx = new LinkedHashSet<>(); |
| for (String v : value) |
| bpx.addAll(asList(split(v))); |
| return this; |
| } |
| |
| /** |
| * Configuration property: Read-only bean properties. |
| * |
| * <p> |
| * Specifies one or more properties on a bean that are read-only despite having valid getters. |
| * Serializers will serialize such properties as usual, but parsers will silently ignore them. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * bpro(<js>"foo,bar"</js>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a parser.</jc> |
| * ReaderParser p = JsonParser |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Parsers all properties except for 'foo' and 'bar'.</jc> |
| * MyBean b = p.parse(<js>"..."</js>, MyBean.<jk>class</jk>); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#bpro()} |
| * <li class='ja'>{@link Beanp#ro()} |
| * <li class='jf'>{@link BeanContext#BEAN_bpro} |
| * </ul> |
| * |
| * @param value |
| * The new value for this setting. |
| * <br>Values can contain comma-delimited list of property names. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> bpro(String...value) { |
| this.bpro = new LinkedHashSet<>(); |
| for (String v : value) |
| bpro.addAll(asList(split(v))); |
| return this; |
| } |
| |
| /** |
| * Configuration property: Write-only bean properties. |
| * |
| * <p> |
| * Specifies one or more properties on a bean that are write-only despite having valid setters. |
| * Parsers will parse such properties as usual, but serializers will silently ignore them. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * bpwo(<js>"foo,bar"</js>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a serializer.</jc> |
| * WriterSerializer s = JsonSerializer |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Serializes all properties except for 'foo' and 'bar'.</jc> |
| * String json = s.serialize(<jk>new</jk> MyBean()); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#bpwo()} |
| * <li class='ja'>{@link Beanp#wo()} |
| * <li class='jf'>{@link BeanContext#BEAN_bpwo} |
| * </ul> |
| * |
| * @param value |
| * The new value for this setting. |
| * <br>Values can contain comma-delimited list of property names. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> bpwo(String...value) { |
| this.bpwo = new LinkedHashSet<>(); |
| for (String v : value) |
| bpwo.addAll(asList(split(v))); |
| return this; |
| } |
| |
| /** |
| * Configuration property: Bean dictionary. |
| * |
| * <p> |
| * Adds to the list of classes that make up the bean dictionary for this bean. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * <jc>// Our bean contains generic collections of Foo and Bar objects.</jc> |
| * beanDictionary(Foo.<jk>class</jk>, Bar.<jk>class</jk>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a parser.</jc> |
| * ReaderParser p = JsonParser |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * |
| * <jc>// Instantiate our bean.</jc> |
| * MyBean myBean = p.parse(json); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#dictionary()} |
| * <li class='jf'>{@link BeanContext#BEAN_beanDictionary} |
| * </ul> |
| * |
| * @param values |
| * The values to add to this property. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> dictionary(Class<?>...values) { |
| if (dictionary == null) |
| dictionary = new ArrayList<>(Arrays.asList(values)); |
| else for (Class<?> cc : values) |
| dictionary.add(cc); |
| return this; |
| } |
| |
| /** |
| * Configuration property: Property filter. |
| * |
| * <p> |
| * The property filter to use for intercepting and altering getter and setter calls. |
| * |
| * <h5 class='section'>Example:</h5> |
| * <p class='bcode w800'> |
| * <jc>// Define our filter.</jc> |
| * <jk>public class</jk> MyFilter <jk>extends</jk> BeanFilterBuilder<MyBean> { |
| * <jk>public</jk> MyFilter() { |
| * <jc>// Our bean contains generic collections of Foo and Bar objects.</jc> |
| * propertyFilter(AddressPropertyFilter.<jk>class</jk>); |
| * } |
| * } |
| * |
| * <jc>// Register it with a serializer or parser.</jc> |
| * WriterSerializer s = JsonSerializer |
| * .<jsm>create</jsm>() |
| * .beanFilters(MyFilter.<jk>class</jk>) |
| * .build(); |
| * </p> |
| * |
| * <ul class='seealso'> |
| * <li class='ja'>{@link Bean#propertyFilter()} |
| * <li class='jc'>{@link PropertyFilter} |
| * </ul> |
| * |
| * @param value |
| * The new value for this setting. |
| * <br>The default value is {@link PropertyFilter}. |
| * @return This object (for method chaining). |
| */ |
| public BeanFilterBuilder<T> propertyFilter(Class<? extends PropertyFilter> value) { |
| this.propertyFilter = value; |
| return this; |
| } |
| |
| /** |
| * Creates a {@link BeanFilter} with settings in this builder class. |
| * |
| * @return A new {@link BeanFilter} instance. |
| */ |
| public BeanFilter build() { |
| return new BeanFilter(this); |
| } |
| } |
