com.fasterxml.jackson.databind

## Class ObjectWriter

- java.lang.Object
- - com.fasterxml.jackson.databind.ObjectWriter

- All Implemented Interfaces:
    Versioned, Serializable

      public class ObjectWriter
      extends Object
      implements Versioned, Serializable

  Builder object that can be used for per-serialization configuration of serialization parameters, such as JSON View and root type to use. (and thus fully thread-safe with no external synchronization); new instances are constructed for different configurations. Instances are initially constructed by `ObjectMapper` and can be reused in completely thread-safe manner with no explicit synchronization
  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `static class` | `ObjectWriter.GeneratorSettings` Helper class used for containing settings specifically related to (re)configuring `JsonGenerator` constructed for writing output.
    `static class` | `ObjectWriter.Prefetch` As a minor optimization, we will make an effort to pre-fetch a serializer, or at least relevant `TypeSerializer`, if given enough information.

  - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `protected SerializationConfig` | `_config` General serialization configuration settings
    `protected JsonFactory` | `_generatorFactory` Factory used for constructing `JsonGenerator`s
    `protected ObjectWriter.GeneratorSettings` | `_generatorSettings` Container for settings that need to be passed to `JsonGenerator` constructed for serializing values.
    `protected ObjectWriter.Prefetch` | `_prefetch` We may pre-fetch serializer if root type is known (has been explicitly declared), and if so, reuse it afterwards.
    `protected SerializerFactory` | `_serializerFactory`
    `protected DefaultSerializerProvider` | `_serializerProvider`
    `protected static PrettyPrinter` | `NULL_PRETTY_PRINTER` We need to keep track of explicit disabling of pretty printing; easiest to do by a token value.

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `ObjectWriter(ObjectMapper mapper, SerializationConfig config)` Alternative constructor for initial instantiation by `ObjectMapper`
    `protected` | `ObjectWriter(ObjectMapper mapper, SerializationConfig config, FormatSchema s)` Alternative constructor for initial instantiation by `ObjectMapper`
    `protected` | `ObjectWriter(ObjectMapper mapper, SerializationConfig config, JavaType rootType, PrettyPrinter pp)` Constructor used by `ObjectMapper` for initial instantiation
    `protected` | `ObjectWriter(ObjectWriter base, JsonFactory f)`
    `protected` | `ObjectWriter(ObjectWriter base, SerializationConfig config)` Copy constructor used for building variations.
    `protected` | `ObjectWriter(ObjectWriter base, SerializationConfig config, ObjectWriter.GeneratorSettings genSettings, ObjectWriter.Prefetch prefetch)` Copy constructor used for building variations.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `protected void` | `_configAndWriteValue(JsonGenerator gen, Object value)` Method called to configure the generator as necessary and then call write functionality
    `protected void` | `_configureGenerator(JsonGenerator gen)` Helper method called to set or override settings of passed-in `JsonGenerator`
    `protected ObjectWriter` | `_new(ObjectWriter.GeneratorSettings genSettings, ObjectWriter.Prefetch prefetch)` Overridable factory method called by various "withXxx()" methods.
    `protected ObjectWriter` | `_new(ObjectWriter base, JsonFactory f)` Overridable factory method called by various "withXxx()" methods
    `protected ObjectWriter` | `_new(ObjectWriter base, SerializationConfig config)` Overridable factory method called by various "withXxx()" methods
    `protected SequenceWriter` | `_newSequenceWriter(boolean wrapInArray, JsonGenerator gen, boolean managedInput)` Overridable factory method called by `writeValues(OutputStream)` method (and its various overrides), and initializes it as necessary.
    `protected DefaultSerializerProvider` | `_serializerProvider()` Overridable helper method used for constructing `SerializerProvider` to use for serialization.
    `protected void` | `_verifySchemaType(FormatSchema schema)`
    `void` | `acceptJsonFormatVisitor(Class<?> rawType, JsonFormatVisitorWrapper visitor)` Since 2.6
    `void` | `acceptJsonFormatVisitor(JavaType type, JsonFormatVisitorWrapper visitor)` Method for visiting type hierarchy for given type, using specified visitor.
    `boolean` | `canSerialize(Class<?> type)`
    `boolean` | `canSerialize(Class<?> type, AtomicReference<Throwable> cause)` Method for checking whether instances of given type can be serialized, and optionally why (as per `Throwable` returned).
    `ObjectWriter` | `forType(Class<?> rootType)` Method that will construct a new instance that uses specific type as the root type for serialization, instead of runtime dynamic type of the root object itself.
    `ObjectWriter` | `forType(JavaType rootType)` Method that will construct a new instance that uses specific type as the root type for serialization, instead of runtime dynamic type of the root object itself.
    `ObjectWriter` | `forType(TypeReference<?> rootType)` Method that will construct a new instance that uses specific type as the root type for serialization, instead of runtime dynamic type of the root object itself.
    `ContextAttributes` | `getAttributes()`
    `SerializationConfig` | `getConfig()`
    `JsonFactory` | `getFactory()`
    `TypeFactory` | `getTypeFactory()`
    `boolean` | `hasPrefetchedSerializer()` Diagnostics method that can be called to check whether this writer has pre-fetched serializer to use: pre-fetching improves performance when writer instances are reused as it avoids a per-call serializer lookup.
    `boolean` | `isEnabled(JsonParser.Feature f)`
    `boolean` | `isEnabled(MapperFeature f)`
    `boolean` | `isEnabled(SerializationFeature f)`
    `Version` | `version()` Method that will return version information stored in and read from jar that contains this class.
    `ObjectWriter` | `with(Base64Variant b64variant)` Method that will construct a new instance that uses specified default `Base64Variant` for base64 encoding
    `ObjectWriter` | `with(CharacterEscapes escapes)`
    `ObjectWriter` | `with(ContextAttributes attrs)`
    `ObjectWriter` | `with(DateFormat df)` Fluent factory method that will construct a new writer instance that will use specified date format for serializing dates; or if null passed, one that will serialize dates as numeric timestamps.
    `ObjectWriter` | `with(FilterProvider filterProvider)` Method that will construct a new instance that uses specified provider for resolving filter instances by id.
    `ObjectWriter` | `with(FormatFeature feature)`
    `ObjectWriter` | `with(FormatSchema schema)` Method that will construct a new instance that uses specific format schema for serialization.
    `ObjectWriter` | `with(JsonFactory f)`
    `ObjectWriter` | `with(JsonGenerator.Feature feature)`
    `ObjectWriter` | `with(Locale l)`
    `ObjectWriter` | `with(PrettyPrinter pp)` Method that will construct a new instance that will use specified pretty printer (or, if null, will not do any pretty-printing)
    `ObjectWriter` | `with(SerializationFeature feature)` Method for constructing a new instance that is configured with specified feature enabled.
    `ObjectWriter` | `with(SerializationFeature first, SerializationFeature... other)` Method for constructing a new instance that is configured with specified features enabled.
    `ObjectWriter` | `with(TimeZone tz)`
    `ObjectWriter` | `withAttribute(Object key, Object value)`
    `ObjectWriter` | `withAttributes(Map<?,?> attrs)` Mutant factory method that allows construction of a new writer instance that uses specified set of default attribute values.
    `ObjectWriter` | `withDefaultPrettyPrinter()` Method that will construct a new instance that will use the default pretty printer for serialization.
    `ObjectWriter` | `withFeatures(FormatFeature... features)`
    `ObjectWriter` | `withFeatures(JsonGenerator.Feature... features)`
    `ObjectWriter` | `withFeatures(SerializationFeature... features)` Method for constructing a new instance that is configured with specified features enabled.
    `ObjectWriter` | `without(FormatFeature feature)`
    `ObjectWriter` | `without(JsonGenerator.Feature feature)`
    `ObjectWriter` | `without(SerializationFeature feature)` Method for constructing a new instance that is configured with specified feature enabled.
    `ObjectWriter` | `without(SerializationFeature first, SerializationFeature... other)` Method for constructing a new instance that is configured with specified features enabled.
    `ObjectWriter` | `withoutAttribute(Object key)`
    `ObjectWriter` | `withoutFeatures(FormatFeature... features)`
    `ObjectWriter` | `withoutFeatures(JsonGenerator.Feature... features)`
    `ObjectWriter` | `withoutFeatures(SerializationFeature... features)` Method for constructing a new instance that is configured with specified features enabled.
    `ObjectWriter` | `withoutRootName()` Convenience method that is same as calling: `withRootName("")` which will forcibly prevent use of root name wrapping when writing values with this `ObjectWriter`.
    `ObjectWriter` | `withRootName(PropertyName rootName)`
    `ObjectWriter` | `withRootName(String rootName)` Method for constructing a new instance with configuration that specifies what root name to use for "root element wrapping".
    `ObjectWriter` | `withRootValueSeparator(SerializableString sep)`
    `ObjectWriter` | `withRootValueSeparator(String sep)`
    `ObjectWriter` | `withSchema(FormatSchema schema)` Deprecated. Since 2.5 use `with(FormatSchema)` instead
    `ObjectWriter` | `withType(Class<?> rootType)` Deprecated. since 2.5 Use `forType(Class)` instead
    `ObjectWriter` | `withType(JavaType rootType)` Deprecated. since 2.5 Use `forType(JavaType)` instead
    `ObjectWriter` | `withType(TypeReference<?> rootType)` Deprecated. since 2.5 Use `forType(TypeReference)` instead
    `ObjectWriter` | `withView(Class<?> view)` Method that will construct a new instance that uses specified serialization view for serialization (with null basically disables view processing)
    `void` | `writeValue(DataOutput out, Object value)`
    `void` | `writeValue(File resultFile, Object value)` Method that can be used to serialize any Java value as JSON output, written to File provided.
    `void` | `writeValue(JsonGenerator gen, Object value)` Method that can be used to serialize any Java value as JSON output, using provided `JsonGenerator`.
    `void` | `writeValue(OutputStream out, Object value)` Method that can be used to serialize any Java value as JSON output, using output stream provided (using encoding `JsonEncoding.UTF8`).
    `void` | `writeValue(Writer w, Object value)` Method that can be used to serialize any Java value as JSON output, using Writer provided.
    `byte[]` | `writeValueAsBytes(Object value)` Method that can be used to serialize any Java value as a byte array.
    `String` | `writeValueAsString(Object value)` Method that can be used to serialize any Java value as a String.
    `SequenceWriter` | `writeValues(DataOutput out)`
    `SequenceWriter` | `writeValues(File out)` Method for creating a `SequenceWriter` to write a sequence of root values using configuration of this `ObjectWriter`.
    `SequenceWriter` | `writeValues(JsonGenerator gen)` Method for creating a `SequenceWriter` to write a sequence of root values using configuration of this `ObjectWriter`.
    `SequenceWriter` | `writeValues(OutputStream out)` Method for creating a `SequenceWriter` to write a sequence of root values using configuration of this `ObjectWriter`.
    `SequenceWriter` | `writeValues(Writer out)` Method for creating a `SequenceWriter` to write a sequence of root values using configuration of this `ObjectWriter`.
    `SequenceWriter` | `writeValuesAsArray(DataOutput out)`
    `SequenceWriter` | `writeValuesAsArray(File out)` Method for creating a `SequenceWriter` to write an array of root-level values, using configuration of this `ObjectWriter`.
    `SequenceWriter` | `writeValuesAsArray(JsonGenerator gen)` Method for creating a `SequenceWriter` to write an array of root-level values, using configuration of this `ObjectWriter`.
    `SequenceWriter` | `writeValuesAsArray(OutputStream out)` Method for creating a `SequenceWriter` to write an array of root-level values, using configuration of this `ObjectWriter`.
    `SequenceWriter` | `writeValuesAsArray(Writer out)` Method for creating a `SequenceWriter` to write an array of root-level values, using configuration of this `ObjectWriter`.

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

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

- - ### Field Detail

    - #### NULL_PRETTY_PRINTER

          protected static final PrettyPrinter NULL_PRETTY_PRINTER

      We need to keep track of explicit disabling of pretty printing; easiest to do by a token value.

    - #### _config

          protected final SerializationConfig _config

      General serialization configuration settings

    - #### _serializerProvider

          protected final DefaultSerializerProvider _serializerProvider

    - #### _serializerFactory

          protected final SerializerFactory _serializerFactory

    - #### _generatorFactory

          protected final JsonFactory _generatorFactory

      Factory used for constructing `JsonGenerator`s

    - #### _generatorSettings

          protected final ObjectWriter.GeneratorSettings _generatorSettings

      Container for settings that need to be passed to `JsonGenerator` constructed for serializing values.
      Since:
        2.5

    - #### _prefetch

          protected final ObjectWriter.Prefetch _prefetch

      We may pre-fetch serializer if root type is known (has been explicitly declared), and if so, reuse it afterwards. This allows avoiding further serializer lookups and increases performance a bit on cases where readers are reused.
      Since:
        2.5

  - ### Constructor Detail

    - #### ObjectWriter

          protected ObjectWriter(ObjectMapper mapper,
                      SerializationConfig config,
                      JavaType rootType,
                      PrettyPrinter pp)

      Constructor used by `ObjectMapper` for initial instantiation

    - #### ObjectWriter

          protected ObjectWriter(ObjectMapper mapper,
                      SerializationConfig config)

      Alternative constructor for initial instantiation by `ObjectMapper`

    - #### ObjectWriter

          protected ObjectWriter(ObjectMapper mapper,
                      SerializationConfig config,
                      FormatSchema s)

      Alternative constructor for initial instantiation by `ObjectMapper`

    - #### ObjectWriter

          protected ObjectWriter(ObjectWriter base,
                      SerializationConfig config,
                      ObjectWriter.GeneratorSettings genSettings,
                      ObjectWriter.Prefetch prefetch)

      Copy constructor used for building variations.

    - #### ObjectWriter

          protected ObjectWriter(ObjectWriter base,
                      SerializationConfig config)

      Copy constructor used for building variations.

    - #### ObjectWriter

          protected ObjectWriter(ObjectWriter base,
                      JsonFactory f)

      Since:
        2.3

  - ### Method Detail

    - #### version

          public Version version()

      Method that will return version information stored in and read from jar that contains this class.
      Specified by:
        `version` in interface `Versioned`

    - #### _new

          protected ObjectWriter _new(ObjectWriter base,
                          JsonFactory f)

      Overridable factory method called by various "withXxx()" methods
      Since:
        2.5

    - #### _new

          protected ObjectWriter _new(ObjectWriter base,
                          SerializationConfig config)

      Overridable factory method called by various "withXxx()" methods
      Since:
        2.5

    - #### _new

          protected ObjectWriter _new(ObjectWriter.GeneratorSettings genSettings,
                          ObjectWriter.Prefetch prefetch)

      Overridable factory method called by various "withXxx()" methods. It assumes `this` as base for settings other than those directly passed in.
      Since:
        2.5

    - #### _newSequenceWriter

          protected SequenceWriter _newSequenceWriter(boolean wrapInArray,
                                          JsonGenerator gen,
                                          boolean managedInput)
                                               throws IOException

      Overridable factory method called by `writeValues(OutputStream)` method (and its various overrides), and initializes it as necessary.
      Throws:
        `IOException`
      Since:
        2.5

    - #### with

          public ObjectWriter with(SerializationFeature feature)

      Method for constructing a new instance that is configured with specified feature enabled.

    - #### with

          public ObjectWriter with(SerializationFeature first,
                          SerializationFeature... other)

      Method for constructing a new instance that is configured with specified features enabled.

    - #### withFeatures

          public ObjectWriter withFeatures(SerializationFeature... features)

      Method for constructing a new instance that is configured with specified features enabled.

    - #### without

          public ObjectWriter without(SerializationFeature feature)

      Method for constructing a new instance that is configured with specified feature enabled.

    - #### without

          public ObjectWriter without(SerializationFeature first,
                             SerializationFeature... other)

      Method for constructing a new instance that is configured with specified features enabled.

    - #### withoutFeatures

          public ObjectWriter withoutFeatures(SerializationFeature... features)

      Method for constructing a new instance that is configured with specified features enabled.

    - #### with

          public ObjectWriter with(JsonGenerator.Feature feature)

      Since:
        2.5

    - #### withFeatures

          public ObjectWriter withFeatures(JsonGenerator.Feature... features)

      Since:
        2.5

    - #### without

          public ObjectWriter without(JsonGenerator.Feature feature)

      Since:
        2.5

    - #### withoutFeatures

          public ObjectWriter withoutFeatures(JsonGenerator.Feature... features)

      Since:
        2.5

    - #### with

          public ObjectWriter with(FormatFeature feature)

      Since:
        2.7

    - #### withFeatures

          public ObjectWriter withFeatures(FormatFeature... features)

      Since:
        2.7

    - #### without

          public ObjectWriter without(FormatFeature feature)

      Since:
        2.7

    - #### withoutFeatures

          public ObjectWriter withoutFeatures(FormatFeature... features)

      Since:
        2.7

    - #### forType

          public ObjectWriter forType(JavaType rootType)

      Method that will construct a new instance that uses specific type as the root type for serialization, instead of runtime dynamic type of the root object itself.

      Note that method does NOT change state of this reader, but rather construct and returns a newly configured instance.

      Since:
        2.5

    - #### forType

          public ObjectWriter forType(Class<?> rootType)

      Method that will construct a new instance that uses specific type as the root type for serialization, instead of runtime dynamic type of the root object itself.
      Since:
        2.5

    - #### forType

          public ObjectWriter forType(TypeReference<?> rootType)

      Method that will construct a new instance that uses specific type as the root type for serialization, instead of runtime dynamic type of the root object itself.
      Since:
        2.5

    - #### withType

          @Deprecated
          public ObjectWriter withType(JavaType rootType)

      Deprecated. since 2.5 Use `forType(JavaType)` instead

    - #### withType

          @Deprecated
          public ObjectWriter withType(Class<?> rootType)

      Deprecated. since 2.5 Use `forType(Class)` instead

    - #### withType

          @Deprecated
          public ObjectWriter withType(TypeReference<?> rootType)

      Deprecated. since 2.5 Use `forType(TypeReference)` instead

    - #### with

          public ObjectWriter with(DateFormat df)

      Fluent factory method that will construct a new writer instance that will use specified date format for serializing dates; or if null passed, one that will serialize dates as numeric timestamps.

      Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

    - #### withDefaultPrettyPrinter

          public ObjectWriter withDefaultPrettyPrinter()

      Method that will construct a new instance that will use the default pretty printer for serialization.

    - #### with

          public ObjectWriter with(FilterProvider filterProvider)

      Method that will construct a new instance that uses specified provider for resolving filter instances by id.

    - #### with

          public ObjectWriter with(PrettyPrinter pp)

      Method that will construct a new instance that will use specified pretty printer (or, if null, will not do any pretty-printing)

    - #### withRootName

          public ObjectWriter withRootName(String rootName)

      Method for constructing a new instance with configuration that specifies what root name to use for "root element wrapping". See `MapperConfigBase.withRootName(String)` for details.

      Note that method does NOT change state of this reader, but rather construct and returns a newly configured instance.

      Parameters:
        `rootName` - Root name to use, if non-empty; `null` for "use defaults", and empty String ("") for "do NOT add root wrapper"

    - #### withRootName

          public ObjectWriter withRootName(PropertyName rootName)

      Since:
        2.6

    - #### withoutRootName

          public ObjectWriter withoutRootName()

      Convenience method that is same as calling: `withRootName("")` which will forcibly prevent use of root name wrapping when writing values with this `ObjectWriter`.
      Since:
        2.6

    - #### with

          public ObjectWriter with(FormatSchema schema)

      Method that will construct a new instance that uses specific format schema for serialization.

      Note that method does NOT change state of this reader, but rather construct and returns a newly configured instance.

    - #### withSchema

          @Deprecated
          public ObjectWriter withSchema(FormatSchema schema)

      Deprecated. Since 2.5 use `with(FormatSchema)` instead

    - #### withView

          public ObjectWriter withView(Class<?> view)

      Method that will construct a new instance that uses specified serialization view for serialization (with null basically disables view processing)

      Note that the method does NOT change state of this reader, but rather construct and returns a newly configured instance.

    - #### with

          public ObjectWriter with(Locale l)

    - #### with

          public ObjectWriter with(TimeZone tz)

    - #### with

          public ObjectWriter with(Base64Variant b64variant)

      Method that will construct a new instance that uses specified default `Base64Variant` for base64 encoding
      Since:
        2.1

    - #### with

          public ObjectWriter with(CharacterEscapes escapes)

      Since:
        2.3

    - #### with

          public ObjectWriter with(JsonFactory f)

      Since:
        2.3

    - #### with

          public ObjectWriter with(ContextAttributes attrs)

      Since:
        2.3

    - #### withAttributes

          public ObjectWriter withAttributes(Map<?,?> attrs)

      Mutant factory method that allows construction of a new writer instance that uses specified set of default attribute values.
      Since:
        2.3

    - #### withAttribute

          public ObjectWriter withAttribute(Object key,
                                   Object value)

      Since:
        2.3

    - #### withoutAttribute

          public ObjectWriter withoutAttribute(Object key)

      Since:
        2.3

    - #### withRootValueSeparator

          public ObjectWriter withRootValueSeparator(String sep)

      Since:
        2.5

    - #### withRootValueSeparator

          public ObjectWriter withRootValueSeparator(SerializableString sep)

      Since:
        2.5

    - #### writeValues

          public SequenceWriter writeValues(File out)
                                     throws IOException

      Method for creating a `SequenceWriter` to write a sequence of root values using configuration of this `ObjectWriter`. Sequence is not surrounded by JSON array; some backend types may not support writing of such sequences as root level. Resulting writer needs to be `SequenceWriter.close()`d after all values have been written to ensure closing of underlying generator and output stream.
      Parameters:
        `out` - Target file to write value sequence to.
      Throws:
        `IOException`
      Since:
        2.5

    - #### writeValues

          public SequenceWriter writeValues(JsonGenerator gen)
                                     throws IOException

      Method for creating a `SequenceWriter` to write a sequence of root values using configuration of this `ObjectWriter`. Sequence is not surrounded by JSON array; some backend types may not support writing of such sequences as root level. Resulting writer needs to be `SequenceWriter.close()`d after all values have been written to ensure that all content gets flushed by the generator. However, since a `JsonGenerator` is explicitly passed, it will NOT be closed when `SequenceWriter.close()` is called.
      Parameters:
        `gen` - Low-level generator caller has already constructed that will be used for actual writing of token stream.
      Throws:
        `IOException`
      Since:
        2.5

    - #### writeValues

          public SequenceWriter writeValues(Writer out)
                                     throws IOException

      Method for creating a `SequenceWriter` to write a sequence of root values using configuration of this `ObjectWriter`. Sequence is not surrounded by JSON array; some backend types may not support writing of such sequences as root level. Resulting writer needs to be `SequenceWriter.close()`d after all values have been written to ensure closing of underlying generator and output stream.
      Parameters:
        `out` - Target writer to use for writing the token stream
      Throws:
        `IOException`
      Since:
        2.5

    - #### writeValues

          public SequenceWriter writeValues(OutputStream out)
                                     throws IOException

      Method for creating a `SequenceWriter` to write a sequence of root values using configuration of this `ObjectWriter`. Sequence is not surrounded by JSON array; some backend types may not support writing of such sequences as root level. Resulting writer needs to be `SequenceWriter.close()`d after all values have been written to ensure closing of underlying generator and output stream.
      Parameters:
        `out` - Physical output stream to use for writing the token stream
      Throws:
        `IOException`
      Since:
        2.5

    - #### writeValues

          public SequenceWriter writeValues(DataOutput out)
                                     throws IOException

      Throws:
        `IOException`
      Since:
        2.8

    - #### writeValuesAsArray

          public SequenceWriter writeValuesAsArray(File out)
                                            throws IOException

      Method for creating a `SequenceWriter` to write an array of root-level values, using configuration of this `ObjectWriter`. Resulting writer needs to be `SequenceWriter.close()`d after all values have been written to ensure closing of underlying generator and output stream.

      Note that the type to use with `forType(Class)` needs to be type of individual values (elements) to write and NOT matching array or `Collection` type.

      Parameters:
        `out` - File to write token stream to
      Throws:
        `IOException`
      Since:
        2.5

    - #### writeValuesAsArray

          public SequenceWriter writeValuesAsArray(JsonGenerator gen)
                                            throws IOException

      Method for creating a `SequenceWriter` to write an array of root-level values, using configuration of this `ObjectWriter`. Resulting writer needs to be `SequenceWriter.close()`d after all values have been written to ensure that all content gets flushed by the generator. However, since a `JsonGenerator` is explicitly passed, it will NOT be closed when `SequenceWriter.close()` is called.

      Note that the type to use with `forType(Class)` needs to be type of individual values (elements) to write and NOT matching array or `Collection` type.

      Parameters:
        `gen` - Underlying generator to use for writing the token stream
      Throws:
        `IOException`
      Since:
        2.5

    - #### writeValuesAsArray

          public SequenceWriter writeValuesAsArray(Writer out)
                                            throws IOException

      Method for creating a `SequenceWriter` to write an array of root-level values, using configuration of this `ObjectWriter`. Resulting writer needs to be `SequenceWriter.close()`d after all values have been written to ensure closing of underlying generator and output stream.

      Note that the type to use with `forType(Class)` needs to be type of individual values (elements) to write and NOT matching array or `Collection` type.

      Parameters:
        `out` - Writer to use for writing the token stream
      Throws:
        `IOException`
      Since:
        2.5

    - #### writeValuesAsArray

          public SequenceWriter writeValuesAsArray(OutputStream out)
                                            throws IOException

      Method for creating a `SequenceWriter` to write an array of root-level values, using configuration of this `ObjectWriter`. Resulting writer needs to be `SequenceWriter.close()`d after all values have been written to ensure closing of underlying generator and output stream.

      Note that the type to use with `forType(Class)` needs to be type of individual values (elements) to write and NOT matching array or `Collection` type.

      Parameters:
        `out` - Physical output stream to use for writing the token stream
      Throws:
        `IOException`
      Since:
        2.5

    - #### writeValuesAsArray

          public SequenceWriter writeValuesAsArray(DataOutput out)
                                            throws IOException

      Throws:
        `IOException`
      Since:
        2.8

    - #### isEnabled

          public boolean isEnabled(SerializationFeature f)

    - #### isEnabled

          public boolean isEnabled(MapperFeature f)

    - #### isEnabled

          public boolean isEnabled(JsonParser.Feature f)

    - #### getConfig

          public SerializationConfig getConfig()

      Since:
        2.2

    - #### getFactory

          public JsonFactory getFactory()

      Since:
        2.2

    - #### getTypeFactory

          public TypeFactory getTypeFactory()

    - #### hasPrefetchedSerializer

          public boolean hasPrefetchedSerializer()

      Diagnostics method that can be called to check whether this writer has pre-fetched serializer to use: pre-fetching improves performance when writer instances are reused as it avoids a per-call serializer lookup.
      Since:
        2.2

    - #### getAttributes

          public ContextAttributes getAttributes()

      Since:
        2.3

    - #### writeValue

          public void writeValue(JsonGenerator gen,
                        Object value)
                          throws IOException

      Method that can be used to serialize any Java value as JSON output, using provided `JsonGenerator`.
      Throws:
        `IOException`

    - #### writeValue

          public void writeValue(File resultFile,
                        Object value)
                          throws IOException,
                                 JsonGenerationException,
                                 JsonMappingException

      Method that can be used to serialize any Java value as JSON output, written to File provided.
      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`

    - #### writeValue

          public void writeValue(OutputStream out,
                        Object value)
                          throws IOException,
                                 JsonGenerationException,
                                 JsonMappingException

      Method that can be used to serialize any Java value as JSON output, using output stream provided (using encoding `JsonEncoding.UTF8`).

      Note: method does not close the underlying stream explicitly here; however, `JsonFactory` this mapper uses may choose to close the stream depending on its settings (by default, it will try to close it when `JsonGenerator` we construct is closed).

      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`

    - #### writeValue

          public void writeValue(Writer w,
                        Object value)
                          throws IOException,
                                 JsonGenerationException,
                                 JsonMappingException

      Method that can be used to serialize any Java value as JSON output, using Writer provided.

      Note: method does not close the underlying stream explicitly here; however, `JsonFactory` this mapper uses may choose to close the stream depending on its settings (by default, it will try to close it when `JsonGenerator` we construct is closed).

      Throws:
        `IOException`
        `JsonGenerationException`
        `JsonMappingException`

    - #### writeValue

          public void writeValue(DataOutput out,
                        Object value)
                          throws IOException

      Throws:
        `IOException`
      Since:
        2.8

    - #### writeValueAsString

          public String writeValueAsString(Object value)
                                    throws JsonProcessingException

      Method that can be used to serialize any Java value as a String. Functionally equivalent to calling `writeValue(Writer,Object)` with `StringWriter` and constructing String, but more efficient.

      Note: prior to version 2.1, throws clause included `IOException`; 2.1 removed it.

      Throws:
        `JsonProcessingException`

    - #### writeValueAsBytes

          public byte[] writeValueAsBytes(Object value)
                                   throws JsonProcessingException

      Method that can be used to serialize any Java value as a byte array. Functionally equivalent to calling `writeValue(Writer,Object)` with `ByteArrayOutputStream` and getting bytes, but more efficient. Encoding used will be UTF-8.

      Note: prior to version 2.1, throws clause included `IOException`; 2.1 removed it.

      Throws:
        `JsonProcessingException`

    - #### acceptJsonFormatVisitor

          public void acceptJsonFormatVisitor(JavaType type,
                                     JsonFormatVisitorWrapper visitor)
                                       throws JsonMappingException

      Method for visiting type hierarchy for given type, using specified visitor. Visitation uses `Serializer` hierarchy and related properties

      This method can be used for things like generating Json Schema instance for specified type.

      Parameters:
        `type` - Type to generate schema for (possibly with generic signature)
      Throws:
        `JsonMappingException`
      Since:
        2.2

    - #### acceptJsonFormatVisitor

          public void acceptJsonFormatVisitor(Class<?> rawType,
                                     JsonFormatVisitorWrapper visitor)
                                       throws JsonMappingException

      Since 2.6
      Throws:
        `JsonMappingException`

    - #### canSerialize

          public boolean canSerialize(Class<?> type)

    - #### canSerialize

          public boolean canSerialize(Class<?> type,
                             AtomicReference<Throwable> cause)

      Method for checking whether instances of given type can be serialized, and optionally why (as per `Throwable` returned).
      Since:
        2.3

    - #### _serializerProvider

          protected DefaultSerializerProvider _serializerProvider()

      Overridable helper method used for constructing `SerializerProvider` to use for serialization.

    - #### _verifySchemaType

          protected void _verifySchemaType(FormatSchema schema)

      Since:
        2.2

    - #### _configAndWriteValue

          protected final void _configAndWriteValue(JsonGenerator gen,
                                  Object value)
                                             throws IOException

      Method called to configure the generator as necessary and then call write functionality
      Throws:
        `IOException`

    - #### _configureGenerator

          protected final void _configureGenerator(JsonGenerator gen)

      Helper method called to set or override settings of passed-in `JsonGenerator`
      Since:
        2.5

Copyright © 2008–2016 FasterXML. All rights reserved.