Java 类com.fasterxml.jackson.databind.cfg.MapperConfig 实例源码

@Bean(name = "objectMapper")
public ObjectMapper getObjectMapper() {
    ObjectMapper mapper = new ObjectMapper();

    mapper.registerModule(new GuavaModule());
    mapper.registerModule(new Jdk8Module());
    mapper.registerModule(new JodaModule());
    mapper.setAnnotationIntrospector(new JacksonAnnotationIntrospector() {
        // borrowed from: http://jackson-users.ning.com/forum/topics/how-to-not-include-type-info-during-serialization-with
        @Override
        protected TypeResolverBuilder<?> _findTypeResolver(MapperConfig<?> config, Annotated ann, JavaType baseType) {

            // Don't serialize JsonTypeInfo Property includes
            if (ann.hasAnnotation(JsonTypeInfo.class)
                    && ann.getAnnotation(JsonTypeInfo.class).include() == JsonTypeInfo.As.PROPERTY
                    && SerializationConfig.class.isAssignableFrom(config.getClass())) {
                return null;

            }

            return super._findTypeResolver(config, ann, baseType);
        }
    });

    return mapper;
}

@Test
public void fieldNamingStrategySerialize() throws IOException {
    final ObjectMapper mapper = new VPackMapper();
    mapper.setPropertyNamingStrategy(new PropertyNamingStrategy() {
        private static final long serialVersionUID = 1L;

        @Override
        public String nameForGetterMethod(
            final MapperConfig<?> config,
            final AnnotatedMethod method,
            final String defaultName) {
            return "bla";
        }
    });
    final VPackSlice vpack = new VPackSlice(mapper.writeValueAsBytes(new TestEntityA()));
    assertThat(vpack, is(notNullValue()));
    assertThat(vpack.isObject(), is(true));
    final VPackSlice bla = vpack.get("bla");
    assertThat(bla.isString(), is(true));
    assertThat(bla.getAsString(), is("a"));
}

@Test
public void fieldNamingStrategyDeserialize() throws IOException {
    final VPackBuilder builder = new VPackBuilder();
    builder.add(ValueType.OBJECT);
    builder.add("bla", "test");
    builder.close();
    final ObjectMapper mapper = new VPackMapper();
    mapper.setPropertyNamingStrategy(new PropertyNamingStrategy() {
        private static final long serialVersionUID = 1L;

        @Override
        public String nameForSetterMethod(
            final MapperConfig<?> config,
            final AnnotatedMethod method,
            final String defaultName) {
            return "bla";
        }
    });
    final TestEntityA entity = mapper.readValue(builder.slice().getBuffer(), TestEntityA.class);
    assertThat(entity, is(notNullValue()));
    assertThat(entity.a, is("test"));
}

public Collection<NamedType> collectAndResolveSubtypes(AnnotatedClass paramAnnotatedClass, MapperConfig<?> paramMapperConfig, AnnotationIntrospector paramAnnotationIntrospector)
{
  HashMap localHashMap = new HashMap();
  if (this._registeredSubtypes != null)
  {
    Class localClass = paramAnnotatedClass.getRawType();
    Iterator localIterator = this._registeredSubtypes.iterator();
    while (localIterator.hasNext())
    {
      NamedType localNamedType = (NamedType)localIterator.next();
      if (localClass.isAssignableFrom(localNamedType.getType()))
        _collectAndResolve(AnnotatedClass.constructWithoutSuperTypes(localNamedType.getType(), paramAnnotationIntrospector, paramMapperConfig), localNamedType, paramMapperConfig, paramAnnotationIntrospector, localHashMap);
    }
  }
  _collectAndResolve(paramAnnotatedClass, new NamedType(paramAnnotatedClass.getRawType(), null), paramMapperConfig, paramAnnotationIntrospector, localHashMap);
  return new ArrayList(localHashMap.values());
}

protected TypeIdResolver idResolver(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, Collection<NamedType> paramCollection, boolean paramBoolean1, boolean paramBoolean2)
{
  if (this._customIdResolver != null)
    return this._customIdResolver;
  if (this._idType == null)
    throw new IllegalStateException("Can not build, 'init()' not yet called");
  switch (1.$SwitchMap$com$fasterxml$jackson$annotation$JsonTypeInfo$Id[this._idType.ordinal()])
  {
  default:
    break;
  case 1:
    return new ClassNameIdResolver(paramJavaType, paramMapperConfig.getTypeFactory());
  case 2:
    return new MinimalClassNameIdResolver(paramJavaType, paramMapperConfig.getTypeFactory());
  case 3:
    return TypeNameIdResolver.construct(paramMapperConfig, paramJavaType, paramCollection, paramBoolean1, paramBoolean2);
  case 4:
    return null;
  }
  throw new IllegalStateException("Do not know how to construct standard type id resolver for idType: " + this._idType);
}

protected POJOPropertiesCollector(MapperConfig<?> paramMapperConfig, boolean paramBoolean, JavaType paramJavaType, AnnotatedClass paramAnnotatedClass, String paramString)
{
  this._config = paramMapperConfig;
  this._forSerialization = paramBoolean;
  this._type = paramJavaType;
  this._classDef = paramAnnotatedClass;
  String str;
  if (paramString == null)
    str = "set";
  else
    str = paramString;
  this._mutatorPrefix = str;
  AnnotationIntrospector localAnnotationIntrospector;
  if (paramMapperConfig.isAnnotationProcessingEnabled())
    localAnnotationIntrospector = this._config.getAnnotationIntrospector();
  else
    localAnnotationIntrospector = null;
  this._annotationIntrospector = localAnnotationIntrospector;
  if (this._annotationIntrospector == null)
  {
    this._visibilityChecker = this._config.getDefaultVisibilityChecker();
    return;
  }
  this._visibilityChecker = this._annotationIntrospector.findAutoDetectVisibility(paramAnnotatedClass, this._config.getDefaultVisibilityChecker());
}

protected POJOPropertiesCollector collectPropertiesWithBuilder(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, ClassIntrospector.MixInResolver paramMixInResolver, boolean paramBoolean)
{
  AnnotationIntrospector localAnnotationIntrospector;
  if (paramMapperConfig.isAnnotationProcessingEnabled())
    localAnnotationIntrospector = paramMapperConfig.getAnnotationIntrospector();
  else
    localAnnotationIntrospector = null;
  AnnotatedClass localAnnotatedClass = AnnotatedClass.construct(paramJavaType.getRawClass(), localAnnotationIntrospector, paramMixInResolver);
  JsonPOJOBuilder.Value localValue1;
  if (localAnnotationIntrospector == null)
    localValue1 = null;
  else
    localValue1 = localAnnotationIntrospector.findPOJOBuilderConfig(localAnnotatedClass);
  JsonPOJOBuilder.Value localValue2 = localValue1;
  String str;
  if (localValue1 == null)
    str = "with";
  else
    str = localValue2.withPrefix;
  return constructPropertyCollector(paramMapperConfig, localAnnotatedClass, paramJavaType, paramBoolean, str).collect();
}

@Override
public Collection<NamedType> collectAndResolveSubtypes(AnnotatedClass type,
        MapperConfig<?> config, AnnotationIntrospector ai)
{
    HashMap<NamedType, NamedType> subtypes = new HashMap<NamedType, NamedType>();
    // [JACKSON-257] then consider registered subtypes (which have precedence over annotations)
    if (_registeredSubtypes != null) {
        Class<?> rawBase = type.getRawType();
        for (NamedType subtype : _registeredSubtypes) {
            // is it a subtype of root type?
            if (rawBase.isAssignableFrom(subtype.getType())) { // yes
                AnnotatedClass curr = AnnotatedClass.constructWithoutSuperTypes(subtype.getType(), ai, config);
                _collectAndResolve(curr, subtype, config, ai, subtypes);
            }
        }
    }
    // and then check subtypes via annotations from base type (recursively)
    NamedType rootType = new NamedType(type.getRawType(), null);
    _collectAndResolve(type, rootType, config, ai, subtypes);
    return new ArrayList<NamedType>(subtypes.values());
}

/**
 * Helper method that will either return configured custom
 * type id resolver, or construct a standard resolver
 * given configuration.
 */
protected TypeIdResolver idResolver(MapperConfig<?> config,
        JavaType baseType, Collection<NamedType> subtypes,
        boolean forSer, boolean forDeser)
{
    // Custom id resolver?
    if (_customIdResolver != null) {
        return _customIdResolver;
    }
    if (_idType == null) {
        throw new IllegalStateException("Can not build, 'init()' not yet called");
    }
    switch (_idType) {
    case CLASS:
        return new ClassNameIdResolver(baseType, config.getTypeFactory());
    case MINIMAL_CLASS:
        return new MinimalClassNameIdResolver(baseType, config.getTypeFactory());
    case NAME:
        return TypeNameIdResolver.construct(config, baseType, subtypes, forSer, forDeser);
    case NONE: // hmmh. should never get this far with 'none'
        return null;
    case CUSTOM: // need custom resolver...
    }
    throw new IllegalStateException("Do not know how to construct standard type id resolver for idType: "+_idType);
}

protected POJOPropertiesCollector(MapperConfig<?> config, boolean forSerialization,
        JavaType type, AnnotatedClass classDef, String mutatorPrefix)
{
    _config = config;
    _forSerialization = forSerialization;
    _type = type;
    _classDef = classDef;
    _mutatorPrefix = (mutatorPrefix == null) ? "set" : mutatorPrefix;
    _annotationIntrospector = config.isAnnotationProcessingEnabled() ?
            _config.getAnnotationIntrospector() : null;
    if (_annotationIntrospector == null) {
        _visibilityChecker = _config.getDefaultVisibilityChecker();
    } else {
        _visibilityChecker = _annotationIntrospector.findAutoDetectVisibility(classDef,
                _config.getDefaultVisibilityChecker());
    }
}

@Override
public String nameForConstructorParameter(MapperConfig<?> config, AnnotatedParameter ctorParam,
                                          String defaultName) {

  if (ctorParam.getDeclaringClass() != effectiveType) {
    return fieldToJsonMapping
        .getOrDefault(defaultName,
            super.nameForConstructorParameter(config, ctorParam, defaultName));
  } else {
    return super.nameForConstructorParameter(config, ctorParam, defaultName);
  }
}

@Override
public String nameForField(MapperConfig<?> config, AnnotatedField field, String defaultName) {
  if (field.getDeclaringClass() == this.effectiveType) {
    return fieldToJsonMapping
        .getOrDefault(defaultName, super.nameForField(config, field, defaultName));
  } else {
    return super.nameForField(config, field, defaultName);
  }
}

@Override
public String nameForGetterMethod(MapperConfig<?> config, AnnotatedMethod method,
                                  String defaultName) {
  if (method.getDeclaringClass() == this.effectiveType) {
    return fieldToJsonMapping
        .getOrDefault(defaultName, super.nameForGetterMethod(config, method, defaultName));
  } else {
    return super.nameForGetterMethod(config, method, defaultName);
  }
}

@Override
public String nameForSetterMethod(MapperConfig<?> config, AnnotatedMethod method,
                                  String defaultName) {
  if (method.getDeclaringClass() == this.effectiveType) {
    return fieldToJsonMapping
        .getOrDefault(defaultName, super.nameForSetterMethod(config, method, defaultName));
  } else {
    return super.nameForSetterMethod(config, method, defaultName);
  }
}

@Override
public BasicBeanDescription forClassAnnotations(MapperConfig<?> cfg, JavaType type, MixInResolver r) {
    BasicBeanDescription desc = _findStdTypeDesc(type);
    if (desc == null) {
        desc = _cachedFCA.get(type);
        if (desc == null) {
            boolean useAnnotations = cfg.isAnnotationProcessingEnabled();
            AnnotatedClass ac = annotatedClassConstructor.constructForSerialization(type.getRawClass(),
                    (useAnnotations ? cfg.getAnnotationIntrospector() : null), r);
            desc = BasicBeanDescription.forOtherUse(cfg, type, ac);
            _cachedFCA.put(type, desc);
        }
    }
    return desc;
}

@Override
public BasicBeanDescription forDirectClassAnnotations(MapperConfig<?> cfg, JavaType type, MixInResolver r) {
    BasicBeanDescription desc = _findStdTypeDesc(type);
    if (desc == null) {
        boolean useAnnotations = cfg.isAnnotationProcessingEnabled();
        AnnotationIntrospector ai = cfg.getAnnotationIntrospector();
        AnnotatedClass ac = annotatedClassConstructor.constructWithoutSuperTypes(type.getRawClass(),
                (useAnnotations ? ai : null), r);
        desc = BasicBeanDescription.forOtherUse(cfg, type, ac);
    }
    return desc;
}

@Override
protected POJOPropertiesCollector collectProperties(MapperConfig<?> config, JavaType type, MixInResolver r, boolean forSerialization, String mutatorPrefix) {
    boolean useAnnotations = config.isAnnotationProcessingEnabled();
    AnnotatedClass ac;
    if (forSerialization) {
         ac = annotatedClassConstructor.constructForSerialization(type.getRawClass(),
                (useAnnotations ? config.getAnnotationIntrospector() : null), r);
    } else {
         ac = annotatedClassConstructor.constructForDeserialization(type.getRawClass(),
                (useAnnotations ? config.getAnnotationIntrospector() : null), r);
    }
    POJOPropertiesCollector propertyCollector = constructPropertyCollector(config, ac, type, forSerialization, mutatorPrefix);
    return propertyCollector.collect();
}

protected POJOPropertiesCollector collectPropertiesWithBuilder(MapperConfig<?> config, JavaType type, MixInResolver r, boolean forSerialization) {
    boolean useAnnotations = config.isAnnotationProcessingEnabled();
    AnnotationIntrospector ai = useAnnotations ? config.getAnnotationIntrospector() : null;
    AnnotatedClass ac;
    if (forSerialization) {
        ac = annotatedClassConstructor.constructForSerialization(type.getRawClass(), ai, r);
    } else {
        ac = annotatedClassConstructor.constructForDeserialization(type.getRawClass(), ai, r);
    }
    JsonPOJOBuilder.Value builderConfig = (ai == null) ? null : ai.findPOJOBuilderConfig(ac);
    String mutatorPrefix = (builderConfig == null) ? "with" : builderConfig.withPrefix;
    return constructPropertyCollector(config, ac, type, forSerialization, mutatorPrefix).collect();
}

@Override
public JsonCreator.Mode findCreatorAnnotation(MapperConfig<?> config, Annotated a) {
    JsonCreator ann = _findAnnotation(a, JsonCreator.class);
    if (ann != null) {
        JsonCreator.Mode mode = ann.mode();
        // but keep in mind that there may be explicit default for this module
        if ((creatorBinding != null)
                && (mode == JsonCreator.Mode.DEFAULT)) {
            mode = creatorBinding;
        }
        return mode;
    }
    return null;
}

@Override
public ObjectIdGenerator<?> objectIdGeneratorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass) {
    if(annotated.getRawType().equals(TokenList.class)) {
        return tokenIdGenerator;
    } else {
        return null;
    }
}

@Override
public ObjectIdResolver resolverIdGeneratorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass) {
    if(annotated.getRawType().equals(TokenList.class)) {
        return tokenResolver;
    } else {
        return null;
    }
}

@Override
public ObjectIdResolver resolverIdGeneratorInstance(MapperConfig<?> config, Annotated annotated, Class<?> implClass) {
    if (implClass.isAssignableFrom(EntityStoreResolver.class)) {
        return new EntityStoreResolver(store);
    }
    return null;
}

@Override
public String nameForSetterMethod(
    MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
  return OBJECT_ID_FIELD_NAME.equals(defaultName)
      ? MONGO_ID_FIELD_NAME
      : super.nameForSetterMethod(config, method, defaultName);
}

@Override
public String nameForGetterMethod(
    MapperConfig<?> config, AnnotatedMethod method, String defaultName) {
  return OBJECT_ID_FIELD_NAME.equals(defaultName)
      ? MONGO_ID_FIELD_NAME
      : super.nameForGetterMethod(config, method, defaultName);
}

@Override
public TypeResolverBuilder<?> typeResolverBuilderInstance(
        MapperConfig<?> mapperConfig, Annotated annotated,
        Class<?>
        typeResolverBuilderClass) {
    return null;
}

@Override
public TypeResolverBuilder<?> typeResolverBuilderInstance(
        MapperConfig<?> mapperConfig, Annotated annotated,
        Class<?>
        typeResolverBuilderClass) {
    return null;
}

@Override
protected TypeIdResolver idResolver(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes, boolean forSer, boolean forDeser) {
    if (_customIdResolver != null) {
        return _customIdResolver;
    }
    if (_idType == null) {
        throw new IllegalStateException("Can not build, 'init()' not yet called");
    }
    if (_idType == JsonTypeInfo.Id.CLASS){
        return new WideningClassNameIdResolver(baseType, config.getTypeFactory());
    }
    return super.idResolver(config, baseType, subtypes, forSer, forDeser); //To change body of generated methods, choose Tools | Templates.
}

@Override
protected TypeIdResolver idResolver(MapperConfig<?> config, JavaType baseType, Collection<NamedType> subtypes,
        boolean forSer, boolean forDeser) {

    if (_idType == null) {
        throw new IllegalStateException("Can not build, 'init()' not yet called");
    }

    return new NsTypeIdResolver(baseType, config.getTypeFactory(), basicMetaData);
}

protected TypeNameIdResolver(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, HashMap<String, String> paramHashMap, HashMap<String, JavaType> paramHashMap1)
{
  super(paramJavaType, paramMapperConfig.getTypeFactory());
  this._config = paramMapperConfig;
  this._typeToId = paramHashMap;
  this._idToType = paramHashMap1;
}

public static TypeNameIdResolver construct(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, Collection<NamedType> paramCollection, boolean paramBoolean1, boolean paramBoolean2)
{
  if (paramBoolean1 == paramBoolean2)
    throw new IllegalArgumentException();
  HashMap localHashMap1 = null;
  if (paramBoolean1)
    localHashMap1 = new HashMap();
  HashMap localHashMap2 = null;
  if (paramBoolean2)
    localHashMap2 = new HashMap();
  if (paramCollection != null)
  {
    Iterator localIterator = paramCollection.iterator();
    while (localIterator.hasNext())
    {
      NamedType localNamedType = (NamedType)localIterator.next();
      Class localClass = localNamedType.getType();
      String str;
      if (localNamedType.hasName())
        str = localNamedType.getName();
      else
        str = _defaultTypeId(localClass);
      if (paramBoolean1)
        localHashMap1.put(localClass.getName(), str);
      if (paramBoolean2)
      {
        JavaType localJavaType = (JavaType)localHashMap2.get(str);
        if ((localJavaType == null) || (!localClass.isAssignableFrom(localJavaType.getRawClass())))
          localHashMap2.put(str, paramMapperConfig.constructType(localClass));
      }
    }
  }
  return new TypeNameIdResolver(paramMapperConfig, paramJavaType, localHashMap1, localHashMap2);
}

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());
}

protected BasicBeanDescription(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, AnnotatedClass paramAnnotatedClass, List<BeanPropertyDefinition> paramList)
{
  super(paramJavaType);
  this._config = paramMapperConfig;
  AnnotationIntrospector localAnnotationIntrospector;
  if (paramMapperConfig == null)
    localAnnotationIntrospector = null;
  else
    localAnnotationIntrospector = paramMapperConfig.getAnnotationIntrospector();
  this._annotationIntrospector = localAnnotationIntrospector;
  this._classInfo = paramAnnotatedClass;
  this._properties = paramList;
}

public TypeResolverBuilder<?> findPropertyContentTypeResolver(MapperConfig<?> paramMapperConfig, AnnotatedMember paramAnnotatedMember, JavaType paramJavaType)
{
  TypeResolverBuilder localTypeResolverBuilder1 = this._primary.findPropertyContentTypeResolver(paramMapperConfig, paramAnnotatedMember, paramJavaType);
  TypeResolverBuilder localTypeResolverBuilder2 = localTypeResolverBuilder1;
  if (localTypeResolverBuilder1 == null)
    localTypeResolverBuilder2 = this._secondary.findPropertyContentTypeResolver(paramMapperConfig, paramAnnotatedMember, paramJavaType);
  return localTypeResolverBuilder2;
}

public TypeResolverBuilder<?> findPropertyTypeResolver(MapperConfig<?> paramMapperConfig, AnnotatedMember paramAnnotatedMember, JavaType paramJavaType)
{
  TypeResolverBuilder localTypeResolverBuilder1 = this._primary.findPropertyTypeResolver(paramMapperConfig, paramAnnotatedMember, paramJavaType);
  TypeResolverBuilder localTypeResolverBuilder2 = localTypeResolverBuilder1;
  if (localTypeResolverBuilder1 == null)
    localTypeResolverBuilder2 = this._secondary.findPropertyTypeResolver(paramMapperConfig, paramAnnotatedMember, paramJavaType);
  return localTypeResolverBuilder2;
}

public TypeResolverBuilder<?> findTypeResolver(MapperConfig<?> paramMapperConfig, AnnotatedClass paramAnnotatedClass, JavaType paramJavaType)
{
  TypeResolverBuilder localTypeResolverBuilder1 = this._primary.findTypeResolver(paramMapperConfig, paramAnnotatedClass, paramJavaType);
  TypeResolverBuilder localTypeResolverBuilder2 = localTypeResolverBuilder1;
  if (localTypeResolverBuilder1 == null)
    localTypeResolverBuilder2 = this._secondary.findTypeResolver(paramMapperConfig, paramAnnotatedClass, paramJavaType);
  return localTypeResolverBuilder2;
}

protected TypeResolverBuilder<?> _findTypeResolver(MapperConfig<?> paramMapperConfig, Annotated paramAnnotated, JavaType paramJavaType)
{
  JsonTypeInfo localJsonTypeInfo = (JsonTypeInfo)paramAnnotated.getAnnotation(JsonTypeInfo.class);
  JsonTypeResolver localJsonTypeResolver = (JsonTypeResolver)paramAnnotated.getAnnotation(JsonTypeResolver.class);
  Object localObject;
  if (localJsonTypeResolver != null)
  {
    if (localJsonTypeInfo == null)
      return null;
    localObject = paramMapperConfig.typeResolverBuilderInstance(paramAnnotated, localJsonTypeResolver.value());
  }
  else
  {
    if (localJsonTypeInfo == null)
      return null;
    if (localJsonTypeInfo.use() == JsonTypeInfo.Id.NONE)
      return _constructNoTypeResolverBuilder();
    localObject = _constructStdTypeResolverBuilder();
  }
  JsonTypeIdResolver localJsonTypeIdResolver = (JsonTypeIdResolver)paramAnnotated.getAnnotation(JsonTypeIdResolver.class);
  TypeIdResolver localTypeIdResolver1;
  if (localJsonTypeIdResolver == null)
    localTypeIdResolver1 = null;
  else
    localTypeIdResolver1 = paramMapperConfig.typeIdResolverInstance(paramAnnotated, localJsonTypeIdResolver.value());
  TypeIdResolver localTypeIdResolver2 = localTypeIdResolver1;
  if (localTypeIdResolver1 != null)
    localTypeIdResolver2.init(paramJavaType);
  TypeResolverBuilder localTypeResolverBuilder1 = ((TypeResolverBuilder)localObject).init(localJsonTypeInfo.use(), localTypeIdResolver2);
  JsonTypeInfo.As localAs1 = localJsonTypeInfo.include();
  JsonTypeInfo.As localAs2 = localAs1;
  if ((localAs1 == JsonTypeInfo.As.EXTERNAL_PROPERTY) && ((paramAnnotated instanceof AnnotatedClass)))
    localAs2 = JsonTypeInfo.As.PROPERTY;
  TypeResolverBuilder localTypeResolverBuilder2 = localTypeResolverBuilder1.inclusion(localAs2).typeProperty(localJsonTypeInfo.property());
  Class localClass = localJsonTypeInfo.defaultImpl();
  if (localClass != JsonTypeInfo.None.class)
    localTypeResolverBuilder2 = localTypeResolverBuilder2.defaultImpl(localClass);
  return localTypeResolverBuilder2.typeIdVisibility(localJsonTypeInfo.visible());
}

protected POJOPropertiesCollector collectProperties(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, ClassIntrospector.MixInResolver paramMixInResolver, boolean paramBoolean, String paramString)
{
  boolean bool = paramMapperConfig.isAnnotationProcessingEnabled();
  Class localClass = paramJavaType.getRawClass();
  AnnotationIntrospector localAnnotationIntrospector;
  if (bool)
    localAnnotationIntrospector = paramMapperConfig.getAnnotationIntrospector();
  else
    localAnnotationIntrospector = null;
  return constructPropertyCollector(paramMapperConfig, AnnotatedClass.construct(localClass, localAnnotationIntrospector, paramMixInResolver), paramJavaType, paramBoolean, paramString).collect();
}

public BasicBeanDescription forClassAnnotations(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, ClassIntrospector.MixInResolver paramMixInResolver)
{
  boolean bool = paramMapperConfig.isAnnotationProcessingEnabled();
  Class localClass = paramJavaType.getRawClass();
  AnnotationIntrospector localAnnotationIntrospector;
  if (bool)
    localAnnotationIntrospector = paramMapperConfig.getAnnotationIntrospector();
  else
    localAnnotationIntrospector = null;
  return BasicBeanDescription.forOtherUse(paramMapperConfig, paramJavaType, AnnotatedClass.construct(localClass, localAnnotationIntrospector, paramMixInResolver));
}

public BasicBeanDescription forDirectClassAnnotations(MapperConfig<?> paramMapperConfig, JavaType paramJavaType, ClassIntrospector.MixInResolver paramMixInResolver)
{
  boolean bool = paramMapperConfig.isAnnotationProcessingEnabled();
  AnnotationIntrospector localAnnotationIntrospector1 = paramMapperConfig.getAnnotationIntrospector();
  Class localClass = paramJavaType.getRawClass();
  AnnotationIntrospector localAnnotationIntrospector2;
  if (bool)
    localAnnotationIntrospector2 = localAnnotationIntrospector1;
  else
    localAnnotationIntrospector2 = null;
  return BasicBeanDescription.forOtherUse(paramMapperConfig, paramJavaType, AnnotatedClass.constructWithoutSuperTypes(localClass, localAnnotationIntrospector2, paramMixInResolver));
}

public SerializedString findRootName(Class<?> paramClass, MapperConfig<?> paramMapperConfig)
{
  try
  {
    ClassKey localClassKey = new ClassKey(paramClass);
    if (this._rootNames == null)
    {
      this._rootNames = new LRUMap(20, 200);
    }
    else
    {
      SerializedString localSerializedString1 = (SerializedString)this._rootNames.get(localClassKey);
      if (localSerializedString1 != null)
        return localSerializedString1;
    }
    BeanDescription localBeanDescription = paramMapperConfig.introspectClassAnnotations(paramClass);
    PropertyName localPropertyName = paramMapperConfig.getAnnotationIntrospector().findRootName(localBeanDescription.getClassInfo());
    String str;
    if ((localPropertyName == null) || (!localPropertyName.hasSimpleName()))
      str = paramClass.getSimpleName();
    else
      str = localPropertyName.getSimpleName();
    SerializedString localSerializedString2 = new SerializedString(str);
    this._rootNames.put(localClassKey, localSerializedString2);
    return localSerializedString2;
  }
  finally
  {
  }
}