jackson-mapper-asl-1.8.2

16:36:56.614 INFO  jd.cli.Main - Decompiling jackson-mapper-asl-1.8.2.jar
package org.codehaus.jackson.map;

import org.codehaus.jackson.type.JavaType;

public abstract class AbstractTypeResolver
{
  public JavaType findTypeMapping(DeserializationConfig config, JavaType type)
  {
    return null;
  }
  
  public JavaType resolveAbstractType(DeserializationConfig config, JavaType type)
  {
    return null;
  }
}

/* Location:
 * Qualified Name:     org.codehaus.jackson.map.AbstractTypeResolver
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.codehaus.jackson.map;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;
import org.codehaus.jackson.map.annotate.JsonSerialize.Typing;
import org.codehaus.jackson.map.introspect.Annotated;
import org.codehaus.jackson.map.introspect.AnnotatedClass;
import org.codehaus.jackson.map.introspect.AnnotatedConstructor;
import org.codehaus.jackson.map.introspect.AnnotatedField;
import org.codehaus.jackson.map.introspect.AnnotatedMember;
import org.codehaus.jackson.map.introspect.AnnotatedMethod;
import org.codehaus.jackson.map.introspect.AnnotatedParameter;
import org.codehaus.jackson.map.introspect.VisibilityChecker;
import org.codehaus.jackson.map.jsontype.NamedType;
import org.codehaus.jackson.map.jsontype.TypeResolverBuilder;
import org.codehaus.jackson.type.JavaType;

public class AnnotationIntrospector$Pair
  extends AnnotationIntrospector
{
  protected final AnnotationIntrospector _primary;
  protected final AnnotationIntrospector _secondary;
  
  public AnnotationIntrospector$Pair(AnnotationIntrospector p, AnnotationIntrospector s)
  {
    _primary = p;
    _secondary = s;
  }
  
  public static AnnotationIntrospector create(AnnotationIntrospector primary, AnnotationIntrospector secondary)
  {
    if (primary == null) {
      return secondary;
    }
    if (secondary == null) {
      return primary;
    }
    return new Pair(primary, secondary);
  }
  
  public Collection<AnnotationIntrospector> allIntrospectors()
  {
    return allIntrospectors(new ArrayList());
  }
  
  public Collection<AnnotationIntrospector> allIntrospectors(Collection<AnnotationIntrospector> result)
  {
    _primary.allIntrospectors(result);
    _secondary.allIntrospectors(result);
    return result;
  }
  
  public boolean isHandled(Annotation ann)
  {
    return (_primary.isHandled(ann)) || (_secondary.isHandled(ann));
  }
  
  public Boolean findCachability(AnnotatedClass ac)
  {
    Boolean result = _primary.findCachability(ac);
    if (result == null) {
      result = _secondary.findCachability(ac);
    }
    return result;
  }
  
  public String findRootName(AnnotatedClass ac)
  {
    String name1 = _primary.findRootName(ac);
    if (name1 == null) {
      return _secondary.findRootName(ac);
    }
    if (name1.length() > 0) {
      return name1;
    }
    String name2 = _secondary.findRootName(ac);
    return name2 == null ? name1 : name2;
  }
  
  public String[] findPropertiesToIgnore(AnnotatedClass ac)
  {
    String[] result = _primary.findPropertiesToIgnore(ac);
    if (result == null) {
      result = _secondary.findPropertiesToIgnore(ac);
    }
    return result;
  }
  
  public Boolean findIgnoreUnknownProperties(AnnotatedClass ac)
  {
    Boolean result = _primary.findIgnoreUnknownProperties(ac);
    if (result == null) {
      result = _secondary.findIgnoreUnknownProperties(ac);
    }
    return result;
  }
  
  public Boolean isIgnorableType(AnnotatedClass ac)
  {
    Boolean result = _primary.isIgnorableType(ac);
    if (result == null) {
      result = _secondary.isIgnorableType(ac);
    }
    return result;
  }
  
  public Object findFilterId(AnnotatedClass ac)
  {
    Object id = _primary.findFilterId(ac);
    if (id == null) {
      id = _secondary.findFilterId(ac);
    }
    return id;
  }
  
  public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)
  {
    checker = _secondary.findAutoDetectVisibility(ac, checker);
    return _primary.findAutoDetectVisibility(ac, checker);
  }
  
  public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)
  {
    TypeResolverBuilder<?> b = _primary.findTypeResolver(config, ac, baseType);
    if (b == null) {
      b = _secondary.findTypeResolver(config, ac, baseType);
    }
    return b;
  }
  
  public TypeResolverBuilder<?> findPropertyTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType)
  {
    TypeResolverBuilder<?> b = _primary.findPropertyTypeResolver(config, am, baseType);
    if (b == null) {
      b = _secondary.findPropertyTypeResolver(config, am, baseType);
    }
    return b;
  }
  
  public TypeResolverBuilder<?> findPropertyContentTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType)
  {
    TypeResolverBuilder<?> b = _primary.findPropertyContentTypeResolver(config, am, baseType);
    if (b == null) {
      b = _secondary.findPropertyContentTypeResolver(config, am, baseType);
    }
    return b;
  }
  
  public List<NamedType> findSubtypes(Annotated a)
  {
    List<NamedType> types1 = _primary.findSubtypes(a);
    List<NamedType> types2 = _secondary.findSubtypes(a);
    if ((types1 == null) || (types1.isEmpty())) {
      return types2;
    }
    if ((types2 == null) || (types2.isEmpty())) {
      return types1;
    }
    ArrayList<NamedType> result = new ArrayList(types1.size() + types2.size());
    result.addAll(types1);
    result.addAll(types2);
    return result;
  }
  
  public String findTypeName(AnnotatedClass ac)
  {
    String name = _primary.findTypeName(ac);
    if ((name == null) || (name.length() == 0)) {
      name = _secondary.findTypeName(ac);
    }
    return name;
  }
  
  public AnnotationIntrospector.ReferenceProperty findReferenceType(AnnotatedMember member)
  {
    AnnotationIntrospector.ReferenceProperty ref = _primary.findReferenceType(member);
    if (ref == null) {
      ref = _secondary.findReferenceType(member);
    }
    return ref;
  }
  
  public boolean isIgnorableMethod(AnnotatedMethod m)
  {
    return (_primary.isIgnorableMethod(m)) || (_secondary.isIgnorableMethod(m));
  }
  
  public boolean isIgnorableConstructor(AnnotatedConstructor c)
  {
    return (_primary.isIgnorableConstructor(c)) || (_secondary.isIgnorableConstructor(c));
  }
  
  public boolean isIgnorableField(AnnotatedField f)
  {
    return (_primary.isIgnorableField(f)) || (_secondary.isIgnorableField(f));
  }
  
  public Object findSerializer(Annotated am, BeanProperty property)
  {
    Object result = _primary.findSerializer(am, property);
    if (result == null) {
      result = _secondary.findSerializer(am, property);
    }
    return result;
  }
  
  public Object findSerializer(Annotated am)
  {
    Object result = _primary.findSerializer(am);
    if (result == null) {
      result = _secondary.findSerializer(am);
    }
    return result;
  }
  
  public Class<? extends JsonSerializer<?>> findKeySerializer(Annotated a)
  {
    Class<? extends JsonSerializer<?>> result = _primary.findKeySerializer(a);
    if ((result == null) || (result == JsonSerializer.None.class)) {
      result = _secondary.findKeySerializer(a);
    }
    return result;
  }
  
  public Class<? extends JsonSerializer<?>> findContentSerializer(Annotated a)
  {
    Class<? extends JsonSerializer<?>> result = _primary.findContentSerializer(a);
    if ((result == null) || (result == JsonSerializer.None.class)) {
      result = _secondary.findContentSerializer(a);
    }
    return result;
  }
  
  public JsonSerialize.Inclusion findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)
  {
    defValue = _secondary.findSerializationInclusion(a, defValue);
    defValue = _primary.findSerializationInclusion(a, defValue);
    return defValue;
  }
  
  public Class<?> findSerializationType(Annotated a)
  {
    Class<?> result = _primary.findSerializationType(a);
    if (result == null) {
      result = _secondary.findSerializationType(a);
    }
    return result;
  }
  
  public Class<?> findSerializationKeyType(Annotated am, JavaType baseType)
  {
    Class<?> result = _primary.findSerializationKeyType(am, baseType);
    if (result == null) {
      result = _secondary.findSerializationKeyType(am, baseType);
    }
    return result;
  }
  
  public Class<?> findSerializationContentType(Annotated am, JavaType baseType)
  {
    Class<?> result = _primary.findSerializationContentType(am, baseType);
    if (result == null) {
      result = _secondary.findSerializationContentType(am, baseType);
    }
    return result;
  }
  
  public JsonSerialize.Typing findSerializationTyping(Annotated a)
  {
    JsonSerialize.Typing result = _primary.findSerializationTyping(a);
    if (result == null) {
      result = _secondary.findSerializationTyping(a);
    }
    return result;
  }
  
  public Class<?>[] findSerializationViews(Annotated a)
  {
    Class<?>[] result = _primary.findSerializationViews(a);
    if (result == null) {
      result = _secondary.findSerializationViews(a);
    }
    return result;
  }
  
  public String[] findSerializationPropertyOrder(AnnotatedClass ac)
  {
    String[] result = _primary.findSerializationPropertyOrder(ac);
    if (result == null) {
      result = _secondary.findSerializationPropertyOrder(ac);
    }
    return result;
  }
  
  public Boolean findSerializationSortAlphabetically(AnnotatedClass ac)
  {
    Boolean result = _primary.findSerializationSortAlphabetically(ac);
    if (result == null) {
      result = _secondary.findSerializationSortAlphabetically(ac);
    }
    return result;
  }
  
  public String findGettablePropertyName(AnnotatedMethod am)
  {
    String result = _primary.findGettablePropertyName(am);
    if (result == null)
    {
      result = _secondary.findGettablePropertyName(am);
    }
    else if (result.length() == 0)
    {
      String str2 = _secondary.findGettablePropertyName(am);
      if (str2 != null) {
        result = str2;
      }
    }
    return result;
  }
  
  public boolean hasAsValueAnnotation(AnnotatedMethod am)
  {
    return (_primary.hasAsValueAnnotation(am)) || (_secondary.hasAsValueAnnotation(am));
  }
  
  public String findEnumValue(Enum<?> value)
  {
    String result = _primary.findEnumValue(value);
    if (result == null) {
      result = _secondary.findEnumValue(value);
    }
    return result;
  }
  
  public String findSerializablePropertyName(AnnotatedField af)
  {
    String result = _primary.findSerializablePropertyName(af);
    if (result == null)
    {
      result = _secondary.findSerializablePropertyName(af);
    }
    else if (result.length() == 0)
    {
      String str2 = _secondary.findSerializablePropertyName(af);
      if (str2 != null) {
        result = str2;
      }
    }
    return result;
  }
  
  public Object findDeserializer(Annotated am)
  {
    Object result = _primary.findDeserializer(am);
    if (result == null) {
      result = _secondary.findDeserializer(am);
    }
    return result;
  }
  
  public Object findDeserializer(Annotated am, BeanProperty property)
  {
    Object result = _primary.findDeserializer(am, property);
    if (result == null) {
      result = _secondary.findDeserializer(am, property);
    }
    return result;
  }
  
  public Class<? extends KeyDeserializer> findKeyDeserializer(Annotated am)
  {
    Class<? extends KeyDeserializer> result = _primary.findKeyDeserializer(am);
    if ((result == null) || (result == KeyDeserializer.None.class)) {
      result = _secondary.findKeyDeserializer(am);
    }
    return result;
  }
  
  public Class<? extends JsonDeserializer<?>> findContentDeserializer(Annotated am)
  {
    Class<? extends JsonDeserializer<?>> result = _primary.findContentDeserializer(am);
    if ((result == null) || (result == JsonDeserializer.None.class)) {
      result = _secondary.findContentDeserializer(am);
    }
    return result;
  }
  
  public Class<?> findDeserializationType(Annotated am, JavaType baseType, String propName)
  {
    Class<?> result = _primary.findDeserializationType(am, baseType, propName);
    if (result == null) {
      result = _secondary.findDeserializationType(am, baseType, propName);
    }
    return result;
  }
  
  public Class<?> findDeserializationKeyType(Annotated am, JavaType baseKeyType, String propName)
  {
    Class<?> result = _primary.findDeserializationKeyType(am, baseKeyType, propName);
    if (result == null) {
      result = _secondary.findDeserializationKeyType(am, baseKeyType, propName);
    }
    return result;
  }
  
  public Class<?> findDeserializationContentType(Annotated am, JavaType baseContentType, String propName)
  {
    Class<?> result = _primary.findDeserializationContentType(am, baseContentType, propName);
    if (result == null) {
      result = _secondary.findDeserializationContentType(am, baseContentType, propName);
    }
    return result;
  }
  
  public String findSettablePropertyName(AnnotatedMethod am)
  {
    String result = _primary.findSettablePropertyName(am);
    if (result == null)
    {
      result = _secondary.findSettablePropertyName(am);
    }
    else if (result.length() == 0)
    {
      String str2 = _secondary.findSettablePropertyName(am);
      if (str2 != null) {
        result = str2;
      }
    }
    return result;
  }
  
  public boolean hasAnySetterAnnotation(AnnotatedMethod am)
  {
    return (_primary.hasAnySetterAnnotation(am)) || (_secondary.hasAnySetterAnnotation(am));
  }
  
  public boolean hasAnyGetterAnnotation(AnnotatedMethod am)
  {
    return (_primary.hasAnyGetterAnnotation(am)) || (_secondary.hasAnyGetterAnnotation(am));
  }
  
  public boolean hasCreatorAnnotation(Annotated a)
  {
    return (_primary.hasCreatorAnnotation(a)) || (_secondary.hasCreatorAnnotation(a));
  }
  
  public String findDeserializablePropertyName(AnnotatedField af)
  {
    String result = _primary.findDeserializablePropertyName(af);
    if (result == null)
    {
      result = _secondary.findDeserializablePropertyName(af);
    }
    else if (result.length() == 0)
    {
      String str2 = _secondary.findDeserializablePropertyName(af);
      if (str2 != null) {
        result = str2;
      }
    }
    return result;
  }
  
  public String findPropertyNameForParam(AnnotatedParameter param)
  {
    String result = _primary.findPropertyNameForParam(param);
    if (result == null) {
      result = _secondary.findPropertyNameForParam(param);
    }
    return result;
  }
}

/* Location:
 * Qualified Name:     org.codehaus.jackson.map.AnnotationIntrospector.Pair
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.codehaus.jackson.map;

public enum AnnotationIntrospector$ReferenceProperty$Type
{
  MANAGED_REFERENCE,  BACK_REFERENCE;
  
  private AnnotationIntrospector$ReferenceProperty$Type() {}
}

/* Location:
 * Qualified Name:     org.codehaus.jackson.map.AnnotationIntrospector.ReferenceProperty.Type
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.codehaus.jackson.map;

public class AnnotationIntrospector$ReferenceProperty
{
  private final Type _type;
  private final String _name;
  
  public static enum Type
  {
    MANAGED_REFERENCE,  BACK_REFERENCE;
    
    private Type() {}
  }
  
  public AnnotationIntrospector$ReferenceProperty(Type t, String n)
  {
    _type = t;
    _name = n;
  }
  
  public static ReferenceProperty managed(String name)
  {
    return new ReferenceProperty(Type.MANAGED_REFERENCE, name);
  }
  
  public static ReferenceProperty back(String name)
  {
    return new ReferenceProperty(Type.BACK_REFERENCE, name);
  }
  
  public Type getType()
  {
    return _type;
  }
  
  public String getName()
  {
    return _name;
  }
  
  public boolean isManagedReference()
  {
    return _type == Type.MANAGED_REFERENCE;
  }
  
  public boolean isBackReference()
  {
    return _type == Type.BACK_REFERENCE;
  }
}

/* Location:
 * Qualified Name:     org.codehaus.jackson.map.AnnotationIntrospector.ReferenceProperty
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.codehaus.jackson.map;

import java.lang.annotation.Annotation;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import org.codehaus.jackson.map.annotate.JsonSerialize.Inclusion;
import org.codehaus.jackson.map.annotate.JsonSerialize.Typing;
import org.codehaus.jackson.map.introspect.Annotated;
import org.codehaus.jackson.map.introspect.AnnotatedClass;
import org.codehaus.jackson.map.introspect.AnnotatedConstructor;
import org.codehaus.jackson.map.introspect.AnnotatedField;
import org.codehaus.jackson.map.introspect.AnnotatedMember;
import org.codehaus.jackson.map.introspect.AnnotatedMethod;
import org.codehaus.jackson.map.introspect.AnnotatedParameter;
import org.codehaus.jackson.map.introspect.NopAnnotationIntrospector;
import org.codehaus.jackson.map.introspect.VisibilityChecker;
import org.codehaus.jackson.map.jsontype.NamedType;
import org.codehaus.jackson.map.jsontype.TypeResolverBuilder;
import org.codehaus.jackson.type.JavaType;

public abstract class AnnotationIntrospector
{
  public static class ReferenceProperty
  {
    private final Type _type;
    private final String _name;
    
    public static enum Type
    {
      MANAGED_REFERENCE,  BACK_REFERENCE;
      
      private Type() {}
    }
    
    public ReferenceProperty(Type t, String n)
    {
      _type = t;
      _name = n;
    }
    
    public static ReferenceProperty managed(String name)
    {
      return new ReferenceProperty(Type.MANAGED_REFERENCE, name);
    }
    
    public static ReferenceProperty back(String name)
    {
      return new ReferenceProperty(Type.BACK_REFERENCE, name);
    }
    
    public Type getType()
    {
      return _type;
    }
    
    public String getName()
    {
      return _name;
    }
    
    public boolean isManagedReference()
    {
      return _type == Type.MANAGED_REFERENCE;
    }
    
    public boolean isBackReference()
    {
      return _type == Type.BACK_REFERENCE;
    }
  }
  
  public static AnnotationIntrospector nopInstance()
  {
    return NopAnnotationIntrospector.instance;
  }
  
  public static AnnotationIntrospector pair(AnnotationIntrospector a1, AnnotationIntrospector a2)
  {
    return new Pair(a1, a2);
  }
  
  public Collection<AnnotationIntrospector> allIntrospectors()
  {
    return Collections.singletonList(this);
  }
  
  public Collection<AnnotationIntrospector> allIntrospectors(Collection<AnnotationIntrospector> result)
  {
    result.add(this);
    return result;
  }
  
  public abstract boolean isHandled(Annotation paramAnnotation);
  
  public abstract Boolean findCachability(AnnotatedClass paramAnnotatedClass);
  
  public abstract String findRootName(AnnotatedClass paramAnnotatedClass);
  
  public abstract String[] findPropertiesToIgnore(AnnotatedClass paramAnnotatedClass);
  
  public abstract Boolean findIgnoreUnknownProperties(AnnotatedClass paramAnnotatedClass);
  
  public Boolean isIgnorableType(AnnotatedClass ac)
  {
    return null;
  }
  
  public Object findFilterId(AnnotatedClass ac)
  {
    return null;
  }
  
  public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)
  {
    return checker;
  }
  
  public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)
  {
    return null;
  }
  
  public TypeResolverBuilder<?> findPropertyTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType)
  {
    return null;
  }
  
  public TypeResolverBuilder<?> findPropertyContentTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType containerType)
  {
    return null;
  }
  
  public List<NamedType> findSubtypes(Annotated a)
  {
    return null;
  }
  
  public String findTypeName(AnnotatedClass ac)
  {
    return null;
  }
  
  public ReferenceProperty findReferenceType(AnnotatedMember member)
  {
    return null;
  }
  
  public abstract boolean isIgnorableMethod(AnnotatedMethod paramAnnotatedMethod);
  
  public abstract boolean isIgnorableConstructor(AnnotatedConstructor paramAnnotatedConstructor);
  
  public abstract boolean isIgnorableField(AnnotatedField paramAnnotatedField);
  
  public Object findSerializer(Annotated am)
  {
    return findSerializer(am, null);
  }
  
  @Deprecated
  public Object findSerializer(Annotated am, BeanProperty property)
  {
    if (property != null) {
      return findSerializer(am);
    }
    return null;
  }
  
  public Class<? extends JsonSerializer<?>> findKeySerializer(Annotated am)
  {
    return null;
  }
  
  public Class<? extends JsonSerializer<?>> findContentSerializer(Annotated am)
  {
    return null;
  }
  
  public JsonSerialize.Inclusion findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)
  {
    return defValue;
  }
  
  public abstract Class<?> findSerializationType(Annotated paramAnnotated);
  
  public Class<?> findSerializationKeyType(Annotated am, JavaType baseType)
  {
    return null;
  }
  
  public Class<?> findSerializationContentType(Annotated am, JavaType baseType)
  {
    return null;
  }
  
  public abstract JsonSerialize.Typing findSerializationTyping(Annotated paramAnnotated);
  
  public abstract Class<?>[] findSerializationViews(Annotated paramAnnotated);
  
  public abstract String[] findSerializationPropertyOrder(AnnotatedClass paramAnnotatedClass);
  
  public abstract Boolean findSerializationSortAlphabetically(AnnotatedClass paramAnnotatedClass);
  
  public abstract String findGettablePropertyName(AnnotatedMethod paramAnnotatedMethod);
  
  public abstract boolean hasAsValueAnnotation(AnnotatedMethod paramAnnotatedMethod);
  
  public abstract String findEnumValue(Enum<?> paramEnum);
  
  public abstract String findSerializablePropertyName(AnnotatedField paramAnnotatedField);
  
  public Object findDeserializer(Annotated am)
  {
    return findDeserializer(am, null);
  }
  
  @Deprecated
  public Object findDeserializer(Annotated am, BeanProperty property)
  {
    if (property != null) {
      return findDeserializer(am);
    }
    return null;
  }
  
  public abstract Class<? extends KeyDeserializer> findKeyDeserializer(Annotated paramAnnotated);
  
  public abstract Class<? extends JsonDeserializer<?>> findContentDeserializer(Annotated paramAnnotated);
  
  public abstract Class<?> findDeserializationType(Annotated paramAnnotated, JavaType paramJavaType, String paramString);
  
  public abstract Class<?> findDeserializationKeyType(Annotated paramAnnotated, JavaType paramJavaType, String paramString);
  
  public abstract Class<?> findDeserializationContentType(Annotated paramAnnotated, JavaType paramJavaType, String paramString);
  
  public abstract String findSettablePropertyName(AnnotatedMethod paramAnnotatedMethod);
  
  public boolean hasAnySetterAnnotation(AnnotatedMethod am)
  {
    return false;
  }
  
  public boolean hasAnyGetterAnnotation(AnnotatedMethod am)
  {
    return false;
  }
  
  public boolean hasCreatorAnnotation(Annotated a)
  {
    return false;
  }
  
  public abstract String findDeserializablePropertyName(AnnotatedField paramAnnotatedField);
  
  public abstract String findPropertyNameForParam(AnnotatedParameter paramAnnotatedParameter);
  
  public static class Pair
    extends AnnotationIntrospector
  {
    protected final AnnotationIntrospector _primary;
    protected final AnnotationIntrospector _secondary;
    
    public Pair(AnnotationIntrospector p, AnnotationIntrospector s)
    {
      _primary = p;
      _secondary = s;
    }
    
    public static AnnotationIntrospector create(AnnotationIntrospector primary, AnnotationIntrospector secondary)
    {
      if (primary == null) {
        return secondary;
      }
      if (secondary == null) {
        return primary;
      }
      return new Pair(primary, secondary);
    }
    
    public Collection<AnnotationIntrospector> allIntrospectors()
    {
      return allIntrospectors(new ArrayList());
    }
    
    public Collection<AnnotationIntrospector> allIntrospectors(Collection<AnnotationIntrospector> result)
    {
      _primary.allIntrospectors(result);
      _secondary.allIntrospectors(result);
      return result;
    }
    
    public boolean isHandled(Annotation ann)
    {
      return (_primary.isHandled(ann)) || (_secondary.isHandled(ann));
    }
    
    public Boolean findCachability(AnnotatedClass ac)
    {
      Boolean result = _primary.findCachability(ac);
      if (result == null) {
        result = _secondary.findCachability(ac);
      }
      return result;
    }
    
    public String findRootName(AnnotatedClass ac)
    {
      String name1 = _primary.findRootName(ac);
      if (name1 == null) {
        return _secondary.findRootName(ac);
      }
      if (name1.length() > 0) {
        return name1;
      }
      String name2 = _secondary.findRootName(ac);
      return name2 == null ? name1 : name2;
    }
    
    public String[] findPropertiesToIgnore(AnnotatedClass ac)
    {
      String[] result = _primary.findPropertiesToIgnore(ac);
      if (result == null) {
        result = _secondary.findPropertiesToIgnore(ac);
      }
      return result;
    }
    
    public Boolean findIgnoreUnknownProperties(AnnotatedClass ac)
    {
      Boolean result = _primary.findIgnoreUnknownProperties(ac);
      if (result == null) {
        result = _secondary.findIgnoreUnknownProperties(ac);
      }
      return result;
    }
    
    public Boolean isIgnorableType(AnnotatedClass ac)
    {
      Boolean result = _primary.isIgnorableType(ac);
      if (result == null) {
        result = _secondary.isIgnorableType(ac);
      }
      return result;
    }
    
    public Object findFilterId(AnnotatedClass ac)
    {
      Object id = _primary.findFilterId(ac);
      if (id == null) {
        id = _secondary.findFilterId(ac);
      }
      return id;
    }
    
    public VisibilityChecker<?> findAutoDetectVisibility(AnnotatedClass ac, VisibilityChecker<?> checker)
    {
      checker = _secondary.findAutoDetectVisibility(ac, checker);
      return _primary.findAutoDetectVisibility(ac, checker);
    }
    
    public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> config, AnnotatedClass ac, JavaType baseType)
    {
      TypeResolverBuilder<?> b = _primary.findTypeResolver(config, ac, baseType);
      if (b == null) {
        b = _secondary.findTypeResolver(config, ac, baseType);
      }
      return b;
    }
    
    public TypeResolverBuilder<?> findPropertyTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType)
    {
      TypeResolverBuilder<?> b = _primary.findPropertyTypeResolver(config, am, baseType);
      if (b == null) {
        b = _secondary.findPropertyTypeResolver(config, am, baseType);
      }
      return b;
    }
    
    public TypeResolverBuilder<?> findPropertyContentTypeResolver(MapperConfig<?> config, AnnotatedMember am, JavaType baseType)
    {
      TypeResolverBuilder<?> b = _primary.findPropertyContentTypeResolver(config, am, baseType);
      if (b == null) {
        b = _secondary.findPropertyContentTypeResolver(config, am, baseType);
      }
      return b;
    }
    
    public List<NamedType> findSubtypes(Annotated a)
    {
      List<NamedType> types1 = _primary.findSubtypes(a);
      List<NamedType> types2 = _secondary.findSubtypes(a);
      if ((types1 == null) || (types1.isEmpty())) {
        return types2;
      }
      if ((types2 == null) || (types2.isEmpty())) {
        return types1;
      }
      ArrayList<NamedType> result = new ArrayList(types1.size() + types2.size());
      result.addAll(types1);
      result.addAll(types2);
      return result;
    }
    
    public String findTypeName(AnnotatedClass ac)
    {
      String name = _primary.findTypeName(ac);
      if ((name == null) || (name.length() == 0)) {
        name = _secondary.findTypeName(ac);
      }
      return name;
    }
    
    public AnnotationIntrospector.ReferenceProperty findReferenceType(AnnotatedMember member)
    {
      AnnotationIntrospector.ReferenceProperty ref = _primary.findReferenceType(member);
      if (ref == null) {
        ref = _secondary.findReferenceType(member);
      }
      return ref;
    }
    
    public boolean isIgnorableMethod(AnnotatedMethod m)
    {
      return (_primary.isIgnorableMethod(m)) || (_secondary.isIgnorableMethod(m));
    }
    
    public boolean isIgnorableConstructor(AnnotatedConstructor c)
    {
      return (_primary.isIgnorableConstructor(c)) || (_secondary.isIgnorableConstructor(c));
    }
    
    public boolean isIgnorableField(AnnotatedField f)
    {
      return (_primary.isIgnorableField(f)) || (_secondary.isIgnorableField(f));
    }
    
    public Object findSerializer(Annotated am, BeanProperty property)
    {
      Object result = _primary.findSerializer(am, property);
      if (result == null) {
        result = _secondary.findSerializer(am, property);
      }
      return result;
    }
    
    public Object findSerializer(Annotated am)
    {
      Object result = _primary.findSerializer(am);
      if (result == null) {
        result = _secondary.findSerializer(am);
      }
      return result;
    }
    
    public Class<? extends JsonSerializer<?>> findKeySerializer(Annotated a)
    {
      Class<? extends JsonSerializer<?>> result = _primary.findKeySerializer(a);
      if ((result == null) || (result == JsonSerializer.None.class)) {
        result = _secondary.findKeySerializer(a);
      }
      return result;
    }
    
    public Class<? extends JsonSerializer<?>> findContentSerializer(Annotated a)
    {
      Class<? extends JsonSerializer<?>> result = _primary.findContentSerializer(a);
      if ((result == null) || (result == JsonSerializer.None.class)) {
        result = _secondary.findContentSerializer(a);
      }
      return result;
    }
    
    public JsonSerialize.Inclusion findSerializationInclusion(Annotated a, JsonSerialize.Inclusion defValue)
    {
      defValue = _secondary.findSerializationInclusion(a, defValue);
      defValue = _primary.findSerializationInclusion(a, defValue);
      return defValue;
    }
    
    public Class<?> findSerializationType(Annotated a)
    {
      Class<?> result = _primary.findSerializationType(a);
      if (result == null) {
        result = _secondary.findSerializationType(a);
      }
      return result;
    }
    
    public Class<?> findSerializationKeyType(Annotated am, JavaType baseType)
    {
      Class<?> result = _primary.findSerializationKeyType(am, baseType);
      if (result == null) {
        result = _secondary.findSerializationKeyType(am, baseType);
      }
      return result;
    }
    
    public Class<?> findSerializationContentType(Annotated am, JavaType baseType)
    {
      Class<?> result = _primary.findSerializationContentType(am, baseType);
      if (result == null) {
        result = _secondary.findSerializationContentType(am, baseType);
      }
      return result;
    }
    
    public JsonSerialize.Typing findSerializationTyping(Annotated a)
    {
      JsonSerialize.Typing result = _primary.findSerializationTyping(a);
      if (result == null) {
        result = _secondary.findSerializationTyping(a);
      }
      return result;
    }
    
    public Class<?>[] findSerializationViews(Annotated a)
    {
      Class<?>[] result = _primary.findSerializationViews(a);
      if (result == null) {
        result = _secondary.findSerializationViews(a);
      }
      return result;
    }
    
    public String[] findSerializationPropertyOrder(AnnotatedClass ac)
    {
      String[] result = _primary.findSerializationPropertyOrder(ac);
      if (result == null) {
        result = _secondary.findSerializationPropertyOrder(ac);
      }
      return result;
    }
    
    public Boolean findSerializationSortAlphabetically(AnnotatedClass ac)
    {
      Boolean result = _primary.findSerializationSortAlphabetically(ac);
      if (result == null) {
        result = _secondary.findSerializationSortAlphabetically(ac);
      }
      return result;
    }
    
    public String findGettablePropertyName(AnnotatedMethod am)
    {
      String result = _primary.findGettablePropertyName(am);
      if (result == null)
      {
        result = _secondary.findGettablePropertyName(am);
      }
      else if (result.length() == 0)
      {
        String str2 = _secondary.findGettablePropertyName(am);
        if (str2 != null) {
          result = str2;
        }
      }
      return result;
    }
    
    public boolean hasAsValueAnnotation(AnnotatedMethod am)
    {
      return (_primary.hasAsValueAnnotation(am)) || (_secondary.hasAsValueAnnotation(am));
    }
    
    public String findEnumValue(Enum<?> value)
    {
      String result = _primary.findEnumValue(value);
      if (result == null) {
        result = _secondary.findEnumValue(value);
      }
      return result;
    }
    
    public String findSerializablePropertyName(AnnotatedField af)
    {
      String result = _primary.findSerializablePropertyName(af);
      if (result == null)
      {
        result = _secondary.findSerializablePropertyName(af);
      }
      else if (result.length() == 0)
      {
        String str2 = _secondary.findSerializablePropertyName(af);
        if (str2 != null) {
          result = str2;
        }
      }
      return result;
    }
    
    public Object findDeserializer(Annotated am)
    {
      Object result = _primary.findDeserializer(am);
      if (result == null) {
        result = _secondary.findDeserializer(am);
      }
      return result;
    }
    
    public Object findDeserializer(Annotated am, BeanProperty property)
    {
      Object result = _primary.findDeserializer(am, property);
      if (result == null) {
        result = _secondary.findDeserializer(am, property);
      }
      return result;
    }
    
    public Class<? extends KeyDeserializer> findKeyDeserializer(Annotated am)
    {
      Class<? extends KeyDeserializer> result = _primary.findKeyDeserializer(am);
      if ((result == null) || (result == KeyDeserializer.None.class)) {
        result = _secondary.findKeyDeserializer(am);
      }
      return result;
    }
    
    public Class<? extends JsonDeserializer<?>> findContentDeserializer(Annotated am)
    {
      Class<? extends JsonDeserializer<?>> result = _primary.findContentDeserializer(am);
      if ((result == null) || (result == JsonDeserializer.None.class)) {
        result = _secondary.findContentDeserializer(am);
      }
      return result;
    }
    
    public Class<?> findDeserializationType(Annotated am, JavaType baseType, String propName)
    {
      Class<?> result = _primary.findDeserializationType(am, baseType, propName);
      if (result == null) {
        result = _secondary.findDeserializationType(am, baseType, propName);
      }
      return result;
    }
    
    public Class<?> findDeserializationKeyType(Annotated am, JavaType baseKeyType, String propName)
    {
      Class<?> result = _primary.findDeserializationKeyType(am, baseKeyType, propName);
      if (result == null) {
        result = _secondary.findDeserializationKeyType(am, baseKeyType, propName);
      }
      return result;
    }
    
    public Class<?> findDeserializationContentType(Annotated am, JavaType baseContentType, String propName)
    {
      Class<?> result = _primary.findDeserializationContentType(am, baseContentType, propName);
      if (result == null) {
        result = _secondary.findDeserializationContentType(am, baseContentType, propName);
      }
      return result;
    }
    
    public String findSettablePropertyName(AnnotatedMethod am)
    {
      String result = _primary.findSettablePropertyName(am);
      if (result == null)
      {
        result = _secondary.findSettablePropertyName(am);
      }
      else if (result.length() == 0)
      {
        String str2 = _secondary.findSettablePropertyName(am);
        if (str2 != null) {
          result = str2;
        }
      }
      return result;
    }
    
    public boolean hasAnySetterAnnotation(AnnotatedMethod am)
    {
      return (_primary.hasAnySetterAnnotation(am)) || (_secondary.hasAnySetterAnnotation(am));
    }
    
    public boolean hasAnyGetterAnnotation(AnnotatedMethod am)
    {
      return (_primary.hasAnyGetterAnnotation(am)) || (_secondary.hasAnyGetterAnnotation(am));
    }
    
    public boolean hasCreatorAnnotation(Annotated a)
    {
      return (_primary.hasCreatorAnnotation(a)) || (_secondary.hasCreatorAnnotation(a));
    }
    
    public String findDeserializablePropertyName(AnnotatedField af)
    {
      String result = _primary.findDeserializablePropertyName(af);
      if (result == null)
      {
        result = _secondary.findDeserializablePropertyName(af);
      }
      else if (result.length() == 0)
      {
        String str2 = _secondary.findDeserializablePropertyName(af);
        if (str2 != null) {
          result = str2;
        }
      }
      return result;
    }
    
    public String findPropertyNameForParam(AnnotatedParameter param)
    {
      String result = _primary.findPropertyNameForParam(param);
      if (result == null) {
        result = _secondary.findPropertyNameForParam(param);
      }
      return result;
    }
  }
}

/* Location:
 * Qualified Name:     org.codehaus.jackson.map.AnnotationIntrospector
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.codehaus.jackson.map;

import java.util.Collection;
import java.util.LinkedHashMap;
import org.codehaus.jackson.map.introspect.AnnotatedMethod;
import org.codehaus.jackson.map.introspect.VisibilityChecker;
import org.codehaus.jackson.map.type.TypeBindings;
import org.codehaus.jackson.map.util.Annotations;
import org.codehaus.jackson.type.JavaType;

public abstract class BeanDescription
{
  protected final JavaType _type;
  
  protected BeanDescription(JavaType type)
  {
    _type = type;
  }
  
  public JavaType getType()
  {
    return _type;
  }
  
  public Class<?> getBeanClass()
  {
    return _type.getRawClass();
  }
  
  public abstract boolean hasKnownClassAnnotations();
  
  public abstract TypeBindings bindingsForBeanType();
  
  public abstract Annotations getClassAnnotations();
  
  public abstract LinkedHashMap<String, AnnotatedMethod> findGetters(VisibilityChecker<?> paramVisibilityChecker, Collection<String> paramCollection);
  
  public abstract LinkedHashMap<String, AnnotatedMethod> findSetters(VisibilityChecker<?> paramVisibilityChecker);
}

/* Location:
 * Qualified Name:     org.codehaus.jackson.map.BeanDescription
 * Java Class Version: 5 (49.0)
 * JD-Core Version:    0.7.1
 */
package org.codehaus.jackson.map;

import java.lang.annotation.Annotation;
import org.codehaus.jackson.map.introspect.AnnotatedMember;
import org.codehaus.jackson.map.util.Annotations;
import org.codehaus.jackson.type.JavaType;

public class BeanProperty$Std
  implements BeanProperty
{
  protected final String _name;
  protected final JavaType _type;
  protected final AnnotatedMember _member;
  protected final Annotations _contextAnnotations;
  
  public BeanProperty$Std(String name, JavaType type, Annotations contextAnnotations, AnnotatedMember member)
  {
    _name = name;
    _type = type;
    _member = member;
    _contextAnnotations = contextAnnotations;
  }
  
  public Std withType(JavaType type)
  {
    return new Std(_name, type, _contextAnnotations, _member);
  }
  
  public <A extends Annotation> A getAnnotation(Class<A> acls)
  {
    return _member.getAnnotation(acls);
  }
  
  public <A extends Annotation> A getContextAnnotation(Class<A> acls)
  {
    return _contextAnnotations == null ? null : _contextAnnotations.get(acls);
  }
  
  public String getName()
  {
    return _name;
  }
  
  public JavaType getType()
  {
    return _ty
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33

Further reading...

For more information on Java 1.5 Tiger, you may find Java 1.5 Tiger, A developer's Notebook by D. Flanagan and B. McLaughlin from O'Reilly of interest.

New!JAR listings


Copyright 2006-2017. Infinite Loop Ltd