Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
   package com.fasterxml.jackson.module.jaxb;
   
   import java.lang.reflect.*;
   import java.util.*;
   
   import javax.xml.bind.*;
  
  
Annotation introspector that leverages JAXB annotations where applicable to JSON mapping. As of Jackson 2.0, most JAXB annotations are supported at least to some degree. Ones that are NOT yet supported are: Note also the following limitations:
  
  public class JaxbAnnotationIntrospector
      extends AnnotationIntrospector
      implements Versioned
  {
      protected final static boolean DEFAULT_IGNORE_XMLIDREF = false;
      
      protected final static String MARKER_FOR_DEFAULT = "##default";
      
      protected final String _jaxbPackageName;
      protected final JsonSerializer<?> _dataHandlerSerializer;
      protected final JsonDeserializer<?> _dataHandlerDeserializer;
  
      protected final TypeFactory _typeFactory;
      
      protected final boolean _ignoreXmlIDREF;
    
    

Deprecated:
Since 2.1, use the ctor that takes TypeFactory
  
      @Deprecated
      public JaxbAnnotationIntrospector() {
          this(TypeFactory.defaultInstance());
      }
  
      public JaxbAnnotationIntrospector(MapperConfig<?> config) {
          this(config.getTypeFactory());
      }
  
      public JaxbAnnotationIntrospector(TypeFactory typeFactory) {
          this(typeFactory);
      }

    

Parameters:
typeFactory Type factory used for resolving type information
ignoreXmlIDREF Whether javax.xml.bind.annotation.XmlIDREF annotation should be processed JAXB style (meaning that references are always serialized using id), or not (first reference as full POJO, others as ids)
 
     public JaxbAnnotationIntrospector(TypeFactory typeFactoryboolean ignoreXmlIDREF)
     {
          = (typeFactory == null)? TypeFactory.defaultInstance() : typeFactory;
          = ignoreXmlIDREF;
          = XmlElement.class.getPackage().getName();
 
         JsonSerializer<?> dataHandlerSerializer = null;
         JsonDeserializer<?> dataHandlerDeserializer = null;
         /* Data handlers included dynamically, to try to prevent issues on platforms
          * with less than complete support for JAXB API
          */
         try {
             dataHandlerSerializer = (JsonSerializer<?>) DataHandlerJsonSerializer.class.newInstance();
             dataHandlerDeserializer = (JsonDeserializer<?>) DataHandlerJsonDeserializer.class.newInstance();
         } catch (Throwable e) {
             //dataHandlers not supported...
         }
          = dataHandlerSerializer;
          = dataHandlerDeserializer;
     }

    
Method that will return version information stored in and read from jar that contains this class.
 
     @Override
     public Version version() {
         return ..version();
     }
 
     /*
     /**********************************************************
     /* General annotations (for classes, properties)
     /**********************************************************
      */
     
     @Override
     public ObjectIdInfo findObjectIdInfo(Annotated ann)
     {
         /* To work in the way that works with JAXB and Jackson,
          * we need to do things in bit of round-about way, starting
          * with AnnotatedClass, locating @XmlID property, if any.
          */
         if (!(ann instanceof AnnotatedClass)) {
             return null;
         }
         AnnotatedClass ac = (AnnotatedClassann;
         /* Ideally, should not have to infer settings for class from
          * individual fields and/or methods; but for now this
          * has to do ...
          */
         PropertyName idPropName = null;
 
         method_loop:
         for (AnnotatedMethod m : ac.memberMethods()) {
             XmlID idProp = m.getAnnotation(XmlID.class);
             if (idProp == null) {
                 continue;
             }
             switch (m.getParameterCount()) {
             case 0: // getter
                 idPropName = findJaxbPropertyName(mm.getRawType(), BeanUtil.okNameForGetter(m));
                 break method_loop;
             case 1: // setter
                 idPropName = findJaxbPropertyName(mm.getRawType(), BeanUtil.okNameForSetter(m));
                 break method_loop;
             }
         }
         if (idPropName == null) {
             for (AnnotatedField f : ac.fields()) {
                 XmlID idProp = f.getAnnotation(XmlID.class);
                 if (idProp != null) {
                     idPropName = findJaxbPropertyName(ff.getRawType(), f.getName());
                     break;
                 }
             }
         }
         if (idPropName != null) {
             /* Scoping... hmmh. Could XML requires somewhat global scope, n'est pas?
              * The alternative would be to use declared type of this class.
              */
             Class<?> scope = Object.class// alternatively would use 'ac.getRawType()'
             // and we will assume that there exists property thus named...
             return new ObjectIdInfo(idPropName.getSimpleName(), scopeObjectIdGenerators.PropertyGenerator.class);
         }
         
         return null;
     }
 
     @Override
     {
         if (!) {
             XmlIDREF idref = ann.getAnnotation(XmlIDREF.class);
             /* JAXB makes XmlIDREF mean "always as id", as far as I know.
              * May need to make it configurable in future, but for not that
              * is fine...
              */
             if (idref != null) {
                 base = base.withAlwaysAsId(true);
             }
         }
         return base;
     }
     
     /*
     /**********************************************************
     /* General class annotations
     /**********************************************************
      */
 
     @Override
     {
         XmlRootElement elem = findRootElementAnnotation(ac);
         if (elem != null) {
             return _combineNames(elem.name(), elem.namespace(), "");
         }
         return null;
     }
     
     /*
     @Override
     public String[] findPropertiesToIgnore(Annotated a) {
         // nothing in JAXB for this?
         return null;
     }
     */
 
     @Override
         /* 08-Nov-2009, tatus: This is bit trickier: by default JAXB
          * does actually ignore all unknown properties.
          * But since there is no annotation to
          * specify or change this, it seems wrong to claim such setting
          * is in effect. May need to revisit this issue in future
          */
         return null;
     }
 
     @Override
     public Boolean isIgnorableType(AnnotatedClass ac) {
         // Does JAXB have any such indicators? No?
         return null;
     }
 
     /*
     /**********************************************************
     /* General member (field, method/constructor) annotations
     /**********************************************************
      */
 
     @Override
     public boolean hasIgnoreMarker(AnnotatedMember m) {
         return m.getAnnotation(XmlTransient.class) != null;
     }
 
     @Override
     public PropertyName findWrapperName(Annotated ann)
     {
         XmlElementWrapper w = findAnnotation(XmlElementWrapper.classannfalsefalsefalse);
         if (w != null) {
             return _combineNames(w.name(), w.namespace(), "");
         }
         return null;
     }
     
     /*
     /**********************************************************
     /* Property auto-detection
     /**********************************************************
      */
     
     @Override
         VisibilityChecker<?> checker)
     {
         XmlAccessType at = findAccessType(ac);
         if (at == null) {
             /* JAXB default is "PUBLIC_MEMBER"; however, here we should not
              * override settings if there is no annotation -- that would mess
              * up global baseline. Fortunately Jackson defaults are very close
              * to JAXB 'PUBLIC_MEMBER' settings (considering that setters and
              * getters must come in pairs)
              */
             return checker;
         }
         
         // Note: JAXB does not do creator auto-detection, can (and should) ignore
         switch (at) {
         case // all fields, independent of visibility; no methods
             return checker.withFieldVisibility(.)
                 .withSetterVisibility(.)
                 .withGetterVisibility(.)
                 .withIsGetterVisibility(.)
                 ;
         case // no auto-detection
             return checker.withFieldVisibility(.)
             .withSetterVisibility(.)
             .withGetterVisibility(.)
             .withIsGetterVisibility(.)
             ;
         case :
             return checker.withFieldVisibility(.)
             .withSetterVisibility(.)
             .withGetterVisibility(.)
             ;
         case :       
             return checker.withFieldVisibility(.)
             .withSetterVisibility(.)
             .withGetterVisibility(.)
             ;
         }
         return checker;
     }

    
Method for locating JAXB javax.xml.bind.annotation.XmlAccessType annotation value for given annotated entity, if it has one, or inherits one from its ancestors (in JAXB sense, package etc). Returns null if nothing has been explicitly defined.
 
     protected XmlAccessType findAccessType(Annotated ac)
     {
         XmlAccessorType at = findAnnotation(XmlAccessorType.classactruetruetrue);
         return (at == null) ? null : at.value();
     }
     
     /*
     /**********************************************************
     /* Class annotations for PM type handling (1.5+)
     /**********************************************************
      */
     
     @Override
     public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> config,
             AnnotatedClass acJavaType baseType)
     {
         // no per-class type resolvers, right?
         return null;
     }
 
     @Override
             AnnotatedMember amJavaType baseType)
     {
         /* First: @XmlElements and @XmlElementRefs only applies type for immediate property, if it
          * is NOT a structured type.
          */
         if (baseType.isContainerType()) return null;
         return _typeResolverFromXmlElements(am);
     }
 
     @Override
             AnnotatedMember amJavaType containerType)
     {
         /* First: let's ensure property is a container type: caller should have
          * verified but just to be sure
          */
         if (!containerType.isContainerType()) {
             throw new IllegalArgumentException("Must call method with a container type (got "+containerType+")");
         }
         return _typeResolverFromXmlElements(am);
     }
 
     {
         /* If simple type, @XmlElements and @XmlElementRefs are applicable.
          * Note: @XmlElement and @XmlElementRef are NOT handled here, since they
          * are handled specifically as non-polymorphic indication
          * of the actual type
          */
         XmlElements elems = findAnnotation(XmlElements.classamfalsefalsefalse);
         XmlElementRefs elemRefs = findAnnotation(XmlElementRefs.classamfalsefalsefalse);
         if (elems == null && elemRefs == null) {
             return null;
         }
 
         TypeResolverBuilder<?> b = new StdTypeResolverBuilder();
         // JAXB always uses type name as id
         b = b.init(..null);
         // and let's consider WRAPPER_OBJECT to be canonical inclusion method
         b = b.inclusion(..);
         return b;        
     }
     
     @Override
     public List<NamedTypefindSubtypes(Annotated a)
     {
         // No package/superclass defaulting (only used with fields, methods)
         XmlElements elems = findAnnotation(XmlElements.classafalsefalsefalse);
         ArrayList<NamedTyperesult = null;
         if (elems != null) {
             result = new ArrayList<NamedType>();
             for (XmlElement elem : elems.value()) {
                 String name = elem.name();
                 if (.equals(name)) name = null;
                 result.add(new NamedType(elem.type(), name));
             }
         } else {
             XmlElementRefs elemRefs = findAnnotation(XmlElementRefs.classafalsefalsefalse);
             if (elemRefs != null) {
                 result = new ArrayList<NamedType>();
                 for (XmlElementRef elemRef : elemRefs.value()) {
                     Class<?> refType = elemRef.type();
                     // only good for types other than JAXBElement (which is XML based)
                     if (!JAXBElement.class.isAssignableFrom(refType)) {
                         // [JACKSON-253] first consider explicit name declaration
                         String name = elemRef.name();
                         if (name == null || .equals(name)) {
                             XmlRootElement rootElement = (XmlRootElementrefType.getAnnotation(XmlRootElement.class);
                             if (rootElement != null) {
                                 name = rootElement.name();
                             }
                         }
                         if (name == null || .equals(name)) {
                             name = Introspector.decapitalize(refType.getSimpleName());
                         }
                         result.add(new NamedType(refTypename));
                     }
                 }
             }
         }
         
         // [Issue#1] check @XmlSeeAlso as well.
         /* 17-Aug-2012, tatu:  But wait! For structured type, what we really is
          *    value (content) type!
          *    If code below does not make full (or any) sense, do not despair -- it
          *    is wrong. Yet it works. The call sequence before we get here is mangled,
          *    its logic twisted... but as Dire Straits put it: "That ain't working --
          *    that's The Way You Do It!"
          */
         XmlSeeAlso ann = a.getAnnotation(XmlSeeAlso.class);
         if (ann != null) {
             if (result == null) {
                 result = new ArrayList<NamedType>();
             }
             for (Class<?> cls : ann.value()) {
                 result.add(new NamedType(cls));
             }
         }
         return result;
     }
 
     @Override
     public String findTypeName(AnnotatedClass ac) {
         XmlType type = findAnnotation(XmlType.classacfalsefalsefalse);
         if (type != null) {
             String name = type.name();
             if (!.equals(name)) return name;
         }
         return null;
     }
 
     /*
     /**********************************************************
     /* Serialization: general annotations
     /**********************************************************
      */
 
     @Override
     public JsonSerializer<?> findSerializer(Annotated am)
     {
         final Class<?> type = am.getRawType();
         // As per [JACKSON-722], more checks for structured types
         XmlAdapter<Object,Objectadapter = findAdapter(amtruetype);
         if (adapter != null) {
             boolean fromClass = !(am instanceof AnnotatedMember);
             // Ugh. Must match to see if adapter's bounded type (result to map to) matches property type
             if (isContainerType(type)) {
                 if (adapterTypeMatches(adaptertype)) {
                     return new XmlAdapterJsonSerializer(adapterfromClass);
                 }
             } else {
                 return new XmlAdapterJsonSerializer(adapterfromClass);
             }
         }
         // [JACKSON-150]: add support for additional core XML types needed by JAXB
         if (type != null) {
             if ( != null && isDataHandler(type)) {
                 return ;
             }
         }
         return null;
     }

    
Determines whether the type is assignable to class javax.activation.DataHandler without requiring that class to be on the classpath.

Parameters:
type The type.
Returns:
Whether the type is assignable to class javax.activation.DataHandler
 
     private boolean isDataHandler(Class<?> type)
     {
         return type != null && (Object.class != type)
                && (("javax.activation.DataHandler".equals(type.getName()) || isDataHandler(type.getSuperclass())));
     }
 
     @Override
     public Object findContentSerializer(Annotated am)
     {
         // [JACKSON-722]: Adapter applicable to value types
         XmlAdapter<?,?> adapter = _findContentAdapter(am);
         boolean fromClass = !(am instanceof AnnotatedMember);
         return (adapter == null) ? null : new XmlAdapterJsonSerializer(adapterfromClass);
     }
 
     @Override
     public Class<?> findSerializationType(Annotated a)
     {
         // As per [JACKSON-416], need to allow coercing serialization type...
         /* false for class, package, super-class, since annotation can
          * only be attached to fields and methods
          */
         // Note: caller does necessary sub/supertype checks
         XmlElement annotation = findAnnotation(XmlElement.classafalsefalsefalse);
         if (annotation == null || annotation.type() == XmlElement.DEFAULT.class) {
             return null;
         }
         /* [JACKSON-436]: Apparently collection types (array, Collection, maybe Map)
          *   require type definition to relate to contents, not collection type
          *   itself. So; we must return null here for those cases, and modify content
          *   type on another method.
          */
         Class<?> rawPropType = a.getRawType();
         if (isContainerType(rawPropType)) {
             return null;
         }
         /* [JACKSON-288]: Further, JAXB has peculiar notion of declaring intermediate
          *  (and, for the most part, useless) type... So basically we better
          *  just ignore type if there is adapter annotation
          *  (we could check to see if intermediate type is compatible, but let's not yet
          *  bother)
          * 
          */
         Class<?> allegedType = annotation.type();
         if (a.getAnnotation(XmlJavaTypeAdapter.class) != null) {
             return null;
         }
         return allegedType;
     }

    
Implementation of this method is slightly tricky, given that JAXB defaults differ from Jackson defaults. As of version 1.5 and above, this is resolved by honoring Jackson defaults (which are configurable), and only using JAXB explicit annotations.
 
     @Override
     {
         XmlElementWrapper w = a.getAnnotation(XmlElementWrapper.class);
         if (w != null) {
             return w.nillable() ? .. : ..;
         }
         XmlElement e = a.getAnnotation(XmlElement.class);
         if (e != null) {
             return e.nillable() ? .. : ..;
         }
         /* [JACKSON-256]: better pass default value through, if no explicit direction indicating
          * otherwise
          */
         return defValue;
     }
     
     /*
     /**********************************************************
     /* Serialization: class annotations
     /**********************************************************
      */
 
     @Override
     {
         // @XmlType.propOrder fits the bill here:
         XmlType type = findAnnotation(XmlType.classactruetruetrue);
         if (type == null) {
             return null;
         }
         String[] order = type.propOrder();
         if (order == null || order.length == 0) {
             return null;
         }
         return order;
     }
 
     @Override
         // Yup, XmlAccessorOrder can provide this...
         XmlAccessorOrder order = findAnnotation(XmlAccessorOrder.classactruetruetrue);
         return (order == null) ? null : (order.value() == .);
     }
 
     /*
     /**********************************************************
     /* Serialization: property annotations
     /**********************************************************
      */
 
     @Override
     {
         // [Issue#69], need bit of delegation (note: copy of super-class functionality)
         // !!! TODO: in 2.2, remove old methods?
         if (a instanceof AnnotatedMethod) {
             AnnotatedMethod am = (AnnotatedMethoda;
             if (!isVisible(am)) {
                 return null;
             }
             return findJaxbPropertyName(amam.getRawType(), BeanUtil.okNameForGetter(am));
         }
         if (a instanceof AnnotatedField) {
             AnnotatedField af = (AnnotatedFielda;
             if (!isVisible(af)) {
                 return null;
             }
             PropertyName name = findJaxbPropertyName(afaf.getRawType(), null);
             /* This may seem wrong, but since JAXB field auto-detection
              * needs to find even non-public fields (if enabled by
              * JAXB access type), we need to return name like so:
              */
             if (name == null) {
                 return new PropertyName(af.getName());
             }
             return name;
         }
         return null;
     }
     
     @Deprecated
     @Override
     {
         if (!isVisible(am)) {
             return null;
         }
         return _propertyNameToString(findJaxbPropertyName(amam.getRawType(), BeanUtil.okNameForGetter(am)));
     }
     
     @Deprecated
     @Override
     {
         if (!isVisible(af)) {
             return null;
         }
         PropertyName name = findJaxbPropertyName(afaf.getRawType(), null);
         /* This may seem wrong, but since JAXB field auto-detection
          * needs to find even non-public fields (if enabled by
          * JAXB access type), we need to return name like so:
          */
         if (name == null) {
             return af.getName();
         }
         return _propertyNameToString(name);
     }
     
     @Override
     public boolean hasAsValueAnnotation(AnnotatedMethod am)
     {
         //since jaxb says @XmlValue can exist with attributes, this won't map as a JSON value.
         return false;
     }

    

!!! 12-Oct-2009, tatu: This is hideously slow implementation, called potentially for every single enum value being serialized. Should improve...

 
     @Override
     public String findEnumValue(Enum<?> e)
     {
         Class<?> enumClass = e.getDeclaringClass();
         String enumValue = e.name();
         try {
             XmlEnumValue xmlEnumValue = enumClass.getDeclaredField(enumValue).getAnnotation(XmlEnumValue.class);
             return (xmlEnumValue != null) ? xmlEnumValue.value() : enumValue;
         } catch (NoSuchFieldException e1) {
             throw new IllegalStateException("Could not locate Enum entry '"+enumValue+"' (Enum class "+enumClass.getName()+")"e1);
         }
     }
 
     /*
     /**********************************************************
     /* Deserialization: general annotations
     /**********************************************************
      */
 
     @Override
     public Object findDeserializer(Annotated am)
     {
         final Class<?> type = am.getRawType();
 
         // As per [JACKSON-722], more checks for structured types
         XmlAdapter<Object,Objectadapter = findAdapter(amtruetype);
         if (adapter != null) {
             // Ugh. Must match to see if adapter's bounded type (result to map to) matches property type
             if (isContainerType(type)) {
                 if (adapterTypeMatches(adaptertype)) {
                     return new XmlAdapterJsonDeserializer(adapter);
                 }
             } else {
                 return new XmlAdapterJsonDeserializer(adapter);
             }
         }
 
         // [JACKSON-150]: add support for additional core XML types needed by JAXB
         if (type != null) {
             if ( != null && isDataHandler(type)) {
                 return ;
             }
         }
 
         return null;
     }
 
     @Override
     public Object findKeyDeserializer(Annotated am)
     {
         // Is there something like this in JAXB?
         return null;
     }
 
     @Override
     {
         // [JACKSON-722]: Adapter applicable to value types
         XmlAdapter<?,?> adapter = _findContentAdapter(am);
         return (adapter == null) ? null : new XmlAdapterJsonDeserializer(adapter);
     }

    
JAXB does allow specifying (more) concrete class for deserialization by using \@XmlElement annotation.
 
     @Override
     public Class<?> findDeserializationType(Annotated aJavaType baseType)
     {
         /* First: only applicable for non-structured types (yes, JAXB annotations
          * are tricky)
          */
         if (!baseType.isContainerType()) {
             return _doFindDeserializationType(abaseType);
         }
         return null;
     }
 
     //public Class<?> findDeserializationKeyType(Annotated am, JavaType baseKeyType)
 
     @Override
     public Class<?> findDeserializationContentType(Annotated aJavaType baseContentType)
     {
         /* 15-Feb-2010, tatus: JAXB usage of XmlElement/XmlElements is really
          *   confusing: sometimes it's for type (non-container types), sometimes for
          *   contents (container) types. I guess it's frugal to reuse these... but
          *   I think it's rather short-sighted. Whatever, it is what it is, and here
          *   we are being given content type explicitly.
          */
         return _doFindDeserializationType(abaseContentType);
     }
 
     protected Class<?> _doFindDeserializationType(Annotated aJavaType baseType)
     {
         /* As per [JACKSON-288], @XmlJavaTypeAdapter will complicate handling of type
          * information; basically we better just ignore type we might find here altogether
          * in that case
          */
         if (a.hasAnnotation(XmlJavaTypeAdapter.class)) {
             return null;
         }
         
         /* false for class, package, super-class, since annotation can
          * only be attached to fields and methods
          */
         XmlElement annotation = findAnnotation(XmlElement.classafalsefalsefalse);
         if (annotation != null) {
             Class<?> type = annotation.type();
             if (type != XmlElement.DEFAULT.class) {
                 return type;
             }
         }
         /* 16-Feb-2010, tatu: May also have annotation associated with field, not method
          *    itself... and findAnnotation() won't find that (nor property descriptor)
          */
         /*
         if (a instanceof AnnotatedMethod) {
             AnnotatedMethod am = (AnnotatedMethod) a;
             // Hmmhh. does name have to match?
             String propName = am.getName();
             annotation = findFieldAnnotation(XmlElement.class, am.getDeclaringClass(), propName);
             if (annotation != null && annotation.type() != XmlElement.DEFAULT.class) {
                 return annotation.type();
             }
         }
         */
         return null;
     }
 
     /*
     /**********************************************************
     /* Deserialization: property annotations
     /**********************************************************
      */
 
     @Override
     {
         // [Issue#69], need bit of delegation -- note: copy from super-class
         // TODO: should simplify, messy.
         if (a instanceof AnnotatedMethod) {
             AnnotatedMethod am = (AnnotatedMethoda;
             if (!isVisible((AnnotatedMethoda)) {
                 return null;
             }
             Class<?> rawType = am.getRawParameterType(0);
             return findJaxbPropertyName(amrawType, BeanUtil.okNameForSetter(am));
         }
         if (a instanceof AnnotatedField) {
             AnnotatedField af = (AnnotatedFielda;
             if (!isVisible(af)) {
                 return null;
             }
             PropertyName name = findJaxbPropertyName(afaf.getRawType(), null);
             /* This may seem wrong, but since JAXB field auto-detection
              * needs to find even non-public fields (if enabled by
              * JAXB access type), we need to return name like so:
              */
             if (name == null) {
                 return new PropertyName(af.getName());
             }
             return name;
         }
         return null;
 
         /*
         if (name != null) {
             if (name.length() == 0) { // empty String means 'default'
                 return PropertyName.USE_DEFAULT;
             }
             return new PropertyName(name);
         }
         */
     }
     
     @Deprecated
     @Override
     {
         if (!isVisible(am)) {
             return null;
         }
         Class<?> rawType = am.getRawParameterType(0);
         return _propertyNameToString(findJaxbPropertyName(amrawType, BeanUtil.okNameForSetter(am)));
     }
 
     @Deprecated
     @Override
     {
         if (!isVisible(af)) {
             return null;
         }
         PropertyName name = findJaxbPropertyName(afaf.getRawType(), null);
         /* This may seem wrong, but since JAXB field auto-detection
          * needs to find even non-public fields (if enabled by
          * JAXB access type), we need to return name like so:
          */
         if (name == null) {
             return af.getName();
         }
         return _propertyNameToString(name);
     }
 
     /*
     public String findDeserializationName(AnnotatedParameter param)
     {
         // JAXB has nothing like this...
         return null;
     }
     */
 
     @Override
     public boolean hasAnySetterAnnotation(AnnotatedMethod am)
     {
         //(ryan) JAXB has @XmlAnyAttribute and @XmlAnyElement annotations, but they're not applicable in this case
         // because JAXB says those annotations are only applicable to methods with specific signatures
         // that Jackson doesn't support (Jackson's any setter needs 2 arguments, name and value, whereas
         // JAXB expects use of Map
         return false;
     }
 
     @Override
     public boolean hasCreatorAnnotation(Annotated am)
     {
         return false;
     }
 
     @Override
     public Boolean hasRequiredMarker(AnnotatedMember m) {
         XmlElement annotation = m.getAnnotation(XmlElement.class);
         return annotation == null ? null : Boolean.valueOf(annotation.required());
     }
     
     /*
     /**********************************************************
     /* Helper methods (non-API)
     /**********************************************************
      */

    
Whether the specified field is invisible, per the JAXB visibility rules.

Parameters:
f The field.
Returns:
Whether the field is invisible.
 
     private boolean isVisible(AnnotatedField f)
     {
         // TODO: use AnnotatedField's annotations directly
         for (Annotation annotation : f.getAnnotated().getDeclaredAnnotations()) {
             if (isJAXBAnnotation(annotation)) {
                 return true;
             }
         }
         XmlAccessType accessType = .;
         XmlAccessorType at = findAnnotation(XmlAccessorType.classftruetruetrue);
         if (at != null) {
             accessType = at.value();
         }
         if (accessType == .) {
             return true;
         }
         if (accessType == .) {
             return Modifier.isPublic(f.getAnnotated().getModifiers());
         }
         return false;
     }
 
     private boolean isVisible(AnnotatedMethod m)
     {
         // TODO: use AnnotatedField's annotations directly
         for (Annotation annotation : m.getAnnotated().getDeclaredAnnotations()) {
             if (isJAXBAnnotation(annotation)) {
                 return true;
             }
         }
         XmlAccessType accessType = .;
         XmlAccessorType at = findAnnotation(XmlAccessorType.classmtruetruetrue);
         if (at != null) {
             accessType = at.value();
         }
         if (accessType == . || accessType == .) {
             return Modifier.isPublic(m.getModifiers());
         }
         return false;
     }
    
    
Finds an annotation associated with given annotatable thing; or if not found, a default annotation it may have (from super class, package and so on)

Parameters:
annotationClass the annotation class.
annotated The annotated element.
includePackage Whether the annotation can be found on the package of the annotated element.
includeClass Whether the annotation can be found on the class of the annotated element.
includeSuperclasses Whether the annotation can be found on any superclasses of the class of the annotated element.
Returns:
The annotation, or null if not found.
 
     private <A extends Annotation> A findAnnotation(Class<A> annotationClassAnnotated annotated,
             boolean includePackageboolean includeClassboolean includeSuperclasses)
     {
         A annotation = annotated.getAnnotation(annotationClass);
         if (annotation != null) {
             return annotation;
         }
         Class<?> memberClass = null;
         /* 13-Feb-2011, tatu: [JACKSON-495] - need to handle AnnotatedParameter
          *   bit differently, since there is no JDK counterpart. We can still
          *   access annotations directly, just using different calls.
          */
         if (annotated instanceof AnnotatedParameter) {
             memberClass = ((AnnotatedParameterannotated).getDeclaringClass();
         } else {
             AnnotatedElement annType = annotated.getAnnotated();
             if (annType instanceof Member) {
                 memberClass = ((MemberannType).getDeclaringClass();
                 if (includeClass) {
                     annotation = (A) memberClass.getAnnotation(annotationClass);
                     if (annotation != null) {
                         return annotation;
                     }
                 }
            } else if (annType instanceof Class<?>) {
                memberClass = (Class<?>) annType;
            } else {
                throw new IllegalStateException("Unsupported annotated member: " + annotated.getClass().getName());
            }
        }
        if (memberClass != null) {
            if (includeSuperclasses) {
                Class<?> superclass = memberClass.getSuperclass();
                while (superclass != null && superclass != Object.class) {
                    annotation = (A) superclass.getAnnotation(annotationClass);
                    if (annotation != null) {
                        return annotation;
                    }
                    superclass = superclass.getSuperclass();
                }
            }
            if (includePackage) {
                Package pkg = memberClass.getPackage();
                if (pkg != null) {
                    return memberClass.getPackage().getAnnotation(annotationClass);
                }
            }
        }
        return null;
    }
    /*
    /**********************************************************
    /* Helper methods for bean property introspection
    /**********************************************************
     */

    
An annotation is handled if it's in the same package as

Parameters:
ann The annotation.
Returns:
Whether the annotation is in the JAXB package.
XmlElement:
including subpackages.
    protected boolean isJAXBAnnotation(Annotation ann)
    {
        /* note: class we want is the annotation class, not instance
         * (since annotation instances, like enums, may be of different
         * physical type!)
         */
        Class<?> cls = ann.annotationType();
        Package pkg = cls.getPackage();
        String pkgName = (pkg != null) ? pkg.getName() : cls.getName();
        if (pkgName.startsWith()) {
            return true;
        }
        return false;
    }
    
    private static PropertyName findJaxbPropertyName(Annotated aeClass<?> aeTypeString defaultName)
    {
        XmlAttribute attribute = ae.getAnnotation(XmlAttribute.class);
        if (attribute != null) {
            return _combineNames(attribute.name(), attribute.namespace(), defaultName);
        }
        XmlElement element = ae.getAnnotation(XmlElement.class);
        if (element != null) {
            return _combineNames(element.name(), element.namespace(), defaultName);
        }
        /* 11-Sep-2012, tatu: Wrappers should not be automatically used for renaming.
         *   At least not here (databinding core can do it if feature enabled).
         */
        /*
        XmlElementWrapper elementWrapper = ae.getAnnotation(XmlElementWrapper.class);
        if (elementWrapper != null) {
            return _combineNames(elementWrapper.name(), elementWrapper.namespace(), defaultName);
        }
        */
        XmlElementRef elementRef = ae.getAnnotation(XmlElementRef.class);
        if (elementRef != null) {
            if (!.equals(elementRef.name())) {
                return _combineNames(elementRef.name(), elementRef.namespace(), defaultName);
            }
            if (aeType != null) {
                XmlRootElement rootElement = (XmlRootElementaeType.getAnnotation(XmlRootElement.class);
                if (rootElement != null) {
                    String name = rootElement.name();
                    if (!.equals(name)) {
                        return _combineNames(namerootElement.namespace(), defaultName);
                    }
                    // Is there a namespace there to use? Probably not?
                    return new PropertyName(Introspector.decapitalize(aeType.getSimpleName()));
                }
            }
        }
        XmlValue valueInfo = ae.getAnnotation(XmlValue.class);
        if (valueInfo != null) {
            return new PropertyName("value");
        }
        return null;
    }
    private static PropertyName _combineNames(String localNameString namespace,
            String defaultName)
    {
        if (.equals(localName)) {
            if (.equals(namespace)) {
                return new PropertyName(defaultName);
            }
            return new PropertyName(defaultNamenamespace);
        }
        if (.equals(namespace)) {
            return new PropertyName(localName);
        }
        return new PropertyName(localNamenamespace);
    }
    
    {
        // Yes, check package, no class (already included), yes superclasses
        return findAnnotation(XmlRootElement.classactruefalsetrue);
    }

    
Finds the XmlAdapter for the specified annotation.

Parameters:
am The annotated element.
forSerialization If true, adapter for serialization; if false, for deserialization
type
Returns:
The adapter, or null if none.
    private XmlAdapter<Object,ObjectfindAdapter(Annotated amboolean forSerialization,
            Class<?> type)
    {
        // First of all, are we looking for annotations for class?
        if (am instanceof AnnotatedClass) {
            return findAdapterForClass((AnnotatedClassamforSerialization);
        }