Java 类com.fasterxml.jackson.databind.introspect.AnnotatedMember 实例源码

public DefaultMethodSkippingModuleProvider() {
    module = new SimpleModule();
    module.setSerializerModifier(new BeanSerializerModifier() {
        @Override
        public List<BeanPropertyWriter> changeProperties(SerializationConfig config, BeanDescription beanDesc, List<BeanPropertyWriter> beanProperties) {

            return super.changeProperties(config, beanDesc, beanProperties.stream().filter(bpw -> {
                final AnnotatedMember jacksonMember = bpw.getMember();
                final Member member = jacksonMember.getMember();
                if (member instanceof Method) {
                    final Method method = (Method) member;
                    if (method.isDefault()) {
                        // only exclude default methods if they are defined on interfaces from the core components
                        return !method.getDeclaringClass().getName().startsWith(PACKAGE_CORE_COMPONENTS);
                    }
                }
                return true;
            }).collect(Collectors.toList()));
        }
    });
}

@Override
public void setupModule(SetupContext context) {

    context.insertAnnotationIntrospector(new NopAnnotationIntrospector() {

        private static final long serialVersionUID = 479313244908256455L;

        @Override
        public boolean hasIgnoreMarker(AnnotatedMember m) {

            if (!(m instanceof AnnotatedMethod)) {
                return super.hasIgnoreMarker(m);
            }

            AnnotatedMethod method = (AnnotatedMethod) m;

            return method.getName().startsWith("lambda$") ? true : super.hasIgnoreMarker(m);
        }
    });
}

@Override
public Boolean hasRequiredMarker(AnnotatedMember m)
{
    ApiParam apiParam = m.getAnnotation(ApiParam.class);
    if (apiParam != null) {
        return apiParam.required();
    }

    ApiModelProperty ann = m.getAnnotation(ApiModelProperty.class);
    if (ann != null) {
        return ann.required();
    }
    XmlElement elem = m.getAnnotation(XmlElement.class);
    if (elem != null) {
        if (elem.required()) {
            return true;
        }
    }
    return null;
}

protected BeanPropertyWriter _constructWriter(SerializerProvider paramSerializerProvider, BeanPropertyDefinition paramBeanPropertyDefinition, TypeBindings paramTypeBindings, PropertyBuilder paramPropertyBuilder, boolean paramBoolean, AnnotatedMember paramAnnotatedMember)
{
  String str = paramBeanPropertyDefinition.getName();
  if (paramSerializerProvider.canOverrideAccessModifiers())
    paramAnnotatedMember.fixAccess();
  JavaType localJavaType = paramAnnotatedMember.getType(paramTypeBindings);
  BeanProperty.Std localStd = new BeanProperty.Std(str, localJavaType, paramBeanPropertyDefinition.getWrapperName(), paramPropertyBuilder.getClassAnnotations(), paramAnnotatedMember, paramBeanPropertyDefinition.isRequired());
  JsonSerializer localJsonSerializer1 = findSerializerFromAnnotation(paramSerializerProvider, paramAnnotatedMember);
  JsonSerializer localJsonSerializer2 = localJsonSerializer1;
  if ((localJsonSerializer1 instanceof ResolvableSerializer))
    ((ResolvableSerializer)localJsonSerializer2).resolve(paramSerializerProvider);
  if ((localJsonSerializer2 instanceof ContextualSerializer))
    localJsonSerializer2 = ((ContextualSerializer)localJsonSerializer2).createContextual(paramSerializerProvider, localStd);
  boolean bool = ClassUtil.isCollectionMapOrArray(localJavaType.getRawClass());
  TypeSerializer localTypeSerializer1 = null;
  if (bool)
    localTypeSerializer1 = findPropertyContentTypeSerializer(localJavaType, paramSerializerProvider.getConfig(), paramAnnotatedMember);
  TypeSerializer localTypeSerializer2 = findPropertyTypeSerializer(localJavaType, paramSerializerProvider.getConfig(), paramAnnotatedMember);
  return paramPropertyBuilder.buildWriter(paramBeanPropertyDefinition, localJavaType, localJsonSerializer2, localTypeSerializer2, localTypeSerializer1, paramAnnotatedMember, paramBoolean);
}

protected void addInjectables(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, BeanDeserializerBuilder paramBeanDeserializerBuilder)
{
  Map localMap = paramBeanDescription.findInjectables();
  if (localMap != null)
  {
    boolean bool = paramDeserializationContext.canOverrideAccessModifiers();
    Iterator localIterator = localMap.entrySet().iterator();
    while (localIterator.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)localIterator.next();
      AnnotatedMember localAnnotatedMember = (AnnotatedMember)localEntry.getValue();
      if (bool)
        localAnnotatedMember.fixAccess();
      paramBeanDeserializerBuilder.addInjectable(localAnnotatedMember.getName(), paramBeanDescription.resolveType(localAnnotatedMember.getGenericType()), paramBeanDescription.getClassAnnotations(), localAnnotatedMember, localEntry.getKey());
    }
  }
}

protected void addReferenceProperties(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, BeanDeserializerBuilder paramBeanDeserializerBuilder)
{
  Map localMap = paramBeanDescription.findBackReferenceProperties();
  if (localMap != null)
  {
    Iterator localIterator = localMap.entrySet().iterator();
    while (localIterator.hasNext())
    {
      Map.Entry localEntry = (Map.Entry)localIterator.next();
      String str = (String)localEntry.getKey();
      AnnotatedMember localAnnotatedMember = (AnnotatedMember)localEntry.getValue();
      Object localObject;
      if ((localAnnotatedMember instanceof AnnotatedMethod))
        localObject = ((AnnotatedMethod)localAnnotatedMember).getGenericParameterType(0);
      else
        localObject = localAnnotatedMember.getRawType();
      paramBeanDeserializerBuilder.addBackReferenceProperty(str, constructSettableProperty(paramDeserializationContext, paramBeanDescription, SimpleBeanPropertyDefinition.construct(paramDeserializationContext.getConfig(), localAnnotatedMember), (Type)localObject));
    }
  }
}

protected SettableBeanProperty constructSettableProperty(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, BeanPropertyDefinition paramBeanPropertyDefinition, Type paramType)
{
  AnnotatedMember localAnnotatedMember = paramBeanPropertyDefinition.getMutator();
  if (paramDeserializationContext.canOverrideAccessModifiers())
    localAnnotatedMember.fixAccess();
  JavaType localJavaType1 = paramBeanDescription.resolveType(paramType);
  BeanProperty.Std localStd = new BeanProperty.Std(paramBeanPropertyDefinition.getName(), localJavaType1, paramBeanPropertyDefinition.getWrapperName(), paramBeanDescription.getClassAnnotations(), localAnnotatedMember, paramBeanPropertyDefinition.isRequired());
  JavaType localJavaType2 = resolveType(paramDeserializationContext, paramBeanDescription, localJavaType1, localAnnotatedMember);
  if (localJavaType2 != localJavaType1)
    localStd.withType(localJavaType2);
  JsonDeserializer localJsonDeserializer = findDeserializerFromAnnotation(paramDeserializationContext, localAnnotatedMember);
  JavaType localJavaType3 = modifyTypeByAnnotation(paramDeserializationContext, localAnnotatedMember, localJavaType2);
  TypeDeserializer localTypeDeserializer = (TypeDeserializer)localJavaType3.getTypeHandler();
  Object localObject;
  if ((localAnnotatedMember instanceof AnnotatedMethod))
    localObject = new MethodProperty(paramBeanPropertyDefinition, localJavaType3, localTypeDeserializer, paramBeanDescription.getClassAnnotations(), (AnnotatedMethod)localAnnotatedMember);
  else
    localObject = new FieldProperty(paramBeanPropertyDefinition, localJavaType3, localTypeDeserializer, paramBeanDescription.getClassAnnotations(), (AnnotatedField)localAnnotatedMember);
  if (localJsonDeserializer != null)
    localObject = ((SettableBeanProperty)localObject).withValueDeserializer(localJsonDeserializer);
  AnnotationIntrospector.ReferenceProperty localReferenceProperty = paramBeanPropertyDefinition.findReferenceType();
  if ((localReferenceProperty != null) && (localReferenceProperty.isManagedReference()))
    ((SettableBeanProperty)localObject).setManagedReferenceName(localReferenceProperty.getName());
  return localObject;
}

protected SettableBeanProperty _resolveUnwrappedProperty(DeserializationContext paramDeserializationContext, SettableBeanProperty paramSettableBeanProperty)
{
  AnnotatedMember localAnnotatedMember = paramSettableBeanProperty.getMember();
  if (localAnnotatedMember != null)
  {
    NameTransformer localNameTransformer = paramDeserializationContext.getAnnotationIntrospector().findUnwrappingNameTransformer(localAnnotatedMember);
    if (localNameTransformer != null)
    {
      JsonDeserializer localJsonDeserializer1 = paramSettableBeanProperty.getValueDeserializer();
      JsonDeserializer localJsonDeserializer2 = localJsonDeserializer1.unwrappingDeserializer(localNameTransformer);
      if ((localJsonDeserializer2 != localJsonDeserializer1) && (localJsonDeserializer2 != null))
        return paramSettableBeanProperty.withValueDeserializer(localJsonDeserializer2);
    }
  }
  return null;
}

@Override
public BeanDeserializerBuilder updateBuilder(DeserializationConfig config, BeanDescription beanDesc, BeanDeserializerBuilder builder) {
    for (BeanPropertyDefinition propDef : beanDesc.findProperties()) {
        if (!propDef.hasGetter() || propDef.hasSetter()) {
            continue;
        }
        AnnotatedMember getter = propDef.getAccessor();
        if (!Keeper.class.equals(getter.getRawType())) {
            continue;
        }

        builder.addOrReplaceProperty(new CustomGetterBeanProperty(propDef, getter), true);
    }
    return builder;
}

@Override
public boolean hasIgnoreMarker(AnnotatedMember m) {
    if (!(m instanceof AnnotatedField) && !(m instanceof AnnotatedMethod)) return false;

    return (m.getAnnotation(IndexableProperty.class) == null
        && m.getAnnotation(IndexableComponent.class) == null && m.getAnnotation(IndexableProperties.class) == null);
}

@Override
public boolean hasIgnoreMarker(AnnotatedMember m)
{
    ApiModelProperty ann = m.getAnnotation(ApiModelProperty.class);
    if (ann != null && ann.hidden()) {
        return true;
    }
    return false;
}

@Override
public String findImplicitPropertyName(AnnotatedMember member)
{
    ApiParam annotation = member.getAnnotation(ApiParam.class);
    if (annotation != null && annotation.value() != "") {
        return annotation.value();
    }
    else {
        return super.findImplicitPropertyName(member);
    }
}

public Std(String paramString, JavaType paramJavaType, PropertyName paramPropertyName, Annotations paramAnnotations, AnnotatedMember paramAnnotatedMember, boolean paramBoolean)
{
  this._name = paramString;
  this._type = paramJavaType;
  this._wrapperName = paramPropertyName;
  this._isRequired = paramBoolean;
  this._member = paramAnnotatedMember;
  this._contextAnnotations = paramAnnotations;
}

public Collection<NamedType> collectAndResolveSubtypes(AnnotatedMember paramAnnotatedMember, MapperConfig<?> paramMapperConfig, AnnotationIntrospector paramAnnotationIntrospector, JavaType paramJavaType)
{
  Class localClass;
  if (paramJavaType == null)
    localClass = paramAnnotatedMember.getRawType();
  else
    localClass = paramJavaType.getRawClass();
  HashMap localHashMap = new HashMap();
  if (this._registeredSubtypes != null)
  {
    Iterator localIterator2 = this._registeredSubtypes.iterator();
    while (localIterator2.hasNext())
    {
      NamedType localNamedType3 = (NamedType)localIterator2.next();
      if (localClass.isAssignableFrom(localNamedType3.getType()))
        _collectAndResolve(AnnotatedClass.constructWithoutSuperTypes(localNamedType3.getType(), paramAnnotationIntrospector, paramMapperConfig), localNamedType3, paramMapperConfig, paramAnnotationIntrospector, localHashMap);
    }
  }
  List localList = paramAnnotationIntrospector.findSubtypes(paramAnnotatedMember);
  if (localList != null)
  {
    Iterator localIterator1 = localList.iterator();
    while (localIterator1.hasNext())
    {
      NamedType localNamedType2 = (NamedType)localIterator1.next();
      _collectAndResolve(AnnotatedClass.constructWithoutSuperTypes(localNamedType2.getType(), paramAnnotationIntrospector, paramMapperConfig), localNamedType2, paramMapperConfig, paramAnnotationIntrospector, localHashMap);
    }
  }
  NamedType localNamedType1 = new NamedType(localClass, null);
  _collectAndResolve(AnnotatedClass.constructWithoutSuperTypes(localClass, paramAnnotationIntrospector, paramMapperConfig), localNamedType1, paramMapperConfig, paramAnnotationIntrospector, localHashMap);
  return new ArrayList(localHashMap.values());
}

public JsonSerializer<?> createContextual(SerializerProvider paramSerializerProvider, BeanProperty paramBeanProperty)
{
  TypeSerializer localTypeSerializer1 = this._valueTypeSerializer;
  TypeSerializer localTypeSerializer2 = localTypeSerializer1;
  if (localTypeSerializer1 != null)
    localTypeSerializer2 = localTypeSerializer2.forProperty(paramBeanProperty);
  JsonSerializer localJsonSerializer1 = null;
  if (paramBeanProperty != null)
  {
    AnnotatedMember localAnnotatedMember = paramBeanProperty.getMember();
    localJsonSerializer1 = null;
    if (localAnnotatedMember != null)
    {
      Object localObject = paramSerializerProvider.getAnnotationIntrospector().findContentSerializer(localAnnotatedMember);
      localJsonSerializer1 = null;
      if (localObject != null)
        localJsonSerializer1 = paramSerializerProvider.serializerInstance(localAnnotatedMember, localObject);
    }
  }
  if (localJsonSerializer1 == null)
    localJsonSerializer1 = this._elementSerializer;
  JsonSerializer localJsonSerializer2 = findConvertingContentSerializer(paramSerializerProvider, paramBeanProperty, localJsonSerializer1);
  JsonSerializer localJsonSerializer3 = localJsonSerializer2;
  if (localJsonSerializer2 == null)
  {
    if ((this._elementType != null) && ((this._staticTyping) || (hasContentTypeAnnotation(paramSerializerProvider, paramBeanProperty))))
      localJsonSerializer3 = paramSerializerProvider.findValueSerializer(this._elementType, paramBeanProperty);
  }
  else if ((localJsonSerializer3 instanceof ContextualSerializer))
    localJsonSerializer3 = ((ContextualSerializer)localJsonSerializer3).createContextual(paramSerializerProvider, paramBeanProperty);
  return withResolved(paramBeanProperty, localTypeSerializer2, localJsonSerializer3);
}

public JsonSerializer<?> createContextual(SerializerProvider paramSerializerProvider, BeanProperty paramBeanProperty)
{
  TypeSerializer localTypeSerializer1 = this._valueTypeSerializer;
  TypeSerializer localTypeSerializer2 = localTypeSerializer1;
  if (localTypeSerializer1 != null)
    localTypeSerializer2 = localTypeSerializer2.forProperty(paramBeanProperty);
  JsonSerializer localJsonSerializer1 = null;
  if (paramBeanProperty != null)
  {
    AnnotatedMember localAnnotatedMember = paramBeanProperty.getMember();
    localJsonSerializer1 = null;
    if (localAnnotatedMember != null)
    {
      Object localObject = paramSerializerProvider.getAnnotationIntrospector().findContentSerializer(localAnnotatedMember);
      localJsonSerializer1 = null;
      if (localObject != null)
        localJsonSerializer1 = paramSerializerProvider.serializerInstance(localAnnotatedMember, localObject);
    }
  }
  if (localJsonSerializer1 == null)
    localJsonSerializer1 = this._elementSerializer;
  JsonSerializer localJsonSerializer2 = findConvertingContentSerializer(paramSerializerProvider, paramBeanProperty, localJsonSerializer1);
  JsonSerializer localJsonSerializer3 = localJsonSerializer2;
  if (localJsonSerializer2 == null)
  {
    if ((localJsonSerializer3 == null) && (this._elementType != null) && ((this._staticTyping) || (hasContentTypeAnnotation(paramSerializerProvider, paramBeanProperty))))
      localJsonSerializer3 = paramSerializerProvider.findValueSerializer(this._elementType, paramBeanProperty);
  }
  else if ((localJsonSerializer3 instanceof ContextualSerializer))
    localJsonSerializer3 = ((ContextualSerializer)localJsonSerializer3).createContextual(paramSerializerProvider, paramBeanProperty);
  if ((localJsonSerializer3 != this._elementSerializer) || (paramBeanProperty != this._property) || (this._valueTypeSerializer != localTypeSerializer2))
    return withResolved(paramBeanProperty, localTypeSerializer2, localJsonSerializer3);
  return this;
}

public JsonSerializer<?> createContextual(SerializerProvider paramSerializerProvider, BeanProperty paramBeanProperty)
{
  JsonSerializer localJsonSerializer1 = null;
  if (paramBeanProperty != null)
  {
    AnnotatedMember localAnnotatedMember = paramBeanProperty.getMember();
    localJsonSerializer1 = null;
    if (localAnnotatedMember != null)
    {
      Object localObject = paramSerializerProvider.getAnnotationIntrospector().findContentSerializer(localAnnotatedMember);
      localJsonSerializer1 = null;
      if (localObject != null)
        localJsonSerializer1 = paramSerializerProvider.serializerInstance(localAnnotatedMember, localObject);
    }
  }
  if (localJsonSerializer1 == null)
    localJsonSerializer1 = this._valueSerializer;
  JsonSerializer localJsonSerializer2 = findConvertingContentSerializer(paramSerializerProvider, paramBeanProperty, localJsonSerializer1);
  JsonSerializer localJsonSerializer3 = localJsonSerializer2;
  if (localJsonSerializer2 == null)
  {
    if (this._staticTyping)
      return withValueSerializer(paramBeanProperty, paramSerializerProvider.findValueSerializer(this._valueType, paramBeanProperty));
  }
  else if ((this._valueSerializer instanceof ContextualSerializer))
    localJsonSerializer3 = ((ContextualSerializer)localJsonSerializer3).createContextual(paramSerializerProvider, paramBeanProperty);
  if (localJsonSerializer3 != this._valueSerializer)
    return withValueSerializer(paramBeanProperty, localJsonSerializer3);
  return this;
}

protected List<BeanPropertyWriter> findBeanProperties(SerializerProvider paramSerializerProvider, BeanDescription paramBeanDescription, BeanSerializerBuilder paramBeanSerializerBuilder)
{
  List localList = paramBeanDescription.findProperties();
  SerializationConfig localSerializationConfig = paramSerializerProvider.getConfig();
  removeIgnorableTypes(localSerializationConfig, paramBeanDescription, localList);
  if (localSerializationConfig.isEnabled(MapperFeature.REQUIRE_SETTERS_FOR_GETTERS))
    removeSetterlessGetters(localSerializationConfig, paramBeanDescription, localList);
  if (localList.isEmpty())
    return null;
  boolean bool = usesStaticTyping(localSerializationConfig, paramBeanDescription, null);
  PropertyBuilder localPropertyBuilder = constructPropertyBuilder(localSerializationConfig, paramBeanDescription);
  ArrayList localArrayList = new ArrayList(localList.size());
  TypeBindings localTypeBindings = paramBeanDescription.bindingsForBeanType();
  Iterator localIterator = localList.iterator();
  while (localIterator.hasNext())
  {
    BeanPropertyDefinition localBeanPropertyDefinition = (BeanPropertyDefinition)localIterator.next();
    AnnotatedMember localAnnotatedMember = localBeanPropertyDefinition.getAccessor();
    if (localBeanPropertyDefinition.isTypeId())
    {
      if (localAnnotatedMember != null)
      {
        if (localSerializationConfig.canOverrideAccessModifiers())
          localAnnotatedMember.fixAccess();
        paramBeanSerializerBuilder.setTypeId(localAnnotatedMember);
      }
    }
    else
    {
      AnnotationIntrospector.ReferenceProperty localReferenceProperty = localBeanPropertyDefinition.findReferenceType();
      if ((localReferenceProperty == null) || (!localReferenceProperty.isBackReference()))
        if ((localAnnotatedMember instanceof AnnotatedMethod))
          localArrayList.add(_constructWriter(paramSerializerProvider, localBeanPropertyDefinition, localTypeBindings, localPropertyBuilder, bool, (AnnotatedMethod)localAnnotatedMember));
        else
          localArrayList.add(_constructWriter(paramSerializerProvider, localBeanPropertyDefinition, localTypeBindings, localPropertyBuilder, bool, (AnnotatedField)localAnnotatedMember));
    }
  }
  return localArrayList;
}

public TypeSerializer findPropertyContentTypeSerializer(JavaType paramJavaType, SerializationConfig paramSerializationConfig, AnnotatedMember paramAnnotatedMember)
{
  JavaType localJavaType = paramJavaType.getContentType();
  AnnotationIntrospector localAnnotationIntrospector = paramSerializationConfig.getAnnotationIntrospector();
  TypeResolverBuilder localTypeResolverBuilder = localAnnotationIntrospector.findPropertyContentTypeResolver(paramSerializationConfig, paramAnnotatedMember, paramJavaType);
  if (localTypeResolverBuilder == null)
    return createTypeSerializer(paramSerializationConfig, localJavaType);
  return localTypeResolverBuilder.buildTypeSerializer(paramSerializationConfig, localJavaType, paramSerializationConfig.getSubtypeResolver().collectAndResolveSubtypes(paramAnnotatedMember, paramSerializationConfig, localAnnotationIntrospector, localJavaType));
}

public TypeSerializer findPropertyTypeSerializer(JavaType paramJavaType, SerializationConfig paramSerializationConfig, AnnotatedMember paramAnnotatedMember)
{
  AnnotationIntrospector localAnnotationIntrospector = paramSerializationConfig.getAnnotationIntrospector();
  TypeResolverBuilder localTypeResolverBuilder = localAnnotationIntrospector.findPropertyTypeResolver(paramSerializationConfig, paramAnnotatedMember, paramJavaType);
  if (localTypeResolverBuilder == null)
    return createTypeSerializer(paramSerializationConfig, paramJavaType);
  return localTypeResolverBuilder.buildTypeSerializer(paramSerializationConfig, paramJavaType, paramSerializationConfig.getSubtypeResolver().collectAndResolveSubtypes(paramAnnotatedMember, paramSerializationConfig, localAnnotationIntrospector, paramJavaType));
}

protected void removeIgnorableTypes(SerializationConfig paramSerializationConfig, BeanDescription paramBeanDescription, List<BeanPropertyDefinition> paramList)
{
  AnnotationIntrospector localAnnotationIntrospector = paramSerializationConfig.getAnnotationIntrospector();
  HashMap localHashMap = new HashMap();
  Iterator localIterator = paramList.iterator();
  while (localIterator.hasNext())
  {
    AnnotatedMember localAnnotatedMember = ((BeanPropertyDefinition)localIterator.next()).getAccessor();
    if (localAnnotatedMember == null)
    {
      localIterator.remove();
    }
    else
    {
      Class localClass = localAnnotatedMember.getRawType();
      Boolean localBoolean1 = (Boolean)localHashMap.get(localClass);
      Object localObject = localBoolean1;
      if (localBoolean1 == null)
      {
        Boolean localBoolean2 = localAnnotationIntrospector.isIgnorableType(paramSerializationConfig.introspectClassAnnotations(localClass).getClassInfo());
        localObject = localBoolean2;
        if (localBoolean2 == null)
          localObject = Boolean.FALSE;
        localHashMap.put(localClass, localObject);
      }
      if (((Boolean)localObject).booleanValue())
        localIterator.remove();
    }
  }
}

public BeanPropertyWriter(BeanPropertyDefinition paramBeanPropertyDefinition, AnnotatedMember paramAnnotatedMember, Annotations paramAnnotations, JavaType paramJavaType1, JsonSerializer<?> paramJsonSerializer, TypeSerializer paramTypeSerializer, JavaType paramJavaType2, boolean paramBoolean, Object paramObject)
{
  this._member = paramAnnotatedMember;
  this._contextAnnotations = paramAnnotations;
  this._name = new SerializedString(paramBeanPropertyDefinition.getName());
  this._wrapperName = paramBeanPropertyDefinition.getWrapperName();
  this._declaredType = paramJavaType1;
  this._serializer = paramJsonSerializer;
  PropertySerializerMap localPropertySerializerMap;
  if (paramJsonSerializer == null)
    localPropertySerializerMap = PropertySerializerMap.emptyMap();
  else
    localPropertySerializerMap = null;
  this._dynamicSerializers = localPropertySerializerMap;
  this._typeSerializer = paramTypeSerializer;
  this._cfgSerializationType = paramJavaType2;
  this._isRequired = paramBeanPropertyDefinition.isRequired();
  if ((paramAnnotatedMember instanceof AnnotatedField))
  {
    this._accessorMethod = null;
    this._field = ((Field)paramAnnotatedMember.getMember());
  }
  else if ((paramAnnotatedMember instanceof AnnotatedMethod))
  {
    this._accessorMethod = ((Method)paramAnnotatedMember.getMember());
    this._field = null;
  }
  else
  {
    throw new IllegalArgumentException("Can not pass member of type " + paramAnnotatedMember.getClass().getName());
  }
  this._suppressNulls = paramBoolean;
  this._suppressableValue = paramObject;
  this._includeInViews = paramBeanPropertyDefinition.findViews();
  this._nullSerializer = null;
}

protected Object getDefaultValue(String paramString, AnnotatedMember paramAnnotatedMember)
{
  Object localObject1 = getDefaultBean();
  try
  {
    Object localObject2 = paramAnnotatedMember.getValue(localObject1);
    return localObject2;
  }
  catch (Exception localException)
  {
    return _throwWrapped(localException, paramString, localObject1);
  }
}

public final JsonSerializer<?> createContextual(SerializerProvider paramSerializerProvider, BeanProperty paramBeanProperty)
{
  JsonSerializer localJsonSerializer1 = null;
  if (paramBeanProperty != null)
  {
    AnnotatedMember localAnnotatedMember = paramBeanProperty.getMember();
    localJsonSerializer1 = null;
    if (localAnnotatedMember != null)
    {
      Object localObject = paramSerializerProvider.getAnnotationIntrospector().findContentSerializer(localAnnotatedMember);
      localJsonSerializer1 = null;
      if (localObject != null)
        localJsonSerializer1 = paramSerializerProvider.serializerInstance(localAnnotatedMember, localObject);
    }
  }
  if (localJsonSerializer1 == null)
    localJsonSerializer1 = this._serializer;
  JsonSerializer localJsonSerializer2 = findConvertingContentSerializer(paramSerializerProvider, paramBeanProperty, localJsonSerializer1);
  JsonSerializer localJsonSerializer3 = localJsonSerializer2;
  if (localJsonSerializer2 == null)
    localJsonSerializer3 = paramSerializerProvider.findValueSerializer(String.class, paramBeanProperty);
  else if ((localJsonSerializer3 instanceof ContextualSerializer))
    localJsonSerializer3 = ((ContextualSerializer)localJsonSerializer3).createContextual(paramSerializerProvider, paramBeanProperty);
  if (isDefaultSerializer(localJsonSerializer3))
    localJsonSerializer3 = null;
  if (localJsonSerializer3 == this._serializer)
    return this;
  return new IndexedStringListSerializer(localJsonSerializer3);
}

public JsonSerializer<?> createContextual(SerializerProvider paramSerializerProvider, BeanProperty paramBeanProperty)
{
  JsonSerializer localJsonSerializer1 = null;
  if (paramBeanProperty != null)
  {
    AnnotatedMember localAnnotatedMember = paramBeanProperty.getMember();
    localJsonSerializer1 = null;
    if (localAnnotatedMember != null)
    {
      Object localObject = paramSerializerProvider.getAnnotationIntrospector().findContentSerializer(localAnnotatedMember);
      localJsonSerializer1 = null;
      if (localObject != null)
        localJsonSerializer1 = paramSerializerProvider.serializerInstance(localAnnotatedMember, localObject);
    }
  }
  if (localJsonSerializer1 == null)
    localJsonSerializer1 = this._serializer;
  JsonSerializer localJsonSerializer2 = findConvertingContentSerializer(paramSerializerProvider, paramBeanProperty, localJsonSerializer1);
  JsonSerializer localJsonSerializer3 = localJsonSerializer2;
  if (localJsonSerializer2 == null)
    localJsonSerializer3 = paramSerializerProvider.findValueSerializer(String.class, paramBeanProperty);
  else if ((localJsonSerializer3 instanceof ContextualSerializer))
    localJsonSerializer3 = ((ContextualSerializer)localJsonSerializer3).createContextual(paramSerializerProvider, paramBeanProperty);
  if (isDefaultSerializer(localJsonSerializer3))
    localJsonSerializer3 = null;
  if (localJsonSerializer3 == this._serializer)
    return this;
  return new StringCollectionSerializer(localJsonSerializer3);
}

public JsonSerializer<?> createContextual(SerializerProvider paramSerializerProvider, BeanProperty paramBeanProperty)
{
  JsonSerializer localJsonSerializer1 = null;
  if (paramBeanProperty != null)
  {
    AnnotatedMember localAnnotatedMember = paramBeanProperty.getMember();
    localJsonSerializer1 = null;
    if (localAnnotatedMember != null)
    {
      Object localObject = paramSerializerProvider.getAnnotationIntrospector().findContentSerializer(localAnnotatedMember);
      localJsonSerializer1 = null;
      if (localObject != null)
        localJsonSerializer1 = paramSerializerProvider.serializerInstance(localAnnotatedMember, localObject);
    }
  }
  if (localJsonSerializer1 == null)
    localJsonSerializer1 = this._elementSerializer;
  JsonSerializer localJsonSerializer2 = findConvertingContentSerializer(paramSerializerProvider, paramBeanProperty, localJsonSerializer1);
  JsonSerializer localJsonSerializer3 = localJsonSerializer2;
  if (localJsonSerializer2 == null)
    localJsonSerializer3 = paramSerializerProvider.findValueSerializer(String.class, paramBeanProperty);
  else if ((localJsonSerializer3 instanceof ContextualSerializer))
    localJsonSerializer3 = ((ContextualSerializer)localJsonSerializer3).createContextual(paramSerializerProvider, paramBeanProperty);
  if (isDefaultSerializer(localJsonSerializer3))
    localJsonSerializer3 = null;
  if (localJsonSerializer3 == this._elementSerializer)
    return this;
  return new StringArraySerializer(this, paramBeanProperty, localJsonSerializer3);
}

public TypeDeserializer findPropertyContentTypeDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, AnnotatedMember paramAnnotatedMember)
{
  AnnotationIntrospector localAnnotationIntrospector = paramDeserializationConfig.getAnnotationIntrospector();
  TypeResolverBuilder localTypeResolverBuilder = localAnnotationIntrospector.findPropertyContentTypeResolver(paramDeserializationConfig, paramAnnotatedMember, paramJavaType);
  JavaType localJavaType = paramJavaType.getContentType();
  if (localTypeResolverBuilder == null)
    return findTypeDeserializer(paramDeserializationConfig, localJavaType);
  return localTypeResolverBuilder.buildTypeDeserializer(paramDeserializationConfig, localJavaType, paramDeserializationConfig.getSubtypeResolver().collectAndResolveSubtypes(paramAnnotatedMember, paramDeserializationConfig, localAnnotationIntrospector, localJavaType));
}

public TypeDeserializer findPropertyTypeDeserializer(DeserializationConfig paramDeserializationConfig, JavaType paramJavaType, AnnotatedMember paramAnnotatedMember)
{
  AnnotationIntrospector localAnnotationIntrospector = paramDeserializationConfig.getAnnotationIntrospector();
  TypeResolverBuilder localTypeResolverBuilder = localAnnotationIntrospector.findPropertyTypeResolver(paramDeserializationConfig, paramAnnotatedMember, paramJavaType);
  if (localTypeResolverBuilder == null)
    return findTypeDeserializer(paramDeserializationConfig, paramJavaType);
  return localTypeResolverBuilder.buildTypeDeserializer(paramDeserializationConfig, paramJavaType, paramDeserializationConfig.getSubtypeResolver().collectAndResolveSubtypes(paramAnnotatedMember, paramDeserializationConfig, localAnnotationIntrospector, paramJavaType));
}

protected JavaType resolveType(DeserializationContext paramDeserializationContext, BeanDescription paramBeanDescription, JavaType paramJavaType, AnnotatedMember paramAnnotatedMember)
{
  if (paramJavaType.isContainerType())
  {
    AnnotationIntrospector localAnnotationIntrospector = paramDeserializationContext.getAnnotationIntrospector();
    if (paramJavaType.getKeyType() != null)
    {
      KeyDeserializer localKeyDeserializer = paramDeserializationContext.keyDeserializerInstance(paramAnnotatedMember, localAnnotationIntrospector.findKeyDeserializer(paramAnnotatedMember));
      if (localKeyDeserializer != null)
      {
        MapLikeType localMapLikeType = ((MapLikeType)paramJavaType).withKeyValueHandler(localKeyDeserializer);
        paramJavaType = localMapLikeType;
        localMapLikeType.getKeyType();
      }
    }
    JsonDeserializer localJsonDeserializer = paramDeserializationContext.deserializerInstance(paramAnnotatedMember, localAnnotationIntrospector.findContentDeserializer(paramAnnotatedMember));
    if (localJsonDeserializer != null)
      paramJavaType = paramJavaType.withContentValueHandler(localJsonDeserializer);
    if ((paramAnnotatedMember instanceof AnnotatedMember))
    {
      TypeDeserializer localTypeDeserializer2 = findPropertyContentTypeDeserializer(paramDeserializationContext.getConfig(), paramJavaType, paramAnnotatedMember);
      if (localTypeDeserializer2 != null)
        paramJavaType = paramJavaType.withContentTypeHandler(localTypeDeserializer2);
    }
  }
  TypeDeserializer localTypeDeserializer1;
  if ((paramAnnotatedMember instanceof AnnotatedMember))
    localTypeDeserializer1 = findPropertyTypeDeserializer(paramDeserializationContext.getConfig(), paramJavaType, paramAnnotatedMember);
  else
    localTypeDeserializer1 = findTypeDeserializer(paramDeserializationContext.getConfig(), paramJavaType);
  if (localTypeDeserializer1 != null)
    paramJavaType = paramJavaType.withTypeHandler(localTypeDeserializer1);
  return paramJavaType;
}

public static SimpleBeanPropertyDefinition construct(MapperConfig<?> paramMapperConfig, AnnotatedMember paramAnnotatedMember)
{
  String str = paramAnnotatedMember.getName();
  AnnotationIntrospector localAnnotationIntrospector;
  if (paramMapperConfig == null)
    localAnnotationIntrospector = null;
  else
    localAnnotationIntrospector = paramMapperConfig.getAnnotationIntrospector();
  return new SimpleBeanPropertyDefinition(paramAnnotatedMember, str, localAnnotationIntrospector);
}

public static SimpleBeanPropertyDefinition construct(MapperConfig<?> paramMapperConfig, AnnotatedMember paramAnnotatedMember, String paramString)
{
  AnnotationIntrospector localAnnotationIntrospector;
  if (paramMapperConfig == null)
    localAnnotationIntrospector = null;
  else
    localAnnotationIntrospector = paramMapperConfig.getAnnotationIntrospector();
  return new SimpleBeanPropertyDefinition(paramAnnotatedMember, paramString, localAnnotationIntrospector);
}

public AnnotatedMember getAccessor()
{
  AnnotatedMethod localAnnotatedMethod = getGetter();
  Object localObject = localAnnotatedMethod;
  if (localAnnotatedMethod == null)
    localObject = getField();
  return localObject;
}

public AnnotatedMember getMutator()
{
  AnnotatedParameter localAnnotatedParameter = getConstructorParameter();
  Object localObject = localAnnotatedParameter;
  if (localAnnotatedParameter == null)
  {
    AnnotatedMethod localAnnotatedMethod = getSetter();
    localObject = localAnnotatedMethod;
    if (localAnnotatedMethod == null)
      localObject = getField();
  }
  return localObject;
}

@Override
public String findImplicitPropertyName(final AnnotatedMember member) {
  final AutoMatter.Field field = member.getAnnotation(AutoMatter.Field.class);
  if (field == null) {
    return null;
  }
  if (member instanceof AnnotatedParameter) {
    return field.value();
  }
  if (member instanceof AnnotatedMethod) {
    return member.getName();
  }
  return null;
}

@Override
public String findImplicitPropertyName(AnnotatedMember member) {
    JsonProperty property = member.getAnnotation(JsonProperty.class);
    if (property == null) {
        if (member instanceof AnnotatedMethod) {
            AnnotatedMethod method = (AnnotatedMethod) member;
            String fieldName = BeanUtil.okNameForGetter(method);
            return getJacksonPropertyName(member.getDeclaringClass(), fieldName);
        }
    } else if (!property.value().equals("")) {
        return property.value();
    }

    return null;
}

@Override
public TypeResolverBuilder<?> findPropertyTypeResolver(MapperConfig<?> config,
                                                       AnnotatedMember am, JavaType baseType)
{
    /* As per definition of @JsonTypeInfo, should only apply to contents of container
     * (collection, map) types, not container types themselves:
     */
    if (baseType.isContainerType()) return null;
    // No per-member type overrides (yet)
    return _findTypeResolver(config, am, baseType);
}

@Override
public TypeResolverBuilder<?> findPropertyContentTypeResolver(MapperConfig<?> config,
                                                              AnnotatedMember am, JavaType 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 _findTypeResolver(config, am, containerType);
}

@Override
public boolean hasIgnoreMarker(AnnotatedMember m) {
    FieldConfig fieldConfig = m.getAnnotation(FieldConfig.class);
    if (fieldConfig != null) {
        return !fieldConfig.codable();
    }
    return false;
}

@Override
public Boolean hasRequiredMarker(AnnotatedMember m) {
    FieldConfig fieldConfig = m.getAnnotation(FieldConfig.class);
    if (fieldConfig != null) {
        return fieldConfig.required();
    }
    return null;
}

public Std(String name, JavaType type, Annotations contextAnnotations, AnnotatedMember member)
{
    _name = name;
    _type = type;
    _member = member;
    _contextAnnotations = contextAnnotations;
}