// Decompiled by Jad v1.5.8e. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/kpdus/jad.html
// Decompiler options: braces fieldsfirst space lnc 

package com.fasterxml.jackson.databind.deser.std;

import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.core.JsonToken;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.DeserializationConfig;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.DeserializationFeature;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.deser.ContextualDeserializer;
import com.fasterxml.jackson.databind.introspect.AnnotatedMethod;
import com.fasterxml.jackson.databind.jsontype.TypeDeserializer;
import com.fasterxml.jackson.databind.util.ClassUtil;
import com.fasterxml.jackson.databind.util.CompactStringObjectMap;
import com.fasterxml.jackson.databind.util.EnumResolver;
import java.io.IOException;
import java.lang.reflect.Method;

// Referenced classes of package com.fasterxml.jackson.databind.deser.std:
//            StdScalarDeserializer, StdDeserializer

public class EnumDeserializer extends StdScalarDeserializer
{
    protected static class FactoryBasedDeserializer extends StdDeserializer
        implements ContextualDeserializer
    {

        private static final long serialVersionUID = 1L;
        protected final JsonDeserializer _deser;
        protected final Method _factory;
        protected final Class _inputType;

        public JsonDeserializer createContextual(DeserializationContext deserializationcontext, BeanProperty beanproperty)
            throws JsonMappingException
        {
            FactoryBasedDeserializer factorybaseddeserializer = this;
            if (_deser == null)
            {
                factorybaseddeserializer = this;
                if (_inputType != java/lang/String)
                {
                    factorybaseddeserializer = new FactoryBasedDeserializer(this, deserializationcontext.findContextualValueDeserializer(deserializationcontext.constructType(_inputType), beanproperty));
                }
            }
            return factorybaseddeserializer;
        }

        public Object deserialize(JsonParser jsonparser, DeserializationContext deserializationcontext)
            throws IOException
        {
            if (_deser != null)
            {
                jsonparser = ((JsonParser) (_deser.deserialize(jsonparser, deserializationcontext)));
            } else
            {
                JsonToken jsontoken = jsonparser.getCurrentToken();
                if (jsontoken == JsonToken.VALUE_STRING || jsontoken == JsonToken.FIELD_NAME)
                {
                    jsonparser = jsonparser.getText();
                } else
                {
                    jsonparser = jsonparser.getValueAsString();
                }
            }
            try
            {
                jsonparser = ((JsonParser) (_factory.invoke(_valueClass, new Object[] {
                    jsonparser
                })));
            }
            // Misplaced declaration of an exception variable
            catch (JsonParser jsonparser)
            {
                jsonparser = ClassUtil.getRootCause(jsonparser);
                if (jsonparser instanceof IOException)
                {
                    throw (IOException)jsonparser;
                } else
                {
                    throw deserializationcontext.instantiationException(_valueClass, jsonparser);
                }
            }
            return jsonparser;
        }

        public Object deserializeWithType(JsonParser jsonparser, DeserializationContext deserializationcontext, TypeDeserializer typedeserializer)
            throws IOException
        {
            if (_deser == null)
            {
                return deserialize(jsonparser, deserializationcontext);
            } else
            {
                return typedeserializer.deserializeTypedFromAny(jsonparser, deserializationcontext);
            }
        }

        protected FactoryBasedDeserializer(FactoryBasedDeserializer factorybaseddeserializer, JsonDeserializer jsondeserializer)
        {
            super(factorybaseddeserializer._valueClass);
            _inputType = factorybaseddeserializer._inputType;
            _factory = factorybaseddeserializer._factory;
            _deser = jsondeserializer;
        }

        public FactoryBasedDeserializer(Class class1, AnnotatedMethod annotatedmethod, Class class2)
        {
            super(class1);
            _factory = annotatedmethod.getAnnotated();
            _inputType = class2;
            _deser = null;
        }
    }


    private static final long serialVersionUID = 1L;
    protected final CompactStringObjectMap _enumLookup;
    protected Object _enumsByIndex[];

    public EnumDeserializer(EnumResolver enumresolver)
    {
        super(enumresolver.getEnumClass());
        _enumLookup = enumresolver.constructLookup();
        _enumsByIndex = enumresolver.getRawEnums();
    }

    private final Object _deserializeAltString(JsonParser jsonparser, DeserializationContext deserializationcontext, String s)
        throws IOException
    {
        jsonparser = s.trim();
        if (jsonparser.length() != 0) goto _L2; else goto _L1
_L1:
        if (!deserializationcontext.isEnabled(DeserializationFeature.ACCEPT_EMPTY_STRING_AS_NULL_OBJECT)) goto _L4; else goto _L3
_L3:
        return null;
_L2:
        char c = jsonparser.charAt(0);
        if (c < '0' || c > '9')
        {
            continue; /* Loop/switch isn't completed */
        }
        int i;
        i = Integer.parseInt(jsonparser);
        _checkFailOnNumber(deserializationcontext);
        if (i < 0)
        {
            continue; /* Loop/switch isn't completed */
        }
        if (i > _enumsByIndex.length)
        {
            continue; /* Loop/switch isn't completed */
        }
        s = ((String) (_enumsByIndex[i]));
        return s;
        s;
_L4:
        if (deserializationcontext.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL)) goto _L3; else goto _L5
_L5:
        throw deserializationcontext.weirdStringException(jsonparser, _enumClass(), (new StringBuilder()).append("value not one of declared Enum instance names: ").append(_enumLookup.keys()).toString());
    }

    public static JsonDeserializer deserializerForCreator(DeserializationConfig deserializationconfig, Class class1, AnnotatedMethod annotatedmethod)
    {
        Class class2 = annotatedmethod.getRawParameterType(0);
        if (deserializationconfig.canOverrideAccessModifiers())
        {
            ClassUtil.checkAndFixAccess(annotatedmethod.getMember());
        }
        return new FactoryBasedDeserializer(class1, annotatedmethod, class2);
    }

    protected void _checkFailOnNumber(DeserializationContext deserializationcontext)
        throws IOException
    {
        if (deserializationcontext.isEnabled(DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS))
        {
            throw deserializationcontext.mappingException("Not allowed to deserialize Enum value out of JSON number (disable DeserializationConfig.DeserializationFeature.FAIL_ON_NUMBERS_FOR_ENUMS to allow)");
        } else
        {
            return;
        }
    }

    protected Object _deserializeOther(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        jsonparser.getCurrentToken();
        if (deserializationcontext.isEnabled(DeserializationFeature.UNWRAP_SINGLE_VALUE_ARRAYS) && jsonparser.isExpectedStartArrayToken())
        {
            jsonparser.nextToken();
            Object obj = deserialize(jsonparser, deserializationcontext);
            if (jsonparser.nextToken() != JsonToken.END_ARRAY)
            {
                throw deserializationcontext.wrongTokenException(jsonparser, JsonToken.END_ARRAY, (new StringBuilder()).append("Attempted to unwrap single value array for single '").append(_enumClass().getName()).append("' value but there was more than a single value in the array").toString());
            } else
            {
                return obj;
            }
        } else
        {
            throw deserializationcontext.mappingException(_enumClass());
        }
    }

    protected Class _enumClass()
    {
        return handledType();
    }

    public Object deserialize(JsonParser jsonparser, DeserializationContext deserializationcontext)
        throws IOException
    {
        Object obj = jsonparser.getCurrentToken();
        if (obj == JsonToken.VALUE_STRING || obj == JsonToken.FIELD_NAME)
        {
            String s = jsonparser.getText();
            Object obj1 = _enumLookup.find(s);
            obj = obj1;
            if (obj1 == null)
            {
                obj = _deserializeAltString(jsonparser, deserializationcontext, s);
            }
            return obj;
        }
        if (obj == JsonToken.VALUE_NUMBER_INT)
        {
            _checkFailOnNumber(deserializationcontext);
            int i = jsonparser.getIntValue();
            if (i >= 0 && i <= _enumsByIndex.length)
            {
                return _enumsByIndex[i];
            }
            if (!deserializationcontext.isEnabled(DeserializationFeature.READ_UNKNOWN_ENUM_VALUES_AS_NULL))
            {
                throw deserializationcontext.weirdNumberException(Integer.valueOf(i), _enumClass(), (new StringBuilder()).append("index value outside legal index range [0..").append(_enumsByIndex.length - 1).append("]").toString());
            } else
            {
                return null;
            }
        } else
        {
            return _deserializeOther(jsonparser, deserializationcontext);
        }
    }

    public boolean isCachable()
    {
        return true;
    }
}