org.codehaus.jackson.map.ser.std

## Class SerializerBase<T>

- java.lang.Object
- - org.codehaus.jackson.map.JsonSerializer<T>
  - - org.codehaus.jackson.map.ser.std.SerializerBase<T>

- All Implemented Interfaces:
    SchemaAware
  Direct Known Subclasses:
    BeanSerializerBase, ContainerSerializerBase, CoreXMLSerializers.XMLGregorianCalendarSerializer, DataHandlerJsonSerializer, DomElementJsonSerializer, DOMSerializer, FailingSerializer, JodaSerializers.JodaSerializer, JsonValueSerializer, NullSerializer, RawSerializer, ScalarSerializerBase, ScalarSerializerBase, SerializableWithTypeSerializer, SerializerBase, StaticListSerializerBase, StdArraySerializers.ByteArraySerializer, StdArraySerializers.CharArraySerializer, StdJdkSerializers.AtomicReferenceSerializer, StdKeySerializer, StdKeySerializers.CalendarKeySerializer, StdKeySerializers.DateKeySerializer, StdKeySerializers.StringKeySerializer, TokenBufferSerializer, ToStringSerializer, UnknownSerializer, XmlAdapterJsonSerializer

      public abstract class SerializerBase<T>
      extends JsonSerializer<T>
      implements SchemaAware

  Base class used by all standard serializers. Provides some convenience methods for implementing `SchemaAware`
  Since:
    1.9 (renamed from 'org.codehaus.jackson.map.ser.SerializerBase')

- - ### 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 Class<T>` | `_handledType`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `SerializerBase(Class<?> t, boolean dummy)` Alternate constructor that is (alas!) needed to work around kinks of generic type handling
    `protected` | `SerializerBase(Class<T> t)`
    `protected` | `SerializerBase(JavaType type)`

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected ObjectNode` | `createObjectNode()`
    `protected ObjectNode` | `createSchemaNode(String type)`
    `protected ObjectNode` | `createSchemaNode(String type, boolean isOptional)`
    `JsonNode` | `getSchema(SerializerProvider provider, Type typeHint)` Note: since Jackson 1.9, default implementation claims type is "string"
    `Class<T>` | `handledType()` Method for accessing type of Objects this serializer can handle.
    `protected boolean` | `isDefaultSerializer(JsonSerializer<?> serializer)` Method that can be called to determine if given serializer is the default serializer Jackson uses; as opposed to a custom serializer installed by a module or calling application.
    `abstract void` | `serialize(T value, JsonGenerator jgen, SerializerProvider provider)` Method that can be called to ask implementation to serialize values of type this serializer handles.
    `void` | `wrapAndThrow(SerializerProvider provider, Throwable t, Object bean, int index)`
    `void` | `wrapAndThrow(SerializerProvider provider, Throwable t, Object bean, String fieldName)` Method that will modify caught exception (passed in as argument) as necessary to include reference information, and to ensure it is a subtype of `IOException`, or an unchecked exception.
    `void` | `wrapAndThrow(Throwable t, Object bean, int index)` Deprecated. Use version that takes `SerializerProvider` instead.
    `void` | `wrapAndThrow(Throwable t, Object bean, String fieldName)` Deprecated. Use version that takes `SerializerProvider` instead.

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

      `isUnwrappingSerializer, serializeWithType, unwrappingSerializer`

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

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

- - ### Field Detail

    - #### _handledType

          protected final Class<T> _handledType

  - ### Constructor Detail

    - #### SerializerBase

          protected SerializerBase(Class<T> t)

    - #### SerializerBase

          protected SerializerBase(JavaType type)

      Since:
        1.7

    - #### SerializerBase

          protected SerializerBase(Class<?> t,
                        boolean dummy)

      Alternate constructor that is (alas!) needed to work around kinks of generic type handling

  - ### Method Detail

    - #### handledType

          public final Class<T> handledType()

      Description copied from class: `JsonSerializer`
      Method for accessing type of Objects this serializer can handle. Note that this information is not guaranteed to be exact -- it may be a more generic (super-type) -- but it should not be incorrect (return a non-related type).

      Default implementation will return null, which essentially means same as returning `Object.class` would; that is, that nothing is known about handled type.

      Overrides:
        `handledType` in class `JsonSerializer<T>`

    - #### serialize

          public abstract void serialize(T 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 `JsonSerializer<T>`
      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`

    - #### getSchema

          public JsonNode getSchema(SerializerProvider provider,
                           Type typeHint)
                             throws JsonMappingException

      Note: since Jackson 1.9, default implementation claims type is "string"
      Specified by:
        `getSchema` in interface `SchemaAware`
      Parameters:
        `provider` - The serializer provider.
        `typeHint` - A hint about the type.
      Returns:
        Json-schema for this serializer.
      Throws:
        `JsonMappingException`

    - #### createObjectNode

          protected ObjectNode createObjectNode()

    - #### createSchemaNode

          protected ObjectNode createSchemaNode(String type)

    - #### createSchemaNode

          protected ObjectNode createSchemaNode(String type,
                                    boolean isOptional)

    - #### isDefaultSerializer

          protected boolean isDefaultSerializer(JsonSerializer<?> serializer)

      Method that can be called to determine if given serializer is the default serializer Jackson uses; as opposed to a custom serializer installed by a module or calling application. Determination is done using `JacksonStdImpl` annotation on serializer class.
      Since:
        1.7

    - #### wrapAndThrow

          public void wrapAndThrow(SerializerProvider provider,
                          Throwable t,
                          Object bean,
                          String fieldName)
                            throws IOException

      Method that will modify caught exception (passed in as argument) as necessary to include reference information, and to ensure it is a subtype of `IOException`, or an unchecked exception.

      Rules for wrapping and unwrapping are bit complicated; essentially:

      - Errors are to be passed as is (if uncovered via unwrapping)
      - "Plain" IOExceptions (ones that are not of type `JsonMappingException` are to be passed as is
      Throws:
        `IOException`

    - #### wrapAndThrow

          public void wrapAndThrow(SerializerProvider provider,
                          Throwable t,
                          Object bean,
                          int index)
                            throws IOException

      Throws:
        `IOException`

    - #### wrapAndThrow

          @Deprecated
          public void wrapAndThrow(Throwable t,
                                     Object bean,
                                     String fieldName)
                            throws IOException

      Deprecated. Use version that takes `SerializerProvider` instead.
      Throws:
        `IOException`

    - #### wrapAndThrow

          @Deprecated
          public void wrapAndThrow(Throwable t,
                                     Object bean,
                                     int index)
                            throws IOException

      Deprecated. Use version that takes `SerializerProvider` instead.
      Throws:
        `IOException`