Working on refactoring auto-detection handling.
diff --git a/src/java/org/codehaus/jackson/annotate/JsonAutoDetect.java b/src/java/org/codehaus/jackson/annotate/JsonAutoDetect.java
index b3d0c89..8eac37e 100644
--- a/src/java/org/codehaus/jackson/annotate/JsonAutoDetect.java
+++ b/src/java/org/codehaus/jackson/annotate/JsonAutoDetect.java
@@ -69,7 +69,14 @@
* this can be essentially used to disable auto-detection for specified
* types.
*/
- NONE;
+ NONE,
+
+ /**
+ * Value that indicates that default visibility level (whatever it is,
+ * depends on context) is to be used. This usually means that inherited
+ * value (from parent visibility settings) is to be used.
+ */
+ DEFAULT;
public boolean isVisible(Member m) {
switch (this) {
@@ -98,24 +105,39 @@
JsonMethod[] value() default { JsonMethod.ALL };
/**
- * Minimum visibility required for auto-detecting getter methods.
+ * Minimum visibility required for auto-detecting regular getter methods.
+ *
+ * @since 1.5
*/
Visibility getterVisibility() default Visibility.PUBLIC_ONLY;
/**
+ * Minimum visibility required for auto-detecting is-getter methods.
+ *
+ * @since 1.5
+ */
+ Visibility isGetterVisibility() default Visibility.PUBLIC_ONLY;
+
+ /**
* Minimum visibility required for auto-detecting setter methods.
+ *
+ * @since 1.5
*/
Visibility setterVisibility() default Visibility.ANY;
/**
- * Minimum visibility required for auto-detecting member fields.
- */
- Visibility fieldVisibility() default Visibility.PUBLIC_ONLY;
-
- /**
* Minimum visibility required for auto-detecting Creator methods,
* except for no-argument constructors (which are always detected
* no matter what).
+ *
+ * @since 1.5
*/
Visibility creatorVisibility() default Visibility.PUBLIC_ONLY;
+
+ /**
+ * Minimum visibility required for auto-detecting member fields.
+ *
+ * @since 1.5
+ */
+ Visibility fieldVisibility() default Visibility.PUBLIC_ONLY;
}
diff --git a/src/mapper/java/org/codehaus/jackson/map/AnnotationIntrospector.java b/src/mapper/java/org/codehaus/jackson/map/AnnotationIntrospector.java
index b5c5818..5bc9226 100644
--- a/src/mapper/java/org/codehaus/jackson/map/AnnotationIntrospector.java
+++ b/src/mapper/java/org/codehaus/jackson/map/AnnotationIntrospector.java
@@ -95,15 +95,6 @@
public abstract Boolean findCachability(AnnotatedClass ac);
/**
- * Method for checking whether there is a class annotation that
- * indicates whether field auto detection should be enabled.
- *
- * @return null if no relevant annotation is located; Boolean.TRUE
- * if enabling annotation found, Boolean.FALSE if disabling annotation
- */
- public abstract Boolean findFieldAutoDetection(AnnotatedClass ac);
-
- /**
* Method for locating name used as "root name" (for use by
* some serializers when outputting root-level object -- mostly
* for XML compatibility purposes) for given class, if one
@@ -133,6 +124,79 @@
public abstract Boolean findIgnoreUnknownProperties(AnnotatedClass ac);
/*
+ /******************************************************
+ /* Property auto-detection
+ /******************************************************
+ */
+
+ /**
+ * Method for checking whether there is a class annotation that
+ * indicates whether field auto detection should be enabled.
+ *
+ * @return null if no relevant annotation is located; Boolean.TRUE
+ * if enabling annotation found, Boolean.FALSE if disabling annotation
+ */
+ public abstract Boolean findFieldAutoDetection(AnnotatedClass ac);
+
+
+ /**
+ * Method for checking whether there is a class annotation that
+ * indicates whether (regular) getter-method auto detection
+ * should be enabled.
+ * Getter methods are methods with name "getXxx()" (for property "xxx");
+ * "isXxx()" are not included (instead those are considered
+ * "is getters")
+ *
+ * @return null if no relevant annotation is located; Boolean.TRUE
+ * if enabling annotation found, Boolean.FALSE if disabling annotation
+ */
+ public abstract Boolean findGetterAutoDetection(AnnotatedClass ac);
+
+ /**
+ * Method for checking whether there is a class annotation that
+ * indicates whether getter-method auto-detection for "is getters"
+ * should be enabled.
+ * Is-getter methods are methods with name "isXxx()" (for property "xxx").
+ *
+ * @since 1.3
+ *
+ * @return null if no relevant annotation is located; Boolean.TRUE
+ * if enabling annotation found, Boolean.FALSE if disabling annotation
+ */
+ public abstract Boolean findIsGetterAutoDetection(AnnotatedClass ac);
+
+ /**
+ * Method for checking whether there is a class annotation that
+ * indicates whether creator-method auto detection should be enabled.
+ *
+ * @return null if no relevant annotation is located; Boolean.TRUE
+ * if enabling annotation found, Boolean.FALSE if disabling annotation
+ */
+ public abstract Boolean findCreatorAutoDetection(AnnotatedClass ac);
+
+ /**
+ * Method for checking whether there is a class annotation that
+ * indicates whether setter-method auto detection should be enabled.
+ *
+ * @return null if no relevant annotation is located; Boolean.TRUE
+ * if enabling annotation found, Boolean.FALSE if disabling annotation
+ */
+ public abstract Boolean findSetterAutoDetection(AnnotatedClass ac);
+
+
+ /**
+ * Method for checking if annotations indicate changes to minimum visibility levels
+ * needed for auto-detecting property elements (fields, methods, constructors).
+ * A baseline checker is given, and introspector is to either return it as is (if
+ * no annotations are found), or build and return a derived instance (using checker's build
+ * methods).
+ *
+ * @since 1.5
+ */
+ public abstract VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac,
+ VisibilityChecker<?> baseChecker);
+
+ /*
/****************************************************
/* Class annotations for PM type handling (1.5+)
/****************************************************
@@ -324,34 +388,6 @@
*/
/**
- * Method for checking whether there is a class annotation that
- * indicates whether (regular) getter-method auto detection
- * should be enabled.
- * Getter methods are methods with name "getXxx()" (for property "xxx");
- * "isXxx()" are not included (instead those are considered
- * "is getters")
- *
- * @return null if no relevant annotation is located; Boolean.TRUE
- * if enabling annotation found, Boolean.FALSE if disabling annotation
- */
- public abstract Boolean findGetterAutoDetection(AnnotatedClass ac);
-
- /**
- * Method for checking whether there is a class annotation that
- * indicates whether (regular) getter-method auto detection
- * should be enabled.
- * Getter methods are methods with name "getXxx()" (for property "xxx");
- * "isXxx()" are not included (instead those are considered
- * "is getters")
- *
- * @since 1.3
- *
- * @return null if no relevant annotation is located; Boolean.TRUE
- * if enabling annotation found, Boolean.FALSE if disabling annotation
- */
- public abstract Boolean findIsGetterAutoDetection(AnnotatedClass ac);
-
- /**
* Method for accessing defined property serialization order (which may be
* partial). May return null if no ordering is defined.
*
@@ -519,24 +555,6 @@
/******************************************************
*/
- /**
- * Method for checking whether there is a class annotation that
- * indicates whether creator-method auto detection should be enabled.
- *
- * @return null if no relevant annotation is located; Boolean.TRUE
- * if enabling annotation found, Boolean.FALSE if disabling annotation
- */
- public abstract Boolean findCreatorAutoDetection(AnnotatedClass ac);
-
- /**
- * Method for checking whether there is a class annotation that
- * indicates whether setter-method auto detection should be enabled.
- *
- * @return null if no relevant annotation is located; Boolean.TRUE
- * if enabling annotation found, Boolean.FALSE if disabling annotation
- */
- public abstract Boolean findSetterAutoDetection(AnnotatedClass ac);
-
/*
///////////////////////////////////////////////////////
// Deserialization: method annotations
@@ -685,16 +703,6 @@
}
return result;
}
-
- @Override
- public Boolean findFieldAutoDetection(AnnotatedClass ac)
- {
- Boolean result = _primary.findFieldAutoDetection(ac);
- if (result == null) {
- result = _secondary.findFieldAutoDetection(ac);
- }
- return result;
- }
@Override
public String findRootName(AnnotatedClass ac)
@@ -730,6 +738,79 @@
return result;
}
+ /*
+ /******************************************************
+ /* Property auto-detection
+ /******************************************************
+ */
+
+ @Override
+ public Boolean findFieldAutoDetection(AnnotatedClass ac)
+ {
+ Boolean result = _primary.findFieldAutoDetection(ac);
+ if (result == null) {
+ result = _secondary.findFieldAutoDetection(ac);
+ }
+ return result;
+ }
+
+ @Override
+ public Boolean findGetterAutoDetection(AnnotatedClass ac)
+ {
+ Boolean result = _primary.findGetterAutoDetection(ac);
+ if (result == null) {
+ result = _secondary.findGetterAutoDetection(ac);
+ }
+ return result;
+ }
+
+ @Override
+ public Boolean findIsGetterAutoDetection(AnnotatedClass ac)
+ {
+ Boolean result = _primary.findIsGetterAutoDetection(ac);
+ if (result == null) {
+ result = _secondary.findIsGetterAutoDetection(ac);
+ }
+ return result;
+ }
+
+ @Override
+ public Boolean findCreatorAutoDetection(AnnotatedClass ac)
+ {
+ Boolean result = _primary.findCreatorAutoDetection(ac);
+ if (result == null) {
+ result = _secondary.findCreatorAutoDetection(ac);
+ }
+ return result;
+ }
+
+ @Override
+ public Boolean findSetterAutoDetection(AnnotatedClass ac)
+ {
+ Boolean result = _primary.findSetterAutoDetection(ac);
+ if (result == null) {
+ result = _secondary.findSetterAutoDetection(ac);
+ }
+ return result;
+ }
+
+ @Override
+ public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac,
+ VisibilityChecker<?> checker)
+ {
+ /* Note: to have proper priorities, we must actually call delegatees
+ * in reverse order:
+ */
+ checker = _secondary.findAutoDetectVisibility(ac, checker);
+ return _primary.findAutoDetectVisibility(ac, checker);
+ }
+
+ /*
+ /******************************************************
+ /* Type handling
+ /******************************************************
+ */
+
@Override
public TypeResolverBuilder<?> findTypeResolver(AnnotatedClass ac, JavaType baseType)
{
@@ -877,25 +958,6 @@
// // // Serialization: class annotations
- @Override
- public Boolean findGetterAutoDetection(AnnotatedClass ac)
- {
- Boolean result = _primary.findGetterAutoDetection(ac);
- if (result == null) {
- result = _secondary.findGetterAutoDetection(ac);
- }
- return result;
- }
-
- @Override
- public Boolean findIsGetterAutoDetection(AnnotatedClass ac)
- {
- Boolean result = _primary.findIsGetterAutoDetection(ac);
- if (result == null) {
- result = _secondary.findIsGetterAutoDetection(ac);
- }
- return result;
- }
public String[] findSerializationPropertyOrder(AnnotatedClass ac) {
String[] result = _primary.findSerializationPropertyOrder(ac);
@@ -1039,27 +1101,6 @@
return result;
}
- // // // Deserialization: class annotations
-
- @Override
- public Boolean findCreatorAutoDetection(AnnotatedClass ac)
- {
- Boolean result = _primary.findCreatorAutoDetection(ac);
- if (result == null) {
- result = _secondary.findCreatorAutoDetection(ac);
- }
- return result;
- }
-
- @Override
- public Boolean findSetterAutoDetection(AnnotatedClass ac)
- {
- Boolean result = _primary.findSetterAutoDetection(ac);
- if (result == null) {
- result = _secondary.findSetterAutoDetection(ac);
- }
- return result;
- }
// // // Deserialization: method annotations
diff --git a/src/mapper/java/org/codehaus/jackson/map/introspect/JacksonAnnotationIntrospector.java b/src/mapper/java/org/codehaus/jackson/map/introspect/JacksonAnnotationIntrospector.java
index 26bb0e9..73c4c4b 100644
--- a/src/mapper/java/org/codehaus/jackson/map/introspect/JacksonAnnotationIntrospector.java
+++ b/src/mapper/java/org/codehaus/jackson/map/introspect/JacksonAnnotationIntrospector.java
@@ -119,6 +119,14 @@
return (ignore == null) ? null : ignore.ignoreUnknown();
}
+ @Override
+ public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac,
+ VisibilityChecker<?> checker)
+ {
+ JsonAutoDetect ann = ac.getAnnotation(JsonAutoDetect.class);
+ return (ann == null) ? checker : checker.with(ann);
+ }
+
/*
/****************************************************
/* Class annotations for PM type handling (1.5+)
diff --git a/src/mapper/java/org/codehaus/jackson/map/introspect/NopAnnotationIntrospector.java b/src/mapper/java/org/codehaus/jackson/map/introspect/NopAnnotationIntrospector.java
index d0c2edf..6c7a022 100644
--- a/src/mapper/java/org/codehaus/jackson/map/introspect/NopAnnotationIntrospector.java
+++ b/src/mapper/java/org/codehaus/jackson/map/introspect/NopAnnotationIntrospector.java
@@ -85,6 +85,11 @@
return null;
}
+ @Override
+ public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker) {
+ return checker;
+ }
+
/*
/****************************************************
/* Class annotations for PM type handling (1.5+)
diff --git a/src/mapper/java/org/codehaus/jackson/map/introspect/VisibilityChecker.java b/src/mapper/java/org/codehaus/jackson/map/introspect/VisibilityChecker.java
index 073006c..3b13e4b 100644
--- a/src/mapper/java/org/codehaus/jackson/map/introspect/VisibilityChecker.java
+++ b/src/mapper/java/org/codehaus/jackson/map/introspect/VisibilityChecker.java
@@ -2,6 +2,7 @@
import org.codehaus.jackson.annotate.JsonAutoDetect;
import org.codehaus.jackson.annotate.JsonAutoDetect.Visibility;
+import org.codehaus.jackson.annotate.JsonMethod;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
@@ -20,140 +21,271 @@
*/
public interface VisibilityChecker<T extends VisibilityChecker<T>>
{
- // // Builder
+ // // Builder methods
- public T withGetterVisibility(Visibility v);
- public T withSetterVisibility(Visibility v);
- public T withCreatorVisibility(Visibility v);
- public T withFieldVisibility(Visibility v);
+ /**
+ * Builder method that will return an instance that has same
+ * settings as this instance has, except for values that
+ * given annotation overrides.
+ */
+ public T with(JsonAutoDetect ann);
+
+ /**
+ * Builder method that will return a checker instance that has
+ * specified minimum visibility level for regular ("getXxx") getters.
+ */
+ public T withGetterVisibility(Visibility v);
+
+ /**
+ * Builder method that will return a checker instance that has
+ * specified minimum visibility level for "is-getters" ("isXxx").
+ */
+ public T withIsGetterVisibility(Visibility v);
+
+ /**
+ * Builder method that will return a checker instance that has
+ * specified minimum visibility level for setters.
+ */
+ public T withSetterVisibility(Visibility v);
+
+ /**
+ * Builder method that will return a checker instance that has
+ * specified minimum visibility level for creator methods
+ * (constructors, factory methods)
+ */
+ public T withCreatorVisibility(Visibility v);
+
+ /**
+ * Builder method that will return a checker instance that has
+ * specified minimum visibility level for fields.
+ */
+ public T withFieldVisibility(Visibility v);
- // // Accessors
+ // // Accessors
- public boolean isGetterVisible(Method m);
- public boolean isGetterVisible(AnnotatedMethod m);
+ /**
+ * Method for checking whether given method is auto-detectable
+ * as regular getter, with respect to its visibility (not considering
+ * method signature or name, just visibility)
+ */
+ public boolean isGetterVisible(Method m);
+ public boolean isGetterVisible(AnnotatedMethod m);
- public boolean isSetterVisible(Method m);
- public boolean isSetterVisible(AnnotatedMethod m);
+ /**
+ * Method for checking whether given method is auto-detectable
+ * as is-getter, with respect to its visibility (not considering
+ * method signature or name, just visibility)
+ */
+ public boolean isIsGetterVisible(Method m);
+ public boolean isIsGetterVisible(AnnotatedMethod m);
+
+ /**
+ * Method for checking whether given method is auto-detectable
+ * as setter, with respect to its visibility (not considering
+ * method signature or name, just visibility)
+ */
+ public boolean isSetterVisible(Method m);
+ public boolean isSetterVisible(AnnotatedMethod m);
- public boolean isCreatorVisible(Member m);
- public boolean isCreatorVisible(AnnotatedMember m);
+ /**
+ * Method for checking whether given method is auto-detectable
+ * as Creator, with respect to its visibility (not considering
+ * method signature or name, just visibility)
+ */
+ public boolean isCreatorVisible(Member m);
+ public boolean isCreatorVisible(AnnotatedMember m);
- public boolean isFieldVisible(Field f);
- public boolean isFieldVisible(AnnotatedField f);
+ /**
+ * Method for checking whether given field is auto-detectable
+ * as property, with respect to its visibility (not considering
+ * method signature or name, just visibility)
+ */
+ public boolean isFieldVisible(Field f);
+ public boolean isFieldVisible(AnnotatedField f);
- /*
- /********************************************************
+ /*
+ /********************************************************
/* Standard implementation suitable for basic use
- /********************************************************
- */
+ /********************************************************
+ */
+
+ /**
+ * Default standard implementation is purely based on visibility
+ * modifier of given class members, and its configured minimum
+ * levels.
+ * Implemented using "builder" (aka "Fluid") pattern, whereas instances
+ * are immutable, and configuration is achieved by chainable factory
+ * methods. As a result, type is declared is funky recursive generic
+ * type, to allow for sub-classing of build methods with property type
+ * co-variance.
+ *<p>
+ * Note on <code>JsonAutoDetect</code> annotation: it is used to
+ * access default minimum visibility access definitions.
+ */
+ @JsonAutoDetect(
+ getterVisibility = Visibility.PUBLIC_ONLY,
+ isGetterVisibility = Visibility.PUBLIC_ONLY,
+ setterVisibility = Visibility.ANY,
+ creatorVisibility = Visibility.PUBLIC_ONLY,
+ fieldVisibility = Visibility.PUBLIC_ONLY
+ )
+ public static class Std
+ implements VisibilityChecker<Std>
+ {
+ protected final Visibility _getterMinLevel;
+ protected final Visibility _isGetterMinLevel;
+ protected final Visibility _setterMinLevel;
+ protected final Visibility _creatorMinLevel;
+ protected final Visibility _fieldMinLevel;
+
+ /**
+ * Default constructor; will construct an instance that uses default
+ * Jackson visibility limits, as indicated by {@link JsonAutoDetect}
+ * settings for this class.
+ */
+ public Std() {
+ this(Std.class.getAnnotation(JsonAutoDetect.class));
+ }
+
+ /**
+ * Constructor used for building instance that has minumum visibility
+ * levels as indicated by given annotation instance
+ *
+ * @param ann Annotations to use for determining minimum visibility levels
+ */
+ public Std(JsonAutoDetect ann)
+ {
+ JsonMethod[] incl = ann.value();
+ // let's combine checks for enabled/disabled, with minimimum level checks:
+ _getterMinLevel = hasMethod(incl, JsonMethod.GETTER) ? ann.getterVisibility() : Visibility.NONE;
+ _isGetterMinLevel = hasMethod(incl, JsonMethod.IS_GETTER) ? ann.isGetterVisibility() : Visibility.NONE;
+ _setterMinLevel = hasMethod(incl, JsonMethod.SETTER) ? ann.setterVisibility() : Visibility.NONE;
+ _creatorMinLevel = hasMethod(incl, JsonMethod.CREATOR) ? ann.creatorVisibility() : Visibility.NONE;
+ _fieldMinLevel = hasMethod(incl, JsonMethod.FIELD) ? ann.fieldVisibility() : Visibility.NONE;
+ }
/**
- * Default standard implementation is purely based on visibility
- * modifier of given class members, and its configured minimum
- * levels.
- * Implemented using "builder" (aka "Fluid") pattern, whereas instances
- * are immutable, and configuration is achieved by chainable factory
- * methods. As a result, type is declared is funky recursive generic
- * type, to allow for sub-classing of build methods with property type
- * co-variance.
- *<p>
- * Note on <code>JsonAutoDetect</code> annotation: it is used to
- * access default minimum visibility access needed.
+ * Constructor that allows directly specifying minimum visibility levels to use
*/
- @JsonAutoDetect()
- public static class Std
- implements VisibilityChecker<Std>
- {
- protected final Visibility _getterMinLevel;
- protected final Visibility _setterMinLevel;
- protected final Visibility _creatorMinLevel;
- protected final Visibility _fieldMinLevel;
+ public Std(Visibility getter, Visibility isGetter, Visibility setter, Visibility creator, Visibility field)
+ {
+ _getterMinLevel = getter;
+ _isGetterMinLevel = isGetter;
+ _setterMinLevel = setter;
+ _creatorMinLevel = creator;
+ _fieldMinLevel = field;
+ }
- /**
- * Default constructor uses default {@link JsonAutoDetect}
- * limits.
- */
- public Std() {
- this(Std.class.getAnnotation(JsonAutoDetect.class));
- }
+ /*
+ /********************************************************
+ /* Builder/fluid methods for instantiating configured
+ /* instances
+ /********************************************************
+ */
- public Std(JsonAutoDetect ann)
- {
- _getterMinLevel = ann.getterVisibility();
- _setterMinLevel = ann.setterVisibility();
- _creatorMinLevel = ann.creatorVisibility();
- _fieldMinLevel = ann.fieldVisibility();
- }
+ public Std with(JsonAutoDetect ann)
+ {
+ if (ann == null) return this;
+ Std curr = this;
+
+ JsonMethod[] incl = ann.value();
+ Visibility v;
+
+ v = hasMethod(incl, JsonMethod.GETTER) ? ann.getterVisibility() : Visibility.NONE;
+ curr = curr.withGetterVisibility(v);
+ v = hasMethod(incl, JsonMethod.IS_GETTER) ? ann.isGetterVisibility() : Visibility.NONE;
+ curr = curr.withIsGetterVisibility(v);
+ v = hasMethod(incl, JsonMethod.SETTER) ? ann.setterVisibility() : Visibility.NONE;
+ curr = curr.withSetterVisibility(v);
+ v = hasMethod(incl, JsonMethod.CREATOR) ? ann.creatorVisibility() : Visibility.NONE;
+ curr = curr.withCreatorVisibility(v);
+ v = hasMethod(incl, JsonMethod.FIELD) ? ann.fieldVisibility() : Visibility.NONE;
+ curr = curr.withFieldVisibility(v);
+ return curr;
+ }
+
+ public Std withGetterVisibility(Visibility v) {
+ if (_getterMinLevel == v || v == Visibility.DEFAULT) return this;
+ return new Std(v, _isGetterMinLevel, _setterMinLevel, _creatorMinLevel, _fieldMinLevel);
+ }
+
+ public Std withIsGetterVisibility(Visibility v) {
+ if (_isGetterMinLevel == v || v == Visibility.DEFAULT) return this;
+ return new Std(_getterMinLevel, v, _setterMinLevel, _creatorMinLevel, _fieldMinLevel);
+ }
- public Std(Visibility getter, Visibility setter, Visibility creator, Visibility field)
- {
- _getterMinLevel = getter;
- _setterMinLevel = setter;
- _creatorMinLevel = creator;
- _fieldMinLevel = field;
- }
+ public Std withSetterVisibility(Visibility v) {
+ if (_setterMinLevel == v || v == Visibility.DEFAULT) return this;
+ return new Std(_getterMinLevel, _isGetterMinLevel, v, _creatorMinLevel, _fieldMinLevel);
+ }
+
+ public Std withCreatorVisibility(Visibility v) {
+ if (_creatorMinLevel == v || v == Visibility.DEFAULT) return this;
+ return new Std(_getterMinLevel, _isGetterMinLevel, _setterMinLevel, v, _fieldMinLevel);
+ }
+
+ public Std withFieldVisibility(Visibility v) {
+ if (_fieldMinLevel == v || v == Visibility.DEFAULT) return this;
+ return new Std(_getterMinLevel, _isGetterMinLevel, _setterMinLevel, _creatorMinLevel, v);
+ }
- /*
- /********************************************************
- /* Builder/fluid methods for instantiating configured
- /* instances
- /********************************************************
- */
+ /*
+ /********************************************************
+ /* Public API impl
+ /********************************************************
+ */
- public Std withGetterVisibility(Visibility v) {
- return new Std(v, _setterMinLevel, _creatorMinLevel, _fieldMinLevel);
- }
+ public boolean isCreatorVisible(Member m) {
+ return _creatorMinLevel.isVisible(m);
+ }
+
+ public boolean isCreatorVisible(AnnotatedMember m) {
+ return isCreatorVisible(m.getMember());
+ }
+
+ public boolean isFieldVisible(Field f) {
+ return _fieldMinLevel.isVisible(f);
+ }
+
+ public boolean isFieldVisible(AnnotatedField f) {
+ return isFieldVisible(f.getAnnotated());
+ }
+
+ public boolean isGetterVisible(Method m) {
+ return _getterMinLevel.isVisible(m);
+ }
+ public boolean isGetterVisible(AnnotatedMethod m) {
+ return isGetterVisible(m.getAnnotated());
+ }
- public Std withSetterVisibility(Visibility v) {
- return new Std(_getterMinLevel, v, _creatorMinLevel, _fieldMinLevel);
- }
+ public boolean isIsGetterVisible(Method m) {
+ return _isGetterMinLevel.isVisible(m);
+ }
- public Std withCreatorVisibility(Visibility v) {
- return new Std(_getterMinLevel, _setterMinLevel, v, _fieldMinLevel);
- }
+ public boolean isIsGetterVisible(AnnotatedMethod m) {
+ return isIsGetterVisible(m.getAnnotated());
+ }
- public Std withFieldVisibility(Visibility v) {
- return new Std(_getterMinLevel, _setterMinLevel, _creatorMinLevel, v);
- }
-
- /*
- /********************************************************
- /* Public API impl
- /********************************************************
- */
+ public boolean isSetterVisible(Method m) {
+ return _setterMinLevel.isVisible(m);
+ }
+
+ public boolean isSetterVisible(AnnotatedMethod m) {
+ return isSetterVisible(m.getAnnotated());
+ }
-
- public boolean isCreatorVisible(Member m) {
- return _creatorMinLevel.isVisible(m);
- }
-
- public boolean isCreatorVisible(AnnotatedMember m) {
- return isCreatorVisible(m.getMember());
- }
-
- public boolean isFieldVisible(Field f) {
- return _fieldMinLevel.isVisible(f);
- }
-
- public boolean isFieldVisible(AnnotatedField f) {
- return isFieldVisible(f.getAnnotated());
- }
-
- public boolean isGetterVisible(Method m) {
- return _getterMinLevel.isVisible(m);
- }
-
- public boolean isGetterVisible(AnnotatedMethod m) {
- return isGetterVisible(m.getAnnotated());
- }
-
- public boolean isSetterVisible(Method m) {
- return _setterMinLevel.isVisible(m);
- }
-
- public boolean isSetterVisible(AnnotatedMethod m) {
- return isSetterVisible(m.getAnnotated());
- }
+ /*
+ /********************************************************
+ /* Helper methods
+ /********************************************************
+ */
+
+ private static boolean hasMethod(JsonMethod[] methods, JsonMethod method)
+ {
+ for (JsonMethod curr : methods) {
+ if (curr == method || curr == JsonMethod.ALL) return true;
+ }
+ return false;
+ }
}
-
}
diff --git a/src/xc/java/org/codehaus/jackson/xc/JaxbAnnotationIntrospector.java b/src/xc/java/org/codehaus/jackson/xc/JaxbAnnotationIntrospector.java
index be49a8c..c586c55 100644
--- a/src/xc/java/org/codehaus/jackson/xc/JaxbAnnotationIntrospector.java
+++ b/src/xc/java/org/codehaus/jackson/xc/JaxbAnnotationIntrospector.java
@@ -13,6 +13,7 @@
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapter;
import javax.xml.bind.annotation.adapters.XmlJavaTypeAdapters;
+import org.codehaus.jackson.annotate.JsonAutoDetect.Visibility;
import org.codehaus.jackson.annotate.JsonTypeInfo;
import org.codehaus.jackson.map.AnnotationIntrospector;
import org.codehaus.jackson.map.JsonDeserializer;
@@ -28,18 +29,19 @@
/**
* Annotation introspector that leverages JAXB annotations where applicable to JSON mapping.
* <p/>
- * The following JAXB annotations were determined to be not-applicable:
+ * The following JAXB annotations are not supported yet (but some may be supported in future)
* <ul>
- * <li>{@link XmlAnyAttribute} because it applies only to Map<QName, String>, which jackson can't serialize
- * <li>{@link XmlAnyElement} because it applies only to JAXBElement, which jackson can't serialize
- * <li>{@link javax.xml.bind.annotation.XmlAttachmentRef}: JSON does not support
- * external attachments
+ * <li>{@link XmlAnyAttribute} not yet used (as of 1.5) but may be in future (as an alias for @JsonAnySetter?)
+ * <li>{@link XmlAnyElement} not yet used, may be as per [JACKSON-253]
+ * <li>{@link javax.xml.bind.annotation.XmlAttachmentRef}: JSON does not support external attachments
* <li>{@link XmlElementDecl}
- * <li>{@link XmlElementRefs} because Jackson doesn't have any support for 'named' collection items.
- * <li>{@link XmlID} because Jackson doesn't support referential integrity.
- * <li>{@link XmlIDREF} because the is no JSON support for referential integrity.
+ * <li>{@link XmlElementRefs} because Jackson doesn't have any support for 'named' collection items -- however,
+ * this may become partially supported as per [JACKSON-253].
+ * <li>{@link XmlID} because Jackson doesn't support referential integrity. NOTE: this too may be supported
+ * in future if/when id references are handled
+ * <li>{@link XmlIDREF} same as <code>XmlID</code>
* <li>{@link javax.xml.bind.annotation.XmlInlineBinaryData} since the underlying concepts
- * (like XOP) do not exist in JSON
+ * (like XOP) do not exist in JSON -- Jackson will always use inline base64 encoding as the method
* <li>{@link javax.xml.bind.annotation.XmlList} because JSON does have (or necessarily need)
* method of serializing list of values as space-separated Strings
* <li>{@link javax.xml.bind.annotation.XmlMimeType}
@@ -227,6 +229,45 @@
return null;
}
+ @Override
+ public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac,
+ VisibilityChecker<?> checker)
+ {
+ XmlAccessType at = findAccessType(ac);
+ if (at == null) return checker;
+
+ // Note: JAXB does not do creator auto-detection, can ignore
+ switch (at) {
+ case FIELD: // all fields, independent of visibility; no methods
+ return checker.withFieldVisibility(Visibility.ANY)
+ .withSetterVisibility(Visibility.NONE)
+ .withGetterVisibility(Visibility.NONE)
+ .withIsGetterVisibility(Visibility.NONE)
+ ;
+ case NONE: // no auto-detection
+ return checker.withFieldVisibility(Visibility.NONE)
+ .withSetterVisibility(Visibility.NONE)
+ .withGetterVisibility(Visibility.NONE)
+ .withIsGetterVisibility(Visibility.NONE)
+ ;
+ case PROPERTY:
+ return checker.withFieldVisibility(Visibility.NONE)
+ .withSetterVisibility(Visibility.PUBLIC_ONLY)
+ .withGetterVisibility(Visibility.PUBLIC_ONLY)
+ .withIsGetterVisibility(Visibility.PUBLIC_ONLY)
+ ;
+ case PUBLIC_MEMBER:
+ return checker.withFieldVisibility(Visibility.PUBLIC_ONLY)
+ .withSetterVisibility(Visibility.PUBLIC_ONLY)
+ .withGetterVisibility(Visibility.PUBLIC_ONLY)
+ .withIsGetterVisibility(Visibility.PUBLIC_ONLY)
+ ;
+ //boolean enabled = (at == XmlAccessType.PUBLIC_MEMBER) || (at == XmlAccessType.PROPERTY);
+ //return enabled ? Boolean.TRUE : Boolean.FALSE;
+ }
+ return checker;
+ }
+
/*
/****************************************************
/* Class annotations for PM type handling (1.5+)
