org.codehaus.jackson.map.ser.std

## Class MapSerializer

- java.lang.Object
- - org.codehaus.jackson.map.JsonSerializer<T>
  - - org.codehaus.jackson.map.ser.std.SerializerBase<T>
    - - org.codehaus.jackson.map.ser.std.ContainerSerializerBase<Map<?,?>>
      - - org.codehaus.jackson.map.ser.std.MapSerializer

- All Implemented Interfaces:
    ResolvableSerializer, SchemaAware
  Direct Known Subclasses:
    MapSerializer

      public class MapSerializer
      extends ContainerSerializerBase<Map<?,?>>
      implements ResolvableSerializer

  Standard serializer implementation for serializing {link java.util.Map} types.

  Note: about the only configurable setting currently is ability to filter out entries with specified names.

- - ### Nested Class Summary

    - ### Nested classes/interfaces inherited from class org.codehaus.jackson.map.JsonSerializer

      `JsonSerializer.None`

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected PropertySerializerMap` | `_dynamicValueSerializers` If value type can not be statically determined, mapping from runtime value types to serializers are stored in this object.
    `protected HashSet<String>` | `_ignoredEntries` Set of entries to omit during serialization, if any
    `protected JsonSerializer<Object>` | `_keySerializer` Key serializer to use, if it can be statically determined
    `protected JavaType` | `_keyType` Declared type of keys
    `protected BeanProperty` | `_property` Map-valued property being serialized with this instance
    `protected JsonSerializer<Object>` | `_valueSerializer` Value serializer to use, if it can be statically determined
    `protected JavaType` | `_valueType` Declared type of contained values
    `protected boolean` | `_valueTypeIsStatic` Whether static types should be used for serialization of values or not (if not, dynamic runtime type is used)
    `protected TypeSerializer` | `_valueTypeSerializer` Type identifier serializer used for values, if any.
    `protected static JavaType` | `UNSPECIFIED_TYPE`

    - ### Fields inherited from class org.codehaus.jackson.map.ser.std.SerializerBase

      `_handledType`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `MapSerializer()`
    `protected` | `MapSerializer(HashSet<String> ignoredEntries, JavaType keyType, JavaType valueType, boolean valueTypeIsStatic, TypeSerializer vts, JsonSerializer<Object> keySerializer, JsonSerializer<Object> valueSerializer, BeanProperty property)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected JsonSerializer<Object>` | `_findAndAddDynamic(PropertySerializerMap map, Class<?> type, SerializerProvider provider)`
    `protected JsonSerializer<Object>` | `_findAndAddDynamic(PropertySerializerMap map, JavaType type, SerializerProvider provider)`
    `ContainerSerializerBase<?>` | `_withValueTypeSerializer(TypeSerializer vts)`
    `static MapSerializer` | `construct(String[] ignoredList, JavaType mapType, boolean staticValueType, TypeSerializer vts, BeanProperty property)` Deprecated. As of 1.8; use the variant with more arguments
    `static MapSerializer` | `construct(String[] ignoredList, JavaType mapType, boolean staticValueType, TypeSerializer vts, BeanProperty property, JsonSerializer<Object> keySerializer, JsonSerializer<Object> valueSerializer)`
    `JsonNode` | `getSchema(SerializerProvider provider, Type typeHint)` Note: since Jackson 1.9, default implementation claims type is "string"
    `void` | `resolve(SerializerProvider provider)` Need to get callback to resolve value serializer, if static typing is used (either being forced, or because value type is final)
    `void` | `serialize(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider)` Method that can be called to ask implementation to serialize values of type this serializer handles.
    `void` | `serializeFields(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider)` Method called to serialize fields, when the value type is not statically known.
    `protected void` | `serializeFieldsUsing(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider, JsonSerializer<Object> ser)` Method called to serialize fields, when the value type is statically known, so that value serializer is passed and does not need to be fetched from provider.
    `protected void` | `serializeTypedFields(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider)`
    `void` | `serializeWithType(Map<?,?> value, JsonGenerator jgen, SerializerProvider provider, TypeSerializer typeSer)` Method that can be called to ask implementation to serialize values of type this serializer handles, using specified type serializer for embedding necessary type information.

    - ### Methods inherited from class org.codehaus.jackson.map.ser.std.ContainerSerializerBase

      `withValueTypeSerializer`

    - ### Methods inherited from class org.codehaus.jackson.map.ser.std.SerializerBase

      `createObjectNode, createSchemaNode, createSchemaNode, handledType, isDefaultSerializer, wrapAndThrow, wrapAndThrow, wrapAndThrow, wrapAndThrow`

    - ### Methods inherited from class org.codehaus.jackson.map.JsonSerializer

      `isUnwrappingSerializer, unwrappingSerializer`

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### UNSPECIFIED_TYPE

          protected static final JavaType UNSPECIFIED_TYPE

    - #### _property

          protected final BeanProperty _property

      Map-valued property being serialized with this instance
      Since:
        1.7

    - #### _ignoredEntries

          protected final HashSet<String> _ignoredEntries

      Set of entries to omit during serialization, if any

    - #### _valueTypeIsStatic

          protected final boolean _valueTypeIsStatic

      Whether static types should be used for serialization of values or not (if not, dynamic runtime type is used)

    - #### _keyType

          protected final JavaType _keyType

      Declared type of keys
      Since:
        1.7

    - #### _valueType

          protected final JavaType _valueType

      Declared type of contained values

    - #### _keySerializer

          protected JsonSerializer<Object> _keySerializer

      Key serializer to use, if it can be statically determined
      Since:
        1.7

    - #### _valueSerializer

          protected JsonSerializer<Object> _valueSerializer

      Value serializer to use, if it can be statically determined
      Since:
        1.5

    - #### _valueTypeSerializer

          protected final TypeSerializer _valueTypeSerializer

      Type identifier serializer used for values, if any.

    - #### _dynamicValueSerializers

          protected PropertySerializerMap _dynamicValueSerializers

      If value type can not be statically determined, mapping from runtime value types to serializers are stored in this object.
      Since:
        1.8

  - ### Constructor Detail

    - #### MapSerializer

          protected MapSerializer()

    - #### MapSerializer

          protected MapSerializer(HashSet<String> ignoredEntries,
                       JavaType keyType,
                       JavaType valueType,
                       boolean valueTypeIsStatic,
                       TypeSerializer vts,
                       JsonSerializer<Object> keySerializer,
                       JsonSerializer<Object> valueSerializer,
                       BeanProperty property)

  - ### Method Detail

    - #### _withValueTypeSerializer

          public ContainerSerializerBase<?> _withValueTypeSerializer(TypeSerializer vts)

      Specified by:
        `_withValueTypeSerializer` in class `ContainerSerializerBase<Map<?,?>>`

    - #### construct

          @Deprecated
          public static MapSerializer construct(String[] ignoredList,
                                           JavaType mapType,
                                           boolean staticValueType,
                                           TypeSerializer vts,
                                           BeanProperty property)

      Deprecated. As of 1.8; use the variant with more arguments
      Factory method used to construct Map serializers.
      Parameters:
        `ignoredList` - Array of entry names that are to be filtered on serialization; null if none
        `mapType` - Declared type information (needed for static typing)
        `staticValueType` - Whether static typing should be used for the Map (which includes its contents)
        `vts` - Type serializer to use for map entry values, if any

    - #### construct

          public static MapSerializer construct(String[] ignoredList,
                                JavaType mapType,
                                boolean staticValueType,
                                TypeSerializer vts,
                                BeanProperty property,
                                JsonSerializer<Object> keySerializer,
                                JsonSerializer<Object> valueSerializer)

    - #### serialize

          public void serialize(Map<?,?> value,
                       JsonGenerator jgen,
                       SerializerProvider provider)
                         throws IOException,
                                JsonGenerationException

      Description copied from class: `JsonSerializer`
      Method that can be called to ask implementation to serialize values of type this serializer handles.
      Specified by:
        `serialize` in class `SerializerBase<Map<?,?>>`
      Parameters:
        `value` - Value to serialize; can not be null.
        `jgen` - Generator used to output resulting Json content
        `provider` - Provider that can be used to get serializers for serializing Objects value contains, if any.
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### serializeWithType

          public void serializeWithType(Map<?,?> value,
                               JsonGenerator jgen,
                               SerializerProvider provider,
                               TypeSerializer typeSer)
                                 throws IOException,
                                        JsonGenerationException

      Description copied from class: `JsonSerializer`
      Method that can be called to ask implementation to serialize values of type this serializer handles, using specified type serializer for embedding necessary type information.

      Default implementation will ignore serialization of type information, and just calls `JsonSerializer.serialize(T, org.codehaus.jackson.JsonGenerator, org.codehaus.jackson.map.SerializerProvider)`: serializers that can embed type information should override this to implement actual handling. Most common such handling is done by something like:

            // note: method to call depends on whether this type is serialized as JSON scalar, object or Array!
            typeSer.writeTypePrefixForScalar(value, jgen);
            serialize(value, jgen, provider);
            typeSer.writeTypeSuffixForScalar(value, jgen);

      Overrides:
        `serializeWithType` in class `JsonSerializer<Map<?,?>>`
      Parameters:
        `value` - Value to serialize; can not be null.
        `jgen` - Generator used to output resulting Json content
        `provider` - Provider that can be used to get serializers for serializing Objects value contains, if any.
        `typeSer` - Type serializer to use for including type information
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### serializeFields

          public void serializeFields(Map<?,?> value,
                             JsonGenerator jgen,
                             SerializerProvider provider)
                               throws IOException,
                                      JsonGenerationException

      Method called to serialize fields, when the value type is not statically known.
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### serializeFieldsUsing

          protected void serializeFieldsUsing(Map<?,?> value,
                                  JsonGenerator jgen,
                                  SerializerProvider provider,
                                  JsonSerializer<Object> ser)
                                       throws IOException,
                                              JsonGenerationException

      Method called to serialize fields, when the value type is statically known, so that value serializer is passed and does not need to be fetched from provider.
      Throws:
        `IOException`
        `JsonGenerationException`

    - #### serializeTypedFields

          protected void serializeTypedFields(Map<?,?> value,
                                  JsonGenerator jgen,
                                  SerializerProvider provider)
                                       throws IOException,
                                              JsonGenerationException

      Throws:
        `IOException`
        `JsonGenerationException`

    - #### getSchema

          public JsonNode getSchema(SerializerProvider provider,
                           Type typeHint)

      Description copied from class: `SerializerBase`
      Note: since Jackson 1.9, default implementation claims type is "string"
      Specified by:
        `getSchema` in interface `SchemaAware`
      Overrides:
        `getSchema` in class `SerializerBase<Map<?,?>>`
      Parameters:
        `provider` - The serializer provider.
        `typeHint` - A hint about the type.
      Returns:
        Json-schema for this serializer.

    - #### resolve

          public void resolve(SerializerProvider provider)
                       throws JsonMappingException

      Need to get callback to resolve value serializer, if static typing is used (either being forced, or because value type is final)
      Specified by:
        `resolve` in interface `ResolvableSerializer`
      Parameters:
        `provider` - Provider that has constructed serializer this method is called on.
      Throws:
        `JsonMappingException`

    - #### _findAndAddDynamic

          protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
                                                  Class<?> type,
                                                  SerializerProvider provider)
                                                             throws JsonMappingException

      Throws:
        `JsonMappingException`

    - #### _findAndAddDynamic

          protected final JsonSerializer<Object> _findAndAddDynamic(PropertySerializerMap map,
                                                  JavaType type,
                                                  SerializerProvider provider)
                                                             throws JsonMappingException

      Throws:
        `JsonMappingException`