org.codehaus.jackson.map.util.EnumResolver Maven / Gradle / Ivy

Go to download
Show more of this group Show more artifacts with this name
Show all versions of jackson-mapper-lgpl
Data Mapper package is a high-performance data binding package built on Jackson JSON processor
There is a newer version: 1.9.13
package org.codehaus.jackson.map.util;

import org.codehaus.jackson.map.AnnotationIntrospector;

import java.util.*;

/**
 * Helper class used to resolve String values (either JSON Object field
 * names or regular String values) into Java Enum instances.
 * 
 * @since 1.9 renamed from 'org.codehaus.jackson.map.deser.EnumResolver'
 */
public class EnumResolver>
{
    protected final Class _enumClass;

    protected final T[] _enums;

    protected final HashMap _enumsById;

    protected EnumResolver(Class enumClass, T[] enums, HashMap map)
    {
        _enumClass = enumClass;
        _enums = enums;
        _enumsById = map;
    }

    /**
     * Factory method for constructing resolver that maps from Enum.name() into
     * Enum value
     */
    public static > EnumResolver constructFor(Class enumCls, AnnotationIntrospector ai)
    {
        ET[] enumValues = enumCls.getEnumConstants();
        if (enumValues == null) {
            throw new IllegalArgumentException("No enum constants for class "+enumCls.getName());
        }
        HashMap map = new HashMap();
        for (ET e : enumValues) {
            map.put(ai.findEnumValue(e), e);
        }
        return new EnumResolver(enumCls, enumValues, map);
    }

    /**
     * Factory method for constructing resolver that maps from Enum.toString() into
     * Enum value
     * 
     * @since 1.6
     */
    public static > EnumResolver constructUsingToString(Class enumCls)
    {
        ET[] enumValues = enumCls.getEnumConstants();
        HashMap map = new HashMap();
        // from last to first, so that in case of duplicate values, first wins
        for (int i = enumValues.length; --i >= 0; ) {
            ET e = enumValues[i];
            map.put(e.toString(), e);
        }
        return new EnumResolver(enumCls, enumValues, map);
    }    
    
    /**
     * This method is needed because of the dynamic nature of constructing Enum
     * resolvers.
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static EnumResolver constructUnsafe(Class rawEnumCls, AnnotationIntrospector ai)
    {            
        /* This is oh so wrong... but at least ugliness is mostly hidden in just
         * this one place.
         */
        Class enumCls = (Class) rawEnumCls;
        return constructFor(enumCls, ai);
    }

    /**
     * Method that needs to be used instead of {@link #constructUsingToString}
     * if static type of enum is not known.
     * 
     * @since 1.6
     */
    @SuppressWarnings({ "unchecked", "rawtypes" })
    public static EnumResolver constructUnsafeUsingToString(Class rawEnumCls)
    {            
        // oh so wrong... not much that can be done tho
        Class enumCls = (Class) rawEnumCls;
        return constructUsingToString(enumCls);
    }
    
    public T findEnum(String key)
    {
        return _enumsById.get(key);
    }

    public T getEnum(int index)
    {
        if (index < 0 || index >= _enums.length) {
            return null;
        }
        return _enums[index];
    }

    public Class getEnumClass() { return _enumClass; }

    public int lastValidIndex() { return _enums.length-1; }
}