From 41a4c2b9db3a72c1394ad0750f48ed31b4636f9f Mon Sep 17 00:00:00 2001 From: Tatu Saloranta Date: Wed, 12 Jul 2023 18:41:11 -0700 Subject: [PATCH] Yet more clean up --- .../jackson/databind/util/EnumResolver.java | 153 +++++++++--------- 1 file changed, 81 insertions(+), 72 deletions(-) diff --git a/src/main/java/com/fasterxml/jackson/databind/util/EnumResolver.java b/src/main/java/com/fasterxml/jackson/databind/util/EnumResolver.java index a8fe31dfef..c546b18fff 100644 --- a/src/main/java/com/fasterxml/jackson/databind/util/EnumResolver.java +++ b/src/main/java/com/fasterxml/jackson/databind/util/EnumResolver.java @@ -73,23 +73,32 @@ protected EnumResolver(Class> enumClass, Enum[] enums, */ /** - * Factory method for constructing resolver that maps from Enum.name() into - * Enum value. + * Factory method for constructing an {@link EnumResolver} based on the given {@link DeserializationConfig} and + * {@link AnnotatedClass} of the enum to be resolved. * - * @since 2.12 - * @deprecated Since 2.16 use {@link #constructFor(DeserializationConfig, AnnotatedClass)} instead + * @param config the deserialization configuration to use + * @param annotatedClass the annotated class of the enum to be resolved + * @return the constructed {@link EnumResolver} + * + * @since 2.16 */ - @Deprecated public static EnumResolver constructFor(DeserializationConfig config, - Class enumCls0) + AnnotatedClass annotatedClass) { + // prepare data final AnnotationIntrospector ai = config.getAnnotationIntrospector(); final boolean isIgnoreCase = config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS); + final Class enumCls0 = annotatedClass.getRawType(); final Class> enumCls = _enumClass(enumCls0); final Enum[] enumConstants = _enumConstants(enumCls0); - String[] names = ai.findEnumValues(enumCls, enumConstants, new String[enumConstants.length]); + + // introspect + String[] names = ai.findEnumValues(config, annotatedClass, + enumConstants, new String[enumConstants.length]); final String[][] allAliases = new String[names.length][]; - ai.findEnumAliases(enumCls, enumConstants, allAliases); + ai.findEnumAliases(config, annotatedClass, enumConstants, allAliases); + + // finally, build HashMap> map = new HashMap>(); for (int i = 0, len = enumConstants.length; i < len; ++i) { final Enum enumValue = enumConstants[i]; @@ -107,37 +116,28 @@ public static EnumResolver constructFor(DeserializationConfig config, } } return new EnumResolver(enumCls, enumConstants, map, - _enumDefault(ai, enumCls), isIgnoreCase, - false); + _enumDefault(ai, annotatedClass, enumConstants), + isIgnoreCase, false); } /** - * Factory method for constructing an {@link EnumResolver} based on the given {@link DeserializationConfig} and - * {@link AnnotatedClass} of the enum to be resolved. - * - * @param config the deserialization configuration to use - * @param annotatedClass the annotated class of the enum to be resolved - * @return the constructed {@link EnumResolver} + * Factory method for constructing resolver that maps from Enum.name() into + * Enum value. * - * @since 2.16 + * @since 2.12 + * @deprecated Since 2.16 use {@link #constructFor(DeserializationConfig, AnnotatedClass)} instead */ - public static EnumResolver constructFor(DeserializationConfig config, AnnotatedClass annotatedClass) + @Deprecated + public static EnumResolver constructFor(DeserializationConfig config, + Class enumCls0) { - // prepare data final AnnotationIntrospector ai = config.getAnnotationIntrospector(); final boolean isIgnoreCase = config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS); - final Class enumCls0 = annotatedClass.getRawType(); final Class> enumCls = _enumClass(enumCls0); final Enum[] enumConstants = _enumConstants(enumCls0); - final Enum defaultEnum = _enumDefault(ai, annotatedClass, enumConstants); - - // introspect - String[] names = ai.findEnumValues(config, annotatedClass, - enumConstants, new String[enumConstants.length]); + String[] names = ai.findEnumValues(enumCls, enumConstants, new String[enumConstants.length]); final String[][] allAliases = new String[names.length][]; - ai.findEnumAliases(config, annotatedClass, enumConstants, allAliases); - - // finally, build + ai.findEnumAliases(enumCls, enumConstants, allAliases); HashMap> map = new HashMap>(); for (int i = 0, len = enumConstants.length; i < len; ++i) { final Enum enumValue = enumConstants[i]; @@ -155,31 +155,35 @@ public static EnumResolver constructFor(DeserializationConfig config, AnnotatedC } } return new EnumResolver(enumCls, enumConstants, map, - defaultEnum, isIgnoreCase, false); + _enumDefault(ai, enumCls), + isIgnoreCase, false); } /** * Factory method for constructing resolver that maps from Enum.toString() into * Enum value * - * @since 2.12 - * @deprecated Since 2.16 use {@link #constructUsingToString(DeserializationConfig, AnnotatedClass)} instead + * @since 2.16 */ - @Deprecated public static EnumResolver constructUsingToString(DeserializationConfig config, - Class enumCls0) + AnnotatedClass annotatedClass) { + // prepare data final AnnotationIntrospector ai = config.getAnnotationIntrospector(); final boolean isIgnoreCase = config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS); + final Class enumCls0 = annotatedClass.getRawType(); final Class> enumCls = _enumClass(enumCls0); final Enum[] enumConstants = _enumConstants(enumCls0); - HashMap> map = new HashMap>(); + + // introspect final String[][] allAliases = new String[enumConstants.length][]; if (ai != null) { - ai.findEnumAliases(enumCls, enumConstants, allAliases); + ai.findEnumAliases(config, annotatedClass, enumConstants, allAliases); } - + + // finally, build // from last to first, so that in case of duplicate values, first wins + HashMap> map = new HashMap>(); for (int i = enumConstants.length; --i >= 0; ) { Enum enumValue = enumConstants[i]; map.put(enumValue.toString(), enumValue); @@ -192,33 +196,32 @@ public static EnumResolver constructUsingToString(DeserializationConfig config, } } return new EnumResolver(enumCls, enumConstants, map, - _enumDefault(ai, enumCls), isIgnoreCase, false); + _enumDefault(ai, annotatedClass, enumConstants), + isIgnoreCase, false); } /** * Factory method for constructing resolver that maps from Enum.toString() into * Enum value * - * @since 2.16 + * @since 2.12 + * @deprecated Since 2.16 use {@link #constructUsingToString(DeserializationConfig, AnnotatedClass)} instead */ - public static EnumResolver constructUsingToString(DeserializationConfig config, AnnotatedClass annotatedClass) { - // prepare data + @Deprecated + public static EnumResolver constructUsingToString(DeserializationConfig config, + Class enumCls0) + { final AnnotationIntrospector ai = config.getAnnotationIntrospector(); final boolean isIgnoreCase = config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS); - final Class enumCls0 = annotatedClass.getRawType(); final Class> enumCls = _enumClass(enumCls0); final Enum[] enumConstants = _enumConstants(enumCls0); - final Enum defaultEnum = _enumDefault(ai, annotatedClass, enumConstants); - - // introspect + HashMap> map = new HashMap>(); final String[][] allAliases = new String[enumConstants.length][]; if (ai != null) { - ai.findEnumAliases(config, annotatedClass, enumConstants, allAliases); + ai.findEnumAliases(enumCls, enumConstants, allAliases); } - - // finally, build + // from last to first, so that in case of duplicate values, first wins - HashMap> map = new HashMap>(); for (int i = enumConstants.length; --i >= 0; ) { Enum enumValue = enumConstants[i]; map.put(enumValue.toString(), enumValue); @@ -231,59 +234,63 @@ public static EnumResolver constructUsingToString(DeserializationConfig config, } } return new EnumResolver(enumCls, enumConstants, map, - defaultEnum, isIgnoreCase, false); + _enumDefault(ai, enumCls), + isIgnoreCase, false); } /** * Factory method for constructing resolver that maps from index of Enum.values() into - * Enum value + * Enum value. * - * @since 2.15 - * @deprecated Since 2.16. Use {@link #constructUsingIndex(DeserializationConfig, AnnotatedClass)} instead. + * @since 2.16 */ - @Deprecated public static EnumResolver constructUsingIndex(DeserializationConfig config, - Class> enumCls0) + AnnotatedClass annotatedClass) { + // prepare data final AnnotationIntrospector ai = config.getAnnotationIntrospector(); final boolean isIgnoreCase = config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS); + final Class enumCls0 = annotatedClass.getRawType(); final Class> enumCls = _enumClass(enumCls0); final Enum[] enumConstants = _enumConstants(enumCls0); - HashMap> map = new HashMap<>(); + // finally, build // from last to first, so that in case of duplicate values, first wins + HashMap> map = new HashMap<>(); for (int i = enumConstants.length; --i >= 0; ) { Enum enumValue = enumConstants[i]; map.put(String.valueOf(i), enumValue); } return new EnumResolver(enumCls, enumConstants, map, - _enumDefault(ai, enumCls), isIgnoreCase, false); + _enumDefault(ai, annotatedClass, enumConstants), + isIgnoreCase, false); } + /** * Factory method for constructing resolver that maps from index of Enum.values() into - * Enum value. + * Enum value * - * @since 2.16 + * @since 2.15 + * @deprecated Since 2.16. Use {@link #constructUsingIndex(DeserializationConfig, AnnotatedClass)} instead. */ - public static EnumResolver constructUsingIndex(DeserializationConfig config, AnnotatedClass annotatedClass) + @Deprecated + public static EnumResolver constructUsingIndex(DeserializationConfig config, + Class> enumCls0) { - // prepare data final AnnotationIntrospector ai = config.getAnnotationIntrospector(); final boolean isIgnoreCase = config.isEnabled(MapperFeature.ACCEPT_CASE_INSENSITIVE_ENUMS); - final Class enumCls0 = annotatedClass.getRawType(); final Class> enumCls = _enumClass(enumCls0); final Enum[] enumConstants = _enumConstants(enumCls0); - final Enum defaultEnum = _enumDefault(ai, annotatedClass, enumConstants); + HashMap> map = new HashMap<>(); - // finally, build // from last to first, so that in case of duplicate values, first wins - HashMap> map = new HashMap<>(); for (int i = enumConstants.length; --i >= 0; ) { Enum enumValue = enumConstants[i]; map.put(String.valueOf(i), enumValue); } return new EnumResolver(enumCls, enumConstants, map, - defaultEnum, isIgnoreCase, false); + _enumDefault(ai, enumCls), + isIgnoreCase, false); } /** @@ -314,7 +321,8 @@ public static EnumResolver constructUsingEnumNamingStrategy(DeserializationConfi } return new EnumResolver(enumCls, enumConstants, map, - _enumDefault(ai, enumCls), isIgnoreCase, false); + _enumDefault(ai, enumCls), + isIgnoreCase, false); } /** @@ -331,7 +339,6 @@ public static EnumResolver constructUsingEnumNamingStrategy(DeserializationConfi final Class enumCls0 = annotatedClass.getRawType(); final Class> enumCls = _enumClass(enumCls0); final Enum[] enumConstants = _enumConstants(enumCls0); - final Enum defaultEnum = _enumDefault(ai, annotatedClass, enumConstants); // finally build // from last to first, so that in case of duplicate values, first wins @@ -343,7 +350,8 @@ public static EnumResolver constructUsingEnumNamingStrategy(DeserializationConfi } return new EnumResolver(enumCls, enumConstants, map, - defaultEnum, isIgnoreCase, false); + _enumDefault(ai, annotatedClass, enumConstants), + isIgnoreCase, false); } /** @@ -376,7 +384,8 @@ public static EnumResolver constructUsingMethod(DeserializationConfig config, } } return new EnumResolver(enumCls, enumConstants, map, - _enumDefault(ai, enumCls), isIgnoreCase, + _enumDefault(ai, enumCls), + isIgnoreCase, // 26-Sep-2021, tatu: [databind#1850] Need to consider "from int" case _isIntType(accessor.getRawType()) ); @@ -397,7 +406,6 @@ public static EnumResolver constructUsingMethod(DeserializationConfig config, final Class enumCls0 = annotatedClass.getRawType(); final Class> enumCls = _enumClass(enumCls0); final Enum[] enumConstants = _enumConstants(enumCls0); - final Enum defaultEnum = _enumDefault(ai, annotatedClass, enumConstants); // build HashMap> map = new HashMap>(); @@ -414,7 +422,8 @@ public static EnumResolver constructUsingMethod(DeserializationConfig config, } } return new EnumResolver(enumCls, enumConstants, map, - defaultEnum, isIgnoreCase, + _enumDefault(ai, annotatedClass, enumConstants), + isIgnoreCase, // 26-Sep-2021, tatu: [databind#1850] Need to consider "from int" case _isIntType(accessor.getRawType()) ); @@ -438,7 +447,7 @@ protected static Enum[] _enumConstants(Class enumCls) { } /** - * Internal helper method used to resolve {@link com.fasterxml.jackson.annotation.JsonEnumDefaultValue} + * Internal helper method used to resolve Enum default value to use (if any). * * @since 2.16 * @see AnnotationIntrospector#findDefaultEnumValue(AnnotatedClass, Enum[])