Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.databind.ser.std;
  
  import java.util.*;
  
 
Specialized serializer for java.util.EnumMaps. Somewhat tricky to implement because actual Enum value type may not be available; and if not, it can only be gotten from actual instance.
 
 public class EnumMapSerializer
     extends ContainerSerializer<EnumMap<? extends Enum<?>, ?>>
     implements ContextualSerializer
 {
     protected final boolean _staticTyping;

    
Propery for which this serializer is being used, if any; null for root values.
 
     protected final BeanProperty _property;
    
    
If we know enumeration used as key, this will contain value set to use for serialization
 
     protected final EnumValues _keyEnums;
 
     protected final JavaType _valueType;
    
    
Value serializer to use, if it can be statically determined
 
     protected final JsonSerializer<Object_valueSerializer;

    
Type serializer used for values, if any.
 
     protected final TypeSerializer _valueTypeSerializer;
 
     /*
     /**********************************************************
     /* Life-cycle
     /**********************************************************
      */
     
     public EnumMapSerializer(JavaType valueTypeboolean staticTypingEnumValues keyEnums,
             TypeSerializer vtsJsonSerializer<ObjectvalueSerializer)
     {
         super(EnumMap.classfalse);
          = null// not yet known
          = staticTyping || (valueType != null && valueType.isFinal());
          = valueType;
          = keyEnums;
          = vts;
          = valueSerializer;
     }

    
Constructor called when a contextual instance is created.
 
     @SuppressWarnings("unchecked")
     public EnumMapSerializer(EnumMapSerializer srcBeanProperty property,
             JsonSerializer<?> ser)
     {
         super(src);
          = property;
          = src._staticTyping;
          = src._valueType;
          = src._keyEnums;
          = src._valueTypeSerializer;
          = (JsonSerializer<Object>) ser;
     }
     
     @Override
         return new EnumMapSerializer(vts,  );
     }
        if ( == prop && ser == ) {
            return this;
        }
        return new EnumMapSerializer(thispropser);
    }
    
//  @Override
            BeanProperty property)
        throws JsonMappingException
    {
        /* 29-Sep-2012, tatu: Actually, we need to do much more contextual
         *    checking here since we finally know for sure the property,
         *    and it may have overrides
         */
        JsonSerializer<?> ser = null;
        // First: if we have a property, may have property-annotation overrides
        if (property != null) {
            AnnotatedMember m = property.getMember();
            if (m != null) {
                Object serDef = provider.getAnnotationIntrospector().findContentSerializer(m);
                if (serDef != null) {
                    ser = provider.serializerInstance(mserDef);
                }
            }
        }
        if (ser == null) {
            ser = ;
        }
        if (ser == null) {
            if () {
                return withValueSerializer(propertyprovider.findValueSerializer(property));
            }
        } else if ( instanceof ContextualSerializer) {
            ser = ((ContextualSerializerser).createContextual(providerproperty);
        }
        if (ser != ) {
            return withValueSerializer(propertyser);
        }
        return this;
    }
    
    /*
    /**********************************************************
    /* Accessors
    /**********************************************************
     */
    
    @Override
    public JavaType getContentType() {
        return ;
    }
    @Override
    public JsonSerializer<?> getContentSerializer() {
        return ;
    }
    
    @Override
    public boolean isEmpty(EnumMap<? extends Enum<?>,?> value) {
        return (value == null) || value.isEmpty();
    }
    @Override
    public boolean hasSingleElement(EnumMap<? extends Enum<?>, ?> value) {
        return value.size() == 1;
    }
    
    /*
    /**********************************************************
    /* Serialization
    /**********************************************************
     */
    
    @Override
    public void serialize(EnumMap<? extends Enum<?>,?> valueJsonGenerator jgenSerializerProvider provider)
        throws IOExceptionJsonGenerationException
    {
        jgen.writeStartObject();
        if (!value.isEmpty()) {
            serializeContents(valuejgenprovider);
        }        
        jgen.writeEndObject();
    }
    @Override
    public void serializeWithType(EnumMap<? extends Enum<?>,?> valueJsonGenerator jgenSerializerProvider provider,
            TypeSerializer typeSer)
        throws IOExceptionJsonGenerationException
    {
        typeSer.writeTypePrefixForObject(valuejgen);
        if (!value.isEmpty()) {
            serializeContents(valuejgenprovider);
        }
        typeSer.writeTypeSuffixForObject(valuejgen);
    }
    
    protected void serializeContents(EnumMap<? extends Enum<?>,?> valueJsonGenerator jgenSerializerProvider provider)
        throws IOExceptionJsonGenerationException
    {
        if ( != null) {
            serializeContentsUsing(valuejgenprovider);
            return;
        }
        JsonSerializer<ObjectprevSerializer = null;
        Class<?> prevClass = null;
        EnumValues keyEnums = ;
        for (Map.Entry<? extends Enum<?>,?> entry : value.entrySet()) {
            // First, serialize key
            Enum<?> key = entry.getKey();
            if (keyEnums == null) {
                /* 15-Oct-2009, tatu: This is clumsy, but still the simplest efficient
                 * way to do it currently, as Serializers get cached. (it does assume we'll always use
                 * default serializer tho -- so ideally code should be rewritten)
                 */
                // ... and lovely two-step casting process too...
                StdSerializer<?> ser = (StdSerializer<?>) provider.findValueSerializer(
                        key.getDeclaringClass(), );
                keyEnums = ((EnumSerializerser).getEnumValues();
            }
            jgen.writeFieldName(keyEnums.serializedValueFor(key));
            // And then value
            Object valueElem = entry.getValue();
            if (valueElem == null) {
                provider.defaultSerializeNull(jgen);
            } else {
                Class<?> cc = valueElem.getClass();
                JsonSerializer<ObjectcurrSerializer;
                if (cc == prevClass) {
                    currSerializer = prevSerializer;
                } else {
                    currSerializer = provider.findValueSerializer(cc);
                    prevSerializer = currSerializer;
                    prevClass = cc;
                }
                try {
                    currSerializer.serialize(valueElemjgenprovider);
                } catch (Exception e) {
                    // [JACKSON-55] Need to add reference information
                    wrapAndThrow(providerevalueentry.getKey().name());
                }
            }
        }
    }
    protected void serializeContentsUsing(EnumMap<? extends Enum<?>,?> valueJsonGenerator jgenSerializerProvider provider,
            JsonSerializer<ObjectvalueSer)
        throws IOExceptionJsonGenerationException
    {
        EnumValues keyEnums = ;
        for (Map.Entry<? extends Enum<?>,?> entry : value.entrySet()) {
            Enum<?> key = entry.getKey();
            if (keyEnums == null) {
                // clumsy, but has to do for now:
                StdSerializer<?> ser = (StdSerializer<?>) provider.findValueSerializer(key.getDeclaringClass(),
                        );
                keyEnums = ((EnumSerializerser).getEnumValues();
            }
            jgen.writeFieldName(keyEnums.serializedValueFor(key));
            Object valueElem = entry.getValue();
            if (valueElem == null) {
                provider.defaultSerializeNull(jgen);
            } else {
                try {
                    valueSer.serialize(valueElemjgenprovider);
                } catch (Exception e) {
                    wrapAndThrow(providerevalueentry.getKey().name());
                }
            }
        }
    }
    
    @SuppressWarnings("unchecked")
    @Override
    public JsonNode getSchema(SerializerProvider providerType typeHint)
        throws JsonMappingException
    {
        ObjectNode o = createSchemaNode("object"true);
        if (typeHint instanceof ParameterizedType) {
            Type[] typeArgs = ((ParameterizedTypetypeHint).getActualTypeArguments();
            if (typeArgs.length == 2) {
                JavaType enumType = provider.constructType(typeArgs[0]);
                JavaType valueType = provider.constructType(typeArgs[1]);
                ObjectNode propsNode = ..objectNode();
                Class<Enum<?>> enumClass = (Class<Enum<?>>) enumType.getRawClass();
                for (Enum<?> enumValue : enumClass.getEnumConstants()) {
                    JsonSerializer<Objectser = provider.findValueSerializer(valueType.getRawClass(), );
                    JsonNode schemaNode = (ser instanceof SchemaAware) ?
                            ((SchemaAwareser).getSchema(providernull) :
                            JsonSchema.getDefaultSchemaNode();
                    propsNode.put(provider.getConfig().getAnnotationIntrospector().findEnumValue((Enum<?>)enumValue), schemaNode);
                }
                o.put("properties"propsNode);
            }
        }
        return o;
    }
    /* !!! 03-Oct-2012, tatu: This is total mess, and partly incorrect. MUST be
     *   rewritten in near future, to work.
     */
    @Override
    public void acceptJsonFormatVisitor(JsonFormatVisitorWrapper visitorJavaType typeHint)
        throws JsonMappingException
    {
    	JsonObjectFormatVisitor objectVisitor = visitor.expectObjectFormat(typeHint);
    	/*
        JavaType enumType = typeHint.containedType(0);
    	if (enumType == null) {
    	    enumType = visitor.getProvider().constructType(Object.class);
    	}
    	*/
        JavaType valueType = typeHint.containedType(1);
    	if (valueType == null) {
    	    valueType = visitor.getProvider().constructType(Object.class);
    	}
        JsonSerializer<Objectser = ;
//        Class<Enum<?>> enumClass = (Class<Enum<?>>) enumType.getRawClass();
        for (Map.Entry<?,SerializedStringentry : .internalMap().entrySet()) {
            String name = entry.getValue().getValue();
            // should all have the same type, so:
            if (ser == null) {
                ser = visitor.getProvider().findValueSerializer(entry.getKey().getClass(), );
            }
            objectVisitor.property(name, (JsonFormatVisitableservalueType);
        }
    }
New to GrepCode? Check out our FAQ X