Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  package com.fasterxml.jackson.databind;
  
  import java.io.*;
  import java.util.Locale;
  import java.util.Map;
  import java.util.TimeZone;
  
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
 
 public class ObjectWriter
     implements Versioned,
         java.io.Serializable // since 2.1
 {
     private static final long serialVersionUID = -7040667122552707164L;

    
We need to keep track of explicit disabling of pretty printing; easiest to do by a token value.
 
     protected final static PrettyPrinter NULL_PRETTY_PRINTER = new MinimalPrettyPrinter();
     
     /*
     /**********************************************************
     /* Immutable configuration from ObjectMapper
     /**********************************************************
      */

    
General serialization configuration settings
 
     protected final SerializationConfig _config;
    
     protected final DefaultSerializerProvider _serializerProvider;
 
     protected final SerializerFactory _serializerFactory;

    
Factory used for constructing com.fasterxml.jackson.core.JsonGenerators
 
     protected final JsonFactory _generatorFactory;
 
     /*
     /**********************************************************
     /* Configuration that can be changed via mutant factories
     /**********************************************************
      */

    
Specified root serialization type to use; can be same as runtime type, but usually one of its super types
 
     protected final JavaType _rootType;

    
We may pre-fetch serializer if _rootType is known, 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.1
 
     protected final JsonSerializer<Object_rootSerializer;
    
    
To allow for dynamic enabling/disabling of pretty printing, pretty printer can be optionally configured for writer as well
 
     protected final PrettyPrinter _prettyPrinter;
    
    
When using data format that uses a schema, schema is passed to generator.
 
     protected final FormatSchema _schema;
    
    
Caller may want to specify character escaping details, either as defaults, or on call-by-call basis.

Since:
2.3
    protected final CharacterEscapes _characterEscapes;
    /*
    /**********************************************************
    /* Derived settings
    /**********************************************************
     */

    

Since:
2.3
    protected final boolean  _cfgBigDecimalAsPlain;
    /*
    /**********************************************************
    /* Life-cycle, constructors
    /**********************************************************
     */

    
Constructor used by ObjectMapper for initial instantiation
    protected ObjectWriter(ObjectMapper mapperSerializationConfig config,
            JavaType rootTypePrettyPrinter pp)
    {
         = config;
         = mapper._serializerProvider;
         = mapper._serializerFactory;
         = mapper._jsonFactory;
        if (rootType != null) {
            rootType = rootType.withStaticTyping();
        }
         = rootType;
         = pp;
         = null;
         = null;
         = _prefetchRootSerializer(configrootType);
    }

    
Alternative constructor for initial instantiation by ObjectMapper
    protected ObjectWriter(ObjectMapper mapperSerializationConfig config)
    {
         = config;
         = mapper._serializerProvider;
         = mapper._serializerFactory;
         = mapper._jsonFactory;
         = null;
         = null;
         = null;
         = null;
         = null;
    }

    
Alternative constructor for initial instantiation by ObjectMapper
    protected ObjectWriter(ObjectMapper mapperSerializationConfig config,
            FormatSchema s)
    {
         = config;
         = mapper._serializerProvider;
         = mapper._serializerFactory;
         = mapper._jsonFactory;
         = null;
         = null;
         = null;
         = s;
         = null;
    }
    
    
Copy constructor used for building variations.
    protected ObjectWriter(ObjectWriter baseSerializationConfig config,
            JavaType rootTypeJsonSerializer<ObjectrootSer,
            PrettyPrinter ppFormatSchema sCharacterEscapes escapes)
    {
         = config;
         = base._serializerProvider;
         = base._serializerFactory;
         = base._generatorFactory;
         = rootType;
         = rootSer;
         = pp;
         = s;
         = escapes;
    }

    
Copy constructor used for building variations.
    protected ObjectWriter(ObjectWriter baseSerializationConfig config)
    {
         = config;
         = base._serializerProvider;
         = base._serializerFactory;
         = base._generatorFactory;
         = base._schema;
         = base._characterEscapes;
         = base._rootType;
         = base._rootSerializer;
         = base._prettyPrinter;
    }

    

Since:
2.3
    protected ObjectWriter(ObjectWriter baseJsonFactory f)
    {
        // may need to override ordering, based on data format capabilities
         = base._config
         = base._cfgBigDecimalAsPlain;
         = base._serializerProvider;
         = base._serializerFactory;
         = base._generatorFactory;
         = base._schema;
         = base._characterEscapes;
         = base._rootType;
         = base._rootSerializer;
         = base._prettyPrinter;
    }
    
    
Method that will return version information stored in and read from jar that contains this class.
    @Override
    public Version version() {
    }
    
    /*
    /**********************************************************
    /* Life-cycle, fluent factories
    /**********************************************************
     */

    
Method for constructing a new instance that is configured with specified feature enabled.
    public ObjectWriter with(SerializationFeature feature
    {
        SerializationConfig newConfig = .with(feature);
        return (newConfig == ) ? this : new ObjectWriter(thisnewConfig);
    }

    
Method for constructing a new instance that is configured with specified features enabled.
    public ObjectWriter with(SerializationFeature first,
            SerializationFeature... other)
    {
        SerializationConfig newConfig = .with(firstother);
        return (newConfig == ) ? this : new ObjectWriter(thisnewConfig);
    }    

    
Method for constructing a new instance that is configured with specified features enabled.
    public ObjectWriter withFeatures(SerializationFeature... features)
    {
        SerializationConfig newConfig = .withFeatures(features);
        return (newConfig == ) ? this : new ObjectWriter(thisnewConfig);
    }    
    
    
Method for constructing a new instance that is configured with specified feature enabled.
    public ObjectWriter without(SerializationFeature feature
    {
        SerializationConfig newConfig = .without(feature);
        return (newConfig == ) ? this : new ObjectWriter(thisnewConfig);
    }    

    
Method for constructing a new instance that is configured with specified features enabled.
            SerializationFeature... other)
    {
        SerializationConfig newConfig = .without(firstother);
        return (newConfig == ) ? this : new ObjectWriter(thisnewConfig);
    }    

    
Method for constructing a new instance that is configured with specified features enabled.
    {
        SerializationConfig newConfig = .withoutFeatures(features);
        return (newConfig == ) ? this : new ObjectWriter(thisnewConfig);
    }    
    
    
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.

    public ObjectWriter with(DateFormat df)
    {
        SerializationConfig newConfig = .with(df);
        return (newConfig == ) ? this : new ObjectWriter(thisnewConfig);
    }

    
Method that will construct a new instance that will use the default pretty printer for serialization.
    {
        return with(new DefaultPrettyPrinter());
    }

    
Method that will construct a new instance that uses specified provider for resolving filter instances by id.
    public ObjectWriter with(FilterProvider filterProvider)
    {
        if (filterProvider == .getFilterProvider()) { // no change?
            return this;
        }
        return new ObjectWriter(this.withFilters(filterProvider));
    }

    
Method that will construct a new instance that will use specified pretty printer (or, if null, will not do any pretty-printing)
    public ObjectWriter with(PrettyPrinter pp)
    {
        if (pp == ) {
            return this;
        }
        // since null would mean "don't care", need to use placeholder to indicate "disable"
        if (pp == null) {
            pp = ;
        }
        return new ObjectWriter(this,
                pp);
    }

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

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

    public ObjectWriter withRootName(String rootName)
    {
        SerializationConfig newConfig = .withRootName(rootName);
        return (newConfig == ) ? this :  new ObjectWriter(thisnewConfig);
    }

    
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.

    
    public ObjectWriter withSchema(FormatSchema schema)
    {
        if ( == schema) {
            return this;
        }
        _verifySchemaType(schema);
        return new ObjectWriter(this,
                schema);
    }

    
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.

    public ObjectWriter withType(JavaType rootType)
    {
        // 15-Mar-2013, tatu: Important! Indicate that static typing is needed:
        rootType = rootType.withStaticTyping();
        JsonSerializer<ObjectrootSer = _prefetchRootSerializer(rootType);
        return new ObjectWriter(thisrootTyperootSer,
                );
    }    

    
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.
    public ObjectWriter withType(Class<?> rootType) {
        return withType(.constructType(rootType));
    }
    public ObjectWriter withType(TypeReference<?> rootType) {
        return withType(.getTypeFactory().constructType(rootType.getType()));
    }

    
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.

    public ObjectWriter withView(Class<?> view) {
        SerializationConfig newConfig = .withView(view);
        return (newConfig == ) ? this :  new ObjectWriter(thisnewConfig);
    }    
    public ObjectWriter with(Locale l) {
        SerializationConfig newConfig = .with(l);
        return (newConfig == ) ? this :  new ObjectWriter(thisnewConfig);
    }
    public ObjectWriter with(TimeZone tz) {
        SerializationConfig newConfig = .with(tz);
        return (newConfig == ) ? this :  new ObjectWriter(thisnewConfig);
    }

    
Method that will construct a new instance that uses specified default com.fasterxml.jackson.core.Base64Variant for base64 encoding

Since:
2.1
    public ObjectWriter with(Base64Variant b64variant) {
        SerializationConfig newConfig = .with(b64variant);
        return (newConfig == ) ? this :  new ObjectWriter(thisnewConfig);
    }

    

Since:
2.3
    public ObjectWriter with(CharacterEscapes escapes) {
        if ( == escapes) {
            return this;
        }
        return new ObjectWriter(this,
                escapes);
    }

    

Since:
2.3
    public ObjectWriter with(JsonFactory f) {
        if (f == ) {
            return this;
        }
        return new ObjectWriter(thisf);
    }    

    

Since:
2.3
    public ObjectWriter with(ContextAttributes attrs) {
        SerializationConfig newConfig = .with(attrs);
        return (newConfig == ) ? this :  new ObjectWriter(thisnewConfig);
    }

    

Since:
2.3
    public ObjectWriter withAttributes(Map<Object,Objectattrs) {
        SerializationConfig newConfig = .withAttributes(attrs);
        return (newConfig == ) ? this :  new ObjectWriter(thisnewConfig);
    }

    

Since:
2.3
    public ObjectWriter withAttribute(Object keyObject value) {
        SerializationConfig newConfig = .withAttribute(keyvalue);
        return (newConfig == ) ? this :  new ObjectWriter(thisnewConfig);
    }

    

Since:
2.3
    public ObjectWriter withoutAttribute(Object key) {
        SerializationConfig newConfig = .withoutAttribute(key);
        return (newConfig == ) ? this :  new ObjectWriter(thisnewConfig);
    }
    
    /*
    /**********************************************************
    /* Simple accessors
    /**********************************************************
     */
    public boolean isEnabled(SerializationFeature f) {
        return .isEnabled(f);
    }
    public boolean isEnabled(MapperFeature f) {
        return .isEnabled(f);
    }
    public boolean isEnabled(JsonParser.Feature f) {
        return .isEnabled(f);
    }

    

Since:
2.2
    public SerializationConfig getConfig() {
        return ;
    }

    

Deprecated:
Since 2.2, use getFactory() instead.
    @Deprecated
    public JsonFactory getJsonFactory() {
        return ;
    }

    

Since:
2.2
    public JsonFactory getFactory() {
        return ;
    }
    
    public TypeFactory getTypeFactory() {
        return .getTypeFactory();
    }

    
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
    public boolean hasPrefetchedSerializer() {
        return  != null;
    }

    

Since:
2.3
    public ContextAttributes getAttributes() {
        return .getAttributes();
    }
    
    /*
    /**********************************************************
    /* Serialization methods; ones from ObjectCodec first
    /**********************************************************
     */

    
Method that can be used to serialize any Java value as JSON output, using provided com.fasterxml.jackson.core.JsonGenerator.
    public void writeValue(JsonGenerator jgenObject value)
    {
        // 10-Aug-2012, tatu: As per [Issue#12], may need to force PrettyPrinter settings, so:
        _configureJsonGenerator(jgen);
                && (value instanceof Closeable)) {
            _writeCloseableValue(jgenvalue);
        } else {
            if ( == null) {
                _serializerProvider().serializeValue(jgenvalue);
            } else {
                _serializerProvider().serializeValue(jgenvalue);
            }
                jgen.flush();
            }
        }
    }
    
    /*
    /**********************************************************
    /* Serialization methods, others
    /**********************************************************
     */

    
Method that can be used to serialize any Java value as JSON output, written to File provided.
    public void writeValue(File resultFileObject value)
    {
    }

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

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

    public void writeValue(OutputStream outObject value)
    {
    }

    
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, com.fasterxml.jackson.core.JsonFactory this mapper uses may choose to close the stream depending on its settings (by default, it will try to close it when com.fasterxml.jackson.core.JsonGenerator we construct is closed).

    public void writeValue(Writer wObject value)
    {
    }

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

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

    @SuppressWarnings("resource")
    public String writeValueAsString(Object value)
        throws JsonProcessingException
    {        
        // alas, we have to pull the recycler directly here...
        try {
            _configAndWriteValue(.createGenerator(sw), value);
        } catch (JsonProcessingException e) { // to support [JACKSON-758]
            throw e;
        } catch (IOException e) { // shouldn't really happen, but is declared as possibility so:
            throw JsonMappingException.fromUnexpectedIOE(e);
        }
        return sw.getAndClear();
    }
    
    
Method that can be used to serialize any Java value as a byte array. Functionally equivalent to calling writeValue(java.io.Writer,java.lang.Object) with java.io.ByteArrayOutputStream and getting bytes, but more efficient. Encoding used will be UTF-8.

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

    @SuppressWarnings("resource")
    public byte[] writeValueAsBytes(Object value)
        throws JsonProcessingException
    {
        try {
        } catch (JsonProcessingException e) { // to support [JACKSON-758]
            throw e;
        } catch (IOException e) { // shouldn't really happen, but is declared as possibility so:
            throw JsonMappingException.fromUnexpectedIOE(e);
        }
        byte[] result = bb.toByteArray();
        bb.release();
        return result;
    }
    /*
    /**********************************************************
    /* Other public methods
    /**********************************************************
     */

    
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)
Since:
2.2
    public void acceptJsonFormatVisitor(JavaType typeJsonFormatVisitorWrapper visitor)
        throws JsonMappingException
    {
        if (type == null) {
            throw new IllegalArgumentException("type must be provided");
        }
        _serializerProvider().acceptJsonFormatVisitor(typevisitor);
    }
    
    public boolean canSerialize(Class<?> type) {
        return _serializerProvider().hasSerializerFor(typenull);
    }

    
Method for checking whether instances of given type can be serialized, and optionally why (as per java.lang.Throwable returned).

Since:
2.3
    public boolean canSerialize(Class<?> typeAtomicReference<Throwablecause) {
        return _serializerProvider().hasSerializerFor(typecause);
    }
    
    /*
    /**********************************************************
    /* Overridable helper methods
    /**********************************************************
     */
    
    
Overridable helper method used for constructing SerializerProvider to use for serialization.
        return .createInstance(config);
    }
    
    /*
    /**********************************************************
    /* Internal methods
    /**********************************************************
     */

    

Since:
2.2
    protected void _verifySchemaType(FormatSchema schema)
    {
        if (schema != null) {
            if (!.canUseSchema(schema)) {
                    throw new IllegalArgumentException("Can not use FormatSchema of type "+schema.getClass().getName()
                            +" for format "+.getFormatName());
            }
        }
    }

    
Method called to configure the generator as necessary and then call write functionality
    protected final void _configAndWriteValue(JsonGenerator jgenObject value)
    {
        _configureJsonGenerator(jgen);
        // [JACKSON-282]: consider Closeable
        if (.isEnabled(.) && (value instanceof Closeable)) {
            _writeCloseable(jgenvalue);
            return;
        }
        boolean closed = false;
        try {
            if ( == null) {
                _serializerProvider().serializeValue(jgenvalue);
            } else {
                _serializerProvider().serializeValue(jgenvalue);
            }
            closed = true;
            jgen.close();
        } finally {
            /* won't try to close twice; also, must catch exception (so it 
             * will not mask exception that is pending)
             */
            if (!closed) {
                try {
                    jgen.close();
                } catch (IOException ioe) { }
            }
        }
    }

    
Helper method used when value to serialize is java.io.Closeable and its close() method is to be called right after serialization has been called
    private final void _writeCloseable(JsonGenerator jgenObject valueSerializationConfig cfg)
    {
        Closeable toClose = (Closeablevalue;
        try {
            if ( == null) {
                _serializerProvider(cfg).serializeValue(jgenvalue);
            } else {
                _serializerProvider(cfg).serializeValue(jgenvalue);
            }
            JsonGenerator tmpJgen = jgen;
            jgen = null;
            tmpJgen.close();
            Closeable tmpToClose = toClose;
            toClose = null;
            tmpToClose.close();
        } finally {
            /* Need to close both generator and value, as long as they haven't yet
             * been closed
             */
            if (jgen != null) {
                try {
                    jgen.close();
                } catch (IOException ioe) { }
            }
            if (toClose != null) {
                try {
                    toClose.close();
                } catch (IOException ioe) { }
            }
        }
    }
    
    
Helper method used when value to serialize is java.io.Closeable and its close() method is to be called right after serialization has been called
    private final void _writeCloseableValue(JsonGenerator jgenObject valueSerializationConfig cfg)
    {
        Closeable toClose = (Closeablevalue;
        try {
            if ( == null) {
                _serializerProvider(cfg).serializeValue(jgenvalue);
            } else {
                _serializerProvider(cfg).serializeValue(jgenvalue);
            }
                jgen.flush();
            }
            Closeable tmpToClose = toClose;
            toClose = null;
            tmpToClose.close();
        } finally {
            if (toClose != null) {
                try {
                    toClose.close();
                } catch (IOException ioe) { }
            }
        }
    }

    
Method called to locate (root) serializer ahead of time, if permitted by configuration. Method also is NOT to throw an exception if access fails.
            SerializationConfig configJavaType valueType)
    {
        if (valueType == null || !.isEnabled(.)) {
            return null;
        }
        try {
            return _serializerProvider(config).findTypedValueSerializer(valueTypetruenull);
        } catch (JsonProcessingException e) {
            // need to swallow?
            return null;
        }
    }
    
    
Helper method called to set or override settings of passed-in com.fasterxml.jackson.core.JsonGenerator

Since:
2.1
    private void _configureJsonGenerator(JsonGenerator jgen)
    {
        if ( != null) {
            PrettyPrinter pp = ;
            if (pp == ) {
                jgen.setPrettyPrinter(null);
            } else {
                /* [JACKSON-851]: Better take care of stateful PrettyPrinters...
                 *   like the DefaultPrettyPrinter.
                 */
                if (pp instanceof Instantiatable<?>) {
                    pp = (PrettyPrinter) ((Instantiatable<?>) pp).createInstance();
                }
                jgen.setPrettyPrinter(pp);
            }
        } else if (.isEnabled(.)) {
            jgen.useDefaultPrettyPrinter();
        }
        if ( != null) {
            jgen.setCharacterEscapes();
        }
        // [JACKSON-520]: add support for pass-through schema:
        if ( != null) {
            jgen.setSchema();
        }
        if () { // should only set if explicitly set; this should work for now:
        }
    }
New to GrepCode? Check out our FAQ X