@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 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 { } }