// 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.ser.std;

import com.fasterxml.jackson.core.JsonGenerationException;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.core.SerializableString;
import com.fasterxml.jackson.databind.AnnotationIntrospector;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializationConfig;
import com.fasterxml.jackson.databind.SerializationFeature;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonFormatVisitorWrapper;
import com.fasterxml.jackson.databind.jsonFormatVisitors.JsonObjectFormatVisitor;
import com.fasterxml.jackson.databind.jsonschema.JsonSchema;
import com.fasterxml.jackson.databind.jsonschema.SchemaAware;
import com.fasterxml.jackson.databind.jsontype.TypeSerializer;
import com.fasterxml.jackson.databind.node.JsonNodeFactory;
import com.fasterxml.jackson.databind.node.ObjectNode;
import com.fasterxml.jackson.databind.ser.ContainerSerializer;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
import com.fasterxml.jackson.databind.util.EnumValues;
import java.io.IOException;
import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.util.EnumMap;
import java.util.Iterator;
import java.util.Set;

// Referenced classes of package com.fasterxml.jackson.databind.ser.std:
//            EnumSerializer, StdSerializer

public class EnumMapSerializer extends ContainerSerializer
    implements ContextualSerializer
{

    protected final EnumValues _keyEnums;
    protected final BeanProperty _property;
    protected final boolean _staticTyping;
    protected final JsonSerializer _valueSerializer;
    protected final JavaType _valueType;
    protected final TypeSerializer _valueTypeSerializer;

    public EnumMapSerializer(JavaType javatype, boolean flag, EnumValues enumvalues, TypeSerializer typeserializer, JsonSerializer jsonserializer)
    {
label0:
        {
            boolean flag1 = false;
            super(java/util/EnumMap, false);
            _property = null;
            if (!flag)
            {
                flag = flag1;
                if (javatype == null)
                {
                    break label0;
                }
                flag = flag1;
                if (!javatype.isFinal())
                {
                    break label0;
                }
            }
            flag = true;
        }
        _staticTyping = flag;
        _valueType = javatype;
        _keyEnums = enumvalues;
        _valueTypeSerializer = typeserializer;
        _valueSerializer = jsonserializer;
    }

    public EnumMapSerializer(EnumMapSerializer enummapserializer, BeanProperty beanproperty, JsonSerializer jsonserializer)
    {
        super(enummapserializer);
        _property = beanproperty;
        _staticTyping = enummapserializer._staticTyping;
        _valueType = enummapserializer._valueType;
        _keyEnums = enummapserializer._keyEnums;
        _valueTypeSerializer = enummapserializer._valueTypeSerializer;
        _valueSerializer = jsonserializer;
    }

    public volatile ContainerSerializer _withValueTypeSerializer(TypeSerializer typeserializer)
    {
        return _withValueTypeSerializer(typeserializer);
    }

    public EnumMapSerializer _withValueTypeSerializer(TypeSerializer typeserializer)
    {
        return new EnumMapSerializer(_valueType, _staticTyping, _keyEnums, typeserializer, _valueSerializer);
    }

    public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper jsonformatvisitorwrapper, JavaType javatype)
        throws JsonMappingException
    {
        if (jsonformatvisitorwrapper != null) goto _L2; else goto _L1
_L1:
        JsonObjectFormatVisitor jsonobjectformatvisitor;
        return;
_L2:
        if ((jsonobjectformatvisitor = jsonformatvisitorwrapper.expectObjectFormat(javatype)) != null)
        {
            Object obj2 = javatype.containedType(1);
            Object obj1 = _valueSerializer;
            Object obj = obj1;
            if (obj1 == null)
            {
                obj = obj1;
                if (obj2 != null)
                {
                    obj = jsonformatvisitorwrapper.getProvider().findValueSerializer(((JavaType) (obj2)), _property);
                }
            }
            obj1 = obj2;
            if (obj2 == null)
            {
                obj1 = jsonformatvisitorwrapper.getProvider().constructType(java/lang/Object);
            }
            EnumValues enumvalues = _keyEnums;
            obj2 = enumvalues;
            if (enumvalues == null)
            {
                obj2 = javatype.containedType(0);
                if (obj2 == null)
                {
                    throw new IllegalStateException((new StringBuilder()).append("Can not resolve Enum type of EnumMap: ").append(javatype).toString());
                }
                obj2 = jsonformatvisitorwrapper.getProvider().findValueSerializer(((JavaType) (obj2)), _property);
                if (!(obj2 instanceof EnumSerializer))
                {
                    throw new IllegalStateException((new StringBuilder()).append("Can not resolve Enum type of EnumMap: ").append(javatype).toString());
                }
                obj2 = ((EnumSerializer)obj2).getEnumValues();
            }
            obj2 = ((EnumValues) (obj2)).internalMap().entrySet().iterator();
            while (((Iterator) (obj2)).hasNext()) 
            {
                java.util.Map.Entry entry = (java.util.Map.Entry)((Iterator) (obj2)).next();
                String s = ((SerializableString)entry.getValue()).getValue();
                javatype = ((JavaType) (obj));
                if (obj == null)
                {
                    javatype = jsonformatvisitorwrapper.getProvider().findValueSerializer(entry.getKey().getClass(), _property);
                }
                jsonobjectformatvisitor.property(s, javatype, ((JavaType) (obj1)));
                obj = javatype;
            }
        }
        if (true) goto _L1; else goto _L3
_L3:
    }

    public JsonSerializer createContextual(SerializerProvider serializerprovider, BeanProperty beanproperty)
        throws JsonMappingException
    {
        JsonSerializer jsonserializer;
        JsonSerializer jsonserializer1 = null;
        jsonserializer = jsonserializer1;
        if (beanproperty != null)
        {
            com.fasterxml.jackson.databind.introspect.AnnotatedMember annotatedmember = beanproperty.getMember();
            jsonserializer = jsonserializer1;
            if (annotatedmember != null)
            {
                Object obj = serializerprovider.getAnnotationIntrospector().findContentSerializer(annotatedmember);
                jsonserializer = jsonserializer1;
                if (obj != null)
                {
                    jsonserializer = serializerprovider.serializerInstance(annotatedmember, obj);
                }
            }
        }
        jsonserializer1 = jsonserializer;
        if (jsonserializer == null)
        {
            jsonserializer1 = _valueSerializer;
        }
        jsonserializer = findConvertingContentSerializer(serializerprovider, beanproperty, jsonserializer1);
        if (jsonserializer != null) goto _L2; else goto _L1
_L1:
        if (!_staticTyping) goto _L4; else goto _L3
_L3:
        serializerprovider = withValueSerializer(beanproperty, serializerprovider.findValueSerializer(_valueType, beanproperty));
_L6:
        return serializerprovider;
_L2:
        jsonserializer = serializerprovider.handleSecondaryContextualization(jsonserializer, beanproperty);
_L4:
        serializerprovider = this;
        if (jsonserializer != _valueSerializer)
        {
            return withValueSerializer(beanproperty, jsonserializer);
        }
        if (true) goto _L6; else goto _L5
_L5:
    }

    public JsonSerializer getContentSerializer()
    {
        return _valueSerializer;
    }

    public JavaType getContentType()
    {
        return _valueType;
    }

    public JsonNode getSchema(SerializerProvider serializerprovider, Type type)
        throws JsonMappingException
    {
        ObjectNode objectnode = createSchemaNode("object", true);
        if (type instanceof ParameterizedType)
        {
            Type atype[] = ((ParameterizedType)type).getActualTypeArguments();
            if (atype.length == 2)
            {
                type = serializerprovider.constructType(atype[0]);
                JavaType javatype = serializerprovider.constructType(atype[1]);
                ObjectNode objectnode1 = JsonNodeFactory.instance.objectNode();
                Enum aenum[] = (Enum[])type.getRawClass().getEnumConstants();
                int j = aenum.length;
                int i = 0;
                while (i < j) 
                {
                    Enum enum = aenum[i];
                    type = serializerprovider.findValueSerializer(javatype.getRawClass(), _property);
                    if (type instanceof SchemaAware)
                    {
                        type = ((SchemaAware)type).getSchema(serializerprovider, null);
                    } else
                    {
                        type = JsonSchema.getDefaultSchemaNode();
                    }
                    objectnode1.set(serializerprovider.getConfig().getAnnotationIntrospector().findEnumValue(enum), type);
                    i++;
                }
                objectnode.set("properties", objectnode1);
            }
        }
        return objectnode;
    }

    public volatile boolean hasSingleElement(Object obj)
    {
        return hasSingleElement((EnumMap)obj);
    }

    public boolean hasSingleElement(EnumMap enummap)
    {
        return enummap.size() == 1;
    }

    public volatile boolean isEmpty(SerializerProvider serializerprovider, Object obj)
    {
        return isEmpty(serializerprovider, (EnumMap)obj);
    }

    public boolean isEmpty(SerializerProvider serializerprovider, EnumMap enummap)
    {
        return enummap == null || enummap.isEmpty();
    }

    public volatile void serialize(Object obj, JsonGenerator jsongenerator, SerializerProvider serializerprovider)
        throws IOException
    {
        serialize((EnumMap)obj, jsongenerator, serializerprovider);
    }

    public void serialize(EnumMap enummap, JsonGenerator jsongenerator, SerializerProvider serializerprovider)
        throws IOException, JsonGenerationException
    {
        jsongenerator.writeStartObject();
        if (!enummap.isEmpty())
        {
            serializeContents(enummap, jsongenerator, serializerprovider);
        }
        jsongenerator.writeEndObject();
    }

    protected void serializeContents(EnumMap enummap, JsonGenerator jsongenerator, SerializerProvider serializerprovider)
        throws IOException, JsonGenerationException
    {
        if (_valueSerializer == null) goto _L2; else goto _L1
_L1:
        serializeContentsUsing(enummap, jsongenerator, serializerprovider, _valueSerializer);
_L5:
        return;
_L2:
        Object obj;
        EnumValues enumvalues;
        Class class1;
        TypeSerializer typeserializer;
        Object obj2;
        obj = null;
        class1 = null;
        enumvalues = _keyEnums;
        Iterator iterator;
        boolean flag;
        boolean flag1;
        if (!serializerprovider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES))
        {
            flag = true;
        } else
        {
            flag = false;
        }
        flag1 = serializerprovider.isEnabled(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
        typeserializer = _valueTypeSerializer;
        iterator = enummap.entrySet().iterator();
_L3:
        Object obj1;
        while (iterator.hasNext()) 
        {
            java.util.Map.Entry entry = (java.util.Map.Entry)iterator.next();
            obj2 = entry.getValue();
            if (!flag || obj2 != null)
            {
                Enum enum = (Enum)entry.getKey();
                if (flag1)
                {
                    jsongenerator.writeFieldName(enum.toString());
                } else
                {
                    EnumValues enumvalues1 = enumvalues;
                    if (enumvalues == null)
                    {
                        enumvalues1 = ((EnumSerializer)(StdSerializer)serializerprovider.findValueSerializer(enum.getDeclaringClass(), _property)).getEnumValues();
                    }
                    jsongenerator.writeFieldName(enumvalues1.serializedValueFor(enum));
                    enumvalues = enumvalues1;
                }
                if (obj2 == null)
                {
                    serializerprovider.defaultSerializeNull(jsongenerator);
                } else
                {
label0:
                    {
                        Class class2 = obj2.getClass();
                        if (class2 == class1)
                        {
                            obj1 = obj;
                        } else
                        {
                            obj1 = serializerprovider.findValueSerializer(class2, _property);
                            obj = obj1;
                            class1 = class2;
                        }
                        if (typeserializer != null)
                        {
                            break label0;
                        }
                        try
                        {
                            ((JsonSerializer) (obj1)).serialize(obj2, jsongenerator, serializerprovider);
                        }
                        // Misplaced declaration of an exception variable
                        catch (Object obj1)
                        {
                            wrapAndThrow(serializerprovider, ((Throwable) (obj1)), enummap, ((Enum)entry.getKey()).name());
                        }
                    }
                }
            }
        }
        continue; /* Loop/switch isn't completed */
        ((JsonSerializer) (obj1)).serializeWithType(obj2, jsongenerator, serializerprovider, typeserializer);
          goto _L3
        if (true) goto _L5; else goto _L4
_L4:
    }

    protected void serializeContentsUsing(EnumMap enummap, JsonGenerator jsongenerator, SerializerProvider serializerprovider, JsonSerializer jsonserializer)
        throws IOException, JsonGenerationException
    {
        EnumValues enumvalues;
        TypeSerializer typeserializer;
        java.util.Map.Entry entry;
        Object obj;
        Enum enum;
        enumvalues = _keyEnums;
        Iterator iterator;
        boolean flag;
        boolean flag1;
        if (!serializerprovider.isEnabled(SerializationFeature.WRITE_NULL_MAP_VALUES))
        {
            flag = true;
        } else
        {
            flag = false;
        }
        flag1 = serializerprovider.isEnabled(SerializationFeature.WRITE_ENUMS_USING_TO_STRING);
        typeserializer = _valueTypeSerializer;
        iterator = enummap.entrySet().iterator();
_L2:
        if (!iterator.hasNext())
        {
            break; /* Loop/switch isn't completed */
        }
        entry = (java.util.Map.Entry)iterator.next();
        obj = entry.getValue();
        if (flag && obj == null)
        {
            continue; /* Loop/switch isn't completed */
        }
        enum = (Enum)entry.getKey();
        if (flag1)
        {
            jsongenerator.writeFieldName(enum.toString());
        } else
        {
            EnumValues enumvalues1 = enumvalues;
            if (enumvalues == null)
            {
                enumvalues1 = ((EnumSerializer)(StdSerializer)serializerprovider.findValueSerializer(enum.getDeclaringClass(), _property)).getEnumValues();
            }
            jsongenerator.writeFieldName(enumvalues1.serializedValueFor(enum));
            enumvalues = enumvalues1;
        }
        if (obj == null)
        {
            serializerprovider.defaultSerializeNull(jsongenerator);
            continue; /* Loop/switch isn't completed */
        }
        if (typeserializer == null)
        {
            try
            {
                jsonserializer.serialize(obj, jsongenerator, serializerprovider);
            }
            catch (Exception exception)
            {
                wrapAndThrow(serializerprovider, exception, enummap, ((Enum)entry.getKey()).name());
            }
            continue; /* Loop/switch isn't completed */
        }
        jsonserializer.serializeWithType(obj, jsongenerator, serializerprovider, typeserializer);
        if (true) goto _L2; else goto _L1
_L1:
    }

    public volatile void serializeWithType(Object obj, JsonGenerator jsongenerator, SerializerProvider serializerprovider, TypeSerializer typeserializer)
        throws IOException
    {
        serializeWithType((EnumMap)obj, jsongenerator, serializerprovider, typeserializer);
    }

    public void serializeWithType(EnumMap enummap, JsonGenerator jsongenerator, SerializerProvider serializerprovider, TypeSerializer typeserializer)
        throws IOException, JsonGenerationException
    {
        typeserializer.writeTypePrefixForObject(enummap, jsongenerator);
        if (!enummap.isEmpty())
        {
            serializeContents(enummap, jsongenerator, serializerprovider);
        }
        typeserializer.writeTypeSuffixForObject(enummap, jsongenerator);
    }

    public EnumMapSerializer withValueSerializer(BeanProperty beanproperty, JsonSerializer jsonserializer)
    {
        if (_property == beanproperty && jsonserializer == _valueSerializer)
        {
            return this;
        } else
        {
            return new EnumMapSerializer(this, beanproperty, jsonserializer);
        }
    }
}