智能工厂.apk(点击下载) / BasicSerializerFactory.java
package com.fasterxml.jackson.databind.ser;
import com.fasterxml.jackson.annotation.JsonFormat;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.BeanDescription;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonSerializable;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.MapperFeature;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.annotation.JsonSerialize;
import com.fasterxml.jackson.databind.cfg.SerializerFactoryConfig;
import com.fasterxml.jackson.databind.ext.OptionalHandlerFactory;
import com.fasterxml.jackson.databind.introspect.Annotated;
import com.fasterxml.jackson.databind.introspect.AnnotatedClass;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import com.fasterxml.jackson.databind.introspect.BasicBeanDescription;
import com.fasterxml.jackson.databind.jsontype.NamedType;
import com.fasterxml.jackson.databind.jsontype.TypeResolverBuilder;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.ser.impl.IndexedListSerializer;
import com.fasterxml.jackson.databind.ser.impl.IndexedStringListSerializer;
import com.fasterxml.jackson.databind.ser.impl.IteratorSerializer;
import com.fasterxml.jackson.databind.ser.impl.StringArraySerializer;
import com.fasterxml.jackson.databind.ser.impl.StringCollectionSerializer;
import com.fasterxml.jackson.databind.ser.std.BooleanSerializer;
import com.fasterxml.jackson.databind.ser.std.ByteBufferSerializer;
import com.fasterxml.jackson.databind.ser.std.CalendarSerializer;
import com.fasterxml.jackson.databind.ser.std.CollectionSerializer;
import com.fasterxml.jackson.databind.ser.std.DateSerializer;
import com.fasterxml.jackson.databind.ser.std.EnumSerializer;
import com.fasterxml.jackson.databind.ser.std.EnumSetSerializer;
import com.fasterxml.jackson.databind.ser.std.InetAddressSerializer;
import com.fasterxml.jackson.databind.ser.std.InetSocketAddressSerializer;
import com.fasterxml.jackson.databind.ser.std.IterableSerializer;
import com.fasterxml.jackson.databind.ser.std.JsonValueSerializer;
import com.fasterxml.jackson.databind.ser.std.MapSerializer;
import com.fasterxml.jackson.databind.ser.std.NumberSerializer;
import com.fasterxml.jackson.databind.ser.std.NumberSerializers;
import com.fasterxml.jackson.databind.ser.std.ObjectArraySerializer;
import com.fasterxml.jackson.databind.ser.std.SerializableSerializer;
import com.fasterxml.jackson.databind.ser.std.SqlDateSerializer;
import com.fasterxml.jackson.databind.ser.std.SqlTimeSerializer;
import com.fasterxml.jackson.databind.ser.std.StdArraySerializers;
import com.fasterxml.jackson.databind.ser.std.StdDelegatingSerializer;
import com.fasterxml.jackson.databind.ser.std.StdJdkSerializers;
import com.fasterxml.jackson.databind.ser.std.StdKeySerializers;
import com.fasterxml.jackson.databind.ser.std.StringSerializer;
import com.fasterxml.jackson.databind.ser.std.TimeZoneSerializer;
import com.fasterxml.jackson.databind.ser.std.ToStringSerializer;
import com.fasterxml.jackson.databind.ser.std.TokenBufferSerializer;
import com.fasterxml.jackson.databind.type.ArrayType;
import com.fasterxml.jackson.databind.type.CollectionLikeType;
import com.fasterxml.jackson.databind.type.CollectionType;
import com.fasterxml.jackson.databind.type.MapLikeType;
import com.fasterxml.jackson.databind.type.MapType;
import com.fasterxml.jackson.databind.type.TypeFactory;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.Converter;
import com.fasterxml.jackson.databind.util.TokenBuffer;
import java.io.Serializable;
import java.lang.reflect.Method;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.net.InetAddress;
import java.net.InetSocketAddress;
import java.nio.ByteBuffer;
import java.nio.charset.Charset;
import java.sql.Time;
import java.sql.Timestamp;
import java.util.Calendar;
import java.util.Collection;
import java.util.Date;
import java.util.EnumSet;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.RandomAccess;
import java.util.TimeZone;
public abstract class BasicSerializerFactory extends SerializerFactory implements Serializable {
protected static final HashMap<String, JsonSerializer<?>> _concrete = new HashMap<>();
protected static final HashMap<String, Class<? extends JsonSerializer<?>>> _concreteLazy = new HashMap<>();
protected final SerializerFactoryConfig _factoryConfig;
@Override // com.fasterxml.jackson.databind.ser.SerializerFactory
public abstract JsonSerializer<Object> createSerializer(SerializerProvider serializerProvider, JavaType javaType) throws JsonMappingException;
/* access modifiers changed from: protected */
public abstract Iterable<Serializers> customSerializers();
public abstract SerializerFactory withConfig(SerializerFactoryConfig serializerFactoryConfig);
static {
_concrete.put(String.class.getName(), new StringSerializer());
ToStringSerializer toStringSerializer = ToStringSerializer.instance;
_concrete.put(StringBuffer.class.getName(), toStringSerializer);
_concrete.put(StringBuilder.class.getName(), toStringSerializer);
_concrete.put(Character.class.getName(), toStringSerializer);
_concrete.put(Character.TYPE.getName(), toStringSerializer);
NumberSerializers.addAll(_concrete);
_concrete.put(Boolean.TYPE.getName(), new BooleanSerializer(true));
_concrete.put(Boolean.class.getName(), new BooleanSerializer(false));
NumberSerializer numberSerializer = NumberSerializer.instance;
_concrete.put(BigInteger.class.getName(), numberSerializer);
_concrete.put(BigDecimal.class.getName(), numberSerializer);
_concrete.put(Calendar.class.getName(), CalendarSerializer.instance);
DateSerializer dateSerializer = DateSerializer.instance;
_concrete.put(Date.class.getName(), dateSerializer);
_concrete.put(Timestamp.class.getName(), dateSerializer);
_concreteLazy.put(java.sql.Date.class.getName(), SqlDateSerializer.class);
_concreteLazy.put(Time.class.getName(), SqlTimeSerializer.class);
for (Map.Entry<Class<?>, Object> entry : StdJdkSerializers.all()) {
Object value = entry.getValue();
if (value instanceof JsonSerializer) {
_concrete.put(entry.getKey().getName(), (JsonSerializer) value);
} else if (value instanceof Class) {
_concreteLazy.put(entry.getKey().getName(), (Class) value);
} else {
throw new IllegalStateException("Internal error: unrecognized value of type " + entry.getClass().getName());
}
}
_concreteLazy.put(TokenBuffer.class.getName(), TokenBufferSerializer.class);
}
protected BasicSerializerFactory(SerializerFactoryConfig serializerFactoryConfig) {
this._factoryConfig = serializerFactoryConfig == null ? new SerializerFactoryConfig() : serializerFactoryConfig;
}
public SerializerFactoryConfig getFactoryConfig() {
return this._factoryConfig;
}
@Override // com.fasterxml.jackson.databind.ser.SerializerFactory
public final SerializerFactory withAdditionalSerializers(Serializers serializers) {
return withConfig(this._factoryConfig.withAdditionalSerializers(serializers));
}
@Override // com.fasterxml.jackson.databind.ser.SerializerFactory
public final SerializerFactory withAdditionalKeySerializers(Serializers serializers) {
return withConfig(this._factoryConfig.withAdditionalKeySerializers(serializers));
}
@Override // com.fasterxml.jackson.databind.ser.SerializerFactory
public final SerializerFactory withSerializerModifier(BeanSerializerModifier beanSerializerModifier) {
return withConfig(this._factoryConfig.withSerializerModifier(beanSerializerModifier));
}
/* JADX DEBUG: Failed to insert an additional move for type inference into block B:8:0x002f */
/* JADX DEBUG: Multi-variable search result rejected for r2v4, resolved type: com.fasterxml.jackson.databind.ser.BeanSerializerModifier */
/* JADX WARN: Multi-variable type inference failed */
/* JADX WARNING: Removed duplicated region for block: B:5:0x0021 */
@Override // com.fasterxml.jackson.databind.ser.SerializerFactory
public JsonSerializer<Object> createKeySerializer(SerializationConfig serializationConfig, JavaType javaType, JsonSerializer<Object> jsonSerializer) {
BeanDescription introspectClassAnnotations = serializationConfig.introspectClassAnnotations(javaType.getRawClass());
JsonSerializer<?> jsonSerializer2 = null;
if (this._factoryConfig.hasKeySerializers()) {
Iterator<Serializers> it = this._factoryConfig.keySerializers().iterator();
while (it.hasNext() && (jsonSerializer2 = it.next().findSerializer(serializationConfig, javaType, introspectClassAnnotations)) == null) {
while (it.hasNext()) {
while (it.hasNext()) {
}
}
}
}
if (jsonSerializer2 != null) {
jsonSerializer = jsonSerializer2;
} else if (jsonSerializer == null) {
jsonSerializer = StdKeySerializers.getStdKeySerializer(javaType);
}
if (this._factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier beanSerializerModifier : this._factoryConfig.serializerModifiers()) {
jsonSerializer = beanSerializerModifier.modifyKeySerializer(serializationConfig, javaType, introspectClassAnnotations, jsonSerializer);
}
}
return jsonSerializer;
}
@Override // com.fasterxml.jackson.databind.ser.SerializerFactory
public TypeSerializer createTypeSerializer(SerializationConfig serializationConfig, JavaType javaType) {
Collection<NamedType> collection;
AnnotatedClass classInfo = serializationConfig.introspectClassAnnotations(javaType.getRawClass()).getClassInfo();
AnnotationIntrospector annotationIntrospector = serializationConfig.getAnnotationIntrospector();
TypeResolverBuilder<?> findTypeResolver = annotationIntrospector.findTypeResolver(serializationConfig, classInfo, javaType);
if (findTypeResolver == null) {
findTypeResolver = serializationConfig.getDefaultTyper(javaType);
collection = null;
} else {
collection = serializationConfig.getSubtypeResolver().collectAndResolveSubtypes(classInfo, serializationConfig, annotationIntrospector);
}
if (findTypeResolver == null) {
return null;
}
return findTypeResolver.buildTypeSerializer(serializationConfig, javaType, collection);
}
/* access modifiers changed from: protected */
public final JsonSerializer<?> findSerializerByLookup(JavaType javaType, SerializationConfig serializationConfig, BeanDescription beanDescription, boolean z) {
Class<? extends JsonSerializer<?>> cls;
String name = javaType.getRawClass().getName();
JsonSerializer<?> jsonSerializer = _concrete.get(name);
if (jsonSerializer != null || (cls = _concreteLazy.get(name)) == null) {
return jsonSerializer;
}
try {
return (JsonSerializer) cls.newInstance();
} catch (Exception e) {
throw new IllegalStateException("Failed to instantiate standard serializer (of type " + cls.getName() + "): " + e.getMessage(), e);
}
}
/* access modifiers changed from: protected */
public final JsonSerializer<?> findSerializerByAnnotations(SerializerProvider serializerProvider, JavaType javaType, BeanDescription beanDescription) throws JsonMappingException {
if (JsonSerializable.class.isAssignableFrom(javaType.getRawClass())) {
return SerializableSerializer.instance;
}
AnnotatedMethod findJsonValueMethod = beanDescription.findJsonValueMethod();
if (findJsonValueMethod == null) {
return null;
}
Method annotated = findJsonValueMethod.getAnnotated();
if (serializerProvider.canOverrideAccessModifiers()) {
ClassUtil.checkAndFixAccess(annotated);
}
return new JsonValueSerializer(annotated, findSerializerFromAnnotation(serializerProvider, findJsonValueMethod));
}
/* access modifiers changed from: protected */
public final JsonSerializer<?> findSerializerByPrimaryType(SerializerProvider serializerProvider, JavaType javaType, BeanDescription beanDescription, boolean z) throws JsonMappingException {
JsonFormat.Value findExpectedFormat;
Class<?> rawClass = javaType.getRawClass();
JsonSerializer<?> findOptionalStdSerializer = findOptionalStdSerializer(serializerProvider, javaType, beanDescription, z);
if (findOptionalStdSerializer != null) {
return findOptionalStdSerializer;
}
if (Calendar.class.isAssignableFrom(rawClass)) {
return CalendarSerializer.instance;
}
if (Date.class.isAssignableFrom(rawClass)) {
return DateSerializer.instance;
}
if (ByteBuffer.class.isAssignableFrom(rawClass)) {
return new ByteBufferSerializer();
}
if (InetAddress.class.isAssignableFrom(rawClass)) {
return new InetAddressSerializer();
}
if (InetSocketAddress.class.isAssignableFrom(rawClass)) {
return new InetSocketAddressSerializer();
}
if (TimeZone.class.isAssignableFrom(rawClass)) {
return new TimeZoneSerializer();
}
if (Charset.class.isAssignableFrom(rawClass)) {
return ToStringSerializer.instance;
}
if (Number.class.isAssignableFrom(rawClass)) {
if (beanDescription.findExpectedFormat(null) != null) {
switch (findExpectedFormat.getShape()) {
case STRING:
return ToStringSerializer.instance;
case OBJECT:
case ARRAY:
return null;
}
}
return NumberSerializer.instance;
} else if (Enum.class.isAssignableFrom(rawClass)) {
return buildEnumSerializer(serializerProvider.getConfig(), javaType, beanDescription);
} else {
return null;
}
}
/* access modifiers changed from: protected */
public JsonSerializer<?> findOptionalStdSerializer(SerializerProvider serializerProvider, JavaType javaType, BeanDescription beanDescription, boolean z) throws JsonMappingException {
return OptionalHandlerFactory.instance.findSerializer(serializerProvider.getConfig(), javaType, beanDescription);
}
/* access modifiers changed from: protected */
public final JsonSerializer<?> findSerializerByAddonType(SerializationConfig serializationConfig, JavaType javaType, BeanDescription beanDescription, boolean z) throws JsonMappingException {
Class<?> rawClass = javaType.getRawClass();
if (Iterator.class.isAssignableFrom(rawClass)) {
return buildIteratorSerializer(serializationConfig, javaType, beanDescription, z);
}
if (Iterable.class.isAssignableFrom(rawClass)) {
return buildIterableSerializer(serializationConfig, javaType, beanDescription, z);
}
if (CharSequence.class.isAssignableFrom(rawClass)) {
return ToStringSerializer.instance;
}
return null;
}
/* access modifiers changed from: protected */
public JsonSerializer<Object> findSerializerFromAnnotation(SerializerProvider serializerProvider, Annotated annotated) throws JsonMappingException {
Object findSerializer = serializerProvider.getAnnotationIntrospector().findSerializer(annotated);
if (findSerializer == null) {
return null;
}
return findConvertingSerializer(serializerProvider, annotated, serializerProvider.serializerInstance(annotated, findSerializer));
}
/* access modifiers changed from: protected */
public JsonSerializer<?> findConvertingSerializer(SerializerProvider serializerProvider, Annotated annotated, JsonSerializer<?> jsonSerializer) throws JsonMappingException {
Converter<Object, Object> findConverter = findConverter(serializerProvider, annotated);
if (findConverter == null) {
return jsonSerializer;
}
return new StdDelegatingSerializer(findConverter, findConverter.getOutputType(serializerProvider.getTypeFactory()), jsonSerializer);
}
/* access modifiers changed from: protected */
public Converter<Object, Object> findConverter(SerializerProvider serializerProvider, Annotated annotated) throws JsonMappingException {
Object findSerializationConverter = serializerProvider.getAnnotationIntrospector().findSerializationConverter(annotated);
if (findSerializationConverter == null) {
return null;
}
return serializerProvider.converterInstance(annotated, findSerializationConverter);
}
/* access modifiers changed from: protected */
public JsonSerializer<?> buildContainerSerializer(SerializerProvider serializerProvider, JavaType javaType, BeanDescription beanDescription, boolean z) throws JsonMappingException {
SerializationConfig config = serializerProvider.getConfig();
if (!z && javaType.useStaticType() && (!javaType.isContainerType() || javaType.getContentType().getRawClass() != Object.class)) {
z = true;
}
TypeSerializer createTypeSerializer = createTypeSerializer(config, javaType.getContentType());
boolean z2 = createTypeSerializer != null ? false : z;
JsonSerializer<Object> _findContentSerializer = _findContentSerializer(serializerProvider, beanDescription.getClassInfo());
if (javaType.isMapLikeType()) {
MapLikeType mapLikeType = (MapLikeType) javaType;
JsonSerializer<Object> _findKeySerializer = _findKeySerializer(serializerProvider, beanDescription.getClassInfo());
if (mapLikeType.isTrueMapType()) {
return buildMapSerializer(config, (MapType) mapLikeType, beanDescription, z2, _findKeySerializer, createTypeSerializer, _findContentSerializer);
}
for (Serializers serializers : customSerializers()) {
JsonSerializer<?> findMapLikeSerializer = serializers.findMapLikeSerializer(config, mapLikeType, beanDescription, _findKeySerializer, createTypeSerializer, _findContentSerializer);
if (findMapLikeSerializer != null) {
if (this._factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier beanSerializerModifier : this._factoryConfig.serializerModifiers()) {
findMapLikeSerializer = beanSerializerModifier.modifyMapLikeSerializer(config, mapLikeType, beanDescription, findMapLikeSerializer);
}
}
return findMapLikeSerializer;
}
}
return null;
} else if (javaType.isCollectionLikeType()) {
CollectionLikeType collectionLikeType = (CollectionLikeType) javaType;
if (collectionLikeType.isTrueCollectionType()) {
return buildCollectionSerializer(config, (CollectionType) collectionLikeType, beanDescription, z2, createTypeSerializer, _findContentSerializer);
}
for (Serializers serializers2 : customSerializers()) {
JsonSerializer<?> findCollectionLikeSerializer = serializers2.findCollectionLikeSerializer(config, collectionLikeType, beanDescription, createTypeSerializer, _findContentSerializer);
if (findCollectionLikeSerializer != null) {
if (this._factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier beanSerializerModifier2 : this._factoryConfig.serializerModifiers()) {
findCollectionLikeSerializer = beanSerializerModifier2.modifyCollectionLikeSerializer(config, collectionLikeType, beanDescription, findCollectionLikeSerializer);
}
}
return findCollectionLikeSerializer;
}
}
return null;
} else if (javaType.isArrayType()) {
return buildArraySerializer(config, (ArrayType) javaType, beanDescription, z2, createTypeSerializer, _findContentSerializer);
} else {
return null;
}
}
/* JADX DEBUG: Multi-variable search result rejected for r11v0, resolved type: com.fasterxml.jackson.databind.type.CollectionType */
/* JADX WARN: Multi-variable type inference failed */
/* access modifiers changed from: protected */
/* JADX WARNING: Removed duplicated region for block: B:3:0x0010 */
public JsonSerializer<?> buildCollectionSerializer(SerializationConfig serializationConfig, CollectionType collectionType, BeanDescription beanDescription, boolean z, TypeSerializer typeSerializer, JsonSerializer<Object> jsonSerializer) throws JsonMappingException {
Iterator<Serializers> it = customSerializers().iterator();
JsonSerializer<?> jsonSerializer2 = null;
while (it.hasNext() && (jsonSerializer2 = it.next().findCollectionSerializer(serializationConfig, collectionType, beanDescription, typeSerializer, jsonSerializer)) == null) {
while (it.hasNext()) {
while (it.hasNext()) {
}
}
}
if (jsonSerializer2 == null) {
JsonFormat.Value findExpectedFormat = beanDescription.findExpectedFormat(null);
if (findExpectedFormat != null && findExpectedFormat.getShape() == JsonFormat.Shape.OBJECT) {
return null;
}
Class<?> rawClass = collectionType.getRawClass();
if (EnumSet.class.isAssignableFrom(rawClass)) {
JavaType contentType = collectionType.getContentType();
if (!contentType.isEnumType()) {
contentType = null;
}
jsonSerializer2 = buildEnumSetSerializer(contentType);
} else {
Class<?> rawClass2 = collectionType.getContentType().getRawClass();
if (isIndexedList(rawClass)) {
if (rawClass2 != String.class) {
jsonSerializer2 = buildIndexedListSerializer(collectionType.getContentType(), z, typeSerializer, jsonSerializer);
} else if (jsonSerializer == null || ClassUtil.isJacksonStdImpl(jsonSerializer)) {
jsonSerializer2 = IndexedStringListSerializer.instance;
}
} else if (rawClass2 == String.class && (jsonSerializer == null || ClassUtil.isJacksonStdImpl(jsonSerializer))) {
jsonSerializer2 = StringCollectionSerializer.instance;
}
if (jsonSerializer2 == null) {
jsonSerializer2 = buildCollectionSerializer(collectionType.getContentType(), z, typeSerializer, jsonSerializer);
}
}
}
if (this._factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier beanSerializerModifier : this._factoryConfig.serializerModifiers()) {
jsonSerializer2 = beanSerializerModifier.modifyCollectionSerializer(serializationConfig, collectionType, beanDescription, jsonSerializer2);
}
}
return jsonSerializer2;
}
/* access modifiers changed from: protected */
public boolean isIndexedList(Class<?> cls) {
return RandomAccess.class.isAssignableFrom(cls);
}
public ContainerSerializer<?> buildIndexedListSerializer(JavaType javaType, boolean z, TypeSerializer typeSerializer, JsonSerializer<Object> jsonSerializer) {
return new IndexedListSerializer(javaType, z, typeSerializer, null, jsonSerializer);
}
public ContainerSerializer<?> buildCollectionSerializer(JavaType javaType, boolean z, TypeSerializer typeSerializer, JsonSerializer<Object> jsonSerializer) {
return new CollectionSerializer(javaType, z, typeSerializer, null, jsonSerializer);
}
public JsonSerializer<?> buildEnumSetSerializer(JavaType javaType) {
return new EnumSetSerializer(javaType, null);
}
/* access modifiers changed from: protected */
/* JADX WARNING: Removed duplicated region for block: B:3:0x0015 */
public JsonSerializer<?> buildMapSerializer(SerializationConfig serializationConfig, MapType mapType, BeanDescription beanDescription, boolean z, JsonSerializer<Object> jsonSerializer, TypeSerializer typeSerializer, JsonSerializer<Object> jsonSerializer2) throws JsonMappingException {
Iterator<Serializers> it = customSerializers().iterator();
JsonSerializer<?> jsonSerializer3 = null;
while (it.hasNext() && (jsonSerializer3 = it.next().findMapSerializer(serializationConfig, mapType, beanDescription, jsonSerializer, typeSerializer, jsonSerializer2)) == null) {
while (it.hasNext()) {
while (it.hasNext()) {
}
}
}
if (jsonSerializer3 == null) {
jsonSerializer3 = MapSerializer.construct(serializationConfig.getAnnotationIntrospector().findPropertiesToIgnore(beanDescription.getClassInfo()), mapType, z, typeSerializer, jsonSerializer, jsonSerializer2, findFilterId(serializationConfig, beanDescription));
}
if (this._factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier beanSerializerModifier : this._factoryConfig.serializerModifiers()) {
jsonSerializer3 = beanSerializerModifier.modifyMapSerializer(serializationConfig, mapType, beanDescription, jsonSerializer3);
}
}
return jsonSerializer3;
}
/* access modifiers changed from: protected */
/* JADX WARNING: Removed duplicated region for block: B:3:0x000f */
public JsonSerializer<?> buildArraySerializer(SerializationConfig serializationConfig, ArrayType arrayType, BeanDescription beanDescription, boolean z, TypeSerializer typeSerializer, JsonSerializer<Object> jsonSerializer) throws JsonMappingException {
Iterator<Serializers> it = customSerializers().iterator();
JsonSerializer<?> jsonSerializer2 = null;
while (it.hasNext() && (jsonSerializer2 = it.next().findArraySerializer(serializationConfig, arrayType, beanDescription, typeSerializer, jsonSerializer)) == null) {
while (it.hasNext()) {
while (it.hasNext()) {
}
}
}
if (jsonSerializer2 == null) {
Class<?> rawClass = arrayType.getRawClass();
if (jsonSerializer == null || ClassUtil.isJacksonStdImpl(jsonSerializer)) {
if (String[].class == rawClass) {
jsonSerializer2 = StringArraySerializer.instance;
} else {
jsonSerializer2 = StdArraySerializers.findStandardImpl(rawClass);
}
}
if (jsonSerializer2 == null) {
jsonSerializer2 = new ObjectArraySerializer(arrayType.getContentType(), z, typeSerializer, jsonSerializer);
}
}
if (this._factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier beanSerializerModifier : this._factoryConfig.serializerModifiers()) {
jsonSerializer2 = beanSerializerModifier.modifyArraySerializer(serializationConfig, arrayType, beanDescription, jsonSerializer2);
}
}
return jsonSerializer2;
}
/* access modifiers changed from: protected */
public JsonSerializer<?> buildIteratorSerializer(SerializationConfig serializationConfig, JavaType javaType, BeanDescription beanDescription, boolean z) throws JsonMappingException {
JavaType containedType = javaType.containedType(0);
if (containedType == null) {
containedType = TypeFactory.unknownType();
}
return new IteratorSerializer(containedType, z, createTypeSerializer(serializationConfig, containedType), (BeanProperty) null);
}
/* access modifiers changed from: protected */
public JsonSerializer<?> buildIterableSerializer(SerializationConfig serializationConfig, JavaType javaType, BeanDescription beanDescription, boolean z) throws JsonMappingException {
JavaType containedType = javaType.containedType(0);
if (containedType == null) {
containedType = TypeFactory.unknownType();
}
return new IterableSerializer(containedType, z, createTypeSerializer(serializationConfig, containedType), (BeanProperty) null);
}
/* access modifiers changed from: protected */
public JsonSerializer<?> buildEnumSerializer(SerializationConfig serializationConfig, JavaType javaType, BeanDescription beanDescription) throws JsonMappingException {
JsonFormat.Value findExpectedFormat = beanDescription.findExpectedFormat(null);
if (findExpectedFormat == null || findExpectedFormat.getShape() != JsonFormat.Shape.OBJECT) {
JsonSerializer<?> construct = EnumSerializer.construct(javaType.getRawClass(), serializationConfig, beanDescription, findExpectedFormat);
if (this._factoryConfig.hasSerializerModifiers()) {
for (BeanSerializerModifier beanSerializerModifier : this._factoryConfig.serializerModifiers()) {
construct = beanSerializerModifier.modifyEnumSerializer(serializationConfig, javaType, beanDescription, construct);
}
}
return construct;
}
((BasicBeanDescription) beanDescription).removeProperty("declaringClass");
return null;
}
/* access modifiers changed from: protected */
public <T extends JavaType> T modifyTypeByAnnotation(SerializationConfig serializationConfig, Annotated annotated, T t) {
Class<?> findSerializationType = serializationConfig.getAnnotationIntrospector().findSerializationType(annotated);
if (findSerializationType != null) {
try {
t = (T) t.widenBy(findSerializationType);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to widen type " + t + " with concrete-type annotation (value " + findSerializationType.getName() + "), method '" + annotated.getName() + "': " + e.getMessage());
}
}
return (T) modifySecondaryTypesByAnnotation(serializationConfig, annotated, t);
}
protected static <T extends JavaType> T modifySecondaryTypesByAnnotation(SerializationConfig serializationConfig, Annotated annotated, T t) {
AnnotationIntrospector annotationIntrospector = serializationConfig.getAnnotationIntrospector();
if (!t.isContainerType()) {
return t;
}
Class<?> findSerializationKeyType = annotationIntrospector.findSerializationKeyType(annotated, t.getKeyType());
if (findSerializationKeyType != null) {
if (t instanceof MapType) {
try {
t = (T) ((MapType) t).widenKey(findSerializationKeyType);
} catch (IllegalArgumentException e) {
throw new IllegalArgumentException("Failed to narrow key type " + t + " with key-type annotation (" + findSerializationKeyType.getName() + "): " + e.getMessage());
}
} else {
throw new IllegalArgumentException("Illegal key-type annotation: type " + t + " is not a Map type");
}
}
Class<?> findSerializationContentType = annotationIntrospector.findSerializationContentType(annotated, t.getContentType());
if (findSerializationContentType == null) {
return t;
}
try {
return (T) t.widenContentsBy(findSerializationContentType);
} catch (IllegalArgumentException e2) {
throw new IllegalArgumentException("Failed to narrow content type " + t + " with content-type annotation (" + findSerializationContentType.getName() + "): " + e2.getMessage());
}
}
/* access modifiers changed from: protected */
public JsonSerializer<Object> _findKeySerializer(SerializerProvider serializerProvider, Annotated annotated) throws JsonMappingException {
Object findKeySerializer = serializerProvider.getAnnotationIntrospector().findKeySerializer(annotated);
if (findKeySerializer != null) {
return serializerProvider.serializerInstance(annotated, findKeySerializer);
}
return null;
}
/* access modifiers changed from: protected */
public JsonSerializer<Object> _findContentSerializer(SerializerProvider serializerProvider, Annotated annotated) throws JsonMappingException {
Object findContentSerializer = serializerProvider.getAnnotationIntrospector().findContentSerializer(annotated);
if (findContentSerializer != null) {
return serializerProvider.serializerInstance(annotated, findContentSerializer);
}
return null;
}
/* access modifiers changed from: protected */
public Object findFilterId(SerializationConfig serializationConfig, BeanDescription beanDescription) {
return serializationConfig.getAnnotationIntrospector().findFilterId((Annotated) beanDescription.getClassInfo());
}
/* access modifiers changed from: protected */
public boolean usesStaticTyping(SerializationConfig serializationConfig, BeanDescription beanDescription, TypeSerializer typeSerializer) {
if (typeSerializer != null) {
return false;
}
JsonSerialize.Typing findSerializationTyping = serializationConfig.getAnnotationIntrospector().findSerializationTyping(beanDescription.getClassInfo());
if (findSerializationTyping == null || findSerializationTyping == JsonSerialize.Typing.DEFAULT_TYPING) {
return serializationConfig.isEnabled(MapperFeature.USE_STATIC_TYPING);
}
if (findSerializationTyping == JsonSerialize.Typing.STATIC) {
return true;
}
return false;
}
/* access modifiers changed from: protected */
public Class<?> _verifyAsClass(Object obj, String str, Class<?> cls) {
if (obj == null) {
return null;
}
if (obj instanceof Class) {
Class<?> cls2 = (Class) obj;
if (cls2 == cls || ClassUtil.isBogusClass(cls2)) {
return null;
}
return cls2;
}
throw new IllegalStateException("AnnotationIntrospector." + str + "() returned value of type " + obj.getClass().getName() + ": expected type JsonSerializer or Class<JsonSerializer> instead");
}
}