Repository: incubator-juneau Updated Branches: refs/heads/master daa17605a -> 94b52bd11
Ongoing work involving class lexicon support. Project: http://git-wip-us.apache.org/repos/asf/incubator-juneau/repo Commit: http://git-wip-us.apache.org/repos/asf/incubator-juneau/commit/94b52bd1 Tree: http://git-wip-us.apache.org/repos/asf/incubator-juneau/tree/94b52bd1 Diff: http://git-wip-us.apache.org/repos/asf/incubator-juneau/diff/94b52bd1 Branch: refs/heads/master Commit: 94b52bd114f57afcc936e64574062714295e8f7d Parents: daa1760 Author: jamesbognar <[email protected]> Authored: Thu Sep 1 14:33:15 2016 -0400 Committer: jamesbognar <[email protected]> Committed: Thu Sep 1 14:33:15 2016 -0400 ---------------------------------------------------------------------- .../java/org/apache/juneau/BeanContext.java | 16 ++ .../main/java/org/apache/juneau/BeanMeta.java | 6 + .../org/apache/juneau/BeanPropertyMeta.java | 22 +++ .../java/org/apache/juneau/ClassLexicon.java | 16 +- .../main/java/org/apache/juneau/ClassMeta.java | 18 ++- .../main/java/org/apache/juneau/ObjectMap.java | 8 + .../java/org/apache/juneau/annotation/Bean.java | 4 +- .../apache/juneau/annotation/BeanProperty.java | 16 +- .../java/org/apache/juneau/annotation/Pojo.java | 4 +- .../juneau/transform/AnnotationBeanFilter.java | 9 +- .../org/apache/juneau/transform/BeanFilter.java | 160 ++++++++----------- .../juneau/a/rttests/RoundTripBeanMapsTest.java | 21 ++- .../java/org/apache/juneau/html/CommonTest.java | 1 - 13 files changed, 185 insertions(+), 116 deletions(-) ---------------------------------------------------------------------- http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/BeanContext.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/BeanContext.java b/juneau-core/src/main/java/org/apache/juneau/BeanContext.java index 90d2135..702d262 100644 --- a/juneau-core/src/main/java/org/apache/juneau/BeanContext.java +++ b/juneau-core/src/main/java/org/apache/juneau/BeanContext.java @@ -446,8 +446,19 @@ public class BeanContext extends Context { */ public static final String BEAN_implClasses_put = "BeanContext.implClasses.map.put"; + /** + * Specifies the list of classes that make up the class lexicon for this bean context (<code>List<Class></code>). + */ public static final String BEAN_classLexicon = "BeanContext.classLexicon.list"; + + /** + * Add to the class lexicon list. + */ public static final String BEAN_classLexicon_add = "BeanContext.classLexicon.list.add"; + + /** + * Remove from the class lexicon list. + */ public static final String BEAN_classLexicon_remove = "BeanContext.classLexicon.list.remove"; /** @@ -1463,6 +1474,11 @@ public class BeanContext extends Context { return null; } + /** + * Returns the class lexicon defined in this bean context defined by {@link BeanContext#BEAN_classLexicon}. + * + * @return The class lexicon defined in this bean context. Never <jk>null</jk>. + */ protected ClassLexicon getClassLexicon() { return classLexicon; } http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/BeanMeta.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/BeanMeta.java b/juneau-core/src/main/java/org/apache/juneau/BeanMeta.java index 6322d3f..460bc0c 100644 --- a/juneau-core/src/main/java/org/apache/juneau/BeanMeta.java +++ b/juneau-core/src/main/java/org/apache/juneau/BeanMeta.java @@ -142,6 +142,7 @@ public class BeanMeta<T> { MetadataMap extMeta = new MetadataMap(); BeanPropertyMeta subTypeIdProperty; PropertyNamer propertyNamer; + ClassLexicon classLexicon; private Builder(ClassMeta<T> classMeta, BeanContext ctx, BeanFilter<? extends T> beanFilter, String[] pNames) { this.classMeta = classMeta; @@ -224,6 +225,8 @@ public class BeanMeta<T> { if (beanFilter.getPropertyNamer() != null) propertyNamer = beanFilter.getPropertyNamer(); + + classLexicon = beanFilter.getClassLexicon(); } if (propertyNamer == null) @@ -335,6 +338,9 @@ public class BeanMeta<T> { properties.put(subTypeProperty, this.subTypeIdProperty); } + if (classLexicon == null) + classLexicon = ctx.getClassLexicon(); + properties.putAll(normalProps); // If a beanFilter is defined, look for inclusion and exclusion lists. http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/BeanPropertyMeta.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/BeanPropertyMeta.java b/juneau-core/src/main/java/org/apache/juneau/BeanPropertyMeta.java index c2ab10d..3c8cf44 100644 --- a/juneau-core/src/main/java/org/apache/juneau/BeanPropertyMeta.java +++ b/juneau-core/src/main/java/org/apache/juneau/BeanPropertyMeta.java @@ -58,6 +58,7 @@ public class BeanPropertyMeta { private PojoSwap swap; // PojoSwap defined only via @BeanProperty annotation. private MetadataMap extMeta = new MetadataMap(); // Extended metadata + private ClassLexicon classLexicon; /** * Constructor. @@ -143,6 +144,21 @@ public class BeanPropertyMeta { } /** + * Returns the class lexicon in use for this bean property. + * The order of lookup for the lexicon is as follows: + * <ol> + * <li>Lexicon defined via {@link BeanProperty#classLexicon()}. + * <li>Lexicon defined via {@link Bean#classLexicon()} or {@link Pojo#classLexicon()} (or {@link BeanFilter} equivalent). + * <li>Lexicon defined via {@link BeanContext#BEAN_classLexicon} context property. + * </ol> + * + * @return The class lexicon in use for this bean property. Never <jk>null</jk>. + */ + public ClassLexicon getClassLexicon() { + return classLexicon; + } + + /** * Sets the getter method for this property. * * @param getter The getter method to associate with this property. @@ -240,6 +256,8 @@ public class BeanPropertyMeta { swap = getPropertyPojoSwap(p); if (p.properties().length != 0) properties = p.properties(); + if (p.classLexicon().length > 0) + this.classLexicon = new ClassLexicon(p.classLexicon()); } } @@ -253,6 +271,8 @@ public class BeanPropertyMeta { swap = getPropertyPojoSwap(p); if (properties != null && p.properties().length != 0) properties = p.properties(); + if (p.classLexicon().length > 0) + this.classLexicon = new ClassLexicon(p.classLexicon()); } } @@ -266,6 +286,8 @@ public class BeanPropertyMeta { swap = getPropertyPojoSwap(p); if (properties != null && p.properties().length != 0) properties = p.properties(); + if (p.classLexicon().length > 0) + this.classLexicon = new ClassLexicon(p.classLexicon()); } } http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/ClassLexicon.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/ClassLexicon.java b/juneau-core/src/main/java/org/apache/juneau/ClassLexicon.java index 2dbf639..00d0fb8 100644 --- a/juneau-core/src/main/java/org/apache/juneau/ClassLexicon.java +++ b/juneau-core/src/main/java/org/apache/juneau/ClassLexicon.java @@ -21,7 +21,21 @@ import org.apache.juneau.internal.*; /** * A lookup table for resolving classes by name. * <p> - * Class names are typically defined through the {@link Bean#name()} or {@link Pojo#name()} annotations. + * In a nutshell, provides a simple mapping of class objects to identifying names by implementing the following two methods: + * <ul> + * <li>{@link #getClassForName(String)} + * <li>{@link #getNameForClass(Class)} + * </ul> + * <p> + * Class names are defined through the {@link Bean#name()} or {@link Pojo#name()} annotations when using the {@link ClassLexicon#ClassLexicon(Class...)} + * constructor, but can be defined programmatically by using the {@link ClassLexicon#ClassLexicon(Map)} constructor. + * <p> + * The lexicon is used by the framework in the following ways: + * <ul> + * <li>If a class type cannot be inferred through reflection during parsing, then a helper <js>"_class"</js> is added to the serialized output + * using the name defined for that class in this lexicon. This helps determine the real class at parse time. + * <li>The lexicon name is used as element names when serialized to XML. + * </ul> * * @author james.bognar */ http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/ClassMeta.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/ClassMeta.java b/juneau-core/src/main/java/org/apache/juneau/ClassMeta.java index 64487cc..9d8c630 100644 --- a/juneau-core/src/main/java/org/apache/juneau/ClassMeta.java +++ b/juneau-core/src/main/java/org/apache/juneau/ClassMeta.java @@ -132,11 +132,11 @@ public final class ClassMeta<T> implements Type { classLexicon = beanContext.getClassLexicon(); for (Pojo p : ReflectionUtils.findAnnotationsParentFirst(Pojo.class, innerClass)) - if (p.lexicon().length > 0) - classLexicon = new ClassLexicon(classLexicon, p.lexicon()); + if (p.classLexicon().length > 0) + classLexicon = new ClassLexicon(p.classLexicon()); for (Bean b : ReflectionUtils.findAnnotationsParentFirst(Bean.class, innerClass)) - if (b.lexicon().length > 0) - classLexicon = new ClassLexicon(classLexicon, b.lexicon()); + if (b.classLexicon().length > 0) + classLexicon = new ClassLexicon(b.classLexicon()); serializedClassMeta = (pojoSwap == null ? this : beanContext.getClassMeta(pojoSwap.getSwapClass())); if (serializedClassMeta == null) @@ -384,6 +384,16 @@ public final class ClassMeta<T> implements Type { return this; } + /** + * Returns the class lexicon in use for this class. + * The order of lookup for the lexicon is as follows: + * <ol> + * <li>Lexicon defined via {@link Bean#classLexicon()} or {@link Pojo#classLexicon()} (or {@link BeanFilter} equivalent). + * <li>Lexicon defined via {@link BeanContext#BEAN_classLexicon} context property. + * </ol> + * + * @return The class lexicon in use for this class. Never <jk>null</jk>. + */ public ClassLexicon getClassLexicon() { return classLexicon; } http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/ObjectMap.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/ObjectMap.java b/juneau-core/src/main/java/org/apache/juneau/ObjectMap.java index 6edebf5..8fed80f 100644 --- a/juneau-core/src/main/java/org/apache/juneau/ObjectMap.java +++ b/juneau-core/src/main/java/org/apache/juneau/ObjectMap.java @@ -1153,6 +1153,14 @@ public class ObjectMap extends LinkedHashMap<String,Object> { return cast((ClassLexicon)null); } + /** + * Same as {@link #cast()}, but first do a lookup for the name in the specified lexicon. + * + * @param classLexicon + * The class lexicon to resolve the name. Can be <jk>null</jk>. + * @return The new Java object of type specified by the <js>"_class"</js> entry value, or this + * same object if entry does not exist. + */ public Object cast(ClassLexicon classLexicon) { String c = (String)get("_class"); if (c == null) { http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/annotation/Bean.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/annotation/Bean.java b/juneau-core/src/main/java/org/apache/juneau/annotation/Bean.java index 2d4b7a9..7a540db 100644 --- a/juneau-core/src/main/java/org/apache/juneau/annotation/Bean.java +++ b/juneau-core/src/main/java/org/apache/juneau/annotation/Bean.java @@ -49,7 +49,7 @@ public @interface Bean { * output so that the class can be determined during parsing. * It is also used to specify element names in XML. * <p> - * The name is used in combination with the lexicon defined through {@link #lexicon()}. Together, they make up + * The name is used in combination with the lexicon defined through {@link #classLexicon()}. Together, they make up * a simple name/value mapping of names to classes. * Names do not need to be universally unique. However, they must be unique within a lexicon. * @@ -110,7 +110,7 @@ public @interface Bean { * Note that the subclass MUST implement a no-arg constructor so that it can be instantiated. * </ul> */ - Class<?>[] lexicon() default {}; + Class<?>[] classLexicon() default {}; /** * The set and order of names of properties associated with a bean class. http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/annotation/BeanProperty.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/annotation/BeanProperty.java b/juneau-core/src/main/java/org/apache/juneau/annotation/BeanProperty.java index 9fa2557..83fe596 100644 --- a/juneau-core/src/main/java/org/apache/juneau/annotation/BeanProperty.java +++ b/juneau-core/src/main/java/org/apache/juneau/annotation/BeanProperty.java @@ -168,6 +168,20 @@ public @interface BeanProperty { */ String[] properties() default {}; - Class<?>[] lexicon() default {}; + /** + * The list of classes that make up the class lexicon for this bean proeprty. + * <p> + * The lexicon is a name/class mapping used to find class types during parsing when they cannot be inferred through reflection. + * The names are defined through the {@link #name()} annotation defined on the bean or POJO classes. + * <p> + * This list can consist of the following class types: + * <ul> + * <li>Any bean class that specifies a value for {@link Bean#name() @Bean.name()}; + * <li>Any POJO class that specifies a value for {@link Pojo#name() @Pojo.name()}; + * <li>Any subclass of {@link ClassLexicon} that defines an entire set of mappings. + * Note that the subclass MUST implement a no-arg constructor so that it can be instantiated. + * </ul> + */ + Class<?>[] classLexicon() default {}; } http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/annotation/Pojo.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/annotation/Pojo.java b/juneau-core/src/main/java/org/apache/juneau/annotation/Pojo.java index 9d615c1..cf58755 100644 --- a/juneau-core/src/main/java/org/apache/juneau/annotation/Pojo.java +++ b/juneau-core/src/main/java/org/apache/juneau/annotation/Pojo.java @@ -40,7 +40,7 @@ public @interface Pojo { * output so that the class can be determined during parsing. * It is also used to specify element names in XML. * <p> - * The name is used in combination with the lexicon defined through {@link #lexicon()}. Together, they make up + * The name is used in combination with the lexicon defined through {@link #classLexicon()}. Together, they make up * a simple name/value mapping of names to classes. * Names do not need to be universally unique. However, they must be unique within a lexicon. * @@ -101,7 +101,7 @@ public @interface Pojo { * Note that the subclass MUST implement a no-arg constructor so that it can be instantiated. * </ul> */ - Class<?>[] lexicon() default {}; + Class<?>[] classLexicon() default {}; /** * Associate a {@link PojoSwap} or {@link SurrogateSwap} with this class type. http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/transform/AnnotationBeanFilter.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/transform/AnnotationBeanFilter.java b/juneau-core/src/main/java/org/apache/juneau/transform/AnnotationBeanFilter.java index edbd589..167441a 100644 --- a/juneau-core/src/main/java/org/apache/juneau/transform/AnnotationBeanFilter.java +++ b/juneau-core/src/main/java/org/apache/juneau/transform/AnnotationBeanFilter.java @@ -38,11 +38,7 @@ public final class AnnotationBeanFilter<T> extends BeanFilter<T> { } private AnnotationBeanFilter(Builder<T> b) { - super(b.beanClass, b.properties, b.excludeProperties, b.interfaceClass, b.stopClass, b.sortProperties, b.propertyNamer); - - // Temp - setSubTypeProperty(b.subTypeProperty); - setSubTypes(b.subTypes); + super(b.beanClass, b.properties, b.excludeProperties, b.interfaceClass, b.stopClass, b.sortProperties, b.propertyNamer, b.classLexicon, b.subTypeProperty, b.subTypes); } private static class Builder<T> { @@ -53,6 +49,7 @@ public final class AnnotationBeanFilter<T> extends BeanFilter<T> { Class<?> stopClass; boolean sortProperties; PropertyNamer propertyNamer; + ClassLexicon classLexicon; String subTypeProperty; LinkedHashMap<Class<?>,String> subTypes = new LinkedHashMap<Class<?>,String>(); @@ -84,6 +81,8 @@ public final class AnnotationBeanFilter<T> extends BeanFilter<T> { if (b.stopClass() != Object.class) stopClass = b.stopClass(); + if (b.classLexicon().length > 0) + classLexicon = new ClassLexicon(b.classLexicon()); if (b.subTypes().length > 0) { subTypeProperty = b.subTypeProperty(); http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/main/java/org/apache/juneau/transform/BeanFilter.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/main/java/org/apache/juneau/transform/BeanFilter.java b/juneau-core/src/main/java/org/apache/juneau/transform/BeanFilter.java index 92c6199..17f5a59 100644 --- a/juneau-core/src/main/java/org/apache/juneau/transform/BeanFilter.java +++ b/juneau-core/src/main/java/org/apache/juneau/transform/BeanFilter.java @@ -68,11 +68,12 @@ public abstract class BeanFilter<T> { private final Class<T> beanClass; private final String[] properties, excludeProperties; - private LinkedHashMap<Class<?>, String> subTypes; - private String subTypeAttr; + private final Map<Class<?>, String> subTypes; + private final String subTypeAttr; private final PropertyNamer propertyNamer; private final Class<?> interfaceClass, stopClass; private final boolean sortProperties; + private final ClassLexicon classLexicon; /** * Constructor. @@ -143,9 +144,63 @@ public abstract class BeanFilter<T> { * Sort properties in alphabetical order. * @param propertyNamer * The property namer to use to name bean properties. + * @param classLexicon + * The class lexicon to use for resolving class identifier names from classes. + * @param subTypeProperty + * Defines a virtual property on a superclass that identifies bean subtype classes. + * <p> + * In the following example, the abstract class has two subclasses that are differentiated + * by a property called <code>subType</code> + * + * <p class='bcode'> + * <jc>// Abstract superclass</jc> + * <jk>public abstract class</jk> A { + * <jk>public</jk> String <jf>f0</jf> = <js>"f0"</js>; + * } + * + * <jc>// Subclass 1</jc> + * <jk>public class</jk> A1 <jk>extends</jk> A { + * <jk>public</jk> String <jf>f1</jf>; + * } + * + * <jc>// Subclass 2</jc> + * <jk>public class</jk> A2 <jk>extends</jk> A { + * <jk>public</jk> String <jf>f2</jf>; + * } + * + * <jc>// Filter for defining subtypes</jc> + * <jk>public class</jk> AFilter <jk>extends</jk> BeanFilter<A> { + * <jk>public</jk> AFilter() { + * <jk>super</jk>(A.<jk>class</jk>, <jk>null</jk>, <jk>null</jk>, <jk>null</jk>, <jk>null</jk>, <jk>false</jk>, <jk>null</jk>, <jk>null</jk>, <js>"subType"</js>, <jsm>createSubTypes</jsm>()) + * } + * <jk>private static</jk> Map<Class<?>,String> <jsm>createSubTypes</jsm>() { + * HashMap<Class<?>,String> m = new HashMap<Class<?>,String>(); + * m.put(A1.<jk>class</jk>,<js>"A1"</js>); + * m.put(A2.<jk>class</jk>,<js>"A2"</js>); + * <jk>return</jk> m; + * } + * } + * </p> + * <p> + * The following shows what happens when serializing a subclassed object to JSON: + * <p class='bcode'> + * JsonSerializer s = <jk>new</jk> JsonSerializer().addBeanFilters(AFilter.<jk>class</jk>); + * A1 a1 = <jk>new</jk> A1(); + * a1.<jf>f1</jf> = <js>"f1"</js>; + * String r = s.serialize(a1); + * <jsm>assertEquals</jsm>(<js>"{subType:'A1',f1:'f1',f0:'f0'}"</js>, r); + * </p> + * <p> + * The following shows what happens when parsing back into the original object. + * <p class='bcode'> + * JsonParser p = <jk>new</jk> JsonParser().addBeanFilters(AFilter.<jk>class</jk>); + * A a = p.parse(r, A.<jk>class</jk>); + * <jsm>assertTrue</jsm>(a <jk>instanceof</jk> A1); + * </p> + * @param subTypes */ @SuppressWarnings("unchecked") - public BeanFilter(Class<T> beanClass, String[] properties, String[] excludeProperties, Class<?> interfaceClass, Class<?> stopClass, boolean sortProperties, PropertyNamer propertyNamer) { + public BeanFilter(Class<T> beanClass, String[] properties, String[] excludeProperties, Class<?> interfaceClass, Class<?> stopClass, boolean sortProperties, PropertyNamer propertyNamer, ClassLexicon classLexicon, String subTypeProperty, Map<Class<?>,String> subTypes) { if (beanClass == null) { Class<?> c = this.getClass().getSuperclass(); @@ -177,6 +232,9 @@ public abstract class BeanFilter<T> { this.stopClass = stopClass; this.sortProperties = sortProperties; this.propertyNamer = propertyNamer; + this.classLexicon = classLexicon; + this.subTypeAttr = subTypeProperty; + this.subTypes = subTypes == null ? null : Collections.unmodifiableMap(subTypes); } /** @@ -186,7 +244,7 @@ public abstract class BeanFilter<T> { */ @SuppressWarnings("unchecked") public BeanFilter(Class<?> interfaceClass) { - this((Class<T>)interfaceClass, null, null, interfaceClass, null, false, null); + this((Class<T>)interfaceClass, null, null, interfaceClass, null, false, null, null, null, null); } /** @@ -195,7 +253,7 @@ public abstract class BeanFilter<T> { * @param properties */ public BeanFilter(String...properties) { - this(null, properties, null, null, null, false, null); + this(null, properties, null, null, null, false, null, null, null, null); } /** @@ -254,7 +312,6 @@ public abstract class BeanFilter<T> { /** * Returns the name of the sub type property associated with the bean class. * - * @see #setSubTypeProperty(String) * @return The sub type property name, or <jk>null</jk> if bean has no subtypes defined. */ public String getSubTypeProperty() { @@ -262,105 +319,24 @@ public abstract class BeanFilter<T> { } /** - * Defines a virtual property on a superclass that identifies bean subtype classes. - * <p> - * In the following example, the abstract class has two subclasses that are differentiated - * by a property called <code>subType</code> + * Returns the class lexicon to use for this bean. * - * <p class='bcode'> - * <jc>// Abstract superclass</jc> - * <jk>public abstract class</jk> A { - * <jk>public</jk> String <jf>f0</jf> = <js>"f0"</js>; - * } - * - * <jc>// Subclass 1</jc> - * <jk>public class</jk> A1 <jk>extends</jk> A { - * <jk>public</jk> String <jf>f1</jf>; - * } - * - * <jc>// Subclass 2</jc> - * <jk>public class</jk> A2 <jk>extends</jk> A { - * <jk>public</jk> String <jf>f2</jf>; - * } - * - * <jc>// Filter for defining subtypes</jc> - * <jk>public class</jk> AFilter <jk>extends</jk> BeanFilter<A> { - * <jk>public</jk> AFilter() { - * setSubTypeProperty(<js>"subType"</js>); - * addSubType(Al.<jk>class</jk>, <js>"A1"</js>); - * addSubType(A2.<jk>class</jk>, <js>"A2"</js>); - * } - * } - * </p> - * <p> - * The following shows what happens when serializing a subclassed object to JSON: - * <p class='bcode'> - * JsonSerializer s = <jk>new</jk> JsonSerializer().addBeanFilters(AFilter.<jk>class</jk>); - * A1 a1 = <jk>new</jk> A1(); - * a1.<jf>f1</jf> = <js>"f1"</js>; - * String r = s.serialize(a1); - * <jsm>assertEquals</jsm>(<js>"{subType:'A1',f1:'f1',f0:'f0'}"</js>, r); - * </p> - * <p> - * The following shows what happens when parsing back into the original object. - * <p class='bcode'> - * JsonParser p = <jk>new</jk> JsonParser().addBeanFilters(AFilter.<jk>class</jk>); - * A a = p.parse(r, A.<jk>class</jk>); - * <jsm>assertTrue</jsm>(a <jk>instanceof</jk> A1); - * </p> - * <p> - * This method is an alternative to using the {@link Bean#subTypeProperty()} annotation on a class. - * - * @param subTypeAttr The name of the attribute representing the subtype. - * @return This object (for method chaining). + * @return The class lexicon to use for this bean. */ - @Deprecated - public BeanFilter<T> setSubTypeProperty(String subTypeAttr) { - this.subTypeAttr = subTypeAttr; - return this; + public ClassLexicon getClassLexicon() { + return classLexicon; } /** * Returns the subtypes associated with the bean class. * - * @see #setSubTypeProperty(String) * @return The set of sub types associated with this bean class, or <jk>null</jk> if bean has no subtypes defined. */ - @Deprecated - public LinkedHashMap<Class<?>, String> getSubTypes() { + public Map<Class<?>, String> getSubTypes() { return subTypes; } /** - * Specifies the set of subclasses of this bean class in addition to a string identifier for that subclass. - * - * @see #setSubTypeProperty(String) - * @param subTypes the map of subtype classes to subtype identifier strings. - * @return This object (for method chaining). - */ - @Deprecated - public BeanFilter<T> setSubTypes(LinkedHashMap<Class<?>, String> subTypes) { - this.subTypes = subTypes; - return this; - } - - /** - * Convenience method for adding a single subtype in leu of using {@link #setSubTypes(LinkedHashMap)} in one call. - * - * @see #setSubTypeProperty(String) - * @param c The subtype class. - * @param id The subtype identifier string for the specified subtype class. - * @return This object (for method chaining). - */ - @Deprecated - public BeanFilter<T> addSubType(Class<?> c, String id) { - if (subTypes == null) - subTypes = new LinkedHashMap<Class<?>, String>(); - subTypes.put(c, id); - return this; - } - - /** * Returns the interface class associated with this class. * * @return The interface class associated with this class, or <jk>null</jk> if no interface class is associated. http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/test/java/org/apache/juneau/a/rttests/RoundTripBeanMapsTest.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/test/java/org/apache/juneau/a/rttests/RoundTripBeanMapsTest.java b/juneau-core/src/test/java/org/apache/juneau/a/rttests/RoundTripBeanMapsTest.java index 060f52a..4910217 100755 --- a/juneau-core/src/test/java/org/apache/juneau/a/rttests/RoundTripBeanMapsTest.java +++ b/juneau-core/src/test/java/org/apache/juneau/a/rttests/RoundTripBeanMapsTest.java @@ -357,10 +357,15 @@ public class RoundTripBeanMapsTest extends RoundTripTest { public static class CFilter extends BeanFilter<C> { public CFilter() { - setSubTypeProperty("subType"); - addSubType(C1.class, "C1"); - addSubType(C2.class, "C2"); - addSubType(C3.class, "C3"); + super(C.class, null, null, null, null, false, null, null, "subType", createSubTypes()); + } + + private static Map<Class<?>,String> createSubTypes() { + HashMap<Class<?>,String> m = new HashMap<Class<?>,String>(); + m.put(C1.class,"C1"); + m.put(C2.class,"C2"); + m.put(C3.class,"C3"); + return m; } } @@ -453,9 +458,9 @@ public class RoundTripBeanMapsTest extends RoundTripTest { public static class CAFilter extends BeanFilter<CA> { public CAFilter() { - setSubTypeProperty("subType"); - addSubType(CA1.class, "CA1"); - addSubType(CA2.class, "CA2"); + super(CA.class, null, null, null, null, false, null, null, "subType", + new HashMap<Class<?>,String>(){{put(CA1.class,"CA1");put(CA2.class,"CA2");}} + ); } } @@ -583,7 +588,7 @@ public class RoundTripBeanMapsTest extends RoundTripTest { } public static class E2Filter extends BeanFilter<E2> { public E2Filter() { - super(null, null, new String[]{"f2"}, null, null, false, null); + super(null, null, new String[]{"f2"}, null, null, false, null, null, null, null); } } http://git-wip-us.apache.org/repos/asf/incubator-juneau/blob/94b52bd1/juneau-core/src/test/java/org/apache/juneau/html/CommonTest.java ---------------------------------------------------------------------- diff --git a/juneau-core/src/test/java/org/apache/juneau/html/CommonTest.java b/juneau-core/src/test/java/org/apache/juneau/html/CommonTest.java index cbe2137..dacb28f 100755 --- a/juneau-core/src/test/java/org/apache/juneau/html/CommonTest.java +++ b/juneau-core/src/test/java/org/apache/juneau/html/CommonTest.java @@ -23,7 +23,6 @@ import java.util.*; import org.apache.juneau.*; import org.apache.juneau.annotation.*; -import org.apache.juneau.jena.annotation.*; import org.apache.juneau.serializer.*; import org.apache.juneau.testbeans.*; import org.apache.juneau.xml.*;
